head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.13 netbsd-11-0-RC3:1.1.1.13 netbsd-11-0-RC2:1.1.1.13 netbsd-11-0-RC1:1.1.1.13 perseant-exfatfs-base-20250801:1.1.1.13 netbsd-11:1.1.1.13.0.10 netbsd-11-base:1.1.1.13 netbsd-10-1-RELEASE:1.1.1.13 perseant-exfatfs-base-20240630:1.1.1.13 perseant-exfatfs:1.1.1.13.0.8 perseant-exfatfs-base:1.1.1.13 netbsd-8-3-RELEASE:1.1.1.10 netbsd-9-4-RELEASE:1.1.1.12 netbsd-10-0-RELEASE:1.1.1.13 netbsd-10-0-RC6:1.1.1.13 netbsd-10-0-RC5:1.1.1.13 netbsd-10-0-RC4:1.1.1.13 netbsd-10-0-RC3:1.1.1.13 netbsd-10-0-RC2:1.1.1.13 netbsd-10-0-RC1:1.1.1.13 netbsd-10:1.1.1.13.0.6 netbsd-10-base:1.1.1.13 netbsd-9-3-RELEASE:1.1.1.12 cjep_sun2x:1.1.1.13.0.4 cjep_sun2x-base:1.1.1.13 cjep_staticlib_x-base1:1.1.1.13 netbsd-9-2-RELEASE:1.1.1.12 cjep_staticlib_x:1.1.1.13.0.2 cjep_staticlib_x-base:1.1.1.13 netbsd-9-1-RELEASE:1.1.1.12 phil-wifi-20200421:1.1.1.13 phil-wifi-20200411:1.1.1.13 phil-wifi-20200406:1.1.1.13 netbsd-8-2-RELEASE:1.1.1.10 netbsd-9-0-RELEASE:1.1.1.12 netbsd-9-0-RC2:1.1.1.12 netbsd-9-0-RC1:1.1.1.12 netbsd-9:1.1.1.12.0.2 netbsd-9-base:1.1.1.12 phil-wifi-20190609:1.1.1.12 netbsd-8-1-RELEASE:1.1.1.10 netbsd-8-1-RC1:1.1.1.10 pgoyette-compat-merge-20190127:1.1.1.11.2.1 pgoyette-compat-20190127:1.1.1.12 pgoyette-compat-20190118:1.1.1.12 pgoyette-compat-1226:1.1.1.12 pgoyette-compat-1126:1.1.1.12 pgoyette-compat-1020:1.1.1.12 pgoyette-compat-0930:1.1.1.12 pgoyette-compat-0906:1.1.1.12 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.12 clang-337282:1.1.1.12 netbsd-8-0-RELEASE:1.1.1.10 phil-wifi:1.1.1.11.0.4 phil-wifi-base:1.1.1.11 pgoyette-compat-0625:1.1.1.11 netbsd-8-0-RC2:1.1.1.10 pgoyette-compat-0521:1.1.1.11 pgoyette-compat-0502:1.1.1.11 pgoyette-compat-0422:1.1.1.11 netbsd-8-0-RC1:1.1.1.10 pgoyette-compat-0415:1.1.1.11 pgoyette-compat-0407:1.1.1.11 pgoyette-compat-0330:1.1.1.11 pgoyette-compat-0322:1.1.1.11 pgoyette-compat-0315:1.1.1.11 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.11.0.2 pgoyette-compat-base:1.1.1.11 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.11 matt-nb8-mediatek:1.1.1.10.0.10 matt-nb8-mediatek-base:1.1.1.10 clang-309604:1.1.1.11 perseant-stdc-iso10646:1.1.1.10.0.8 perseant-stdc-iso10646-base:1.1.1.10 netbsd-8:1.1.1.10.0.6 netbsd-8-base:1.1.1.10 prg-localcount2-base3:1.1.1.10 prg-localcount2-base2:1.1.1.10 prg-localcount2-base1:1.1.1.10 prg-localcount2:1.1.1.10.0.4 prg-localcount2-base:1.1.1.10 pgoyette-localcount-20170426:1.1.1.10 bouyer-socketcan-base1:1.1.1.10 pgoyette-localcount-20170320:1.1.1.10 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.10 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.31; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.19; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.07; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.44; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.41; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.27; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.53; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.34.48; author joerg; state Exp; branches; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.08.01.19.34.53; author joerg; state Exp; branches 1.1.1.11.2.1 1.1.1.11.4.1; next 1.1.1.12; commitid pMuDy65V0VicSx1A; 1.1.1.12 date 2018.07.17.18.31.09; author joerg; state Exp; branches; next 1.1.1.13; commitid wDzL46ALjrCZgwKA; 1.1.1.13 date 2019.11.13.22.19.23; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.08; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.44; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.27; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.28; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.27; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.28; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.38; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.11.2.1 date 2018.07.28.04.33.19; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.11.4.1 date 2019.06.10.21.45.23; author christos; state Exp; branches; next 1.1.1.11.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.11.4.2 date 2020.04.13.07.46.34; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // ASTUnit Implementation. // //===----------------------------------------------------------------------===// #include "clang/Frontend/ASTUnit.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclVisitor.h" #include "clang/AST/StmtVisitor.h" #include "clang/AST/TypeOrdering.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/FrontendOptions.h" #include "clang/Frontend/MultiplexConsumer.h" #include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/PreprocessorOptions.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "clang/Serialization/ASTWriter.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" #include "llvm/Support/Atomic.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Host.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Mutex.h" #include "llvm/Support/MutexGuard.h" #include "llvm/Support/Path.h" #include "llvm/Support/Timer.h" #include "llvm/Support/raw_ostream.h" #include #include #include using namespace clang; using llvm::TimeRecord; namespace { class SimpleTimer { bool WantTiming; TimeRecord Start; std::string Output; public: explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) { if (WantTiming) Start = TimeRecord::getCurrentTime(); } void setOutput(const Twine &Output) { if (WantTiming) this->Output = Output.str(); } ~SimpleTimer() { if (WantTiming) { TimeRecord Elapsed = TimeRecord::getCurrentTime(); Elapsed -= Start; llvm::errs() << Output << ':'; Elapsed.print(Elapsed, llvm::errs()); llvm::errs() << '\n'; } } }; struct OnDiskData { /// \brief The file in which the precompiled preamble is stored. std::string PreambleFile; /// \brief Temporary files that should be removed when the ASTUnit is /// destroyed. SmallVector TemporaryFiles; /// \brief Erase temporary files. void CleanTemporaryFiles(); /// \brief Erase the preamble file. void CleanPreambleFile(); /// \brief Erase temporary files and the preamble file. void Cleanup(); }; } static llvm::sys::SmartMutex &getOnDiskMutex() { static llvm::sys::SmartMutex M(/* recursive = */ true); return M; } static void cleanupOnDiskMapAtExit(); typedef llvm::DenseMap OnDiskDataMap; static OnDiskDataMap &getOnDiskDataMap() { static OnDiskDataMap M; static bool hasRegisteredAtExit = false; if (!hasRegisteredAtExit) { hasRegisteredAtExit = true; atexit(cleanupOnDiskMapAtExit); } return M; } static void cleanupOnDiskMapAtExit() { // Use the mutex because there can be an alive thread destroying an ASTUnit. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); for (OnDiskDataMap::iterator I = M.begin(), E = M.end(); I != E; ++I) { // We don't worry about freeing the memory associated with OnDiskDataMap. // All we care about is erasing stale files. I->second->Cleanup(); } } static OnDiskData &getOnDiskData(const ASTUnit *AU) { // We require the mutex since we are modifying the structure of the // DenseMap. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); OnDiskData *&D = M[AU]; if (!D) D = new OnDiskData(); return *D; } static void erasePreambleFile(const ASTUnit *AU) { getOnDiskData(AU).CleanPreambleFile(); } static void removeOnDiskEntry(const ASTUnit *AU) { // We require the mutex since we are modifying the structure of the // DenseMap. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); OnDiskDataMap::iterator I = M.find(AU); if (I != M.end()) { I->second->Cleanup(); delete I->second; M.erase(AU); } } static void setPreambleFile(const ASTUnit *AU, StringRef preambleFile) { getOnDiskData(AU).PreambleFile = preambleFile; } static const std::string &getPreambleFile(const ASTUnit *AU) { return getOnDiskData(AU).PreambleFile; } void OnDiskData::CleanTemporaryFiles() { for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) llvm::sys::fs::remove(TemporaryFiles[I]); TemporaryFiles.clear(); } void OnDiskData::CleanPreambleFile() { if (!PreambleFile.empty()) { llvm::sys::fs::remove(PreambleFile); PreambleFile.clear(); } } void OnDiskData::Cleanup() { CleanTemporaryFiles(); CleanPreambleFile(); } struct ASTUnit::ASTWriterData { SmallString<128> Buffer; llvm::BitstreamWriter Stream; ASTWriter Writer; ASTWriterData() : Stream(Buffer), Writer(Stream) { } }; void ASTUnit::clearFileLevelDecls() { for (FileDeclsTy::iterator I = FileDecls.begin(), E = FileDecls.end(); I != E; ++I) delete I->second; FileDecls.clear(); } void ASTUnit::CleanTemporaryFiles() { getOnDiskData(this).CleanTemporaryFiles(); } void ASTUnit::addTemporaryFile(StringRef TempFile) { getOnDiskData(this).TemporaryFiles.push_back(TempFile); } /// \brief After failing to build a precompiled preamble (due to /// errors in the source that occurs in the preamble), the number of /// reparses during which we'll skip even trying to precompile the /// preamble. const unsigned DefaultPreambleRebuildInterval = 5; /// \brief Tracks the number of ASTUnit objects that are currently active. /// /// Used for debugging purposes only. static llvm::sys::cas_flag ActiveASTUnitObjects; ASTUnit::ASTUnit(bool _MainFileIsAST) : Reader(0), HadModuleLoaderFatalFailure(false), OnlyLocalDecls(false), CaptureDiagnostics(false), MainFileIsAST(_MainFileIsAST), TUKind(TU_Complete), WantTiming(getenv("LIBCLANG_TIMING")), OwnsRemappedFileBuffers(true), NumStoredDiagnosticsFromDriver(0), PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0), NumWarningsInPreamble(0), ShouldCacheCodeCompletionResults(false), IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), CompletionCacheTopLevelHashValue(0), PreambleTopLevelHashValue(0), CurrentTopLevelHashValue(0), UnsafeToFree(false) { if (getenv("LIBCLANG_OBJTRACKING")) { llvm::sys::AtomicIncrement(&ActiveASTUnitObjects); fprintf(stderr, "+++ %d translation units\n", ActiveASTUnitObjects); } } ASTUnit::~ASTUnit() { // If we loaded from an AST file, balance out the BeginSourceFile call. if (MainFileIsAST && getDiagnostics().getClient()) { getDiagnostics().getClient()->EndSourceFile(); } clearFileLevelDecls(); // Clean up the temporary files and the preamble file. removeOnDiskEntry(this); // Free the buffers associated with remapped files. We are required to // perform this operation here because we explicitly request that the // compiler instance *not* free these buffers for each invocation of the // parser. if (Invocation.getPtr() && OwnsRemappedFileBuffers) { PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); for (PreprocessorOptions::remapped_file_buffer_iterator FB = PPOpts.remapped_file_buffer_begin(), FBEnd = PPOpts.remapped_file_buffer_end(); FB != FBEnd; ++FB) delete FB->second; } delete SavedMainFileBuffer; delete PreambleBuffer; ClearCachedCompletionResults(); if (getenv("LIBCLANG_OBJTRACKING")) { llvm::sys::AtomicDecrement(&ActiveASTUnitObjects); fprintf(stderr, "--- %d translation units\n", ActiveASTUnitObjects); } } void ASTUnit::setPreprocessor(Preprocessor *pp) { PP = pp; } /// \brief Determine the set of code-completion contexts in which this /// declaration should be shown. static unsigned getDeclShowContexts(const NamedDecl *ND, const LangOptions &LangOpts, bool &IsNestedNameSpecifier) { IsNestedNameSpecifier = false; if (isa(ND)) ND = dyn_cast(ND->getUnderlyingDecl()); if (!ND) return 0; uint64_t Contexts = 0; if (isa(ND) || isa(ND) || isa(ND) || isa(ND)) { // Types can appear in these contexts. if (LangOpts.CPlusPlus || !isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Type) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); // In C++, types can appear in expressions contexts (for functional casts). if (LangOpts.CPlusPlus) Contexts |= (1LL << CodeCompletionContext::CCC_Expression); // In Objective-C, message sends can send interfaces. In Objective-C++, // all types are available due to functional casts. if (LangOpts.CPlusPlus || isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); // In Objective-C, you can only be a subclass of another Objective-C class if (isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_ObjCInterfaceName); // Deal with tag names. if (isa(ND)) { Contexts |= (1LL << CodeCompletionContext::CCC_EnumTag); // Part of the nested-name-specifier in C++0x. if (LangOpts.CPlusPlus11) IsNestedNameSpecifier = true; } else if (const RecordDecl *Record = dyn_cast(ND)) { if (Record->isUnion()) Contexts |= (1LL << CodeCompletionContext::CCC_UnionTag); else Contexts |= (1LL << CodeCompletionContext::CCC_ClassOrStructTag); if (LangOpts.CPlusPlus) IsNestedNameSpecifier = true; } else if (isa(ND)) IsNestedNameSpecifier = true; } else if (isa(ND) || isa(ND)) { // Values can appear in these contexts. Contexts = (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); } else if (isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_ObjCProtocolName); } else if (isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_ObjCCategoryName); } else if (isa(ND) || isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_Namespace); // Part of the nested-name-specifier. IsNestedNameSpecifier = true; } return Contexts; } void ASTUnit::CacheCodeCompletionResults() { if (!TheSema) return; SimpleTimer Timer(WantTiming); Timer.setOutput("Cache global code completions for " + getMainFileName()); // Clear out the previous results. ClearCachedCompletionResults(); // Gather the set of global code completions. typedef CodeCompletionResult Result; SmallVector Results; CachedCompletionAllocator = new GlobalCodeCompletionAllocator; CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator); TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, CCTUInfo, Results); // Translate global code completions into cached completions. llvm::DenseMap CompletionTypes; for (unsigned I = 0, N = Results.size(); I != N; ++I) { switch (Results[I].Kind) { case Result::RK_Declaration: { bool IsNestedNameSpecifier = false; CachedCodeCompletionResult CachedResult; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier); CachedResult.Priority = Results[I].Priority; CachedResult.Kind = Results[I].CursorKind; CachedResult.Availability = Results[I].Availability; // Keep track of the type of this completion in an ASTContext-agnostic // way. QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration); if (UsageType.isNull()) { CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; } else { CanQualType CanUsageType = Ctx->getCanonicalType(UsageType.getUnqualifiedType()); CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType); // Determine whether we have already seen this type. If so, we save // ourselves the work of formatting the type string by using the // temporary, CanQualType-based hash table to find the associated value. unsigned &TypeValue = CompletionTypes[CanUsageType]; if (TypeValue == 0) { TypeValue = CompletionTypes.size(); CachedCompletionTypes[QualType(CanUsageType).getAsString()] = TypeValue; } CachedResult.Type = TypeValue; } CachedCompletionResults.push_back(CachedResult); /// Handle nested-name-specifiers in C++. if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) { // The contexts in which a nested-name-specifier can appear in C++. uint64_t NNSContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_EnumTag) | (1LL << CodeCompletionContext::CCC_UnionTag) | (1LL << CodeCompletionContext::CCC_ClassOrStructTag) | (1LL << CodeCompletionContext::CCC_Type) | (1LL << CodeCompletionContext::CCC_PotentiallyQualifiedName) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); if (isa(Results[I].Declaration) || isa(Results[I].Declaration)) NNSContexts |= (1LL << CodeCompletionContext::CCC_Namespace); if (unsigned RemainingContexts = NNSContexts & ~CachedResult.ShowInContexts) { // If there any contexts where this completion can be a // nested-name-specifier but isn't already an option, create a // nested-name-specifier completion. Results[I].StartsNestedNameSpecifier = true; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = RemainingContexts; CachedResult.Priority = CCP_NestedNameSpecifier; CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; CachedCompletionResults.push_back(CachedResult); } } break; } case Result::RK_Keyword: case Result::RK_Pattern: // Ignore keywords and patterns; we don't care, since they are so // easily regenerated. break; case Result::RK_Macro: { CachedCodeCompletionResult CachedResult; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCInterface) | (1LL << CodeCompletionContext::CCC_ObjCImplementation) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_MacroNameUse) | (1LL << CodeCompletionContext::CCC_PreprocessorExpression) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_OtherWithMacros); CachedResult.Priority = Results[I].Priority; CachedResult.Kind = Results[I].CursorKind; CachedResult.Availability = Results[I].Availability; CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; CachedCompletionResults.push_back(CachedResult); break; } } } // Save the current top-level hash value. CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue; } void ASTUnit::ClearCachedCompletionResults() { CachedCompletionResults.clear(); CachedCompletionTypes.clear(); CachedCompletionAllocator = 0; } namespace { /// \brief Gathers information from ASTReader that will be used to initialize /// a Preprocessor. class ASTInfoCollector : public ASTReaderListener { Preprocessor &PP; ASTContext &Context; LangOptions &LangOpt; IntrusiveRefCntPtr &TargetOpts; IntrusiveRefCntPtr &Target; unsigned &Counter; bool InitializedLanguage; public: ASTInfoCollector(Preprocessor &PP, ASTContext &Context, LangOptions &LangOpt, IntrusiveRefCntPtr &TargetOpts, IntrusiveRefCntPtr &Target, unsigned &Counter) : PP(PP), Context(Context), LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target), Counter(Counter), InitializedLanguage(false) {} virtual bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain) { if (InitializedLanguage) return false; LangOpt = LangOpts; InitializedLanguage = true; updated(); return false; } virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain) { // If we've already initialized the target, don't do it again. if (Target) return false; this->TargetOpts = new TargetOptions(TargetOpts); Target = TargetInfo::CreateTargetInfo(PP.getDiagnostics(), &*this->TargetOpts); updated(); return false; } virtual void ReadCounter(const serialization::ModuleFile &M, unsigned Value) { Counter = Value; } private: void updated() { if (!Target || !InitializedLanguage) return; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Target->setForcedLangOptions(LangOpt); // Initialize the preprocessor. PP.Initialize(*Target); // Initialize the ASTContext Context.InitBuiltinTypes(*Target); // We didn't have access to the comment options when the ASTContext was // constructed, so register them now. Context.getCommentCommandTraits().registerCommentOptions( LangOpt.CommentOpts); } }; /// \brief Diagnostic consumer that saves each diagnostic it is given. class StoredDiagnosticConsumer : public DiagnosticConsumer { SmallVectorImpl &StoredDiags; SourceManager *SourceMgr; public: explicit StoredDiagnosticConsumer( SmallVectorImpl &StoredDiags) : StoredDiags(StoredDiags), SourceMgr(0) { } virtual void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP = 0) { if (PP) SourceMgr = &PP->getSourceManager(); } virtual void HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info); }; /// \brief RAII object that optionally captures diagnostics, if /// there is no diagnostic client to capture them already. class CaptureDroppedDiagnostics { DiagnosticsEngine &Diags; StoredDiagnosticConsumer Client; DiagnosticConsumer *PreviousClient; public: CaptureDroppedDiagnostics(bool RequestCapture, DiagnosticsEngine &Diags, SmallVectorImpl &StoredDiags) : Diags(Diags), Client(StoredDiags), PreviousClient(0) { if (RequestCapture || Diags.getClient() == 0) { PreviousClient = Diags.takeClient(); Diags.setClient(&Client); } } ~CaptureDroppedDiagnostics() { if (Diags.getClient() == &Client) { Diags.takeClient(); Diags.setClient(PreviousClient); } } }; } // anonymous namespace void StoredDiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info) { // Default implementation (Warnings/errors count). DiagnosticConsumer::HandleDiagnostic(Level, Info); // Only record the diagnostic if it's part of the source manager we know // about. This effectively drops diagnostics from modules we're building. // FIXME: In the long run, ee don't want to drop source managers from modules. if (!Info.hasSourceManager() || &Info.getSourceManager() == SourceMgr) StoredDiags.push_back(StoredDiagnostic(Level, Info)); } ASTMutationListener *ASTUnit::getASTMutationListener() { if (WriterData) return &WriterData->Writer; return 0; } ASTDeserializationListener *ASTUnit::getDeserializationListener() { if (WriterData) return &WriterData->Writer; return 0; } llvm::MemoryBuffer *ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) { assert(FileMgr); return FileMgr->getBufferForFile(Filename, ErrorStr); } /// \brief Configure the diagnostics object for use with ASTUnit. void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr &Diags, const char **ArgBegin, const char **ArgEnd, ASTUnit &AST, bool CaptureDiagnostics) { if (!Diags.getPtr()) { // No diagnostics engine was provided, so create our own diagnostics object // with the default options. DiagnosticConsumer *Client = 0; if (CaptureDiagnostics) Client = new StoredDiagnosticConsumer(AST.StoredDiagnostics); Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions(), Client, /*ShouldOwnClient=*/true); } else if (CaptureDiagnostics) { Diags->setClient(new StoredDiagnosticConsumer(AST.StoredDiagnostics)); } } ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename, IntrusiveRefCntPtr Diags, const FileSystemOptions &FileSystemOpts, bool OnlyLocalDecls, RemappedFile *RemappedFiles, unsigned NumRemappedFiles, bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, bool UserFilesAreVolatile) { OwningPtr AST(new ASTUnit(true)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.getPtr()); ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->Diagnostics = Diags; AST->FileMgr = new FileManager(FileSystemOpts); AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->SourceMgr = new SourceManager(AST->getDiagnostics(), AST->getFileManager(), UserFilesAreVolatile); AST->HSOpts = new HeaderSearchOptions(); AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts, AST->getSourceManager(), AST->getDiagnostics(), AST->ASTFileLangOpts, /*Target=*/0)); for (unsigned I = 0; I != NumRemappedFiles; ++I) { FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; if (const llvm::MemoryBuffer * memBuf = fileOrBuf.dyn_cast()) { // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = AST->getFileManager().getVirtualFile(RemappedFiles[I].first, memBuf->getBufferSize(), 0); if (!FromFile) { AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file) << RemappedFiles[I].first; delete memBuf; continue; } // Override the contents of the "from" file with the contents of // the "to" file. AST->getSourceManager().overrideFileContents(FromFile, memBuf); } else { const char *fname = fileOrBuf.get(); const FileEntry *ToFile = AST->FileMgr->getFile(fname); if (!ToFile) { AST->getDiagnostics().Report(diag::err_fe_remap_missing_to_file) << RemappedFiles[I].first << fname; continue; } // Create the file entry for the file that we're mapping from. const FileEntry *FromFile = AST->getFileManager().getVirtualFile(RemappedFiles[I].first, ToFile->getSize(), 0); if (!FromFile) { AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file) << RemappedFiles[I].first; delete memBuf; continue; } // Override the contents of the "from" file with the contents of // the "to" file. AST->getSourceManager().overrideFileContents(FromFile, ToFile); } } // Gather Info for preprocessor construction later on. HeaderSearch &HeaderInfo = *AST->HeaderInfo.get(); unsigned Counter; OwningPtr Reader; AST->PP = new Preprocessor(new PreprocessorOptions(), AST->getDiagnostics(), AST->ASTFileLangOpts, /*Target=*/0, AST->getSourceManager(), HeaderInfo, *AST, /*IILookup=*/0, /*OwnsHeaderSearch=*/false, /*DelayInitialization=*/true); Preprocessor &PP = *AST->PP; AST->Ctx = new ASTContext(AST->ASTFileLangOpts, AST->getSourceManager(), /*Target=*/0, PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo(), /* size_reserve = */0, /*DelayInitialization=*/true); ASTContext &Context = *AST->Ctx; bool disableValid = false; if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION")) disableValid = true; Reader.reset(new ASTReader(PP, Context, /*isysroot=*/"", /*DisableValidation=*/disableValid, AllowPCHWithCompilerErrors)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ReaderCleanup(Reader.get()); Reader->setListener(new ASTInfoCollector(*AST->PP, Context, AST->ASTFileLangOpts, AST->TargetOpts, AST->Target, Counter)); switch (Reader->ReadAST(Filename, serialization::MK_MainFile, SourceLocation(), ASTReader::ARR_None)) { case ASTReader::Success: break; case ASTReader::Failure: case ASTReader::Missing: case ASTReader::OutOfDate: case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch); return NULL; } AST->OriginalSourceFile = Reader->getOriginalSourceFile(); PP.setCounterValue(Counter); // Attach the AST reader to the AST context as an external AST // source, so that declarations will be deserialized from the // AST file as needed. ASTReader *ReaderPtr = Reader.get(); OwningPtr Source(Reader.take()); // Unregister the cleanup for ASTReader. It will get cleaned up // by the ASTUnit cleanup. ReaderCleanup.unregister(); Context.setExternalSource(Source); // Create an AST consumer, even though it isn't used. AST->Consumer.reset(new ASTConsumer); // Create a semantic analysis object and tell the AST reader about it. AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer)); AST->TheSema->Initialize(); ReaderPtr->InitializeSema(*AST->TheSema); AST->Reader = ReaderPtr; // Tell the diagnostic client that we have started a source file. AST->getDiagnostics().getClient()->BeginSourceFile(Context.getLangOpts(),&PP); return AST.take(); } namespace { /// \brief Preprocessor callback class that updates a hash value with the names /// of all macros that have been defined by the translation unit. class MacroDefinitionTrackerPPCallbacks : public PPCallbacks { unsigned &Hash; public: explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { } virtual void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) { Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash); } }; /// \brief Add the given declaration to the hash of all top-level entities. void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { if (!D) return; DeclContext *DC = D->getDeclContext(); if (!DC) return; if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit())) return; if (NamedDecl *ND = dyn_cast(D)) { if (EnumDecl *EnumD = dyn_cast(D)) { // For an unscoped enum include the enumerators in the hash since they // enter the top-level namespace. if (!EnumD->isScoped()) { for (EnumDecl::enumerator_iterator EI = EnumD->enumerator_begin(), EE = EnumD->enumerator_end(); EI != EE; ++EI) { if ((*EI)->getIdentifier()) Hash = llvm::HashString((*EI)->getIdentifier()->getName(), Hash); } } } if (ND->getIdentifier()) Hash = llvm::HashString(ND->getIdentifier()->getName(), Hash); else if (DeclarationName Name = ND->getDeclName()) { std::string NameStr = Name.getAsString(); Hash = llvm::HashString(NameStr, Hash); } return; } if (ImportDecl *ImportD = dyn_cast(D)) { if (Module *Mod = ImportD->getImportedModule()) { std::string ModName = Mod->getFullModuleName(); Hash = llvm::HashString(ModName, Hash); } return; } } class TopLevelDeclTrackerConsumer : public ASTConsumer { ASTUnit &Unit; unsigned &Hash; public: TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash) : Unit(_Unit), Hash(Hash) { Hash = 0; } void handleTopLevelDecl(Decl *D) { if (!D) return; // FIXME: Currently ObjC method declarations are incorrectly being // reported as top-level declarations, even though their DeclContext // is the containing ObjC @@interface/@@implementation. This is a // fundamental problem in the parser right now. if (isa(D)) return; AddTopLevelDeclarationToHash(D, Hash); Unit.addTopLevelDecl(D); handleFileLevelDecl(D); } void handleFileLevelDecl(Decl *D) { Unit.addFileLevelDecl(D); if (NamespaceDecl *NSD = dyn_cast(D)) { for (NamespaceDecl::decl_iterator I = NSD->decls_begin(), E = NSD->decls_end(); I != E; ++I) handleFileLevelDecl(*I); } } bool HandleTopLevelDecl(DeclGroupRef D) { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) handleTopLevelDecl(*it); return true; } // We're not interested in "interesting" decls. void HandleInterestingDecl(DeclGroupRef) {} void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) handleTopLevelDecl(*it); } virtual ASTMutationListener *GetASTMutationListener() { return Unit.getASTMutationListener(); } virtual ASTDeserializationListener *GetASTDeserializationListener() { return Unit.getDeserializationListener(); } }; class TopLevelDeclTrackerAction : public ASTFrontendAction { public: ASTUnit &Unit; virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { CI.getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue())); return new TopLevelDeclTrackerConsumer(Unit, Unit.getCurrentTopLevelHashValue()); } public: TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} virtual bool hasCodeCompletionSupport() const { return false; } virtual TranslationUnitKind getTranslationUnitKind() { return Unit.getTranslationUnitKind(); } }; class PrecompilePreambleAction : public ASTFrontendAction { ASTUnit &Unit; bool HasEmittedPreamblePCH; public: explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit), HasEmittedPreamblePCH(false) {} virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile); bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; } void setHasEmittedPreamblePCH() { HasEmittedPreamblePCH = true; } virtual bool shouldEraseOutputFiles() { return !hasEmittedPreamblePCH(); } virtual bool hasCodeCompletionSupport() const { return false; } virtual bool hasASTFileSupport() const { return false; } virtual TranslationUnitKind getTranslationUnitKind() { return TU_Prefix; } }; class PrecompilePreambleConsumer : public PCHGenerator { ASTUnit &Unit; unsigned &Hash; std::vector TopLevelDecls; PrecompilePreambleAction *Action; public: PrecompilePreambleConsumer(ASTUnit &Unit, PrecompilePreambleAction *Action, const Preprocessor &PP, StringRef isysroot, raw_ostream *Out) : PCHGenerator(PP, "", 0, isysroot, Out, /*AllowASTWithErrors=*/true), Unit(Unit), Hash(Unit.getCurrentTopLevelHashValue()), Action(Action) { Hash = 0; } virtual bool HandleTopLevelDecl(DeclGroupRef D) { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { Decl *D = *it; // FIXME: Currently ObjC method declarations are incorrectly being // reported as top-level declarations, even though their DeclContext // is the containing ObjC @@interface/@@implementation. This is a // fundamental problem in the parser right now. if (isa(D)) continue; AddTopLevelDeclarationToHash(D, Hash); TopLevelDecls.push_back(D); } return true; } virtual void HandleTranslationUnit(ASTContext &Ctx) { PCHGenerator::HandleTranslationUnit(Ctx); if (hasEmittedPCH()) { // Translate the top-level declarations we captured during // parsing into declaration IDs in the precompiled // preamble. This will allow us to deserialize those top-level // declarations when requested. for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I) { Decl *D = TopLevelDecls[I]; // Invalid top-level decls may not have been serialized. if (D->isInvalidDecl()) continue; Unit.addTopLevelDeclFromPreamble(getWriter().getDeclID(D)); } Action->setHasEmittedPreamblePCH(); } } }; } ASTConsumer *PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { std::string Sysroot; std::string OutputFile; raw_ostream *OS = 0; if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS)) return 0; if (!CI.getFrontendOpts().RelocatablePCH) Sysroot.clear(); CI.getPreprocessor().addPPCallbacks(new MacroDefinitionTrackerPPCallbacks( Unit.getCurrentTopLevelHashValue())); return new PrecompilePreambleConsumer(Unit, this, CI.getPreprocessor(), Sysroot, OS); } static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) { return StoredDiag.getLocation().isValid(); } static void checkAndRemoveNonDriverDiags(SmallVectorImpl &StoredDiags) { // Get rid of stored diagnostics except the ones from the driver which do not // have a source location. StoredDiags.erase( std::remove_if(StoredDiags.begin(), StoredDiags.end(), isNonDriverDiag), StoredDiags.end()); } static void checkAndSanitizeDiags(SmallVectorImpl & StoredDiagnostics, SourceManager &SM) { // The stored diagnostic has the old source manager in it; update // the locations to refer into the new source manager. Since we've // been careful to make sure that the source manager's state // before and after are identical, so that we can reuse the source // location itself. for (unsigned I = 0, N = StoredDiagnostics.size(); I < N; ++I) { if (StoredDiagnostics[I].getLocation().isValid()) { FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SM); StoredDiagnostics[I].setLocation(Loc); } } } /// Parse the source file into a translation unit using the given compiler /// invocation, replacing the current translation unit. /// /// \returns True if a failure occurred that causes the ASTUnit not to /// contain any translation-unit information, false otherwise. bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) { delete SavedMainFileBuffer; SavedMainFileBuffer = 0; if (!Invocation) { delete OverrideMainBuffer; return true; } // Create the compiler instance to use for building the AST. OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); IntrusiveRefCntPtr CCInvocation(new CompilerInvocation(*Invocation)); Clang->setInvocation(CCInvocation.getPtr()); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics that would // otherwise be dropped. Clang->setDiagnostics(&getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) { delete OverrideMainBuffer; return true; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Configure the various subsystems. // FIXME: Should we retain the previous file manager? LangOpts = &Clang->getLangOpts(); FileSystemOpts = Clang->getFileSystemOpts(); FileMgr = new FileManager(FileSystemOpts); SourceMgr = new SourceManager(getDiagnostics(), *FileMgr, UserFilesAreVolatile); TheSema.reset(); Ctx = 0; PP = 0; Reader = 0; // Clear out old caches and data. TopLevelDecls.clear(); clearFileLevelDecls(); CleanTemporaryFiles(); if (!OverrideMainBuffer) { checkAndRemoveNonDriverDiags(StoredDiagnostics); TopLevelDeclsInPreamble.clear(); } // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(&getFileManager()); // Create the source manager. Clang->setSourceManager(&getSourceManager()); // If the main file has been overridden due to the use of a preamble, // make that override happen and introduce the preamble. PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts(); if (OverrideMainBuffer) { PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); PreprocessorOpts.PrecompiledPreambleBytes.second = PreambleEndsAtStartOfLine; PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); PreprocessorOpts.DisablePCHValidation = true; // The stored diagnostic has the old source manager in it; update // the locations to refer into the new source manager. Since we've // been careful to make sure that the source manager's state // before and after are identical, so that we can reuse the source // location itself. checkAndSanitizeDiags(StoredDiagnostics, getSourceManager()); // Keep track of the override buffer; SavedMainFileBuffer = OverrideMainBuffer; } OwningPtr Act( new TopLevelDeclTrackerAction(*this)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ActCleanup(Act.get()); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) goto error; if (OverrideMainBuffer) { std::string ModName = getPreambleFile(this); TranslateStoredDiagnostics(Clang->getModuleManager(), ModName, getSourceManager(), PreambleDiagnostics, StoredDiagnostics); } if (!Act->Execute()) goto error; transferASTDataFromCompilerInstance(*Clang); Act->EndSourceFile(); FailedParseDiagnostics.clear(); return false; error: // Remove the overridden buffer we used for the preamble. if (OverrideMainBuffer) { delete OverrideMainBuffer; SavedMainFileBuffer = 0; } // Keep the ownership of the data in the ASTUnit because the client may // want to see the diagnostics. transferASTDataFromCompilerInstance(*Clang); FailedParseDiagnostics.swap(StoredDiagnostics); StoredDiagnostics.clear(); NumStoredDiagnosticsFromDriver = 0; return true; } /// \brief Simple function to retrieve a path for a preamble precompiled header. static std::string GetPreamblePCHPath() { // FIXME: This is a hack so that we can override the preamble file during // crash-recovery testing, which is the only case where the preamble files // are not necessarily cleaned up. const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE"); if (TmpFile) return TmpFile; SmallString<128> Path; llvm::sys::fs::createTemporaryFile("preamble", "pch", Path); return Path.str(); } /// \brief Compute the preamble for the main file, providing the source buffer /// that corresponds to the main file along with a pair (bytes, start-of-line) /// that describes the preamble. std::pair > ASTUnit::ComputePreamble(CompilerInvocation &Invocation, unsigned MaxLines, bool &CreatedBuffer) { FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); PreprocessorOptions &PreprocessorOpts = Invocation.getPreprocessorOpts(); CreatedBuffer = false; // Try to determine if the main file has been remapped, either from the // command line (to another file) or directly through the compiler invocation // (to a memory buffer). llvm::MemoryBuffer *Buffer = 0; std::string MainFilePath(FrontendOpts.Inputs[0].getFile()); llvm::sys::fs::UniqueID MainFileID; if (!llvm::sys::fs::getUniqueID(MainFilePath, MainFileID)) { // Check whether there is a file-file remapping of the main file for (PreprocessorOptions::remapped_file_iterator M = PreprocessorOpts.remapped_file_begin(), E = PreprocessorOpts.remapped_file_end(); M != E; ++M) { std::string MPath(M->first); llvm::sys::fs::UniqueID MID; if (!llvm::sys::fs::getUniqueID(MPath, MID)) { if (MainFileID == MID) { // We found a remapping. Try to load the resulting, remapped source. if (CreatedBuffer) { delete Buffer; CreatedBuffer = false; } Buffer = getBufferForFile(M->second); if (!Buffer) return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true)); CreatedBuffer = true; } } } // Check whether there is a file-buffer remapping. It supercedes the // file-file remapping. for (PreprocessorOptions::remapped_file_buffer_iterator M = PreprocessorOpts.remapped_file_buffer_begin(), E = PreprocessorOpts.remapped_file_buffer_end(); M != E; ++M) { std::string MPath(M->first); llvm::sys::fs::UniqueID MID; if (!llvm::sys::fs::getUniqueID(MPath, MID)) { if (MainFileID == MID) { // We found a remapping. if (CreatedBuffer) { delete Buffer; CreatedBuffer = false; } Buffer = const_cast(M->second); } } } } // If the main source file was not remapped, load it now. if (!Buffer) { Buffer = getBufferForFile(FrontendOpts.Inputs[0].getFile()); if (!Buffer) return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true)); CreatedBuffer = true; } return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, *Invocation.getLangOpts(), MaxLines)); } static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old, unsigned NewSize, StringRef NewName) { llvm::MemoryBuffer *Result = llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName); memcpy(const_cast(Result->getBufferStart()), Old->getBufferStart(), Old->getBufferSize()); memset(const_cast(Result->getBufferStart()) + Old->getBufferSize(), ' ', NewSize - Old->getBufferSize() - 1); const_cast(Result->getBufferEnd())[-1] = '\n'; return Result; } /// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing /// the source file. /// /// This routine will compute the preamble of the main source file. If a /// non-trivial preamble is found, it will precompile that preamble into a /// precompiled header so that the precompiled preamble can be used to reduce /// reparsing time. If a precompiled preamble has already been constructed, /// this routine will determine if it is still valid and, if so, avoid /// rebuilding the precompiled preamble. /// /// \param AllowRebuild When true (the default), this routine is /// allowed to rebuild the precompiled preamble if it is found to be /// out-of-date. /// /// \param MaxLines When non-zero, the maximum number of lines that /// can occur within the preamble. /// /// \returns If the precompiled preamble can be used, returns a newly-allocated /// buffer that should be used in place of the main file when doing so. /// Otherwise, returns a NULL pointer. llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble( const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, unsigned MaxLines) { IntrusiveRefCntPtr PreambleInvocation(new CompilerInvocation(PreambleInvocationIn)); FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts(); PreprocessorOptions &PreprocessorOpts = PreambleInvocation->getPreprocessorOpts(); bool CreatedPreambleBuffer = false; std::pair > NewPreamble = ComputePreamble(*PreambleInvocation, MaxLines, CreatedPreambleBuffer); // If ComputePreamble() Take ownership of the preamble buffer. OwningPtr OwnedPreambleBuffer; if (CreatedPreambleBuffer) OwnedPreambleBuffer.reset(NewPreamble.first); if (!NewPreamble.second.first) { // We couldn't find a preamble in the main source. Clear out the current // preamble, if we have one. It's obviously no good any more. Preamble.clear(); erasePreambleFile(this); // The next time we actually see a preamble, precompile it. PreambleRebuildCounter = 1; return 0; } if (!Preamble.empty()) { // We've previously computed a preamble. Check whether we have the same // preamble now that we did before, and that there's enough space in // the main-file buffer within the precompiled preamble to fit the // new main file. if (Preamble.size() == NewPreamble.second.first && PreambleEndsAtStartOfLine == NewPreamble.second.second && NewPreamble.first->getBufferSize() < PreambleReservedSize-2 && memcmp(Preamble.getBufferStart(), NewPreamble.first->getBufferStart(), NewPreamble.second.first) == 0) { // The preamble has not changed. We may be able to re-use the precompiled // preamble. // Check that none of the files used by the preamble have changed. bool AnyFileChanged = false; // First, make a record of those files that have been overridden via // remapping or unsaved_files. llvm::StringMap > OverriddenFiles; for (PreprocessorOptions::remapped_file_iterator R = PreprocessorOpts.remapped_file_begin(), REnd = PreprocessorOpts.remapped_file_end(); !AnyFileChanged && R != REnd; ++R) { llvm::sys::fs::file_status Status; if (FileMgr->getNoncachedStatValue(R->second, Status)) { // If we can't stat the file we're remapping to, assume that something // horrible happened. AnyFileChanged = true; break; } OverriddenFiles[R->first] = std::make_pair( Status.getSize(), Status.getLastModificationTime().toEpochTime()); } for (PreprocessorOptions::remapped_file_buffer_iterator R = PreprocessorOpts.remapped_file_buffer_begin(), REnd = PreprocessorOpts.remapped_file_buffer_end(); !AnyFileChanged && R != REnd; ++R) { // FIXME: Should we actually compare the contents of file->buffer // remappings? OverriddenFiles[R->first] = std::make_pair(R->second->getBufferSize(), 0); } // Check whether anything has changed. for (llvm::StringMap >::iterator F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end(); !AnyFileChanged && F != FEnd; ++F) { llvm::StringMap >::iterator Overridden = OverriddenFiles.find(F->first()); if (Overridden != OverriddenFiles.end()) { // This file was remapped; check whether the newly-mapped file // matches up with the previous mapping. if (Overridden->second != F->second) AnyFileChanged = true; continue; } // The file was not remapped; check whether it has changed on disk. llvm::sys::fs::file_status Status; if (FileMgr->getNoncachedStatValue(F->first(), Status)) { // If we can't stat the file, assume that something horrible happened. AnyFileChanged = true; } else if (Status.getSize() != uint64_t(F->second.first) || Status.getLastModificationTime().toEpochTime() != uint64_t(F->second.second)) AnyFileChanged = true; } if (!AnyFileChanged) { // Okay! We can re-use the precompiled preamble. // Set the state of the diagnostic object to mimic its state // after parsing the preamble. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), PreambleInvocation->getDiagnosticOpts()); getDiagnostics().setNumWarnings(NumWarningsInPreamble); // Create a version of the main file buffer that is padded to // buffer size we reserved when creating the preamble. return CreatePaddedMainFileBuffer(NewPreamble.first, PreambleReservedSize, FrontendOpts.Inputs[0].getFile()); } } // If we aren't allowed to rebuild the precompiled preamble, just // return now. if (!AllowRebuild) return 0; // We can't reuse the previously-computed preamble. Build a new one. Preamble.clear(); PreambleDiagnostics.clear(); erasePreambleFile(this); PreambleRebuildCounter = 1; } else if (!AllowRebuild) { // We aren't allowed to rebuild the precompiled preamble; just // return now. return 0; } // If the preamble rebuild counter > 1, it's because we previously // failed to build a preamble and we're not yet ready to try // again. Decrement the counter and return a failure. if (PreambleRebuildCounter > 1) { --PreambleRebuildCounter; return 0; } // Create a temporary file for the precompiled preamble. In rare // circumstances, this can fail. std::string PreamblePCHPath = GetPreamblePCHPath(); if (PreamblePCHPath.empty()) { // Try again next time. PreambleRebuildCounter = 1; return 0; } // We did not previously compute a preamble, or it can't be reused anyway. SimpleTimer PreambleTimer(WantTiming); PreambleTimer.setOutput("Precompiling preamble"); // Create a new buffer that stores the preamble. The buffer also contains // extra space for the original contents of the file (which will be present // when we actually parse the file) along with more room in case the file // grows. PreambleReservedSize = NewPreamble.first->getBufferSize(); if (PreambleReservedSize < 4096) PreambleReservedSize = 8191; else PreambleReservedSize *= 2; // Save the preamble text for later; we'll need to compare against it for // subsequent reparses. StringRef MainFilename = PreambleInvocation->getFrontendOpts().Inputs[0].getFile(); Preamble.assign(FileMgr->getFile(MainFilename), NewPreamble.first->getBufferStart(), NewPreamble.first->getBufferStart() + NewPreamble.second.first); PreambleEndsAtStartOfLine = NewPreamble.second.second; delete PreambleBuffer; PreambleBuffer = llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize, FrontendOpts.Inputs[0].getFile()); memcpy(const_cast(PreambleBuffer->getBufferStart()), NewPreamble.first->getBufferStart(), Preamble.size()); memset(const_cast(PreambleBuffer->getBufferStart()) + Preamble.size(), ' ', PreambleReservedSize - Preamble.size() - 1); const_cast(PreambleBuffer->getBufferEnd())[-1] = '\n'; // Remap the main source file to the preamble buffer. StringRef MainFilePath = FrontendOpts.Inputs[0].getFile(); PreprocessorOpts.addRemappedFile(MainFilePath, PreambleBuffer); // Tell the compiler invocation to generate a temporary precompiled header. FrontendOpts.ProgramAction = frontend::GeneratePCH; // FIXME: Generate the precompiled header into memory? FrontendOpts.OutputFile = PreamblePCHPath; PreprocessorOpts.PrecompiledPreambleBytes.first = 0; PreprocessorOpts.PrecompiledPreambleBytes.second = false; // Create the compiler instance to use for building the precompiled preamble. OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(&*PreambleInvocation); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing all of the diagnostics produced. Clang->setDiagnostics(&getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) { llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); return 0; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Clear out old caches and data. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts()); checkAndRemoveNonDriverDiags(StoredDiagnostics); TopLevelDecls.clear(); TopLevelDeclsInPreamble.clear(); // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(new FileManager(Clang->getFileSystemOpts())); // Create the source manager. Clang->setSourceManager(new SourceManager(getDiagnostics(), Clang->getFileManager())); OwningPtr Act; Act.reset(new PrecompilePreambleAction(*this)); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); return 0; } Act->Execute(); Act->EndSourceFile(); if (!Act->hasEmittedPreamblePCH()) { // The preamble PCH failed (e.g. there was a module loading fatal error), // so no precompiled header was generated. Forget that we even tried. // FIXME: Should we leave a note for ourselves to try again? llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); TopLevelDeclsInPreamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); return 0; } // Transfer any diagnostics generated when parsing the preamble into the set // of preamble diagnostics. PreambleDiagnostics.clear(); PreambleDiagnostics.insert(PreambleDiagnostics.end(), stored_diag_afterDriver_begin(), stored_diag_end()); checkAndRemoveNonDriverDiags(StoredDiagnostics); // Keep track of the preamble we precompiled. setPreambleFile(this, FrontendOpts.OutputFile); NumWarningsInPreamble = getDiagnostics().getNumWarnings(); // Keep track of all of the files that the source manager knows about, // so we can verify whether they have changed or not. FilesInPreamble.clear(); SourceManager &SourceMgr = Clang->getSourceManager(); const llvm::MemoryBuffer *MainFileBuffer = SourceMgr.getBuffer(SourceMgr.getMainFileID()); for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(), FEnd = SourceMgr.fileinfo_end(); F != FEnd; ++F) { const FileEntry *File = F->second->OrigEntry; if (!File || F->second->getRawBuffer() == MainFileBuffer) continue; FilesInPreamble[File->getName()] = std::make_pair(F->second->getSize(), File->getModificationTime()); } PreambleRebuildCounter = 1; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); // If the hash of top-level entities differs from the hash of the top-level // entities the last time we rebuilt the preamble, clear out the completion // cache. if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) { CompletionCacheTopLevelHashValue = 0; PreambleTopLevelHashValue = CurrentTopLevelHashValue; } return CreatePaddedMainFileBuffer(NewPreamble.first, PreambleReservedSize, FrontendOpts.Inputs[0].getFile()); } void ASTUnit::RealizeTopLevelDeclsFromPreamble() { std::vector Resolved; Resolved.reserve(TopLevelDeclsInPreamble.size()); ExternalASTSource &Source = *getASTContext().getExternalSource(); for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) { // Resolve the declaration ID to an actual declaration, possibly // deserializing the declaration in the process. Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]); if (D) Resolved.push_back(D); } TopLevelDeclsInPreamble.clear(); TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end()); } void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) { // Steal the created target, context, and preprocessor. TheSema.reset(CI.takeSema()); Consumer.reset(CI.takeASTConsumer()); Ctx = &CI.getASTContext(); PP = &CI.getPreprocessor(); CI.setSourceManager(0); CI.setFileManager(0); Target = &CI.getTarget(); Reader = CI.getModuleManager(); HadModuleLoaderFatalFailure = CI.hadModuleLoaderFatalFailure(); } StringRef ASTUnit::getMainFileName() const { if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) { const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0]; if (Input.isFile()) return Input.getFile(); else return Input.getBuffer()->getBufferIdentifier(); } if (SourceMgr) { if (const FileEntry * FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID())) return FE->getName(); } return StringRef(); } StringRef ASTUnit::getASTFileName() const { if (!isMainFileAST()) return StringRef(); serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); return Mod.FileName; } ASTUnit *ASTUnit::create(CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool CaptureDiagnostics, bool UserFilesAreVolatile) { OwningPtr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; AST->Invocation = CI; AST->FileSystemOpts = CI->getFileSystemOpts(); AST->FileMgr = new FileManager(AST->FileSystemOpts); AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr, UserFilesAreVolatile); return AST.take(); } ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(CompilerInvocation *CI, IntrusiveRefCntPtr Diags, ASTFrontendAction *Action, ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile, OwningPtr *ErrAST) { assert(CI && "A CompilerInvocation is required"); OwningPtr OwnAST; ASTUnit *AST = Unit; if (!AST) { // Create the AST unit. OwnAST.reset(create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile)); AST = OwnAST.get(); } if (!ResourceFilesPath.empty()) { // Override the resources path. CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; } AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; if (PrecompilePreamble) AST->PreambleRebuildCounter = 2; AST->TUKind = Action ? Action->getTranslationUnitKind() : TU_Complete; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(OwnAST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.getPtr()); // We'll manage file buffers ourselves. CI->getPreprocessorOpts().RetainRemappedFileBuffers = true; CI->getFrontendOpts().DisableFree = false; ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts()); // Create the compiler instance to use for building the AST. OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(CI); AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics that would // otherwise be dropped. Clang->setDiagnostics(&AST->getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) return 0; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not supported here!"); // Configure the various subsystems. AST->TheSema.reset(); AST->Ctx = 0; AST->PP = 0; AST->Reader = 0; // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(&AST->getFileManager()); // Create the source manager. Clang->setSourceManager(&AST->getSourceManager()); ASTFrontendAction *Act = Action; OwningPtr TrackerAct; if (!Act) { TrackerAct.reset(new TopLevelDeclTrackerAction(*AST)); Act = TrackerAct.get(); } // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ActCleanup(TrackerAct.get()); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { AST->transferASTDataFromCompilerInstance(*Clang); if (OwnAST && ErrAST) ErrAST->swap(OwnAST); return 0; } if (Persistent && !TrackerAct) { Clang->getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(AST->getCurrentTopLevelHashValue())); std::vector Consumers; if (Clang->hasASTConsumer()) Consumers.push_back(Clang->takeASTConsumer()); Consumers.push_back(new TopLevelDeclTrackerConsumer(*AST, AST->getCurrentTopLevelHashValue())); Clang->setASTConsumer(new MultiplexConsumer(Consumers)); } if (!Act->Execute()) { AST->transferASTDataFromCompilerInstance(*Clang); if (OwnAST && ErrAST) ErrAST->swap(OwnAST); return 0; } // Steal the created target, context, and preprocessor. AST->transferASTDataFromCompilerInstance(*Clang); Act->EndSourceFile(); if (OwnAST) return OwnAST.take(); else return AST; } bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) { if (!Invocation) return true; // We'll manage file buffers ourselves. Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true; Invocation->getFrontendOpts().DisableFree = false; ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); llvm::MemoryBuffer *OverrideMainBuffer = 0; if (PrecompilePreamble) { PreambleRebuildCounter = 2; OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); } SimpleTimer ParsingTimer(WantTiming); ParsingTimer.setOutput("Parsing " + getMainFileName()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar MemBufferCleanup(OverrideMainBuffer); return Parse(OverrideMainBuffer); } ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile) { // Create the AST unit. OwningPtr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->TUKind = TUKind; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; AST->Invocation = CI; AST->FileSystemOpts = CI->getFileSystemOpts(); AST->FileMgr = new FileManager(AST->FileSystemOpts); AST->UserFilesAreVolatile = UserFilesAreVolatile; // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.getPtr()); return AST->LoadFromCompilerInvocation(PrecompilePreamble)? 0 : AST.take(); } ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin, const char **ArgEnd, IntrusiveRefCntPtr Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, RemappedFile *RemappedFiles, unsigned NumRemappedFiles, bool RemappedFilesKeepOriginalName, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies, bool UserFilesAreVolatile, bool ForSerialization, OwningPtr *ErrAST) { if (!Diags.getPtr()) { // No diagnostics engine was provided, so create our own diagnostics object // with the default options. Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions()); } SmallVector StoredDiagnostics; IntrusiveRefCntPtr CI; { CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags, StoredDiagnostics); CI = clang::createInvocationFromCommandLine( llvm::makeArrayRef(ArgBegin, ArgEnd), Diags); if (!CI) return 0; } // Override any files that need remapping for (unsigned I = 0; I != NumRemappedFiles; ++I) { FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; if (const llvm::MemoryBuffer * memBuf = fileOrBuf.dyn_cast()) { CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, memBuf); } else { const char *fname = fileOrBuf.get(); CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, fname); } } PreprocessorOptions &PPOpts = CI->getPreprocessorOpts(); PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName; PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors; // Override the resources path. CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies; // Create the AST unit. OwningPtr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, ArgBegin, ArgEnd, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; Diags = 0; // Zero out now to ease cleanup during crash recovery. AST->FileSystemOpts = CI->getFileSystemOpts(); AST->FileMgr = new FileManager(AST->FileSystemOpts); AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->TUKind = TUKind; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); AST->StoredDiagnostics.swap(StoredDiagnostics); AST->Invocation = CI; if (ForSerialization) AST->WriterData.reset(new ASTWriterData()); CI = 0; // Zero out now to ease cleanup during crash recovery. // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) { // Some error occurred, if caller wants to examine diagnostics, pass it the // ASTUnit. if (ErrAST) { AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics); ErrAST->swap(AST); } return 0; } return AST.take(); } bool ASTUnit::Reparse(RemappedFile *RemappedFiles, unsigned NumRemappedFiles) { if (!Invocation) return true; clearFileLevelDecls(); SimpleTimer ParsingTimer(WantTiming); ParsingTimer.setOutput("Reparsing " + getMainFileName()); // Remap files. PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); for (PreprocessorOptions::remapped_file_buffer_iterator R = PPOpts.remapped_file_buffer_begin(), REnd = PPOpts.remapped_file_buffer_end(); R != REnd; ++R) { delete R->second; } Invocation->getPreprocessorOpts().clearRemappedFiles(); for (unsigned I = 0; I != NumRemappedFiles; ++I) { FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; if (const llvm::MemoryBuffer * memBuf = fileOrBuf.dyn_cast()) { Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, memBuf); } else { const char *fname = fileOrBuf.get(); Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, fname); } } // If we have a preamble file lying around, or if we might try to // build a precompiled preamble, do so now. llvm::MemoryBuffer *OverrideMainBuffer = 0; if (!getPreambleFile(this).empty() || PreambleRebuildCounter > 0) OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); // Clear out the diagnostics state. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); if (OverrideMainBuffer) getDiagnostics().setNumWarnings(NumWarningsInPreamble); // Parse the sources bool Result = Parse(OverrideMainBuffer); // If we're caching global code-completion results, and the top-level // declarations have changed, clear out the code-completion cache. if (!Result && ShouldCacheCodeCompletionResults && CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue) CacheCodeCompletionResults(); // We now need to clear out the completion info related to this translation // unit; it'll be recreated if necessary. CCTUInfo.reset(); return Result; } //----------------------------------------------------------------------------// // Code completion //----------------------------------------------------------------------------// namespace { /// \brief Code completion consumer that combines the cached code-completion /// results from an ASTUnit with the code-completion results provided to it, /// then passes the result on to class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer { uint64_t NormalContexts; ASTUnit &AST; CodeCompleteConsumer &Next; public: AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next, const CodeCompleteOptions &CodeCompleteOpts) : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), AST(AST), Next(Next) { // Compute the set of contexts in which we will look when we don't have // any information about the specific context. NormalContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCInterface) | (1LL << CodeCompletionContext::CCC_ObjCImplementation) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_DotMemberAccess) | (1LL << CodeCompletionContext::CCC_ArrowMemberAccess) | (1LL << CodeCompletionContext::CCC_ObjCPropertyAccess) | (1LL << CodeCompletionContext::CCC_ObjCProtocolName) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_Recovery); if (AST.getASTContext().getLangOpts().CPlusPlus) NormalContexts |= (1LL << CodeCompletionContext::CCC_EnumTag) | (1LL << CodeCompletionContext::CCC_UnionTag) | (1LL << CodeCompletionContext::CCC_ClassOrStructTag); } virtual void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults); virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates) { Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates); } virtual CodeCompletionAllocator &getAllocator() { return Next.getAllocator(); } virtual CodeCompletionTUInfo &getCodeCompletionTUInfo() { return Next.getCodeCompletionTUInfo(); } }; } /// \brief Helper function that computes which global names are hidden by the /// local code-completion results. static void CalculateHiddenNames(const CodeCompletionContext &Context, CodeCompletionResult *Results, unsigned NumResults, ASTContext &Ctx, llvm::StringSet &HiddenNames){ bool OnlyTagNames = false; switch (Context.getKind()) { case CodeCompletionContext::CCC_Recovery: case CodeCompletionContext::CCC_TopLevel: case CodeCompletionContext::CCC_ObjCInterface: case CodeCompletionContext::CCC_ObjCImplementation: case CodeCompletionContext::CCC_ObjCIvarList: case CodeCompletionContext::CCC_ClassStructUnion: case CodeCompletionContext::CCC_Statement: case CodeCompletionContext::CCC_Expression: case CodeCompletionContext::CCC_ObjCMessageReceiver: case CodeCompletionContext::CCC_DotMemberAccess: case CodeCompletionContext::CCC_ArrowMemberAccess: case CodeCompletionContext::CCC_ObjCPropertyAccess: case CodeCompletionContext::CCC_Namespace: case CodeCompletionContext::CCC_Type: case CodeCompletionContext::CCC_Name: case CodeCompletionContext::CCC_PotentiallyQualifiedName: case CodeCompletionContext::CCC_ParenthesizedExpression: case CodeCompletionContext::CCC_ObjCInterfaceName: break; case CodeCompletionContext::CCC_EnumTag: case CodeCompletionContext::CCC_UnionTag: case CodeCompletionContext::CCC_ClassOrStructTag: OnlyTagNames = true; break; case CodeCompletionContext::CCC_ObjCProtocolName: case CodeCompletionContext::CCC_MacroName: case CodeCompletionContext::CCC_MacroNameUse: case CodeCompletionContext::CCC_PreprocessorExpression: case CodeCompletionContext::CCC_PreprocessorDirective: case CodeCompletionContext::CCC_NaturalLanguage: case CodeCompletionContext::CCC_SelectorName: case CodeCompletionContext::CCC_TypeQualifiers: case CodeCompletionContext::CCC_Other: case CodeCompletionContext::CCC_OtherWithMacros: case CodeCompletionContext::CCC_ObjCInstanceMessage: case CodeCompletionContext::CCC_ObjCClassMessage: case CodeCompletionContext::CCC_ObjCCategoryName: // We're looking for nothing, or we're looking for names that cannot // be hidden. return; } typedef CodeCompletionResult Result; for (unsigned I = 0; I != NumResults; ++I) { if (Results[I].Kind != Result::RK_Declaration) continue; unsigned IDNS = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace(); bool Hiding = false; if (OnlyTagNames) Hiding = (IDNS & Decl::IDNS_Tag); else { unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | Decl::IDNS_Namespace | Decl::IDNS_Ordinary | Decl::IDNS_NonMemberOperator); if (Ctx.getLangOpts().CPlusPlus) HiddenIDNS |= Decl::IDNS_Tag; Hiding = (IDNS & HiddenIDNS); } if (!Hiding) continue; DeclarationName Name = Results[I].Declaration->getDeclName(); if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo()) HiddenNames.insert(Identifier->getName()); else HiddenNames.insert(Name.getAsString()); } } void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) { // Merge the results we were given with the results we cached. bool AddedResult = false; uint64_t InContexts = Context.getKind() == CodeCompletionContext::CCC_Recovery ? NormalContexts : (1LL << Context.getKind()); // Contains the set of names that are hidden by "local" completion results. llvm::StringSet HiddenNames; typedef CodeCompletionResult Result; SmallVector AllResults; for (ASTUnit::cached_completion_iterator C = AST.cached_completion_begin(), CEnd = AST.cached_completion_end(); C != CEnd; ++C) { // If the context we are in matches any of the contexts we are // interested in, we'll add this result. if ((C->ShowInContexts & InContexts) == 0) continue; // If we haven't added any results previously, do so now. if (!AddedResult) { CalculateHiddenNames(Context, Results, NumResults, S.Context, HiddenNames); AllResults.insert(AllResults.end(), Results, Results + NumResults); AddedResult = true; } // Determine whether this global completion result is hidden by a local // completion result. If so, skip it. if (C->Kind != CXCursor_MacroDefinition && HiddenNames.count(C->Completion->getTypedText())) continue; // Adjust priority based on similar type classes. unsigned Priority = C->Priority; CodeCompletionString *Completion = C->Completion; if (!Context.getPreferredType().isNull()) { if (C->Kind == CXCursor_MacroDefinition) { Priority = getMacroUsagePriority(C->Completion->getTypedText(), S.getLangOpts(), Context.getPreferredType()->isAnyPointerType()); } else if (C->Type) { CanQualType Expected = S.Context.getCanonicalType( Context.getPreferredType().getUnqualifiedType()); SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected); if (ExpectedSTC == C->TypeClass) { // We know this type is similar; check for an exact match. llvm::StringMap &CachedCompletionTypes = AST.getCachedCompletionTypes(); llvm::StringMap::iterator Pos = CachedCompletionTypes.find(QualType(Expected).getAsString()); if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type) Priority /= CCF_ExactTypeMatch; else Priority /= CCF_SimilarTypeMatch; } } } // Adjust the completion string, if required. if (C->Kind == CXCursor_MacroDefinition && Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) { // Create a new code-completion string that just contains the // macro name, without its arguments. CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(), CCP_CodePattern, C->Availability); Builder.AddTypedTextChunk(C->Completion->getTypedText()); Priority = CCP_CodePattern; Completion = Builder.TakeString(); } AllResults.push_back(Result(Completion, Priority, C->Kind, C->Availability)); } // If we did not add any cached completion results, just forward the // results we were given to the next consumer. if (!AddedResult) { Next.ProcessCodeCompleteResults(S, Context, Results, NumResults); return; } Next.ProcessCodeCompleteResults(S, Context, AllResults.data(), AllResults.size()); } void ASTUnit::CodeComplete(StringRef File, unsigned Line, unsigned Column, RemappedFile *RemappedFiles, unsigned NumRemappedFiles, bool IncludeMacros, bool IncludeCodePatterns, bool IncludeBriefComments, CodeCompleteConsumer &Consumer, DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, FileManager &FileMgr, SmallVectorImpl &StoredDiagnostics, SmallVectorImpl &OwnedBuffers) { if (!Invocation) return; SimpleTimer CompletionTimer(WantTiming); CompletionTimer.setOutput("Code completion @@ " + File + ":" + Twine(Line) + ":" + Twine(Column)); IntrusiveRefCntPtr CCInvocation(new CompilerInvocation(*Invocation)); FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts(); CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts; PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts(); CodeCompleteOpts.IncludeMacros = IncludeMacros && CachedCompletionResults.empty(); CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns; CodeCompleteOpts.IncludeGlobals = CachedCompletionResults.empty(); CodeCompleteOpts.IncludeBriefComments = IncludeBriefComments; assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion); FrontendOpts.CodeCompletionAt.FileName = File; FrontendOpts.CodeCompletionAt.Line = Line; FrontendOpts.CodeCompletionAt.Column = Column; // Set the language options appropriately. LangOpts = *CCInvocation->getLangOpts(); OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(&*CCInvocation); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics produced. Clang->setDiagnostics(&Diag); CaptureDroppedDiagnostics Capture(true, Clang->getDiagnostics(), StoredDiagnostics); ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) { Clang->setInvocation(0); return; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Use the source and file managers that we were given. Clang->setFileManager(&FileMgr); Clang->setSourceManager(&SourceMgr); // Remap files. PreprocessorOpts.clearRemappedFiles(); PreprocessorOpts.RetainRemappedFileBuffers = true; for (unsigned I = 0; I != NumRemappedFiles; ++I) { FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; if (const llvm::MemoryBuffer * memBuf = fileOrBuf.dyn_cast()) { PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, memBuf); OwnedBuffers.push_back(memBuf); } else { const char *fname = fileOrBuf.get(); PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, fname); } } // Use the code completion consumer we were given, but adding any cached // code-completion results. AugmentedCodeCompleteConsumer *AugmentedConsumer = new AugmentedCodeCompleteConsumer(*this, Consumer, CodeCompleteOpts); Clang->setCodeCompletionConsumer(AugmentedConsumer); // If we have a precompiled preamble, try to use it. We only allow // the use of the precompiled preamble if we're if the completion // point is within the main file, after the end of the precompiled // preamble. llvm::MemoryBuffer *OverrideMainBuffer = 0; if (!getPreambleFile(this).empty()) { std::string CompleteFilePath(File); llvm::sys::fs::UniqueID CompleteFileID; if (!llvm::sys::fs::getUniqueID(CompleteFilePath, CompleteFileID)) { std::string MainPath(OriginalSourceFile); llvm::sys::fs::UniqueID MainID; if (!llvm::sys::fs::getUniqueID(MainPath, MainID)) { if (CompleteFileID == MainID && Line > 1) OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*CCInvocation, false, Line - 1); } } } // If the main file has been overridden due to the use of a preamble, // make that override happen and introduce the preamble. if (OverrideMainBuffer) { PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); PreprocessorOpts.PrecompiledPreambleBytes.second = PreambleEndsAtStartOfLine; PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); PreprocessorOpts.DisablePCHValidation = true; OwnedBuffers.push_back(OverrideMainBuffer); } else { PreprocessorOpts.PrecompiledPreambleBytes.first = 0; PreprocessorOpts.PrecompiledPreambleBytes.second = false; } // Disable the preprocessing record if modules are not enabled. if (!Clang->getLangOpts().Modules) PreprocessorOpts.DetailedRecord = false; OwningPtr Act; Act.reset(new SyntaxOnlyAction); if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { Act->Execute(); Act->EndSourceFile(); } } bool ASTUnit::Save(StringRef File) { if (HadModuleLoaderFatalFailure) return true; // Write to a temporary file and later rename it to the actual file, to avoid // possible race conditions. SmallString<128> TempPath; TempPath = File; TempPath += "-%%%%%%%%"; int fd; if (llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath)) return true; // FIXME: Can we somehow regenerate the stat cache here, or do we need to // unconditionally create a stat cache when we parse the file? llvm::raw_fd_ostream Out(fd, /*shouldClose=*/true); serialize(Out); Out.close(); if (Out.has_error()) { Out.clear_error(); return true; } if (llvm::sys::fs::rename(TempPath.str(), File)) { bool exists; llvm::sys::fs::remove(TempPath.str(), exists); return true; } return false; } static bool serializeUnit(ASTWriter &Writer, SmallVectorImpl &Buffer, Sema &S, bool hasErrors, raw_ostream &OS) { Writer.WriteAST(S, std::string(), 0, "", hasErrors); // Write the generated bitstream to "Out". if (!Buffer.empty()) OS.write(Buffer.data(), Buffer.size()); return false; } bool ASTUnit::serialize(raw_ostream &OS) { bool hasErrors = getDiagnostics().hasErrorOccurred(); if (WriterData) return serializeUnit(WriterData->Writer, WriterData->Buffer, getSema(), hasErrors, OS); SmallString<128> Buffer; llvm::BitstreamWriter Stream(Buffer); ASTWriter Writer(Stream); return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS); } typedef ContinuousRangeMap SLocRemap; static void TranslateSLoc(SourceLocation &L, SLocRemap &Remap) { unsigned Raw = L.getRawEncoding(); const unsigned MacroBit = 1U << 31; L = SourceLocation::getFromRawEncoding((Raw & MacroBit) | ((Raw & ~MacroBit) + Remap.find(Raw & ~MacroBit)->second)); } void ASTUnit::TranslateStoredDiagnostics( ASTReader *MMan, StringRef ModName, SourceManager &SrcMgr, const SmallVectorImpl &Diags, SmallVectorImpl &Out) { // The stored diagnostic has the old source manager in it; update // the locations to refer into the new source manager. We also need to remap // all the locations to the new view. This includes the diag location, any // associated source ranges, and the source ranges of associated fix-its. // FIXME: There should be a cleaner way to do this. SmallVector Result; Result.reserve(Diags.size()); assert(MMan && "Don't have a module manager"); serialization::ModuleFile *Mod = MMan->ModuleMgr.lookup(ModName); assert(Mod && "Don't have preamble module"); SLocRemap &Remap = Mod->SLocRemap; for (unsigned I = 0, N = Diags.size(); I != N; ++I) { // Rebuild the StoredDiagnostic. const StoredDiagnostic &SD = Diags[I]; SourceLocation L = SD.getLocation(); TranslateSLoc(L, Remap); FullSourceLoc Loc(L, SrcMgr); SmallVector Ranges; Ranges.reserve(SD.range_size()); for (StoredDiagnostic::range_iterator I = SD.range_begin(), E = SD.range_end(); I != E; ++I) { SourceLocation BL = I->getBegin(); TranslateSLoc(BL, Remap); SourceLocation EL = I->getEnd(); TranslateSLoc(EL, Remap); Ranges.push_back(CharSourceRange(SourceRange(BL, EL), I->isTokenRange())); } SmallVector FixIts; FixIts.reserve(SD.fixit_size()); for (StoredDiagnostic::fixit_iterator I = SD.fixit_begin(), E = SD.fixit_end(); I != E; ++I) { FixIts.push_back(FixItHint()); FixItHint &FH = FixIts.back(); FH.CodeToInsert = I->CodeToInsert; SourceLocation BL = I->RemoveRange.getBegin(); TranslateSLoc(BL, Remap); SourceLocation EL = I->RemoveRange.getEnd(); TranslateSLoc(EL, Remap); FH.RemoveRange = CharSourceRange(SourceRange(BL, EL), I->RemoveRange.isTokenRange()); } Result.push_back(StoredDiagnostic(SD.getLevel(), SD.getID(), SD.getMessage(), Loc, Ranges, FixIts)); } Result.swap(Out); } void ASTUnit::addFileLevelDecl(Decl *D) { assert(D); // We only care about local declarations. if (D->isFromASTFile()) return; SourceManager &SM = *SourceMgr; SourceLocation Loc = D->getLocation(); if (Loc.isInvalid() || !SM.isLocalSourceLocation(Loc)) return; // We only keep track of the file-level declarations of each file. if (!D->getLexicalDeclContext()->isFileContext()) return; SourceLocation FileLoc = SM.getFileLoc(Loc); assert(SM.isLocalSourceLocation(FileLoc)); FileID FID; unsigned Offset; llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); if (FID.isInvalid()) return; LocDeclsTy *&Decls = FileDecls[FID]; if (!Decls) Decls = new LocDeclsTy(); std::pair LocDecl(Offset, D); if (Decls->empty() || Decls->back().first <= Offset) { Decls->push_back(LocDecl); return; } LocDeclsTy::iterator I = std::upper_bound(Decls->begin(), Decls->end(), LocDecl, llvm::less_first()); Decls->insert(I, LocDecl); } void ASTUnit::findFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl &Decls) { if (File.isInvalid()) return; if (SourceMgr->isLoadedFileID(File)) { assert(Ctx->getExternalSource() && "No external source!"); return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length, Decls); } FileDeclsTy::iterator I = FileDecls.find(File); if (I == FileDecls.end()) return; LocDeclsTy &LocDecls = *I->second; if (LocDecls.empty()) return; LocDeclsTy::iterator BeginIt = std::lower_bound(LocDecls.begin(), LocDecls.end(), std::make_pair(Offset, (Decl *)0), llvm::less_first()); if (BeginIt != LocDecls.begin()) --BeginIt; // If we are pointing at a top-level decl inside an objc container, we need // to backtrack until we find it otherwise we will fail to report that the // region overlaps with an objc container. while (BeginIt != LocDecls.begin() && BeginIt->second->isTopLevelDeclInObjCContainer()) --BeginIt; LocDeclsTy::iterator EndIt = std::upper_bound( LocDecls.begin(), LocDecls.end(), std::make_pair(Offset + Length, (Decl *)0), llvm::less_first()); if (EndIt != LocDecls.end()) ++EndIt; for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt) Decls.push_back(DIt->second); } SourceLocation ASTUnit::getLocation(const FileEntry *File, unsigned Line, unsigned Col) const { const SourceManager &SM = getSourceManager(); SourceLocation Loc = SM.translateFileLineCol(File, Line, Col); return SM.getMacroArgExpandedLocation(Loc); } SourceLocation ASTUnit::getLocation(const FileEntry *File, unsigned Offset) const { const SourceManager &SM = getSourceManager(); SourceLocation FileLoc = SM.translateFileLineCol(File, 1, 1); return SM.getMacroArgExpandedLocation(FileLoc.getLocWithOffset(Offset)); } /// \brief If \arg Loc is a loaded location from the preamble, returns /// the corresponding local location of the main file, otherwise it returns /// \arg Loc. SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) { FileID PreambleID; if (SourceMgr) PreambleID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) return Loc; unsigned Offs; if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble.size()) { SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID()); return FileLoc.getLocWithOffset(Offs); } return Loc; } /// \brief If \arg Loc is a local location of the main file but inside the /// preamble chunk, returns the corresponding loaded location from the /// preamble, otherwise it returns \arg Loc. SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) { FileID PreambleID; if (SourceMgr) PreambleID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) return Loc; unsigned Offs; if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) && Offs < Preamble.size()) { SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID); return FileLoc.getLocWithOffset(Offs); } return Loc; } bool ASTUnit::isInPreambleFileID(SourceLocation Loc) { FileID FID; if (SourceMgr) FID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || FID.isInvalid()) return false; return SourceMgr->isInFileID(Loc, FID); } bool ASTUnit::isInMainFileID(SourceLocation Loc) { FileID FID; if (SourceMgr) FID = SourceMgr->getMainFileID(); if (Loc.isInvalid() || FID.isInvalid()) return false; return SourceMgr->isInFileID(Loc, FID); } SourceLocation ASTUnit::getEndOfPreambleFileID() { FileID FID; if (SourceMgr) FID = SourceMgr->getPreambleFileID(); if (FID.isInvalid()) return SourceLocation(); return SourceMgr->getLocForEndOfFile(FID); } SourceLocation ASTUnit::getStartOfMainFileID() { FileID FID; if (SourceMgr) FID = SourceMgr->getMainFileID(); if (FID.isInvalid()) return SourceLocation(); return SourceMgr->getLocForStartOfFile(FID); } std::pair ASTUnit::getLocalPreprocessingEntities() const { if (isMainFileAST()) { serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); return Reader->getModulePreprocessedEntities(Mod); } if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord()) return std::make_pair(PPRec->local_begin(), PPRec->local_end()); return std::make_pair(PreprocessingRecord::iterator(), PreprocessingRecord::iterator()); } bool ASTUnit::visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn) { if (isMainFileAST()) { serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); ASTReader::ModuleDeclIterator MDI, MDE; llvm::tie(MDI, MDE) = Reader->getModuleFileLevelDecls(Mod); for (; MDI != MDE; ++MDI) { if (!Fn(context, *MDI)) return false; } return true; } for (ASTUnit::top_level_iterator TL = top_level_begin(), TLEnd = top_level_end(); TL != TLEnd; ++TL) { if (!Fn(context, *TL)) return false; } return true; } namespace { struct PCHLocatorInfo { serialization::ModuleFile *Mod; PCHLocatorInfo() : Mod(0) {} }; } static bool PCHLocator(serialization::ModuleFile &M, void *UserData) { PCHLocatorInfo &Info = *static_cast(UserData); switch (M.Kind) { case serialization::MK_Module: return true; // skip dependencies. case serialization::MK_PCH: Info.Mod = &M; return true; // found it. case serialization::MK_Preamble: return false; // look in dependencies. case serialization::MK_MainFile: return false; // look in dependencies. } return true; } const FileEntry *ASTUnit::getPCHFile() { if (!Reader) return 0; PCHLocatorInfo Info; Reader->getModuleManager().visit(PCHLocator, &Info); if (Info.Mod) return Info.Mod->File; return 0; } bool ASTUnit::isModuleFile() { return isMainFileAST() && !ASTFileLangOpts.CurrentModule.empty(); } void ASTUnit::PreambleData::countLines() const { NumLines = 0; if (empty()) return; for (std::vector::const_iterator I = Buffer.begin(), E = Buffer.end(); I != E; ++I) { if (*I == '\n') ++NumLines; } if (Buffer.back() != '\n') ++NumLines; } #ifndef NDEBUG ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = new llvm::sys::MutexImpl(/*recursive=*/true); } ASTUnit::ConcurrencyState::~ConcurrencyState() { delete static_cast(Mutex); } void ASTUnit::ConcurrencyState::start() { bool acquired = static_cast(Mutex)->tryacquire(); assert(acquired && "Concurrent access to ASTUnit!"); } void ASTUnit::ConcurrencyState::finish() { static_cast(Mutex)->release(); } #else // NDEBUG ASTUnit::ConcurrencyState::ConcurrencyState() {} ASTUnit::ConcurrencyState::~ConcurrencyState() {} void ASTUnit::ConcurrencyState::start() {} void ASTUnit::ConcurrencyState::finish() {} #endif @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @a1361 30 ASTUnit::PreambleFileHash ASTUnit::PreambleFileHash::createForFile(off_t Size, time_t ModTime) { PreambleFileHash Result; Result.Size = Size; Result.ModTime = ModTime; memset(Result.MD5, 0, sizeof(Result.MD5)); return Result; } ASTUnit::PreambleFileHash ASTUnit::PreambleFileHash::createForMemoryBuffer( const llvm::MemoryBuffer *Buffer) { PreambleFileHash Result; Result.Size = Buffer->getBufferSize(); Result.ModTime = 0; llvm::MD5 MD5Ctx; MD5Ctx.update(Buffer->getBuffer().data()); MD5Ctx.final(Result.MD5); return Result; } namespace clang { bool operator==(const ASTUnit::PreambleFileHash &LHS, const ASTUnit::PreambleFileHash &RHS) { return LHS.Size == RHS.Size && LHS.ModTime == RHS.ModTime && memcmp(LHS.MD5, RHS.MD5, sizeof(LHS.MD5)) == 0; } } // namespace clang d1431 1 a1431 1 llvm::StringMap OverriddenFiles; d1445 1 a1445 1 OverriddenFiles[R->first] = PreambleFileHash::createForFile( d1453 4 a1456 2 OverriddenFiles[R->first] = PreambleFileHash::createForMemoryBuffer(R->second); d1460 1 a1460 1 for (llvm::StringMap::iterator d1464 1 a1464 1 llvm::StringMap::iterator Overridden d1479 1 a1479 1 } else if (Status.getSize() != uint64_t(F->second.Size) || d1481 1 a1481 1 uint64_t(F->second.ModTime)) d1552 1 a1552 1 StringRef MainFilename = FrontendOpts.Inputs[0].getFile(); d1681 1 a1681 1 if (!File) d1683 3 a1685 12 const llvm::MemoryBuffer *Buffer = F->second->getRawBuffer(); if (Buffer == MainFileBuffer) continue; if (time_t ModTime = File->getModificationTime()) { FilesInPreamble[File->getName()] = PreambleFileHash::createForFile( F->second->getSize(), ModTime); } else { assert(F->second->getSize() == Buffer->getBufferSize()); FilesInPreamble[File->getName()] = PreambleFileHash::createForMemoryBuffer(Buffer); } d2956 1 a2956 1 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = 0; } @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d2594 2 a2595 1 llvm::sys::fs::remove(TempPath.str()); @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @d236 1 a236 1 fprintf(stderr, "+++ %d translation units\n", (int)ActiveASTUnitObjects); d272 1 a272 1 fprintf(stderr, "--- %d translation units\n", (int)ActiveASTUnitObjects); d683 2 a684 1 ArrayRef RemappedFiles, d714 20 d735 8 a742 4 PreprocessorOptions *PPOpts = new PreprocessorOptions(); for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) PPOpts->addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); d744 18 d769 1 a769 1 AST->PP = new Preprocessor(PPOpts, d2024 2 a2025 1 ArrayRef RemappedFiles, d2059 9 a2067 3 for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); d2117 1 a2117 1 bool ASTUnit::Reparse(ArrayRef RemappedFiles) { d2136 11 a2146 3 for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); d2148 1 a2148 1 d2418 2 a2419 1 ArrayRef RemappedFiles, d2502 10 a2511 3 for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); d2513 1 a2513 1 @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @a22 1 #include "clang/Basic/VirtualFileSystem.h" d40 1 d194 4 a197 1 llvm::DeleteContainerSeconds(FileDecls); d724 2 d748 1 a748 1 AST->Reader = new ASTReader(PP, Context, d751 5 a755 1 AllowPCHWithCompilerErrors); d757 1 a757 1 AST->Reader->setListener(new ASTInfoCollector(*AST->PP, Context, d762 1 a762 1 switch (AST->Reader->ReadAST(Filename, serialization::MK_MainFile, d777 1 a777 1 AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile(); d784 8 a791 1 Context.setExternalSource(AST->Reader); d799 2 a800 1 AST->Reader->InitializeSema(*AST->TheSema); d1179 3 a1181 2 TranslateStoredDiagnostics(getFileManager(), getSourceManager(), PreambleDiagnostics, StoredDiagnostics); a1348 47 static std::pair makeStandaloneRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts) { CharSourceRange FileRange = Lexer::makeFileCharRange(Range, SM, LangOpts); unsigned Offset = SM.getFileOffset(FileRange.getBegin()); unsigned EndOffset = SM.getFileOffset(FileRange.getEnd()); return std::make_pair(Offset, EndOffset); } static void makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix, ASTUnit::StandaloneFixIt &OutFix) { OutFix.RemoveRange = makeStandaloneRange(InFix.RemoveRange, SM, LangOpts); OutFix.InsertFromRange = makeStandaloneRange(InFix.InsertFromRange, SM, LangOpts); OutFix.CodeToInsert = InFix.CodeToInsert; OutFix.BeforePreviousInsertions = InFix.BeforePreviousInsertions; } static void makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag, ASTUnit::StandaloneDiagnostic &OutDiag) { OutDiag.ID = InDiag.getID(); OutDiag.Level = InDiag.getLevel(); OutDiag.Message = InDiag.getMessage(); OutDiag.LocOffset = 0; if (InDiag.getLocation().isInvalid()) return; const SourceManager &SM = InDiag.getLocation().getManager(); SourceLocation FileLoc = SM.getFileLoc(InDiag.getLocation()); OutDiag.Filename = SM.getFilename(FileLoc); if (OutDiag.Filename.empty()) return; OutDiag.LocOffset = SM.getFileOffset(FileLoc); for (StoredDiagnostic::range_iterator I = InDiag.range_begin(), E = InDiag.range_end(); I != E; ++I) { OutDiag.Ranges.push_back(makeStandaloneRange(*I, SM, LangOpts)); } for (StoredDiagnostic::fixit_iterator I = InDiag.fixit_begin(), E = InDiag.fixit_end(); I != E; ++I) { ASTUnit::StandaloneFixIt Fix; makeStandaloneFixIt(SM, LangOpts, *I, Fix); OutDiag.FixIts.push_back(Fix); } } d1424 1 a1424 1 vfs::Status Status; d1460 1 a1460 1 vfs::Status Status; a1608 1 PreambleDiagnostics.clear(); a1628 11 // Transfer any diagnostics generated when parsing the preamble into the set // of preamble diagnostics. for (stored_diag_iterator I = stored_diag_afterDriver_begin(), E = stored_diag_end(); I != E; ++I) { StandaloneDiagnostic Diag; makeStandaloneDiagnostic(Clang->getLangOpts(), *I, Diag); PreambleDiagnostics.push_back(Diag); } a1630 2 checkAndRemoveNonDriverDiags(StoredDiagnostics); d1644 7 a2445 1 OwnedBuffers.push_back(RemappedFiles[I].second); d2564 7 d2572 2 a2573 1 FileManager &FileMgr, d2575 1 a2575 1 const SmallVectorImpl &Diags, d2577 4 a2580 3 // Map the standalone diagnostic into the new source manager. We also need to // remap all the locations to the new view. This includes the diag location, // any associated source ranges, and the source ranges of associated fix-its. d2585 4 d2591 3 a2593 11 const StandaloneDiagnostic &SD = Diags[I]; if (SD.Filename.empty()) continue; const FileEntry *FE = FileMgr.getFile(SD.Filename); if (!FE) continue; FileID FID = SrcMgr.translateFile(FE); SourceLocation FileLoc = SrcMgr.getLocForStartOfFile(FID); if (FileLoc.isInvalid()) continue; SourceLocation L = FileLoc.getLocWithOffset(SD.LocOffset); d2597 9 a2605 6 Ranges.reserve(SD.Ranges.size()); for (std::vector >::const_iterator I = SD.Ranges.begin(), E = SD.Ranges.end(); I != E; ++I) { SourceLocation BL = FileLoc.getLocWithOffset((*I).first); SourceLocation EL = FileLoc.getLocWithOffset((*I).second); Ranges.push_back(CharSourceRange::getCharRange(BL, EL)); d2609 3 a2611 3 FixIts.reserve(SD.FixIts.size()); for (std::vector::const_iterator I = SD.FixIts.begin(), E = SD.FixIts.end(); d2616 6 a2621 3 SourceLocation BL = FileLoc.getLocWithOffset(I->RemoveRange.first); SourceLocation EL = FileLoc.getLocWithOffset(I->RemoveRange.second); FH.RemoveRange = CharSourceRange::getCharRange(BL, EL); d2624 2 a2625 2 Result.push_back(StoredDiagnostic(SD.Level, SD.ID, SD.Message, Loc, Ranges, FixIts)); @ 1.1.1.5.2.1 log @Rebase. @ text @d39 1 a47 1 #include d214 1 a214 1 static std::atomic ActiveASTUnitObjects; d217 1 a217 1 : Reader(nullptr), HadModuleLoaderFatalFailure(false), d223 2 a224 2 PreambleRebuildCounter(0), SavedMainFileBuffer(nullptr), PreambleBuffer(nullptr), NumWarningsInPreamble(0), d231 4 a234 2 if (getenv("LIBCLANG_OBJTRACKING")) fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects); d267 4 a270 2 if (getenv("LIBCLANG_OBJTRACKING")) fprintf(stderr, "--- %u translation units\n", --ActiveASTUnitObjects); d500 1 a500 1 CachedCompletionAllocator = nullptr; d526 2 a527 2 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain) override { d538 2 a539 2 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain) override { d552 1 a552 2 void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override { d588 1 a588 1 : StoredDiags(StoredDiags), SourceMgr(nullptr) {} d590 2 a591 2 void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP = nullptr) override { d596 2 a597 2 void HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info) override; d610 1 a610 1 : Diags(Diags), Client(StoredDiags), PreviousClient(nullptr) d612 1 a612 1 if (RequestCapture || Diags.getClient() == nullptr) { d643 1 a643 1 return nullptr; d649 1 a649 1 return nullptr; d665 1 a665 1 DiagnosticConsumer *Client = nullptr; d684 1 a684 1 std::unique_ptr AST(new ASTUnit(true)); d693 1 a693 1 ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); d698 1 a698 2 IntrusiveRefCntPtr VFS = vfs::getRealFileSystem(); AST->FileMgr = new FileManager(FileSystemOpts, VFS); d704 1 a704 1 d709 1 a709 1 /*Target=*/nullptr)); d721 7 a727 5 AST->PP = new Preprocessor(PPOpts, AST->getDiagnostics(), AST->ASTFileLangOpts, AST->getSourceManager(), HeaderInfo, *AST, /*IILookup=*/nullptr, /*OwnsHeaderSearch=*/false); d730 8 a737 3 AST->Ctx = new ASTContext(AST->ASTFileLangOpts, AST->getSourceManager(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); d765 1 a765 1 return nullptr; d788 1 a788 1 return AST.release(); d800 3 a802 3 void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override { d824 4 a827 3 for (const auto *EI : EnumD->enumerators()) { if (EI->getIdentifier()) Hash = llvm::HashString(EI->getIdentifier()->getName(), Hash); d880 3 a882 2 for (auto *I : NSD->decls()) handleFileLevelDecl(I); d886 1 a886 1 bool HandleTopLevelDecl(DeclGroupRef D) override { d893 1 a893 1 void HandleInterestingDecl(DeclGroupRef) override {} d895 1 a895 1 void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override { d900 1 a900 1 ASTMutationListener *GetASTMutationListener() override { d904 1 a904 1 ASTDeserializationListener *GetASTDeserializationListener() override { d913 2 a914 2 ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { d924 2 a925 2 bool hasCodeCompletionSupport() const override { return false; } TranslationUnitKind getTranslationUnitKind() override { d938 2 a939 2 ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override; d942 1 a942 1 bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); } d944 3 a946 3 bool hasCodeCompletionSupport() const override { return false; } bool hasASTFileSupport() const override { return false; } TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; } d959 1 a959 1 : PCHGenerator(PP, "", nullptr, isysroot, Out, /*AllowASTWithErrors=*/true), d964 1 a964 1 bool HandleTopLevelDecl(DeclGroupRef D) override { d979 1 a979 1 void HandleTranslationUnit(ASTContext &Ctx) override { d1005 1 a1005 1 raw_ostream *OS = nullptr; d1008 1 a1008 1 return nullptr; d1055 2 a1056 2 SavedMainFileBuffer = nullptr; d1063 1 a1063 1 std::unique_ptr Clang(new CompilerInstance()); d1101 1 d1104 1 a1104 1 // Re-use the existing FileManager d1108 4 a1111 4 Ctx = nullptr; PP = nullptr; Reader = nullptr; d1149 4 a1152 4 std::unique_ptr Act( new TopLevelDeclTrackerAction(*this)); d1181 1 a1181 1 SavedMainFileBuffer = nullptr; d1221 1 a1221 1 llvm::MemoryBuffer *Buffer = nullptr; d1243 2 a1244 1 return std::make_pair(nullptr, std::make_pair(0, true)); d1277 2 a1278 2 return std::make_pair(nullptr, std::make_pair(0, true)); d1287 14 d1414 1 a1414 1 std::unique_ptr OwnedPreambleBuffer; d1426 1 a1426 1 return nullptr; d1436 1 d1509 5 a1513 2 return llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.first->getBuffer(), FrontendOpts.Inputs[0].getFile()); d1520 1 a1520 1 return nullptr; d1530 1 a1530 1 return nullptr; d1538 1 a1538 1 return nullptr; d1547 1 a1547 1 return nullptr; d1553 10 d1575 7 a1581 2 = llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.first->getBuffer().slice(0, Preamble.size()), MainFilename); d1595 1 a1595 1 std::unique_ptr Clang(new CompilerInstance()); d1616 1 a1616 1 return nullptr; d1639 1 a1639 6 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(Clang->getInvocation(), getDiagnostics()); if (!VFS) return nullptr; d1641 1 a1641 1 Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS)); d1646 2 a1647 2 std::unique_ptr Act; d1655 1 a1655 1 return nullptr; d1684 1 a1684 1 return nullptr; d1730 3 a1732 2 return llvm::MemoryBuffer::getMemBufferCopy(NewPreamble.first->getBuffer(), MainFilename); d1751 1 a1751 4 // Steal the created target, context, and preprocessor if they have been // created. assert(CI.hasInvocation() && "missing invocation"); LangOpts = CI.getInvocation().getLangOpts(); d1754 5 a1758 8 if (CI.hasASTContext()) Ctx = &CI.getASTContext(); if (CI.hasPreprocessor()) PP = &CI.getPreprocessor(); CI.setSourceManager(nullptr); CI.setFileManager(nullptr); if (CI.hasTarget()) Target = &CI.getTarget(); d1794 1 a1794 1 std::unique_ptr AST; d1796 1 a1796 1 ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); d1800 1 a1800 5 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); d1805 1 a1805 1 return AST.release(); d1808 13 a1820 7 ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( CompilerInvocation *CI, IntrusiveRefCntPtr Diags, ASTFrontendAction *Action, ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile, std::unique_ptr *ErrAST) { d1823 1 a1823 1 std::unique_ptr OwnAST; a1828 2 if (!AST) return nullptr; d1857 1 a1857 1 std::unique_ptr Clang(new CompilerInstance()); d1874 1 a1874 1 return nullptr; d1891 4 a1894 4 AST->Ctx = nullptr; AST->PP = nullptr; AST->Reader = nullptr; d1903 1 a1903 1 std::unique_ptr TrackerAct; d1918 1 a1918 1 return nullptr; d1936 1 a1936 1 return nullptr; d1945 1 a1945 1 return OwnAST.release(); d1959 1 a1959 1 llvm::MemoryBuffer *OverrideMainBuffer = nullptr; d1976 9 a1984 5 std::unique_ptr ASTUnit::LoadFromCompilerInvocation( CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile) { d1986 3 a1988 2 std::unique_ptr AST(new ASTUnit(false)); ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); d1998 1 a1998 5 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); d2008 1 a2008 3 if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) return nullptr; return AST; d2011 17 a2027 10 ASTUnit *ASTUnit::LoadFromCommandLine( const char **ArgBegin, const char **ArgEnd, IntrusiveRefCntPtr Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, ArrayRef RemappedFiles, bool RemappedFilesKeepOriginalName, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies, bool UserFilesAreVolatile, bool ForSerialization, std::unique_ptr *ErrAST) { d2047 1 a2047 1 return nullptr; d2065 1 a2065 1 std::unique_ptr AST; d2069 1 a2069 1 Diags = nullptr; // Zero out now to ease cleanup during crash recovery. d2071 1 a2071 5 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); d2084 2 a2085 2 CI = nullptr; // Zero out now to ease cleanup during crash recovery. d2097 1 a2097 1 return nullptr; d2100 1 a2100 1 return AST.release(); d2129 1 a2129 1 llvm::MemoryBuffer *OverrideMainBuffer = nullptr; d2196 9 a2204 8 void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) override; void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates) override { d2207 2 a2208 2 CodeCompletionAllocator &getAllocator() override { d2212 1 a2212 1 CodeCompletionTUInfo &getCodeCompletionTUInfo() override { d2434 1 a2434 1 std::unique_ptr Clang(new CompilerInstance()); d2454 1 a2454 1 Clang->setInvocation(nullptr); d2495 1 a2495 1 llvm::MemoryBuffer *OverrideMainBuffer = nullptr; d2531 2 a2532 2 std::unique_ptr Act; d2577 1 a2577 1 Writer.WriteAST(S, std::string(), nullptr, "", hasErrors); d2676 1 a2676 1 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); d2718 1 a2718 2 std::make_pair(Offset, (Decl *)nullptr), llvm::less_first()); d2731 1 a2731 1 std::make_pair(Offset + Length, (Decl *)nullptr), llvm::less_first()); d2859 1 a2859 1 std::tie(MDI, MDE) = Reader->getModuleFileLevelDecls(Mod); d2881 1 a2881 1 PCHLocatorInfo() : Mod(nullptr) {} d2904 1 a2904 1 return nullptr; d2911 1 a2911 1 return nullptr; @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @d39 1 a47 1 #include d214 1 a214 1 static std::atomic ActiveASTUnitObjects; d217 1 a217 1 : Reader(nullptr), HadModuleLoaderFatalFailure(false), d223 2 a224 2 PreambleRebuildCounter(0), SavedMainFileBuffer(nullptr), PreambleBuffer(nullptr), NumWarningsInPreamble(0), d231 4 a234 2 if (getenv("LIBCLANG_OBJTRACKING")) fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects); d267 4 a270 2 if (getenv("LIBCLANG_OBJTRACKING")) fprintf(stderr, "--- %u translation units\n", --ActiveASTUnitObjects); d500 1 a500 1 CachedCompletionAllocator = nullptr; d526 2 a527 2 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain) override { d538 2 a539 2 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain) override { d552 1 a552 2 void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override { d588 1 a588 1 : StoredDiags(StoredDiags), SourceMgr(nullptr) {} d590 2 a591 2 void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP = nullptr) override { d596 2 a597 2 void HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info) override; d610 1 a610 1 : Diags(Diags), Client(StoredDiags), PreviousClient(nullptr) d612 1 a612 1 if (RequestCapture || Diags.getClient() == nullptr) { d643 1 a643 1 return nullptr; d649 1 a649 1 return nullptr; d665 1 a665 1 DiagnosticConsumer *Client = nullptr; d684 1 a684 1 std::unique_ptr AST(new ASTUnit(true)); d693 1 a693 1 ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); d698 1 a698 2 IntrusiveRefCntPtr VFS = vfs::getRealFileSystem(); AST->FileMgr = new FileManager(FileSystemOpts, VFS); d704 1 a704 1 d709 1 a709 1 /*Target=*/nullptr)); d721 7 a727 5 AST->PP = new Preprocessor(PPOpts, AST->getDiagnostics(), AST->ASTFileLangOpts, AST->getSourceManager(), HeaderInfo, *AST, /*IILookup=*/nullptr, /*OwnsHeaderSearch=*/false); d730 8 a737 3 AST->Ctx = new ASTContext(AST->ASTFileLangOpts, AST->getSourceManager(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); d765 1 a765 1 return nullptr; d788 1 a788 1 return AST.release(); d800 3 a802 3 void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override { d824 4 a827 3 for (const auto *EI : EnumD->enumerators()) { if (EI->getIdentifier()) Hash = llvm::HashString(EI->getIdentifier()->getName(), Hash); d880 3 a882 2 for (auto *I : NSD->decls()) handleFileLevelDecl(I); d886 1 a886 1 bool HandleTopLevelDecl(DeclGroupRef D) override { d893 1 a893 1 void HandleInterestingDecl(DeclGroupRef) override {} d895 1 a895 1 void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override { d900 1 a900 1 ASTMutationListener *GetASTMutationListener() override { d904 1 a904 1 ASTDeserializationListener *GetASTDeserializationListener() override { d913 2 a914 2 ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { d924 2 a925 2 bool hasCodeCompletionSupport() const override { return false; } TranslationUnitKind getTranslationUnitKind() override { d938 2 a939 2 ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override; d942 1 a942 1 bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); } d944 3 a946 3 bool hasCodeCompletionSupport() const override { return false; } bool hasASTFileSupport() const override { return false; } TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; } d959 1 a959 1 : PCHGenerator(PP, "", nullptr, isysroot, Out, /*AllowASTWithErrors=*/true), d964 1 a964 1 bool HandleTopLevelDecl(DeclGroupRef D) override { d979 1 a979 1 void HandleTranslationUnit(ASTContext &Ctx) override { d1005 1 a1005 1 raw_ostream *OS = nullptr; d1008 1 a1008 1 return nullptr; d1055 2 a1056 2 SavedMainFileBuffer = nullptr; d1063 1 a1063 1 std::unique_ptr Clang(new CompilerInstance()); d1101 1 d1104 1 a1104 1 // Re-use the existing FileManager d1108 4 a1111 4 Ctx = nullptr; PP = nullptr; Reader = nullptr; d1149 4 a1152 4 std::unique_ptr Act( new TopLevelDeclTrackerAction(*this)); d1181 1 a1181 1 SavedMainFileBuffer = nullptr; d1221 1 a1221 1 llvm::MemoryBuffer *Buffer = nullptr; d1243 2 a1244 1 return std::make_pair(nullptr, std::make_pair(0, true)); d1277 2 a1278 2 return std::make_pair(nullptr, std::make_pair(0, true)); d1287 14 d1414 1 a1414 1 std::unique_ptr OwnedPreambleBuffer; d1426 1 a1426 1 return nullptr; d1436 1 d1509 5 a1513 2 return llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.first->getBuffer(), FrontendOpts.Inputs[0].getFile()); d1520 1 a1520 1 return nullptr; d1530 1 a1530 1 return nullptr; d1538 1 a1538 1 return nullptr; d1547 1 a1547 1 return nullptr; d1553 10 d1575 7 a1581 2 = llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.first->getBuffer().slice(0, Preamble.size()), MainFilename); d1595 1 a1595 1 std::unique_ptr Clang(new CompilerInstance()); d1616 1 a1616 1 return nullptr; d1639 1 a1639 6 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(Clang->getInvocation(), getDiagnostics()); if (!VFS) return nullptr; d1641 1 a1641 1 Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS)); d1646 2 a1647 2 std::unique_ptr Act; d1655 1 a1655 1 return nullptr; d1684 1 a1684 1 return nullptr; d1730 3 a1732 2 return llvm::MemoryBuffer::getMemBufferCopy(NewPreamble.first->getBuffer(), MainFilename); d1751 1 a1751 4 // Steal the created target, context, and preprocessor if they have been // created. assert(CI.hasInvocation() && "missing invocation"); LangOpts = CI.getInvocation().getLangOpts(); d1754 5 a1758 8 if (CI.hasASTContext()) Ctx = &CI.getASTContext(); if (CI.hasPreprocessor()) PP = &CI.getPreprocessor(); CI.setSourceManager(nullptr); CI.setFileManager(nullptr); if (CI.hasTarget()) Target = &CI.getTarget(); d1794 1 a1794 1 std::unique_ptr AST; d1796 1 a1796 1 ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); d1800 1 a1800 5 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); d1805 1 a1805 1 return AST.release(); d1808 13 a1820 7 ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( CompilerInvocation *CI, IntrusiveRefCntPtr Diags, ASTFrontendAction *Action, ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile, std::unique_ptr *ErrAST) { d1823 1 a1823 1 std::unique_ptr OwnAST; a1828 2 if (!AST) return nullptr; d1857 1 a1857 1 std::unique_ptr Clang(new CompilerInstance()); d1874 1 a1874 1 return nullptr; d1891 4 a1894 4 AST->Ctx = nullptr; AST->PP = nullptr; AST->Reader = nullptr; d1903 1 a1903 1 std::unique_ptr TrackerAct; d1918 1 a1918 1 return nullptr; d1936 1 a1936 1 return nullptr; d1945 1 a1945 1 return OwnAST.release(); d1959 1 a1959 1 llvm::MemoryBuffer *OverrideMainBuffer = nullptr; d1976 9 a1984 5 std::unique_ptr ASTUnit::LoadFromCompilerInvocation( CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile) { d1986 3 a1988 2 std::unique_ptr AST(new ASTUnit(false)); ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); d1998 1 a1998 5 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); d2008 1 a2008 3 if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) return nullptr; return AST; d2011 17 a2027 10 ASTUnit *ASTUnit::LoadFromCommandLine( const char **ArgBegin, const char **ArgEnd, IntrusiveRefCntPtr Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, ArrayRef RemappedFiles, bool RemappedFilesKeepOriginalName, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies, bool UserFilesAreVolatile, bool ForSerialization, std::unique_ptr *ErrAST) { d2047 1 a2047 1 return nullptr; d2065 1 a2065 1 std::unique_ptr AST; d2069 1 a2069 1 Diags = nullptr; // Zero out now to ease cleanup during crash recovery. d2071 1 a2071 5 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); d2084 2 a2085 2 CI = nullptr; // Zero out now to ease cleanup during crash recovery. d2097 1 a2097 1 return nullptr; d2100 1 a2100 1 return AST.release(); d2129 1 a2129 1 llvm::MemoryBuffer *OverrideMainBuffer = nullptr; d2196 9 a2204 8 void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) override; void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates) override { d2207 2 a2208 2 CodeCompletionAllocator &getAllocator() override { d2212 1 a2212 1 CodeCompletionTUInfo &getCodeCompletionTUInfo() override { d2434 1 a2434 1 std::unique_ptr Clang(new CompilerInstance()); d2454 1 a2454 1 Clang->setInvocation(nullptr); d2495 1 a2495 1 llvm::MemoryBuffer *OverrideMainBuffer = nullptr; d2531 2 a2532 2 std::unique_ptr Act; d2577 1 a2577 1 Writer.WriteAST(S, std::string(), nullptr, "", hasErrors); d2676 1 a2676 1 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); d2718 1 a2718 2 std::make_pair(Offset, (Decl *)nullptr), llvm::less_first()); d2731 1 a2731 1 std::make_pair(Offset + Length, (Decl *)nullptr), llvm::less_first()); d2859 1 a2859 1 std::tie(MDI, MDE) = Reader->getModuleFileLevelDecls(Mod); d2881 1 a2881 1 PCHLocatorInfo() : Mod(nullptr) {} d2904 1 a2904 1 return nullptr; d2911 1 a2911 1 return nullptr; @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @d50 1 d250 1 a250 1 if (Invocation.get() && OwnsRemappedFileBuffers) { d252 6 a257 2 for (const auto &RB : PPOpts.RemappedFileBuffers) delete RB.second; d507 1 a507 1 std::shared_ptr &TargetOpts; d513 8 a520 5 ASTInfoCollector(Preprocessor &PP, ASTContext &Context, LangOptions &LangOpt, std::shared_ptr &TargetOpts, IntrusiveRefCntPtr &Target, unsigned &Counter) : PP(PP), Context(Context), LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target), Counter(Counter), InitializedLanguage(false) {} d539 4 a542 4 this->TargetOpts = std::make_shared(TargetOpts); Target = TargetInfo::CreateTargetInfo(PP.getDiagnostics(), this->TargetOpts); d562 1 a562 1 Target->adjust(LangOpt); d659 1 a659 1 if (!Diags.get()) { d688 1 a688 1 DiagCleanup(Diags.get()); d1061 1 a1061 1 Clang->setInvocation(CCInvocation.get()); d1069 2 a1070 2 Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); d1080 1 a1080 1 Clang->getTarget().adjust(Clang->getLangOpts()); d1090 1 a1090 1 LangOpts = Clang->getInvocation().LangOpts; d1092 1 a1092 7 IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(Clang->getInvocation(), getDiagnostics()); if (!VFS) { delete OverrideMainBuffer; return true; } FileMgr = new FileManager(FileSystemOpts, VFS); d1214 6 a1219 2 for (const auto &RF : PreprocessorOpts.RemappedFiles) { std::string MPath(RF.first); d1228 2 a1229 2 Buffer = getBufferForFile(RF.second); d1239 6 a1244 2 for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { std::string MPath(RB.first); d1253 2 a1254 2 Buffer = const_cast(RB.second); d1420 5 a1424 4 for (const auto &R : PreprocessorOpts.RemappedFiles) { if (AnyFileChanged) break; d1426 1 a1426 1 if (FileMgr->getNoncachedStatValue(R.second, Status)) { d1433 1 a1433 1 OverriddenFiles[R.first] = PreambleFileHash::createForFile( d1436 7 a1442 6 for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { if (AnyFileChanged) break; OverriddenFiles[RB.first] = PreambleFileHash::createForMemoryBuffer(RB.second); d1562 2 a1563 2 Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); d1568 2 a1569 1 PreprocessorOpts.RemappedFileBuffers.pop_back(); d1577 1 a1577 1 Clang->getTarget().adjust(Clang->getLangOpts()); a1605 3 auto PreambleDepCollector = std::make_shared(); Clang->addDependencyCollector(PreambleDepCollector); d1612 2 a1613 1 PreprocessorOpts.RemappedFileBuffers.pop_back(); d1641 2 a1642 1 PreprocessorOpts.RemappedFileBuffers.pop_back(); d1654 11 a1664 3 for (auto &Filename : PreambleDepCollector->getDependencies()) { const FileEntry *File = Clang->getFileManager().getFile(Filename); if (!File || File == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())) d1666 1 d1669 1 a1669 1 File->getSize(), ModTime); d1671 1 a1671 1 llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File); d1676 1 a1676 1 d1678 3 a1680 2 PreprocessorOpts.RemappedFileBuffers.pop_back(); d1712 1 a1712 1 LangOpts = CI.getInvocation().LangOpts; d1813 1 a1813 1 DiagCleanup(Diags.get()); d1835 2 a1836 2 Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); d1844 1 a1844 1 Clang->getTarget().adjust(Clang->getLangOpts()); d1969 1 a1969 1 DiagCleanup(Diags.get()); d1986 1 a1986 1 if (!Diags.get()) { d2076 7 a2082 3 for (const auto &RB : PPOpts.RemappedFileBuffers) delete RB.second; d2412 2 a2413 2 Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); d2423 1 a2423 1 Clang->getTarget().adjust(Clang->getLangOpts()); @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d108 1 a108 2 typedef llvm::DenseMap> OnDiskDataMap; d135 1 a135 1 auto &D = M[AU]; d137 1 a137 1 D = llvm::make_unique(); d153 1 d222 2 a223 2 PreambleRebuildCounter(0), NumWarningsInPreamble(0), d254 3 d514 2 a515 2 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override { a594 1 std::unique_ptr OwningPreviousClient; d602 2 a603 3 OwningPreviousClient = Diags.takeClient(); PreviousClient = Diags.getClient(); Diags.setClient(&Client, false); d608 4 a611 2 if (Diags.getClient() == &Client) Diags.setClient(PreviousClient, !!OwningPreviousClient.release()); d641 2 a642 2 std::unique_ptr ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) { d644 1 a644 6 auto Buffer = FileMgr->getBufferForFile(Filename); if (Buffer) return std::move(*Buffer); if (ErrorStr) *ErrorStr = Buffer.getError().message(); return nullptr; d648 2 a649 1 void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr Diags, d651 10 a660 2 assert(Diags.get() && "no DiagnosticsEngine was provided"); if (CaptureDiagnostics) d662 1 d665 8 a672 5 std::unique_ptr ASTUnit::LoadFromASTFile( const std::string &Filename, IntrusiveRefCntPtr Diags, const FileSystemOptions &FileSystemOpts, bool OnlyLocalDecls, ArrayRef RemappedFiles, bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, bool UserFilesAreVolatile) { d682 1 a682 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d708 1 a708 1 HeaderSearch &HeaderInfo = *AST->HeaderInfo; d731 4 a734 3 AST->Reader->setListener(llvm::make_unique( *AST->PP, Context, AST->ASTFileLangOpts, AST->TargetOpts, AST->Target, Counter)); d771 1 a771 1 return AST; d894 2 a895 2 std::unique_ptr CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { d897 3 a899 4 llvm::make_unique( Unit.getCurrentTopLevelHashValue())); return llvm::make_unique( Unit, Unit.getCurrentTopLevelHashValue()); d919 2 a920 2 std::unique_ptr CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override; d982 2 a983 3 std::unique_ptr PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { d994 4 a997 5 CI.getPreprocessor().addPPCallbacks( llvm::make_unique( Unit.getCurrentTopLevelHashValue())); return llvm::make_unique( Unit, this, CI.getPreprocessor(), Sysroot, OS); d1034 3 a1036 2 bool ASTUnit::Parse(std::unique_ptr OverrideMainBuffer) { SavedMainFileBuffer.reset(); d1038 2 a1039 1 if (!Invocation) d1041 2 a1042 1 d1063 2 a1064 1 if (!Clang->hasTarget()) d1066 1 d1086 2 a1087 1 if (!VFS) d1089 1 d1118 1 a1118 2 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer.get()); d1133 1 a1133 1 SavedMainFileBuffer = std::move(OverrideMainBuffer); d1146 1 a1146 1 if (SavedMainFileBuffer) { d1165 4 a1168 1 SavedMainFileBuffer = nullptr; d1197 3 a1199 2 ASTUnit::ComputedPreamble ASTUnit::ComputePreamble(CompilerInvocation &Invocation, unsigned MaxLines) { d1202 1 a1207 1 std::unique_ptr BufferOwner; d1218 9 a1226 3 BufferOwner = getBufferForFile(RF.second); if (!BufferOwner) return ComputedPreamble(nullptr, nullptr, 0, true); d1239 5 a1243 1 BufferOwner.reset(); d1251 6 a1256 4 if (!Buffer && !BufferOwner) { BufferOwner = getBufferForFile(FrontendOpts.Inputs[0].getFile()); if (!BufferOwner) return ComputedPreamble(nullptr, nullptr, 0, true); d1258 4 a1261 7 if (!Buffer) Buffer = BufferOwner.get(); auto Pre = Lexer::ComputePreamble(Buffer->getBuffer(), *Invocation.getLangOpts(), MaxLines); return ComputedPreamble(Buffer, std::move(BufferOwner), Pre.first, Pre.second); d1303 4 a1306 4 static ASTUnit::StandaloneFixIt makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix) { ASTUnit::StandaloneFixIt OutFix; a1311 1 return OutFix; d1314 3 a1316 4 static ASTUnit::StandaloneDiagnostic makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag) { ASTUnit::StandaloneDiagnostic OutDiag; d1322 1 a1322 1 return OutDiag; d1327 1 a1327 1 return OutDiag; d1333 6 a1338 6 for (StoredDiagnostic::fixit_iterator I = InDiag.fixit_begin(), E = InDiag.fixit_end(); I != E; ++I) OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, *I)); return OutDiag; d1361 5 a1365 5 std::unique_ptr ASTUnit::getMainBufferWithPrecompiledPreamble( const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, unsigned MaxLines) { d1372 8 a1379 1 ComputedPreamble NewPreamble = ComputePreamble(*PreambleInvocation, MaxLines); d1381 1 a1381 1 if (!NewPreamble.Size) { d1397 4 a1400 4 if (Preamble.size() == NewPreamble.Size && PreambleEndsAtStartOfLine == NewPreamble.PreambleEndsAtStartOfLine && memcmp(Preamble.getBufferStart(), NewPreamble.Buffer->getBufferStart(), NewPreamble.Size) == 0) { d1470 1 a1470 1 NewPreamble.Buffer->getBuffer(), FrontendOpts.Inputs[0].getFile()); d1515 9 a1523 6 NewPreamble.Buffer->getBufferStart(), NewPreamble.Buffer->getBufferStart() + NewPreamble.Size); PreambleEndsAtStartOfLine = NewPreamble.PreambleEndsAtStartOfLine; PreambleBuffer = llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.Buffer->getBuffer().slice(0, Preamble.size()), MainFilename); d1527 1 a1527 1 PreprocessorOpts.addRemappedFile(MainFilePath, PreambleBuffer.get()); d1610 7 a1616 5 for (stored_diag_iterator I = stored_diag_afterDriver_begin(), E = stored_diag_end(); I != E; ++I) PreambleDiagnostics.push_back( makeStandaloneDiagnostic(Clang->getLangOpts(), *I)); d1666 2 a1667 2 return llvm::MemoryBuffer::getMemBufferCopy(NewPreamble.Buffer->getBuffer(), d1691 2 a1692 2 TheSema = CI.takeSema(); Consumer = CI.takeASTConsumer(); d1738 1 a1738 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d1865 2 a1866 3 llvm::make_unique( AST->getCurrentTopLevelHashValue())); std::vector> Consumers; d1869 3 a1871 4 Consumers.push_back(llvm::make_unique( *AST, AST->getCurrentTopLevelHashValue())); Clang->setASTConsumer( llvm::make_unique(std::move(Consumers))); d1901 1 a1901 1 std::unique_ptr OverrideMainBuffer; d1904 2 a1905 1 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); d1913 3 a1915 3 MemBufferCleanup(OverrideMainBuffer.get()); return Parse(std::move(OverrideMainBuffer)); d1925 1 a1925 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d1964 5 a1968 1 assert(Diags.get() && "no DiagnosticsEngine was provided"); d2003 1 a2003 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d2005 1 d2024 1 a2024 3 // Zero out now to ease cleanup during crash recovery. CI = nullptr; Diags = nullptr; d2065 1 a2065 1 std::unique_ptr OverrideMainBuffer; d2076 2 a2077 2 bool Result = Parse(std::move(OverrideMainBuffer)); a2368 4 // Spell-checking and warnings are wasteful during code-completion. LangOpts.SpellChecking = false; CCInvocation->getDiagnosticOpts().IgnoreWarnings = true; d2430 1 a2430 1 std::unique_ptr OverrideMainBuffer; d2440 3 a2442 2 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble( *CCInvocation, false, Line - 1); d2450 1 a2450 2 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer.get()); d2456 2 a2457 2 OwnedBuffers.push_back(OverrideMainBuffer.release()); d2824 1 a2824 2 case serialization::MK_ImplicitModule: case serialization::MK_ExplicitModule: @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @d108 1 a108 2 typedef llvm::DenseMap> OnDiskDataMap; d135 1 a135 1 auto &D = M[AU]; d137 1 a137 1 D = llvm::make_unique(); d153 1 d222 2 a223 2 PreambleRebuildCounter(0), NumWarningsInPreamble(0), d254 3 d514 2 a515 2 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override { a594 1 std::unique_ptr OwningPreviousClient; d602 2 a603 3 OwningPreviousClient = Diags.takeClient(); PreviousClient = Diags.getClient(); Diags.setClient(&Client, false); d608 4 a611 2 if (Diags.getClient() == &Client) Diags.setClient(PreviousClient, !!OwningPreviousClient.release()); d641 2 a642 2 std::unique_ptr ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) { d644 1 a644 6 auto Buffer = FileMgr->getBufferForFile(Filename); if (Buffer) return std::move(*Buffer); if (ErrorStr) *ErrorStr = Buffer.getError().message(); return nullptr; d648 2 a649 1 void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr Diags, d651 10 a660 2 assert(Diags.get() && "no DiagnosticsEngine was provided"); if (CaptureDiagnostics) d662 1 d665 8 a672 5 std::unique_ptr ASTUnit::LoadFromASTFile( const std::string &Filename, IntrusiveRefCntPtr Diags, const FileSystemOptions &FileSystemOpts, bool OnlyLocalDecls, ArrayRef RemappedFiles, bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, bool UserFilesAreVolatile) { d682 1 a682 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d708 1 a708 1 HeaderSearch &HeaderInfo = *AST->HeaderInfo; d731 4 a734 3 AST->Reader->setListener(llvm::make_unique( *AST->PP, Context, AST->ASTFileLangOpts, AST->TargetOpts, AST->Target, Counter)); d771 1 a771 1 return AST; d894 2 a895 2 std::unique_ptr CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { d897 3 a899 4 llvm::make_unique( Unit.getCurrentTopLevelHashValue())); return llvm::make_unique( Unit, Unit.getCurrentTopLevelHashValue()); d919 2 a920 2 std::unique_ptr CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override; d982 2 a983 3 std::unique_ptr PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { d994 4 a997 5 CI.getPreprocessor().addPPCallbacks( llvm::make_unique( Unit.getCurrentTopLevelHashValue())); return llvm::make_unique( Unit, this, CI.getPreprocessor(), Sysroot, OS); d1034 3 a1036 2 bool ASTUnit::Parse(std::unique_ptr OverrideMainBuffer) { SavedMainFileBuffer.reset(); d1038 2 a1039 1 if (!Invocation) d1041 2 a1042 1 d1063 2 a1064 1 if (!Clang->hasTarget()) d1066 1 d1086 2 a1087 1 if (!VFS) d1089 1 d1118 1 a1118 2 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer.get()); d1133 1 a1133 1 SavedMainFileBuffer = std::move(OverrideMainBuffer); d1146 1 a1146 1 if (SavedMainFileBuffer) { d1165 4 a1168 1 SavedMainFileBuffer = nullptr; d1197 3 a1199 2 ASTUnit::ComputedPreamble ASTUnit::ComputePreamble(CompilerInvocation &Invocation, unsigned MaxLines) { d1202 1 a1207 1 std::unique_ptr BufferOwner; d1218 9 a1226 3 BufferOwner = getBufferForFile(RF.second); if (!BufferOwner) return ComputedPreamble(nullptr, nullptr, 0, true); d1239 5 a1243 1 BufferOwner.reset(); d1251 6 a1256 4 if (!Buffer && !BufferOwner) { BufferOwner = getBufferForFile(FrontendOpts.Inputs[0].getFile()); if (!BufferOwner) return ComputedPreamble(nullptr, nullptr, 0, true); d1258 4 a1261 7 if (!Buffer) Buffer = BufferOwner.get(); auto Pre = Lexer::ComputePreamble(Buffer->getBuffer(), *Invocation.getLangOpts(), MaxLines); return ComputedPreamble(Buffer, std::move(BufferOwner), Pre.first, Pre.second); d1303 4 a1306 4 static ASTUnit::StandaloneFixIt makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix) { ASTUnit::StandaloneFixIt OutFix; a1311 1 return OutFix; d1314 3 a1316 4 static ASTUnit::StandaloneDiagnostic makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag) { ASTUnit::StandaloneDiagnostic OutDiag; d1322 1 a1322 1 return OutDiag; d1327 1 a1327 1 return OutDiag; d1333 6 a1338 6 for (StoredDiagnostic::fixit_iterator I = InDiag.fixit_begin(), E = InDiag.fixit_end(); I != E; ++I) OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, *I)); return OutDiag; d1361 5 a1365 5 std::unique_ptr ASTUnit::getMainBufferWithPrecompiledPreamble( const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, unsigned MaxLines) { d1372 8 a1379 1 ComputedPreamble NewPreamble = ComputePreamble(*PreambleInvocation, MaxLines); d1381 1 a1381 1 if (!NewPreamble.Size) { d1397 4 a1400 4 if (Preamble.size() == NewPreamble.Size && PreambleEndsAtStartOfLine == NewPreamble.PreambleEndsAtStartOfLine && memcmp(Preamble.getBufferStart(), NewPreamble.Buffer->getBufferStart(), NewPreamble.Size) == 0) { d1470 1 a1470 1 NewPreamble.Buffer->getBuffer(), FrontendOpts.Inputs[0].getFile()); d1515 9 a1523 6 NewPreamble.Buffer->getBufferStart(), NewPreamble.Buffer->getBufferStart() + NewPreamble.Size); PreambleEndsAtStartOfLine = NewPreamble.PreambleEndsAtStartOfLine; PreambleBuffer = llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.Buffer->getBuffer().slice(0, Preamble.size()), MainFilename); d1527 1 a1527 1 PreprocessorOpts.addRemappedFile(MainFilePath, PreambleBuffer.get()); d1610 7 a1616 5 for (stored_diag_iterator I = stored_diag_afterDriver_begin(), E = stored_diag_end(); I != E; ++I) PreambleDiagnostics.push_back( makeStandaloneDiagnostic(Clang->getLangOpts(), *I)); d1666 2 a1667 2 return llvm::MemoryBuffer::getMemBufferCopy(NewPreamble.Buffer->getBuffer(), d1691 2 a1692 2 TheSema = CI.takeSema(); Consumer = CI.takeASTConsumer(); d1738 1 a1738 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d1865 2 a1866 3 llvm::make_unique( AST->getCurrentTopLevelHashValue())); std::vector> Consumers; d1869 3 a1871 4 Consumers.push_back(llvm::make_unique( *AST, AST->getCurrentTopLevelHashValue())); Clang->setASTConsumer( llvm::make_unique(std::move(Consumers))); d1901 1 a1901 1 std::unique_ptr OverrideMainBuffer; d1904 2 a1905 1 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); d1913 3 a1915 3 MemBufferCleanup(OverrideMainBuffer.get()); return Parse(std::move(OverrideMainBuffer)); d1925 1 a1925 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d1964 5 a1968 1 assert(Diags.get() && "no DiagnosticsEngine was provided"); d2003 1 a2003 1 ConfigureDiags(Diags, *AST, CaptureDiagnostics); d2005 1 d2024 1 a2024 3 // Zero out now to ease cleanup during crash recovery. CI = nullptr; Diags = nullptr; d2065 1 a2065 1 std::unique_ptr OverrideMainBuffer; d2076 2 a2077 2 bool Result = Parse(std::move(OverrideMainBuffer)); a2368 4 // Spell-checking and warnings are wasteful during code-completion. LangOpts.SpellChecking = false; CCInvocation->getDiagnosticOpts().IgnoreWarnings = true; d2430 1 a2430 1 std::unique_ptr OverrideMainBuffer; d2440 3 a2442 2 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble( *CCInvocation, false, Line - 1); d2450 1 a2450 2 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer.get()); d2456 2 a2457 2 OwnedBuffers.push_back(OverrideMainBuffer.release()); d2824 1 a2824 2 case serialization::MK_ImplicitModule: case serialization::MK_ExplicitModule: @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @d1 1 a1 1 //===--- ASTUnit.cpp - ASTUnit utility --------------------------*- C++ -*-===// a49 1 d123 2 a124 1 for (const auto &I : getOnDiskDataMap()) { d127 1 a127 1 I.second->Cleanup(); d154 1 a154 1 M.erase(I); d167 2 a168 2 for (StringRef File : TemporaryFiles) llvm::sys::fs::remove(File); d189 1 a189 1 ASTWriterData() : Stream(Buffer), Writer(Stream, { }) { } d357 3 a359 4 CodeCompletionContext CCContext(CodeCompletionContext::CCC_TopLevel); for (Result &R : Results) { switch (R.Kind) { d363 10 a372 8 CachedResult.Completion = R.CreateCodeCompletionString( *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = getDeclShowContexts( R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier); CachedResult.Priority = R.Priority; CachedResult.Kind = R.CursorKind; CachedResult.Availability = R.Availability; d376 1 a376 1 QualType UsageType = getDeclUsageType(*Ctx, R.Declaration); d401 2 a402 2 if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier && !R.StartsNestedNameSpecifier) { d418 2 a419 2 if (isa(R.Declaration) || isa(R.Declaration)) d427 6 a432 4 R.StartsNestedNameSpecifier = true; CachedResult.Completion = R.CreateCodeCompletionString( *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); d451 5 a455 3 CachedResult.Completion = R.CreateCodeCompletionString( *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); d469 4 a472 4 CachedResult.Priority = R.Priority; CachedResult.Kind = R.CursorKind; CachedResult.Availability = R.Availability; d523 2 a524 2 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override { d623 1 a623 1 StoredDiags.emplace_back(Level, Info); d658 4 a661 6 const std::string &Filename, const PCHContainerReader &PCHContainerRdr, IntrusiveRefCntPtr Diags, const FileSystemOptions &FileSystemOpts, bool UseDebugInfo, bool OnlyLocalDecls, ArrayRef RemappedFiles, bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, bool UserFilesAreVolatile) { d683 1 a683 1 AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat(); d692 2 a693 2 for (const auto &RemappedFile : RemappedFiles) PPOpts->addRemappedFile(RemappedFile.first, RemappedFile.second); d715 4 a718 4 AST->Reader = new ASTReader(PP, Context, PCHContainerRdr, { }, /*isysroot=*/"", /*DisableValidation=*/disableValid, AllowPCHWithCompilerErrors); a723 7 // Attach the AST reader to the AST context as an external AST // source, so that declarations will be deserialized from the // AST file as needed. // We need the external source to be set up before we read the AST, because // eagerly-deserialized declarations may use it. Context.setExternalSource(AST->Reader); d743 5 d856 2 a857 2 for (Decl *TopLevelDecl : D) handleTopLevelDecl(TopLevelDecl); d865 2 a866 2 for (Decl *TopLevelDecl : D) handleTopLevelDecl(TopLevelDecl); a923 1 raw_ostream *Out; d929 2 a930 5 : PCHGenerator(PP, "", nullptr, isysroot, std::make_shared(), ArrayRef>(), /*AllowASTWithErrors=*/true), Unit(Unit), Hash(Unit.getCurrentTopLevelHashValue()), Action(Action), Out(Out) { d934 3 a936 2 bool HandleTopLevelDecl(DeclGroupRef DG) override { for (Decl *D : DG) { a951 8 // Write the generated bitstream to "Out". *Out << getPCH(); // Make sure it hits disk now. Out->flush(); // Free the buffer. llvm::SmallVector Empty; getPCH() = std::move(Empty); d956 2 a957 1 for (Decl *D : TopLevelDecls) { d969 1 a969 1 } // anonymous namespace d976 3 a978 3 raw_ostream *OS = GeneratePCHAction::ComputeASTConsumerArguments( CI, InFile, Sysroot, OutputFile); if (!OS) d1012 4 a1015 4 for (StoredDiagnostic &SD : StoredDiagnostics) { if (SD.getLocation().isValid()) { FullSourceLoc Loc(SD.getLocation(), SM); SD.setLocation(Loc); d1025 1 a1025 2 bool ASTUnit::Parse(std::shared_ptr PCHContainerOps, std::unique_ptr OverrideMainBuffer) { d1032 1 a1032 2 std::unique_ptr Clang( new CompilerInstance(PCHContainerOps)); d1070 5 a1074 4 if (!FileMgr) { Clang->createFileManager(); FileMgr = &Clang->getFileManager(); } d1303 8 a1310 4 for (const CharSourceRange &Range : InDiag.getRanges()) OutDiag.Ranges.push_back(makeStandaloneRange(Range, SM, LangOpts)); for (const FixItHint &FixIt : InDiag.getFixIts()) OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, FixIt)); a1336 1 std::shared_ptr PCHContainerOps, d1501 1 a1501 2 std::unique_ptr Clang( new CompilerInstance(PCHContainerOps)); d1637 1 a1637 1 for (serialization::DeclID TopLevelDecl : TopLevelDeclsInPreamble) { d1640 2 a1641 1 if (Decl *D = Source.GetExternalDecl(TopLevelDecl)) d1717 4 a1720 6 CompilerInvocation *CI, std::shared_ptr PCHContainerOps, IntrusiveRefCntPtr Diags, ASTFrontendAction *Action, ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, unsigned PrecompilePreambleAfterNParses, bool CacheCodeCompletionResults, d1741 2 a1742 2 if (PrecompilePreambleAfterNParses > 0) AST->PreambleRebuildCounter = PrecompilePreambleAfterNParses; d1761 1 a1761 2 std::unique_ptr Clang( new CompilerInstance(PCHContainerOps)); d1856 1 a1856 3 bool ASTUnit::LoadFromCompilerInvocation( std::shared_ptr PCHContainerOps, unsigned PrecompilePreambleAfterNParses) { d1866 3 a1868 4 if (PrecompilePreambleAfterNParses > 0) { PreambleRebuildCounter = PrecompilePreambleAfterNParses; OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation); d1878 1 a1878 1 return Parse(PCHContainerOps, std::move(OverrideMainBuffer)); d1882 4 a1885 7 CompilerInvocation *CI, std::shared_ptr PCHContainerOps, IntrusiveRefCntPtr Diags, FileManager *FileMgr, bool OnlyLocalDecls, bool CaptureDiagnostics, unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile) { d1897 6 a1902 2 AST->FileSystemOpts = FileMgr->getFileSystemOpts(); AST->FileMgr = FileMgr; d1912 1 a1912 2 if (AST->LoadFromCompilerInvocation(PCHContainerOps, PrecompilePreambleAfterNParses)) a1918 1 std::shared_ptr PCHContainerOps, d1922 1 a1922 1 unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind, d1926 1 a1926 1 llvm::Optional ModuleFormat, std::unique_ptr *ErrAST) { d1946 3 a1948 3 for (const auto &RemappedFile : RemappedFiles) { CI->getPreprocessorOpts().addRemappedFile(RemappedFile.first, RemappedFile.second); a1958 3 if (ModuleFormat) CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue(); d1990 1 a1990 2 if (AST->LoadFromCompilerInvocation(PCHContainerOps, PrecompilePreambleAfterNParses)) { d2003 1 a2003 2 bool ASTUnit::Reparse(std::shared_ptr PCHContainerOps, ArrayRef RemappedFiles) { d2018 3 a2020 3 for (const auto &RemappedFile : RemappedFiles) { Invocation->getPreprocessorOpts().addRemappedFile(RemappedFile.first, RemappedFile.second); d2027 2 a2028 3 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation); a2029 1 FileMgr.reset(); d2036 1 a2036 1 bool Result = Parse(PCHContainerOps, std::move(OverrideMainBuffer)); d2111 1 a2111 1 } // anonymous namespace d2197 1 d2288 12 a2299 9 void ASTUnit::CodeComplete( StringRef File, unsigned Line, unsigned Column, ArrayRef RemappedFiles, bool IncludeMacros, bool IncludeCodePatterns, bool IncludeBriefComments, CodeCompleteConsumer &Consumer, std::shared_ptr PCHContainerOps, DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, FileManager &FileMgr, SmallVectorImpl &StoredDiagnostics, SmallVectorImpl &OwnedBuffers) { d2333 1 a2333 2 std::unique_ptr Clang( new CompilerInstance(PCHContainerOps)); d2378 4 a2381 3 for (const auto &RemappedFile : RemappedFiles) { PreprocessorOpts.addRemappedFile(RemappedFile.first, RemappedFile.second); OwnedBuffers.push_back(RemappedFile.second); d2405 1 a2405 1 PCHContainerOps, *CCInvocation, false, Line - 1); d2449 1 a2449 1 if (llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath)) d2463 2 a2464 2 if (llvm::sys::fs::rename(TempPath, File)) { llvm::sys::fs::remove(TempPath); d2494 1 a2494 1 ASTWriter Writer(Stream, { }); d2512 1 a2512 1 for (const StandaloneDiagnostic &SD : Diags) { d2514 1 d2529 4 a2532 3 for (const auto &Range : SD.Ranges) { SourceLocation BL = FileLoc.getLocWithOffset(Range.first); SourceLocation EL = FileLoc.getLocWithOffset(Range.second); d2538 3 a2540 1 for (const StandaloneFixIt &FixIt : SD.FixIts) { d2543 3 a2545 3 FH.CodeToInsert = FixIt.CodeToInsert; SourceLocation BL = FileLoc.getLocWithOffset(FixIt.RemoveRange.first); SourceLocation EL = FileLoc.getLocWithOffset(FixIt.RemoveRange.second); d2739 1 a2739 1 llvm::iterator_range d2748 1 a2748 1 return llvm::make_range(PPRec->local_begin(), PPRec->local_end()); d2750 2 a2751 2 return llvm::make_range(PreprocessingRecord::iterator(), PreprocessingRecord::iterator()); d2758 4 a2761 2 for (const Decl *D : Reader->getModuleFileLevelDecls(Mod)) { if (!Fn(context, D)) d2778 25 d2807 4 a2810 19 serialization::ModuleFile *Mod = nullptr; Reader->getModuleManager().visit([&Mod](serialization::ModuleFile &M) { switch (M.Kind) { case serialization::MK_ImplicitModule: case serialization::MK_ExplicitModule: return true; // skip dependencies. case serialization::MK_PCH: Mod = &M; return true; // found it. case serialization::MK_Preamble: return false; // look in dependencies. case serialization::MK_MainFile: return false; // look in dependencies. } return true; }); if (Mod) return Mod->File; d2824 5 a2828 2 NumLines = std::count(Buffer.begin(), Buffer.end(), '\n'); d2853 1 a2853 1 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = nullptr; } d2858 1 a2858 1 #endif // NDEBUG @ 1.1.1.9.2.1 log @Sync with HEAD @ text @d44 1 d249 1 a249 1 if (Invocation && OwnsRemappedFileBuffers) { d261 1 a261 3 void ASTUnit::setPreprocessor(std::shared_ptr PP) { this->PP = std::move(PP); } d350 1 a350 1 CachedCompletionAllocator = std::make_shared(); d679 1 a679 1 AST->HSOpts = std::make_shared(); d687 1 a687 1 auto PPOpts = std::make_shared(); d697 5 a701 5 AST->PP = std::make_shared( std::move(PPOpts), AST->getDiagnostics(), AST->ASTFileLangOpts, AST->getSourceManager(), HeaderInfo, *AST, /*IILookup=*/nullptr, /*OwnsHeaderSearch=*/false); d923 1 a923 1 std::unique_ptr Out; d928 3 a930 3 std::unique_ptr Out) : PCHGenerator(PP, "", isysroot, std::make_shared(), ArrayRef>(), d933 1 a933 1 Out(std::move(Out)) { d985 2 a986 3 std::unique_ptr OS = GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile); d997 1 a997 1 Unit, this, CI.getPreprocessor(), Sysroot, std::move(OS)); d1043 1 a1043 1 new CompilerInstance(std::move(PCHContainerOps))); d1049 4 a1052 1 Clang->setInvocation(std::make_shared(*Invocation)); d1141 2 a1142 1 if (SavedMainFileBuffer) d1145 1 d1347 2 a1348 2 auto PreambleInvocation = std::make_shared(PreambleInvocationIn); d1383 1 a1383 1 std::map OverriddenFiles; d1396 2 a1397 3 OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile( Status.getSize(), llvm::sys::toTimeT(Status.getLastModificationTime())); d1403 1 a1403 8 vfs::Status Status; if (FileMgr->getNoncachedStatValue(RB.first, Status)) { AnyFileChanged = true; break; } OverriddenFiles[Status.getUniqueID()] = d1408 1 a1408 1 for (llvm::StringMap::iterator d1412 2 a1413 9 vfs::Status Status; if (FileMgr->getNoncachedStatValue(F->first(), Status)) { // If we can't stat the file, assume that something horrible happened. AnyFileChanged = true; break; } std::map::iterator Overridden = OverriddenFiles.find(Status.getUniqueID()); d1423 7 a1429 3 if (Status.getSize() != uint64_t(F->second.Size) || llvm::sys::toTimeT(Status.getLastModificationTime()) != F->second.ModTime) d1509 1 a1509 1 new CompilerInstance(std::move(PCHContainerOps))); d1515 1 a1515 1 Clang->setInvocation(std::move(PreambleInvocation)); d1665 1 a1665 1 PP = CI.getPreprocessorPtr(); d1701 6 a1706 5 std::unique_ptr ASTUnit::create(std::shared_ptr CI, IntrusiveRefCntPtr Diags, bool CaptureDiagnostics, bool UserFilesAreVolatile) { std::unique_ptr AST(new ASTUnit(false)); d1708 3 a1714 3 AST->Diagnostics = Diags; AST->FileSystemOpts = CI->getFileSystemOpts(); AST->Invocation = std::move(CI); d1720 1 a1720 1 return AST; d1724 1 a1724 1 std::shared_ptr CI, d1726 1 a1726 1 IntrusiveRefCntPtr Diags, FrontendAction *Action, d1738 1 a1738 1 OwnAST = create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile); d1771 1 a1771 1 new CompilerInstance(std::move(PCHContainerOps))); d1777 1 a1777 1 Clang->setInvocation(std::move(CI)); d1815 1 a1815 1 FrontendAction *Act = Action; d1891 1 a1891 1 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer)); d1895 1 a1895 1 std::shared_ptr CI, d1912 1 a1912 1 AST->Invocation = std::move(CI); d1924 1 a1924 1 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps), d1944 2 a1945 2 std::shared_ptr CI; d1953 2 a1954 1 llvm::makeArrayRef(ArgBegin, ArgEnd), Diags); d2007 1 a2007 1 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps), d2057 1 a2057 2 bool Result = Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer)); d2324 2 a2325 1 auto CCInvocation = std::make_shared(*Invocation); d2357 1 a2357 2 auto &Inv = *CCInvocation; Clang->setInvocation(std::move(CCInvocation)); d2365 2 a2366 2 ProcessWarningOptions(Diag, Inv.getDiagnosticOpts()); d2422 1 a2422 1 PCHContainerOps, Inv, false, Line - 1); d2503 1 a2503 2 // For serialization we are lenient if the errors were only warn-as-error kind. bool hasErrors = getDiagnostics().hasUncompilableErrorOccurred(); a2797 1 case serialization::MK_PrebuiltModule: d2817 1 a2817 1 return isMainFileAST() && ASTFileLangOpts.isCompilingModule(); @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @d44 1 d249 1 a249 1 if (Invocation && OwnsRemappedFileBuffers) { d261 1 a261 3 void ASTUnit::setPreprocessor(std::shared_ptr PP) { this->PP = std::move(PP); } d350 1 a350 1 CachedCompletionAllocator = std::make_shared(); d679 1 a679 1 AST->HSOpts = std::make_shared(); d687 1 a687 1 auto PPOpts = std::make_shared(); d697 5 a701 5 AST->PP = std::make_shared( std::move(PPOpts), AST->getDiagnostics(), AST->ASTFileLangOpts, AST->getSourceManager(), HeaderInfo, *AST, /*IILookup=*/nullptr, /*OwnsHeaderSearch=*/false); d923 1 a923 1 std::unique_ptr Out; d928 3 a930 3 std::unique_ptr Out) : PCHGenerator(PP, "", isysroot, std::make_shared(), ArrayRef>(), d933 1 a933 1 Out(std::move(Out)) { d985 2 a986 3 std::unique_ptr OS = GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile); d997 1 a997 1 Unit, this, CI.getPreprocessor(), Sysroot, std::move(OS)); d1043 1 a1043 1 new CompilerInstance(std::move(PCHContainerOps))); d1049 4 a1052 1 Clang->setInvocation(std::make_shared(*Invocation)); d1141 2 a1142 1 if (SavedMainFileBuffer) d1145 1 d1347 2 a1348 2 auto PreambleInvocation = std::make_shared(PreambleInvocationIn); d1383 1 a1383 1 std::map OverriddenFiles; d1396 2 a1397 3 OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile( Status.getSize(), llvm::sys::toTimeT(Status.getLastModificationTime())); d1403 1 a1403 8 vfs::Status Status; if (FileMgr->getNoncachedStatValue(RB.first, Status)) { AnyFileChanged = true; break; } OverriddenFiles[Status.getUniqueID()] = d1408 1 a1408 1 for (llvm::StringMap::iterator d1412 2 a1413 9 vfs::Status Status; if (FileMgr->getNoncachedStatValue(F->first(), Status)) { // If we can't stat the file, assume that something horrible happened. AnyFileChanged = true; break; } std::map::iterator Overridden = OverriddenFiles.find(Status.getUniqueID()); d1423 7 a1429 3 if (Status.getSize() != uint64_t(F->second.Size) || llvm::sys::toTimeT(Status.getLastModificationTime()) != F->second.ModTime) d1509 1 a1509 1 new CompilerInstance(std::move(PCHContainerOps))); d1515 1 a1515 1 Clang->setInvocation(std::move(PreambleInvocation)); d1665 1 a1665 1 PP = CI.getPreprocessorPtr(); d1701 6 a1706 5 std::unique_ptr ASTUnit::create(std::shared_ptr CI, IntrusiveRefCntPtr Diags, bool CaptureDiagnostics, bool UserFilesAreVolatile) { std::unique_ptr AST(new ASTUnit(false)); d1708 3 a1714 3 AST->Diagnostics = Diags; AST->FileSystemOpts = CI->getFileSystemOpts(); AST->Invocation = std::move(CI); d1720 1 a1720 1 return AST; d1724 1 a1724 1 std::shared_ptr CI, d1726 1 a1726 1 IntrusiveRefCntPtr Diags, FrontendAction *Action, d1738 1 a1738 1 OwnAST = create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile); d1771 1 a1771 1 new CompilerInstance(std::move(PCHContainerOps))); d1777 1 a1777 1 Clang->setInvocation(std::move(CI)); d1815 1 a1815 1 FrontendAction *Act = Action; d1891 1 a1891 1 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer)); d1895 1 a1895 1 std::shared_ptr CI, d1912 1 a1912 1 AST->Invocation = std::move(CI); d1924 1 a1924 1 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps), d1944 2 a1945 2 std::shared_ptr CI; d1953 2 a1954 1 llvm::makeArrayRef(ArgBegin, ArgEnd), Diags); d2007 1 a2007 1 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps), d2057 1 a2057 2 bool Result = Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer)); d2324 2 a2325 1 auto CCInvocation = std::make_shared(*Invocation); d2357 1 a2357 2 auto &Inv = *CCInvocation; Clang->setInvocation(std::move(CCInvocation)); d2365 2 a2366 2 ProcessWarningOptions(Diag, Inv.getDiagnosticOpts()); d2422 1 a2422 1 PCHContainerOps, Inv, false, Line - 1); d2503 1 a2503 2 // For serialization we are lenient if the errors were only warn-as-error kind. bool hasErrors = getDiagnostics().hasUncompilableErrorOccurred(); a2797 1 case serialization::MK_PrebuiltModule: d2817 1 a2817 1 return isMainFileAST() && ASTFileLangOpts.isCompilingModule(); @ 1.1.1.11 log @Import clang r309604 from branches/release_50 @ text @a20 1 #include "clang/Basic/MemoryBufferCache.h" d81 26 d108 8 a115 5 template std::unique_ptr valueOrNull(llvm::ErrorOr> Val) { if (!Val) return nullptr; return std::move(*Val); d117 2 d120 7 a126 6 template bool moveOnNoError(llvm::ErrorOr Val, T &Output) { if (!Val) return false; Output = std::move(*Val); return true; d128 1 d130 10 a139 16 /// \brief Get a source buffer for \p MainFilePath, handling all file-to-file /// and file-to-buffer remappings inside \p Invocation. static std::unique_ptr getBufferForFileHandlingRemapping(const CompilerInvocation &Invocation, vfs::FileSystem *VFS, StringRef FilePath) { const auto &PreprocessorOpts = Invocation.getPreprocessorOpts(); // Try to determine if the main file has been remapped, either from the // command line (to another file) or directly through the compiler // invocation (to a memory buffer). llvm::MemoryBuffer *Buffer = nullptr; std::unique_ptr BufferOwner; auto FileStatus = VFS->status(FilePath); if (FileStatus) { llvm::sys::fs::UniqueID MainFileID = FileStatus->getUniqueID(); d141 3 a143 14 // Check whether there is a file-file remapping of the main file for (const auto &RF : PreprocessorOpts.RemappedFiles) { std::string MPath(RF.first); auto MPathStatus = VFS->status(MPath); if (MPathStatus) { llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID(); if (MainFileID == MID) { // We found a remapping. Try to load the resulting, remapped source. BufferOwner = valueOrNull(VFS->getBufferForFile(RF.second)); if (!BufferOwner) return nullptr; } } } d145 9 a153 14 // Check whether there is a file-buffer remapping. It supercedes the // file-file remapping. for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { std::string MPath(RB.first); auto MPathStatus = VFS->status(MPath); if (MPathStatus) { llvm::sys::fs::UniqueID MID = MPathStatus->getUniqueID(); if (MainFileID == MID) { // We found a remapping. BufferOwner.reset(); Buffer = const_cast(RB.second); } } } d155 15 d171 4 a174 5 // If the main source file was not remapped, load it now. if (!Buffer && !BufferOwner) { BufferOwner = valueOrNull(VFS->getBufferForFile(FilePath)); if (!BufferOwner) return nullptr; d176 1 d178 3 a180 6 if (BufferOwner) return BufferOwner; if (!Buffer) return nullptr; return llvm::MemoryBuffer::getMemBufferCopy(Buffer->getBuffer(), FilePath); } d188 1 a188 2 ASTWriterData(MemoryBufferCache &PCMCache) : Stream(Buffer), Writer(Stream, Buffer, PCMCache, {}) {} d195 8 d241 3 d493 1 a493 3 ASTContext *Context; HeaderSearchOptions &HSOpts; PreprocessorOptions &PPOpts; d501 1 a501 3 ASTInfoCollector(Preprocessor &PP, ASTContext *Context, HeaderSearchOptions &HSOpts, PreprocessorOptions &PPOpts, LangOptions &LangOpt, d504 2 a505 3 : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts), LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target), Counter(Counter), InitializedLanguage(false) {} a518 14 virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override { this->HSOpts = HSOpts; return false; } virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override { this->PPOpts = PPOpts; return false; } a551 3 if (!Context) return; d553 1 a553 1 Context->InitBuiltinTypes(*Target); d557 1 a557 1 Context->getCommentCommandTraits().registerCommentOptions( d564 1 a564 3 SmallVectorImpl *StoredDiags; SmallVectorImpl *StandaloneDiags; const LangOptions *LangOpts; d568 3 a570 8 StoredDiagnosticConsumer( SmallVectorImpl *StoredDiags, SmallVectorImpl *StandaloneDiags) : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags), LangOpts(nullptr), SourceMgr(nullptr) { assert((StoredDiags || StandaloneDiags) && "No output collections were passed to StoredDiagnosticConsumer."); } a573 1 this->LangOpts = &LangOpts; d592 2 a593 3 SmallVectorImpl *StoredDiags, SmallVectorImpl *StandaloneDiags) : Diags(Diags), Client(StoredDiags, StandaloneDiags), PreviousClient(nullptr) a609 4 static ASTUnit::StandaloneDiagnostic makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag); d611 1 a611 1 const Diagnostic &Info) { d618 2 a619 21 if (!Info.hasSourceManager() || &Info.getSourceManager() == SourceMgr) { StoredDiagnostic *ResultDiag = nullptr; if (StoredDiags) { StoredDiags->emplace_back(Level, Info); ResultDiag = &StoredDiags->back(); } if (StandaloneDiags) { llvm::Optional StoredDiag = llvm::None; if (!ResultDiag) { StoredDiag.emplace(Level, Info); ResultDiag = StoredDiag.getPointer(); } StandaloneDiags->push_back( makeStandaloneDiagnostic(*LangOpts, *ResultDiag)); } } } IntrusiveRefCntPtr ASTUnit::getASTReader() const { return Reader; d650 1 a650 1 Diags->setClient(new StoredDiagnosticConsumer(&AST.StoredDiagnostics, nullptr)); d655 1 a655 1 WhatToLoad ToLoad, IntrusiveRefCntPtr Diags, a670 1 AST->LangOpts = std::make_shared(); a679 1 AST->PCMCache = new MemoryBufferCache; d685 1 a685 1 AST->getLangOpts(), d687 2 a688 1 AST->PPOpts = std::make_shared(); d691 1 a691 1 AST->PPOpts->addRemappedFile(RemappedFile.first, RemappedFile.second); d699 2 a700 2 AST->PPOpts, AST->getDiagnostics(), *AST->LangOpts, AST->getSourceManager(), *AST->PCMCache, HeaderInfo, AST->ModuleLoader, d705 4 a708 4 if (ToLoad >= LoadASTOnly) AST->Ctx = new ASTContext(*AST->LangOpts, AST->getSourceManager(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); d713 1 a713 1 AST->Reader = new ASTReader(PP, AST->Ctx.get(), PCHContainerRdr, { }, d719 2 a720 2 *AST->PP, AST->Ctx.get(), *AST->HSOpts, *AST->PPOpts, *AST->LangOpts, AST->TargetOpts, AST->Target, Counter)); d727 1 a727 2 if (AST->Ctx) AST->Ctx->setExternalSource(AST->Reader); d749 2 a750 3 if (ToLoad >= LoadASTOnly) AST->Consumer.reset(new ASTConsumer); d752 3 a754 5 if (ToLoad >= LoadEverything) { AST->TheSema.reset(new Sema(PP, *AST->Ctx, *AST->Consumer)); AST->TheSema->Initialize(); AST->Reader->InitializeSema(*AST->TheSema); } d757 1 a757 1 AST->getDiagnostics().getClient()->BeginSourceFile(PP.getLangOpts(), &PP); a763 5 /// \brief Add the given macro to the hash of all top-level entities. void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) { Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash); } d774 1 a774 1 AddDefinedMacroToHash(MacroNameTok, Hash); d900 4 a903 1 class ASTUnitPreambleCallbacks : public PreambleCallbacks { d905 8 a912 1 unsigned getHash() const { return Hash; } d914 4 a917 1 std::vector takeTopLevelDecls() { return std::move(TopLevelDecls); } d919 6 a924 3 std::vector takeTopLevelDeclIDs() { return std::move(TopLevelDeclIDs); } d926 10 a935 8 void AfterPCHEmitted(ASTWriter &Writer) override { TopLevelDeclIDs.reserve(TopLevelDecls.size()); for (Decl *D : TopLevelDecls) { // Invalid top-level decls may not have been serialized. if (D->isInvalidDecl()) continue; TopLevelDeclIDs.push_back(Writer.getDeclID(D)); } d938 1 a938 1 void HandleTopLevelDecl(DeclGroupRef DG) override { d949 1 d952 24 a975 3 void HandleMacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override { AddDefinedMacroToHash(MacroNameTok, Hash); a976 6 private: unsigned Hash = 0; std::vector TopLevelDecls; std::vector TopLevelDeclIDs; llvm::SmallVector PreambleDiags; d981 21 d1037 3 a1039 2 std::unique_ptr OverrideMainBuffer, IntrusiveRefCntPtr VFS) { a1045 6 if (FileMgr && VFS) { assert(VFS == FileMgr->getVirtualFileSystem() && "VFS passed to Parse and VFS in FileMgr are different"); } else if (VFS) { Clang->setVirtualFileSystem(VFS); } d1072 1 a1072 2 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() == InputKind::Source && d1074 1 a1074 2 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() != InputKind::LLVM_IR && d1084 6 d1091 4 a1094 1 ResetForParse(); a1095 2 SourceMgr = new SourceManager(getDiagnostics(), *FileMgr, UserFilesAreVolatile); d1109 1 d1111 7 a1117 2 assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); Preamble->AddImplicitPreamble(Clang->getInvocation(), OverrideMainBuffer.get()); a1142 2 else PreambleSrcLocCache.clear(); d1168 105 d1341 1 a1341 2 const CompilerInvocation &PreambleInvocationIn, IntrusiveRefCntPtr VFS, bool AllowRebuild, d1344 16 a1359 6 auto MainFilePath = PreambleInvocationIn.getFrontendOpts().Inputs[0].getFile(); std::unique_ptr MainFileBuffer = getBufferForFileHandlingRemapping(PreambleInvocationIn, VFS.get(), MainFilePath); if (!MainFileBuffer) d1361 46 d1408 15 a1422 5 PreambleBounds Bounds = ComputePreambleBounds(*PreambleInvocationIn.getLangOpts(), MainFileBuffer.get(), MaxLines); if (!Bounds.Size) return nullptr; d1424 26 a1449 11 if (Preamble) { if (Preamble->CanReuse(PreambleInvocationIn, MainFileBuffer.get(), Bounds, VFS.get())) { // Okay! We can re-use the precompiled preamble. // Set the state of the diagnostic object to mimic its state // after parsing the preamble. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), PreambleInvocationIn.getDiagnosticOpts()); getDiagnostics().setNumWarnings(NumWarningsInPreamble); d1451 3 a1453 7 PreambleRebuildCounter = 1; return MainFileBuffer; } else { Preamble.reset(); PreambleDiagnostics.clear(); TopLevelDeclsInPreamble.clear(); PreambleRebuildCounter = 1; d1455 15 d1480 6 a1485 4 assert(!Preamble && "No Preamble should be stored at that point"); // If we aren't allowed to rebuild the precompiled preamble, just // return now. if (!AllowRebuild) d1487 31 d1519 65 a1583 36 SmallVector NewPreambleDiagsStandalone; SmallVector NewPreambleDiags; ASTUnitPreambleCallbacks Callbacks; { llvm::Optional Capture; if (CaptureDiagnostics) Capture.emplace(/*RequestCapture=*/true, *Diagnostics, &NewPreambleDiags, &NewPreambleDiagsStandalone); // We did not previously compute a preamble, or it can't be reused anyway. SimpleTimer PreambleTimer(WantTiming); PreambleTimer.setOutput("Precompiling preamble"); llvm::ErrorOr NewPreamble = PrecompiledPreamble::Build( PreambleInvocationIn, MainFileBuffer.get(), Bounds, *Diagnostics, VFS, PCHContainerOps, Callbacks); if (NewPreamble) { Preamble = std::move(*NewPreamble); PreambleRebuildCounter = 1; } else { switch (static_cast(NewPreamble.getError().value())) { case BuildPreambleError::CouldntCreateTempFile: case BuildPreambleError::PreambleIsEmpty: // Try again next time. PreambleRebuildCounter = 1; return nullptr; case BuildPreambleError::CouldntCreateTargetInfo: case BuildPreambleError::BeginSourceFileFailed: case BuildPreambleError::CouldntEmitPCH: case BuildPreambleError::CouldntCreateVFSOverlay: // These erros are more likely to repeat, retry after some period. PreambleRebuildCounter = DefaultPreambleRebuildInterval; return nullptr; } llvm_unreachable("unexpected BuildPreambleError"); } d1585 2 d1588 7 a1594 1 assert(Preamble && "Preamble wasn't built"); d1596 3 a1598 3 TopLevelDecls.clear(); TopLevelDeclsInPreamble = Callbacks.takeTopLevelDeclIDs(); PreambleTopLevelHashValue = Callbacks.getHash(); d1600 14 d1615 18 d1634 2 a1635 3 checkAndRemoveNonDriverDiags(NewPreambleDiags); StoredDiagnostics = std::move(NewPreambleDiags); PreambleDiagnostics = std::move(NewPreambleDiagsStandalone); d1645 2 a1646 1 return MainFileBuffer; a1649 2 assert(Preamble && "Should only be called when preamble was built"); a1725 1 AST->PCMCache = new MemoryBufferCache; d1805 1 a1805 2 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() == InputKind::Source && d1807 2 a1808 3 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() != InputKind::LLVM_IR && "IR inputs not support here!"); d1875 1 a1875 2 unsigned PrecompilePreambleAfterNParses, IntrusiveRefCntPtr VFS) { d1878 1 a1878 3 assert(VFS && "VFS is null"); a1881 1 getDiagnostics().Reset(); d1888 1 a1888 3 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS); getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); d1890 1 a1890 1 d1893 1 a1893 1 d1898 1 a1898 1 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS); d1932 1 a1932 2 PrecompilePreambleAfterNParses, AST->FileMgr->getVirtualFileSystem())) d1946 2 a1947 3 bool SingleFileParse, bool UserFilesAreVolatile, bool ForSerialization, llvm::Optional ModuleFormat, std::unique_ptr *ErrAST, IntrusiveRefCntPtr VFS) { d1956 2 a1957 2 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags, &StoredDiagnostics, nullptr); d1960 1 a1960 1 llvm::makeArrayRef(ArgBegin, ArgEnd), Diags, VFS); a1972 2 PPOpts.GeneratePreamble = PrecompilePreambleAfterNParses != 0; PPOpts.SingleFileParseMode = SingleFileParse; d1988 2 a1989 3 if (!VFS) VFS = vfs::getRealFileSystem(); VFS = createVFSFromCompilerInvocation(*CI, *Diags, VFS); a1992 1 AST->PCMCache = new MemoryBufferCache; d2004 1 a2004 1 AST->WriterData.reset(new ASTWriterData(*AST->PCMCache)); d2014 1 a2014 2 PrecompilePreambleAfterNParses, VFS)) { d2028 1 a2028 2 ArrayRef RemappedFiles, IntrusiveRefCntPtr VFS) { a2031 5 if (!VFS) { assert(FileMgr && "FileMgr is null on Reparse call"); VFS = FileMgr->getVirtualFileSystem(); } d2051 1 a2051 1 if (Preamble || PreambleRebuildCounter > 0) d2053 1 a2053 2 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS); d2064 1 a2064 1 Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer), VFS); a2078 13 void ASTUnit::ResetForParse() { SavedMainFileBuffer.reset(); SourceMgr.reset(); TheSema.reset(); Ctx.reset(); PP.reset(); Reader.reset(); TopLevelDecls.clear(); clearFileLevelDecls(); } d2371 1 a2371 1 &StoredDiagnostics, nullptr); d2390 1 a2390 2 assert(Clang->getFrontendOpts().Inputs[0].getKind().getFormat() == InputKind::Source && d2392 1 a2392 2 assert(Clang->getFrontendOpts().Inputs[0].getKind().getLanguage() != InputKind::LLVM_IR && d2394 1 d2419 1 a2419 1 if (Preamble) { d2421 1 d2423 1 a2423 5 auto VFS = FileMgr.getVirtualFileSystem(); auto CompleteFileStatus = VFS->status(CompleteFilePath); if (CompleteFileStatus) { llvm::sys::fs::UniqueID CompleteFileID = CompleteFileStatus->getUniqueID(); d2425 2 a2426 3 auto MainStatus = VFS->status(MainPath); if (MainStatus) { llvm::sys::fs::UniqueID MainID = MainStatus->getUniqueID(); d2429 1 a2429 1 PCHContainerOps, Inv, VFS, false, Line - 1); d2437 8 a2444 2 assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); Preamble->AddImplicitPreamble(Clang->getInvocation(), OverrideMainBuffer.get()); d2519 1 a2519 2 MemoryBufferCache PCMCache; ASTWriter Writer(Stream, Buffer, PCMCache, {}); d2534 1 a2536 1 d2544 2 a2545 10 SourceLocation FileLoc; auto ItFileID = PreambleSrcLocCache.find(SD.Filename); if (ItFileID == PreambleSrcLocCache.end()) { FileID FID = SrcMgr.translateFile(FE); FileLoc = SrcMgr.getLocForStartOfFile(FID); PreambleSrcLocCache[SD.Filename] = FileLoc; } else { FileLoc = ItFileID->getValue(); } d2682 1 a2682 1 if (Loc.isInvalid() || !Preamble || PreambleID.isInvalid()) d2686 1 a2686 1 if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble->getBounds().Size) { d2703 1 a2703 1 if (Loc.isInvalid() || !Preamble || PreambleID.isInvalid()) d2708 1 a2708 1 Offs < Preamble->getBounds().Size) { d2826 1 a2826 1 return isMainFileAST() && getLangOpts().isCompilingModule(); d2829 4 a2832 18 InputKind ASTUnit::getInputKind() const { auto &LangOpts = getLangOpts(); InputKind::Language Lang; if (LangOpts.OpenCL) Lang = InputKind::OpenCL; else if (LangOpts.CUDA) Lang = InputKind::CUDA; else if (LangOpts.RenderScript) Lang = InputKind::RenderScript; else if (LangOpts.CPlusPlus) Lang = LangOpts.ObjC1 ? InputKind::ObjCXX : InputKind::CXX; else Lang = LangOpts.ObjC1 ? InputKind::ObjC : InputKind::C; InputKind::Format Fmt = InputKind::Source; if (LangOpts.getCompilingModule() == LangOptions::CMK_ModuleMap) Fmt = InputKind::ModuleMap; d2834 1 a2834 2 // We don't know if input was preprocessed. Assume not. bool PP = false; d2836 2 a2837 1 return InputKind(Lang, Fmt, PP); @ 1.1.1.11.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ASTUnit.cpp - ASTUnit utility --------------------------------------===// d17 2 a18 11 #include "clang/AST/CommentCommandTraits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclarationName.h" #include "clang/AST/ExternalASTSource.h" #include "clang/AST/PrettyPrinter.h" #include "clang/AST/Type.h" a20 4 #include "clang/Basic/FileManager.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" a21 3 #include "clang/Basic/Module.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" a25 2 #include "clang/Frontend/CompilerInvocation.h" #include "clang/Frontend/FrontendAction.h" a29 2 #include "clang/Frontend/PCHContainerOperations.h" #include "clang/Frontend/PrecompiledPreamble.h" a31 4 #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/Lexer.h" #include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PreprocessingRecord.h" a33 3 #include "clang/Lex/Token.h" #include "clang/Sema/CodeCompleteConsumer.h" #include "clang/Sema/CodeCompleteOptions.h" a34 1 #include "clang/Serialization/ASTBitCodes.h" a36 2 #include "clang/Serialization/ContinuousRangeMap.h" #include "clang/Serialization/Module.h" d38 1 a38 9 #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/None.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" a39 5 #include "llvm/ADT/Twine.h" #include "llvm/ADT/iterator_range.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" d41 1 a41 4 #include "llvm/Support/DJB.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/FileSystem.h" d44 1 a46 1 #include a47 2 #include #include a49 5 #include #include #include #include #include a55 1 d67 5 a80 5 void setOutput(const Twine &Output) { if (WantTiming) this->Output = Output.str(); } d83 6 a88 1 } // namespace d90 7 a96 14 template static std::unique_ptr valueOrNull(llvm::ErrorOr> Val) { if (!Val) return nullptr; return std::move(*Val); } template static bool moveOnNoError(llvm::ErrorOr Val, T &Output) { if (!Val) return false; Output = std::move(*Val); return true; } d98 1 a98 1 /// Get a source buffer for \p MainFilePath, handling all file-to-file d103 1 a103 2 StringRef FilePath, bool isVolatile) { d123 1 a123 1 BufferOwner = valueOrNull(VFS->getBufferForFile(RF.second, -1, true, isVolatile)); d148 1 a148 1 BufferOwner = valueOrNull(VFS->getBufferForFile(FilePath, -1, true, isVolatile)); d159 1 d174 1 a174 1 /// After failing to build a precompiled preamble (due to d180 1 a180 1 /// Tracks the number of ASTUnit objects that are currently active. d186 14 a199 4 : MainFileIsAST(_MainFileIsAST), WantTiming(getenv("LIBCLANG_TIMING")), ShouldCacheCodeCompletionResults(false), IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), UnsafeToFree(false) { d222 2 a223 2 ClearCachedCompletionResults(); d232 1 a232 7 void ASTUnit::enableSourceFileDiagnostics() { assert(getDiagnostics().getClient() && Ctx && "Bad context for source file"); getDiagnostics().getClient()->BeginSourceFile(Ctx->getLangOpts(), PP.get()); } /// Determine the set of code-completion contexts in which this d238 1 a238 1 d240 1 a240 1 ND = ND->getUnderlyingDecl(); d243 1 a243 1 d245 2 a246 3 if (isa(ND) || isa(ND) || isa(ND) || isa(ND) || isa(ND)) { d259 1 a259 1 d264 1 a264 1 d266 1 a266 4 if (const auto *ID = dyn_cast(ND)) { // Objective-C interfaces can be used in a class property expression. if (ID->getDefinition()) Contexts |= (1LL << CodeCompletionContext::CCC_Expression); a267 1 } d272 1 a272 1 d276 1 a276 1 } else if (const auto *Record = dyn_cast(ND)) { d281 1 a281 1 d298 1 a298 1 d302 1 a302 1 d309 1 a309 1 d315 1 a315 1 d317 1 a317 1 using Result = CodeCompletionResult; d323 1 a323 1 d328 1 a328 1 for (auto &R : Results) { d342 1 a342 1 // Keep track of the type of this completion in an ASTContext-agnostic d354 1 a354 1 // ourselves the work of formatting the type string by using the d362 1 a362 1 d365 1 a365 1 d367 1 a367 1 d390 1 a390 1 if (unsigned RemainingContexts d392 2 a393 2 // If there any contexts where this completion can be a // nested-name-specifier but isn't already an option, create a d408 1 a408 1 d414 1 a414 1 d444 1 a444 1 d457 1 a457 1 /// Gathers information from ASTReader that will be used to initialize a467 1 bool InitializedLanguage = false; d469 1 d478 1 a478 1 Counter(Counter) {} d484 1 a484 1 d487 1 a487 1 d492 3 a494 3 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override { d499 3 a501 2 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override { a544 3 // Adjust printing policy based on language options. Context->setPrintingPolicy(PrintingPolicy(LangOpt)); d552 1 a552 1 /// Diagnostic consumer that saves each diagnostic it is given. d556 2 a557 2 const LangOptions *LangOpts = nullptr; SourceManager *SourceMgr = nullptr; d563 2 a564 1 : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags) { d580 1 a580 1 /// RAII object that optionally captures diagnostics, if d585 1 a585 1 DiagnosticConsumer *PreviousClient = nullptr; d589 5 a593 5 CaptureDroppedDiagnostics( bool RequestCapture, DiagnosticsEngine &Diags, SmallVectorImpl *StoredDiags, SmallVectorImpl *StandaloneDiags) : Diags(Diags), Client(StoredDiags, StandaloneDiags) { d607 1 a607 1 } // namespace d629 1 a629 1 llvm::Optional StoredDiag = None; d659 1 a659 1 auto Buffer = FileMgr->getBufferForFile(Filename, UserFilesAreVolatile); d667 1 a667 1 /// Configure the diagnostics object for use with ASTUnit. d688 1 a688 1 llvm::CrashRecoveryContextReleaseRefCleanup> d736 1 a736 1 AST->Reader = new ASTReader(PP, AST->Ctx.get(), PCHContainerRdr, {}, d789 5 a793 3 /// Add the given macro to the hash of all top-level entities. static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) { Hash = llvm::djbHash(MacroNameTok.getIdentifierInfo()->getName(), Hash); d796 1 a796 3 namespace { /// Preprocessor callback class that updates a hash value with the names d800 1 a800 1 d802 1 a802 1 explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) {} d810 2 a811 4 } // namespace /// Add the given declaration to the hash of all top-level entities. static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { d814 1 a814 1 d818 1 a818 1 d822 2 a823 2 if (const auto *ND = dyn_cast(D)) { if (const auto *EnumD = dyn_cast(D)) { d829 1 a829 1 Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash); d835 1 a835 1 Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash); d838 1 a838 1 Hash = llvm::djbHash(NameStr, Hash); d843 2 a844 2 if (const auto *ImportD = dyn_cast(D)) { if (const Module *Mod = ImportD->getImportedModule()) { d846 1 a846 1 Hash = llvm::djbHash(ModName, Hash); a851 2 namespace { d855 1 a855 1 d858 1 a858 1 : Unit(_Unit), Hash(Hash) { d881 1 a881 1 if (auto *NSD = dyn_cast(D)) { d888 1 a888 1 for (auto *TopLevelDecl : D) d897 1 a897 1 for (auto *TopLevelDecl : D) a926 1 d928 1 a928 1 return Unit.getTranslationUnitKind(); d944 1 a944 1 for (const auto *D : TopLevelDecls) { d953 1 a953 1 for (auto *D : DG) { d965 3 a967 2 std::unique_ptr createPPCallbacks() override { return llvm::make_unique(Hash); d977 1 a977 1 } // namespace d1000 1 a1000 1 for (auto &SD : StoredDiagnostics) { a1018 13 auto CCInvocation = std::make_shared(*Invocation); if (OverrideMainBuffer) { assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); IntrusiveRefCntPtr OldVFS = VFS; Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get()); if (OldVFS != VFS && FileMgr) { assert(OldVFS == FileMgr->getVirtualFileSystem() && "VFS passed to Parse and VFS in FileMgr are different"); FileMgr = new FileManager(FileMgr->getFileSystemOpts(), VFS); } } d1033 1 a1033 1 Clang->setInvocation(CCInvocation); d1035 1 a1035 1 d1039 1 a1039 1 d1051 1 a1051 1 d1080 1 a1080 1 d1083 1 a1083 1 d1087 3 d1121 1 a1121 1 d1178 1 a1178 1 for (const auto &Range : InDiag.getRanges()) d1180 1 a1180 1 for (const auto &FixIt : InDiag.getFixIts()) d1186 1 a1186 1 /// Attempt to build or re-use a precompiled preamble when (re-)parsing d1190 1 a1190 1 /// non-trivial preamble is found, it will precompile that preamble into a d1193 1 a1193 1 /// this routine will determine if it is still valid and, if so, avoid d1209 1 a1209 1 CompilerInvocation &PreambleInvocationIn, d1212 1 d1217 1 a1217 1 MainFilePath, UserFilesAreVolatile); a1244 1 PreambleSrcLocCache.clear(); a1275 5 const bool PreviousSkipFunctionBodies = PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies; if (SkipFunctionBodies == SkipFunctionBodiesScope::Preamble) PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = true; d1278 1 a1278 5 PCHContainerOps, /*StoreInMemory=*/false, Callbacks); PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = PreviousSkipFunctionBodies; d1292 1 d1330 1 a1330 1 for (const auto TopLevelDecl : TopLevelDeclsInPreamble) { d1374 1 a1374 1 return {}; d1379 1 a1379 1 return {}; d1394 2 d1428 1 a1428 1 d1446 1 a1446 1 llvm::CrashRecoveryContextReleaseRefCleanup> d1464 1 a1464 1 d1468 1 a1468 1 d1480 1 a1480 1 d1498 1 a1498 1 d1544 1 a1544 1 d1609 1 a1609 1 d1614 1 a1614 1 llvm::CrashRecoveryContextReleaseRefCleanup> d1632 1 a1632 1 bool AllowPCHWithCompilerErrors, SkipFunctionBodiesScope SkipFunctionBodies, d1643 1 d1647 1 a1647 1 CI = createInvocationFromCommandLine( d1661 1 d1663 1 a1663 1 d1667 1 a1667 2 CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies == SkipFunctionBodiesScope::PreambleAndMainFile; a1674 2 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); AST->StoredDiagnostics.swap(StoredDiagnostics); d1681 2 d1692 2 a1694 1 AST->SkipFunctionBodies = SkipFunctionBodies; d1732 1 a1732 1 d1754 1 d1766 1 a1766 1 // If we're caching global code-completion results, and the top-level d1775 1 a1775 1 d1797 1 a1797 2 /// Code completion consumer that combines the cached code-completion d1799 1 a1799 1 /// then passes the result on to d1804 1 a1804 1 d1808 3 a1810 2 : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), AST(AST), Next(Next) { d1813 1 a1813 1 NormalContexts d1852 1 d1854 1 a1854 3 } // namespace /// Helper function that computes which global names are hidden by the d1882 1 a1882 1 d1888 1 a1888 1 d1906 2 a1907 2 using Result = CodeCompletionResult; d1911 1 a1911 1 d1919 1 a1919 1 unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | d1926 1 a1926 1 d1929 1 a1929 1 d1941 1 a1941 1 unsigned NumResults) { d1949 1 a1949 1 using Result = CodeCompletionResult; d1951 1 a1951 1 for (ASTUnit::cached_completion_iterator d1955 1 a1955 1 // If the context we are in matches any of the contexts we are d1959 1 a1959 1 d1962 1 a1962 1 CalculateHiddenNames(Context, Results, NumResults, S.Context, d1967 1 a1967 1 d1973 1 a1973 1 d1981 1 a1981 1 Context.getPreferredType()->isAnyPointerType()); d2000 1 a2000 1 d2012 1 a2012 1 d2016 1 a2016 1 d2023 1 a2023 1 a2054 2 CodeCompleteOpts.LoadExternal = Consumer.loadExternal(); CodeCompleteOpts.IncludeFixIts = Consumer.includeFixIts(); d2079 1 a2079 1 d2082 2 a2083 2 CaptureDroppedDiagnostics Capture(true, Clang->getDiagnostics(), d2094 1 a2094 1 d2100 1 a2100 1 d2109 1 a2109 1 d2155 2 a2156 10 assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); auto VFS = FileMgr.getVirtualFileSystem(); Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS, OverrideMainBuffer.get()); // FIXME: there is no way to update VFS if it was changed by // AddImplicitPreamble as FileMgr is accepted as a parameter by this method. // We use on-disk preambles instead and rely on FileMgr's VFS to ensure the // PCH files are always readable. d2188 1 a2188 1 // FIXME: Can we somehow regenerate the stat cache here, or do we need to d2236 1 a2236 1 using SLocRemap = ContinuousRangeMap; d2250 1 a2250 1 for (const auto &SD : Diags) { d2282 1 a2282 1 for (const auto &FixIt : SD.FixIts) { d2291 1 a2291 1 Result.push_back(StoredDiagnostic(SD.Level, SD.ID, d2299 1 a2299 1 d2376 1 a2376 1 d2395 1 a2395 1 /// If \arg Loc is a loaded location from the preamble, returns d2398 1 a2398 1 SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) const { d2416 1 a2416 1 /// If \arg Loc is a local location of the main file but inside the d2419 1 a2419 1 SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) const { d2437 1 a2437 1 bool ASTUnit::isInPreambleFileID(SourceLocation Loc) const { d2441 1 a2441 1 d2444 1 a2444 1 d2448 1 a2448 1 bool ASTUnit::isInMainFileID(SourceLocation Loc) const { d2452 1 a2452 1 d2455 1 a2455 1 d2459 1 a2459 1 SourceLocation ASTUnit::getEndOfPreambleFileID() const { d2463 1 a2463 1 d2465 1 a2465 1 return {}; d2470 1 a2470 1 SourceLocation ASTUnit::getStartOfMainFileID() const { d2474 1 a2474 1 d2476 2 a2477 2 return {}; d2500 1 a2500 1 for (const auto *D : Reader->getModuleFileLevelDecls(Mod)) { d2546 1 a2546 1 bool ASTUnit::isModuleFile() const { @ 1.1.1.11.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.11.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ASTUnit.cpp - ASTUnit utility --------------------------------------===// d17 2 a18 11 #include "clang/AST/CommentCommandTraits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclarationName.h" #include "clang/AST/ExternalASTSource.h" #include "clang/AST/PrettyPrinter.h" #include "clang/AST/Type.h" a20 4 #include "clang/Basic/FileManager.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" a21 3 #include "clang/Basic/Module.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" a25 2 #include "clang/Frontend/CompilerInvocation.h" #include "clang/Frontend/FrontendAction.h" a29 2 #include "clang/Frontend/PCHContainerOperations.h" #include "clang/Frontend/PrecompiledPreamble.h" a31 4 #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/Lexer.h" #include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PreprocessingRecord.h" a33 3 #include "clang/Lex/Token.h" #include "clang/Sema/CodeCompleteConsumer.h" #include "clang/Sema/CodeCompleteOptions.h" a34 1 #include "clang/Serialization/ASTBitCodes.h" a36 2 #include "clang/Serialization/ContinuousRangeMap.h" #include "clang/Serialization/Module.h" d38 1 a38 9 #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/None.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" a39 5 #include "llvm/ADT/Twine.h" #include "llvm/ADT/iterator_range.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" d41 1 a41 4 #include "llvm/Support/DJB.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/FileSystem.h" d44 1 a46 1 #include a47 2 #include #include a49 5 #include #include #include #include #include a55 1 d67 5 a80 5 void setOutput(const Twine &Output) { if (WantTiming) this->Output = Output.str(); } d83 6 a88 1 } // namespace d90 7 a96 14 template static std::unique_ptr valueOrNull(llvm::ErrorOr> Val) { if (!Val) return nullptr; return std::move(*Val); } template static bool moveOnNoError(llvm::ErrorOr Val, T &Output) { if (!Val) return false; Output = std::move(*Val); return true; } d98 1 a98 1 /// Get a source buffer for \p MainFilePath, handling all file-to-file d103 1 a103 2 StringRef FilePath, bool isVolatile) { d123 1 a123 1 BufferOwner = valueOrNull(VFS->getBufferForFile(RF.second, -1, true, isVolatile)); d148 1 a148 1 BufferOwner = valueOrNull(VFS->getBufferForFile(FilePath, -1, true, isVolatile)); d159 1 d174 1 a174 1 /// After failing to build a precompiled preamble (due to d180 1 a180 1 /// Tracks the number of ASTUnit objects that are currently active. d186 14 a199 4 : MainFileIsAST(_MainFileIsAST), WantTiming(getenv("LIBCLANG_TIMING")), ShouldCacheCodeCompletionResults(false), IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), UnsafeToFree(false) { d222 2 a223 2 ClearCachedCompletionResults(); d232 1 a232 7 void ASTUnit::enableSourceFileDiagnostics() { assert(getDiagnostics().getClient() && Ctx && "Bad context for source file"); getDiagnostics().getClient()->BeginSourceFile(Ctx->getLangOpts(), PP.get()); } /// Determine the set of code-completion contexts in which this d238 1 a238 1 d240 1 a240 1 ND = ND->getUnderlyingDecl(); d243 1 a243 1 d245 2 a246 3 if (isa(ND) || isa(ND) || isa(ND) || isa(ND) || isa(ND)) { d259 1 a259 1 d264 1 a264 1 d266 1 a266 4 if (const auto *ID = dyn_cast(ND)) { // Objective-C interfaces can be used in a class property expression. if (ID->getDefinition()) Contexts |= (1LL << CodeCompletionContext::CCC_Expression); a267 1 } d272 1 a272 1 d276 1 a276 1 } else if (const auto *Record = dyn_cast(ND)) { d281 1 a281 1 d298 1 a298 1 d302 1 a302 1 d309 1 a309 1 d315 1 a315 1 d317 1 a317 1 using Result = CodeCompletionResult; d323 1 a323 1 d328 1 a328 1 for (auto &R : Results) { d342 1 a342 1 // Keep track of the type of this completion in an ASTContext-agnostic d354 1 a354 1 // ourselves the work of formatting the type string by using the d362 1 a362 1 d365 1 a365 1 d367 1 a367 1 d390 1 a390 1 if (unsigned RemainingContexts d392 2 a393 2 // If there any contexts where this completion can be a // nested-name-specifier but isn't already an option, create a d408 1 a408 1 d414 1 a414 1 d444 1 a444 1 d457 1 a457 1 /// Gathers information from ASTReader that will be used to initialize a467 1 bool InitializedLanguage = false; d469 1 d478 1 a478 1 Counter(Counter) {} d484 1 a484 1 d487 1 a487 1 d492 3 a494 3 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override { d499 3 a501 2 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override { a544 3 // Adjust printing policy based on language options. Context->setPrintingPolicy(PrintingPolicy(LangOpt)); d552 1 a552 1 /// Diagnostic consumer that saves each diagnostic it is given. d556 2 a557 2 const LangOptions *LangOpts = nullptr; SourceManager *SourceMgr = nullptr; d563 2 a564 1 : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags) { d580 1 a580 1 /// RAII object that optionally captures diagnostics, if d585 1 a585 1 DiagnosticConsumer *PreviousClient = nullptr; d589 5 a593 5 CaptureDroppedDiagnostics( bool RequestCapture, DiagnosticsEngine &Diags, SmallVectorImpl *StoredDiags, SmallVectorImpl *StandaloneDiags) : Diags(Diags), Client(StoredDiags, StandaloneDiags) { d607 1 a607 1 } // namespace d629 1 a629 1 llvm::Optional StoredDiag = None; d659 1 a659 1 auto Buffer = FileMgr->getBufferForFile(Filename, UserFilesAreVolatile); d667 1 a667 1 /// Configure the diagnostics object for use with ASTUnit. d688 1 a688 1 llvm::CrashRecoveryContextReleaseRefCleanup> d736 1 a736 1 AST->Reader = new ASTReader(PP, AST->Ctx.get(), PCHContainerRdr, {}, d789 5 a793 3 /// Add the given macro to the hash of all top-level entities. static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) { Hash = llvm::djbHash(MacroNameTok.getIdentifierInfo()->getName(), Hash); d796 1 a796 3 namespace { /// Preprocessor callback class that updates a hash value with the names d800 1 a800 1 d802 1 a802 1 explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) {} d810 2 a811 4 } // namespace /// Add the given declaration to the hash of all top-level entities. static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { d814 1 a814 1 d818 1 a818 1 d822 2 a823 2 if (const auto *ND = dyn_cast(D)) { if (const auto *EnumD = dyn_cast(D)) { d829 1 a829 1 Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash); d835 1 a835 1 Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash); d838 1 a838 1 Hash = llvm::djbHash(NameStr, Hash); d843 2 a844 2 if (const auto *ImportD = dyn_cast(D)) { if (const Module *Mod = ImportD->getImportedModule()) { d846 1 a846 1 Hash = llvm::djbHash(ModName, Hash); a851 2 namespace { d855 1 a855 1 d858 1 a858 1 : Unit(_Unit), Hash(Hash) { d881 1 a881 1 if (auto *NSD = dyn_cast(D)) { d888 1 a888 1 for (auto *TopLevelDecl : D) d897 1 a897 1 for (auto *TopLevelDecl : D) a926 1 d928 1 a928 1 return Unit.getTranslationUnitKind(); d944 1 a944 1 for (const auto *D : TopLevelDecls) { d953 1 a953 1 for (auto *D : DG) { d965 3 a967 2 std::unique_ptr createPPCallbacks() override { return llvm::make_unique(Hash); d977 1 a977 1 } // namespace d1000 1 a1000 1 for (auto &SD : StoredDiagnostics) { a1018 13 auto CCInvocation = std::make_shared(*Invocation); if (OverrideMainBuffer) { assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); IntrusiveRefCntPtr OldVFS = VFS; Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get()); if (OldVFS != VFS && FileMgr) { assert(OldVFS == FileMgr->getVirtualFileSystem() && "VFS passed to Parse and VFS in FileMgr are different"); FileMgr = new FileManager(FileMgr->getFileSystemOpts(), VFS); } } d1033 1 a1033 1 Clang->setInvocation(CCInvocation); d1035 1 a1035 1 d1039 1 a1039 1 d1051 1 a1051 1 d1080 1 a1080 1 d1083 1 a1083 1 d1087 3 d1121 1 a1121 1 d1178 1 a1178 1 for (const auto &Range : InDiag.getRanges()) d1180 1 a1180 1 for (const auto &FixIt : InDiag.getFixIts()) d1186 1 a1186 1 /// Attempt to build or re-use a precompiled preamble when (re-)parsing d1190 1 a1190 1 /// non-trivial preamble is found, it will precompile that preamble into a d1193 1 a1193 1 /// this routine will determine if it is still valid and, if so, avoid d1209 1 a1209 1 CompilerInvocation &PreambleInvocationIn, d1212 1 d1217 1 a1217 1 MainFilePath, UserFilesAreVolatile); a1244 1 PreambleSrcLocCache.clear(); a1275 5 const bool PreviousSkipFunctionBodies = PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies; if (SkipFunctionBodies == SkipFunctionBodiesScope::Preamble) PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = true; d1278 1 a1278 5 PCHContainerOps, /*StoreInMemory=*/false, Callbacks); PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = PreviousSkipFunctionBodies; d1292 1 d1330 1 a1330 1 for (const auto TopLevelDecl : TopLevelDeclsInPreamble) { d1374 1 a1374 1 return {}; d1379 1 a1379 1 return {}; d1394 2 d1428 1 a1428 1 d1446 1 a1446 1 llvm::CrashRecoveryContextReleaseRefCleanup> d1464 1 a1464 1 d1468 1 a1468 1 d1480 1 a1480 1 d1498 1 a1498 1 d1544 1 a1544 1 d1609 1 a1609 1 d1614 1 a1614 1 llvm::CrashRecoveryContextReleaseRefCleanup> d1632 1 a1632 1 bool AllowPCHWithCompilerErrors, SkipFunctionBodiesScope SkipFunctionBodies, d1643 1 d1647 1 a1647 1 CI = createInvocationFromCommandLine( d1661 1 d1663 1 a1663 1 d1667 1 a1667 2 CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies == SkipFunctionBodiesScope::PreambleAndMainFile; a1674 2 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); AST->StoredDiagnostics.swap(StoredDiagnostics); d1681 2 d1692 2 a1694 1 AST->SkipFunctionBodies = SkipFunctionBodies; d1732 1 a1732 1 d1754 1 d1766 1 a1766 1 // If we're caching global code-completion results, and the top-level d1775 1 a1775 1 d1797 1 a1797 2 /// Code completion consumer that combines the cached code-completion d1799 1 a1799 1 /// then passes the result on to d1804 1 a1804 1 d1808 3 a1810 2 : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), AST(AST), Next(Next) { d1813 1 a1813 1 NormalContexts d1852 1 d1854 1 a1854 3 } // namespace /// Helper function that computes which global names are hidden by the d1882 1 a1882 1 d1888 1 a1888 1 d1906 2 a1907 2 using Result = CodeCompletionResult; d1911 1 a1911 1 d1919 1 a1919 1 unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | d1926 1 a1926 1 d1929 1 a1929 1 d1941 1 a1941 1 unsigned NumResults) { d1949 1 a1949 1 using Result = CodeCompletionResult; d1951 1 a1951 1 for (ASTUnit::cached_completion_iterator d1955 1 a1955 1 // If the context we are in matches any of the contexts we are d1959 1 a1959 1 d1962 1 a1962 1 CalculateHiddenNames(Context, Results, NumResults, S.Context, d1967 1 a1967 1 d1973 1 a1973 1 d1981 1 a1981 1 Context.getPreferredType()->isAnyPointerType()); d2000 1 a2000 1 d2012 1 a2012 1 d2016 1 a2016 1 d2023 1 a2023 1 a2054 2 CodeCompleteOpts.LoadExternal = Consumer.loadExternal(); CodeCompleteOpts.IncludeFixIts = Consumer.includeFixIts(); d2079 1 a2079 1 d2082 2 a2083 2 CaptureDroppedDiagnostics Capture(true, Clang->getDiagnostics(), d2094 1 a2094 1 d2100 1 a2100 1 d2109 1 a2109 1 d2155 2 a2156 10 assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); auto VFS = FileMgr.getVirtualFileSystem(); Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS, OverrideMainBuffer.get()); // FIXME: there is no way to update VFS if it was changed by // AddImplicitPreamble as FileMgr is accepted as a parameter by this method. // We use on-disk preambles instead and rely on FileMgr's VFS to ensure the // PCH files are always readable. d2188 1 a2188 1 // FIXME: Can we somehow regenerate the stat cache here, or do we need to d2236 1 a2236 1 using SLocRemap = ContinuousRangeMap; d2250 1 a2250 1 for (const auto &SD : Diags) { d2282 1 a2282 1 for (const auto &FixIt : SD.FixIts) { d2291 1 a2291 1 Result.push_back(StoredDiagnostic(SD.Level, SD.ID, d2299 1 a2299 1 d2376 1 a2376 1 d2395 1 a2395 1 /// If \arg Loc is a loaded location from the preamble, returns d2398 1 a2398 1 SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) const { d2416 1 a2416 1 /// If \arg Loc is a local location of the main file but inside the d2419 1 a2419 1 SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) const { d2437 1 a2437 1 bool ASTUnit::isInPreambleFileID(SourceLocation Loc) const { d2441 1 a2441 1 d2444 1 a2444 1 d2448 1 a2448 1 bool ASTUnit::isInMainFileID(SourceLocation Loc) const { d2452 1 a2452 1 d2455 1 a2455 1 d2459 1 a2459 1 SourceLocation ASTUnit::getEndOfPreambleFileID() const { d2463 1 a2463 1 d2465 1 a2465 1 return {}; d2470 1 a2470 1 SourceLocation ASTUnit::getStartOfMainFileID() const { d2474 1 a2474 1 d2476 2 a2477 2 return {}; d2500 1 a2500 1 for (const auto *D : Reader->getModuleFileLevelDecls(Mod)) { d2546 1 a2546 1 bool ASTUnit::isModuleFile() const { @ 1.1.1.12 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- ASTUnit.cpp - ASTUnit utility --------------------------------------===// d17 2 a18 11 #include "clang/AST/CommentCommandTraits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclarationName.h" #include "clang/AST/ExternalASTSource.h" #include "clang/AST/PrettyPrinter.h" #include "clang/AST/Type.h" a20 4 #include "clang/Basic/FileManager.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" a21 3 #include "clang/Basic/Module.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" a25 2 #include "clang/Frontend/CompilerInvocation.h" #include "clang/Frontend/FrontendAction.h" a29 2 #include "clang/Frontend/PCHContainerOperations.h" #include "clang/Frontend/PrecompiledPreamble.h" a31 4 #include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/Lexer.h" #include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PreprocessingRecord.h" a33 3 #include "clang/Lex/Token.h" #include "clang/Sema/CodeCompleteConsumer.h" #include "clang/Sema/CodeCompleteOptions.h" a34 1 #include "clang/Serialization/ASTBitCodes.h" a36 2 #include "clang/Serialization/ContinuousRangeMap.h" #include "clang/Serialization/Module.h" d38 1 a38 9 #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/None.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" a39 5 #include "llvm/ADT/Twine.h" #include "llvm/ADT/iterator_range.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" d41 1 a41 4 #include "llvm/Support/DJB.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/FileSystem.h" d44 1 a46 1 #include a47 2 #include #include a49 5 #include #include #include #include #include a55 1 d67 5 a80 5 void setOutput(const Twine &Output) { if (WantTiming) this->Output = Output.str(); } d83 6 a88 1 } // namespace d90 7 a96 14 template static std::unique_ptr valueOrNull(llvm::ErrorOr> Val) { if (!Val) return nullptr; return std::move(*Val); } template static bool moveOnNoError(llvm::ErrorOr Val, T &Output) { if (!Val) return false; Output = std::move(*Val); return true; } d98 1 a98 1 /// Get a source buffer for \p MainFilePath, handling all file-to-file d103 1 a103 2 StringRef FilePath, bool isVolatile) { d123 1 a123 1 BufferOwner = valueOrNull(VFS->getBufferForFile(RF.second, -1, true, isVolatile)); d148 1 a148 1 BufferOwner = valueOrNull(VFS->getBufferForFile(FilePath, -1, true, isVolatile)); d159 1 d174 1 a174 1 /// After failing to build a precompiled preamble (due to d180 1 a180 1 /// Tracks the number of ASTUnit objects that are currently active. d186 14 a199 4 : MainFileIsAST(_MainFileIsAST), WantTiming(getenv("LIBCLANG_TIMING")), ShouldCacheCodeCompletionResults(false), IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), UnsafeToFree(false) { d222 2 a223 2 ClearCachedCompletionResults(); d232 1 a232 7 void ASTUnit::enableSourceFileDiagnostics() { assert(getDiagnostics().getClient() && Ctx && "Bad context for source file"); getDiagnostics().getClient()->BeginSourceFile(Ctx->getLangOpts(), PP.get()); } /// Determine the set of code-completion contexts in which this d238 1 a238 1 d240 1 a240 1 ND = ND->getUnderlyingDecl(); d243 1 a243 1 d245 2 a246 3 if (isa(ND) || isa(ND) || isa(ND) || isa(ND) || isa(ND)) { d259 1 a259 1 d264 1 a264 1 d266 1 a266 4 if (const auto *ID = dyn_cast(ND)) { // Objective-C interfaces can be used in a class property expression. if (ID->getDefinition()) Contexts |= (1LL << CodeCompletionContext::CCC_Expression); a267 1 } d272 1 a272 1 d276 1 a276 1 } else if (const auto *Record = dyn_cast(ND)) { d281 1 a281 1 d298 1 a298 1 d302 1 a302 1 d309 1 a309 1 d315 1 a315 1 d317 1 a317 1 using Result = CodeCompletionResult; d323 1 a323 1 d328 1 a328 1 for (auto &R : Results) { d342 1 a342 1 // Keep track of the type of this completion in an ASTContext-agnostic d354 1 a354 1 // ourselves the work of formatting the type string by using the d362 1 a362 1 d365 1 a365 1 d367 1 a367 1 d390 1 a390 1 if (unsigned RemainingContexts d392 2 a393 2 // If there any contexts where this completion can be a // nested-name-specifier but isn't already an option, create a d408 1 a408 1 d414 1 a414 1 d444 1 a444 1 d457 1 a457 1 /// Gathers information from ASTReader that will be used to initialize a467 1 bool InitializedLanguage = false; d469 1 d478 1 a478 1 Counter(Counter) {} d484 1 a484 1 d487 1 a487 1 d492 3 a494 3 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override { d499 3 a501 2 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override { a544 3 // Adjust printing policy based on language options. Context->setPrintingPolicy(PrintingPolicy(LangOpt)); d552 1 a552 1 /// Diagnostic consumer that saves each diagnostic it is given. d556 2 a557 2 const LangOptions *LangOpts = nullptr; SourceManager *SourceMgr = nullptr; d563 2 a564 1 : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags) { d580 1 a580 1 /// RAII object that optionally captures diagnostics, if d585 1 a585 1 DiagnosticConsumer *PreviousClient = nullptr; d589 5 a593 5 CaptureDroppedDiagnostics( bool RequestCapture, DiagnosticsEngine &Diags, SmallVectorImpl *StoredDiags, SmallVectorImpl *StandaloneDiags) : Diags(Diags), Client(StoredDiags, StandaloneDiags) { d607 1 a607 1 } // namespace d629 1 a629 1 llvm::Optional StoredDiag = None; d659 1 a659 1 auto Buffer = FileMgr->getBufferForFile(Filename, UserFilesAreVolatile); d667 1 a667 1 /// Configure the diagnostics object for use with ASTUnit. d688 1 a688 1 llvm::CrashRecoveryContextReleaseRefCleanup> d736 1 a736 1 AST->Reader = new ASTReader(PP, AST->Ctx.get(), PCHContainerRdr, {}, d789 5 a793 3 /// Add the given macro to the hash of all top-level entities. static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) { Hash = llvm::djbHash(MacroNameTok.getIdentifierInfo()->getName(), Hash); d796 1 a796 3 namespace { /// Preprocessor callback class that updates a hash value with the names d800 1 a800 1 d802 1 a802 1 explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) {} d810 2 a811 4 } // namespace /// Add the given declaration to the hash of all top-level entities. static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { d814 1 a814 1 d818 1 a818 1 d822 2 a823 2 if (const auto *ND = dyn_cast(D)) { if (const auto *EnumD = dyn_cast(D)) { d829 1 a829 1 Hash = llvm::djbHash(EI->getIdentifier()->getName(), Hash); d835 1 a835 1 Hash = llvm::djbHash(ND->getIdentifier()->getName(), Hash); d838 1 a838 1 Hash = llvm::djbHash(NameStr, Hash); d843 2 a844 2 if (const auto *ImportD = dyn_cast(D)) { if (const Module *Mod = ImportD->getImportedModule()) { d846 1 a846 1 Hash = llvm::djbHash(ModName, Hash); a851 2 namespace { d855 1 a855 1 d858 1 a858 1 : Unit(_Unit), Hash(Hash) { d881 1 a881 1 if (auto *NSD = dyn_cast(D)) { d888 1 a888 1 for (auto *TopLevelDecl : D) d897 1 a897 1 for (auto *TopLevelDecl : D) a926 1 d928 1 a928 1 return Unit.getTranslationUnitKind(); d944 1 a944 1 for (const auto *D : TopLevelDecls) { d953 1 a953 1 for (auto *D : DG) { d965 3 a967 2 std::unique_ptr createPPCallbacks() override { return llvm::make_unique(Hash); d977 1 a977 1 } // namespace d1000 1 a1000 1 for (auto &SD : StoredDiagnostics) { a1018 13 auto CCInvocation = std::make_shared(*Invocation); if (OverrideMainBuffer) { assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); IntrusiveRefCntPtr OldVFS = VFS; Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get()); if (OldVFS != VFS && FileMgr) { assert(OldVFS == FileMgr->getVirtualFileSystem() && "VFS passed to Parse and VFS in FileMgr are different"); FileMgr = new FileManager(FileMgr->getFileSystemOpts(), VFS); } } d1033 1 a1033 1 Clang->setInvocation(CCInvocation); d1035 1 a1035 1 d1039 1 a1039 1 d1051 1 a1051 1 d1080 1 a1080 1 d1083 1 a1083 1 d1087 3 d1121 1 a1121 1 d1178 1 a1178 1 for (const auto &Range : InDiag.getRanges()) d1180 1 a1180 1 for (const auto &FixIt : InDiag.getFixIts()) d1186 1 a1186 1 /// Attempt to build or re-use a precompiled preamble when (re-)parsing d1190 1 a1190 1 /// non-trivial preamble is found, it will precompile that preamble into a d1193 1 a1193 1 /// this routine will determine if it is still valid and, if so, avoid d1209 1 a1209 1 CompilerInvocation &PreambleInvocationIn, d1212 1 d1217 1 a1217 1 MainFilePath, UserFilesAreVolatile); a1244 1 PreambleSrcLocCache.clear(); a1275 5 const bool PreviousSkipFunctionBodies = PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies; if (SkipFunctionBodies == SkipFunctionBodiesScope::Preamble) PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = true; d1278 1 a1278 5 PCHContainerOps, /*StoreInMemory=*/false, Callbacks); PreambleInvocationIn.getFrontendOpts().SkipFunctionBodies = PreviousSkipFunctionBodies; d1292 1 d1330 1 a1330 1 for (const auto TopLevelDecl : TopLevelDeclsInPreamble) { d1374 1 a1374 1 return {}; d1379 1 a1379 1 return {}; d1394 2 d1428 1 a1428 1 d1446 1 a1446 1 llvm::CrashRecoveryContextReleaseRefCleanup> d1464 1 a1464 1 d1468 1 a1468 1 d1480 1 a1480 1 d1498 1 a1498 1 d1544 1 a1544 1 d1609 1 a1609 1 d1614 1 a1614 1 llvm::CrashRecoveryContextReleaseRefCleanup> d1632 1 a1632 1 bool AllowPCHWithCompilerErrors, SkipFunctionBodiesScope SkipFunctionBodies, d1643 1 d1647 1 a1647 1 CI = createInvocationFromCommandLine( d1661 1 d1663 1 a1663 1 d1667 1 a1667 2 CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies == SkipFunctionBodiesScope::PreambleAndMainFile; a1674 2 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); AST->StoredDiagnostics.swap(StoredDiagnostics); d1681 2 d1692 2 a1694 1 AST->SkipFunctionBodies = SkipFunctionBodies; d1732 1 a1732 1 d1754 1 d1766 1 a1766 1 // If we're caching global code-completion results, and the top-level d1775 1 a1775 1 d1797 1 a1797 2 /// Code completion consumer that combines the cached code-completion d1799 1 a1799 1 /// then passes the result on to d1804 1 a1804 1 d1808 3 a1810 2 : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), AST(AST), Next(Next) { d1813 1 a1813 1 NormalContexts d1852 1 d1854 1 a1854 3 } // namespace /// Helper function that computes which global names are hidden by the d1882 1 a1882 1 d1888 1 a1888 1 d1906 2 a1907 2 using Result = CodeCompletionResult; d1911 1 a1911 1 d1919 1 a1919 1 unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | d1926 1 a1926 1 d1929 1 a1929 1 d1941 1 a1941 1 unsigned NumResults) { d1949 1 a1949 1 using Result = CodeCompletionResult; d1951 1 a1951 1 for (ASTUnit::cached_completion_iterator d1955 1 a1955 1 // If the context we are in matches any of the contexts we are d1959 1 a1959 1 d1962 1 a1962 1 CalculateHiddenNames(Context, Results, NumResults, S.Context, d1967 1 a1967 1 d1973 1 a1973 1 d1981 1 a1981 1 Context.getPreferredType()->isAnyPointerType()); d2000 1 a2000 1 d2012 1 a2012 1 d2016 1 a2016 1 d2023 1 a2023 1 a2054 2 CodeCompleteOpts.LoadExternal = Consumer.loadExternal(); CodeCompleteOpts.IncludeFixIts = Consumer.includeFixIts(); d2079 1 a2079 1 d2082 2 a2083 2 CaptureDroppedDiagnostics Capture(true, Clang->getDiagnostics(), d2094 1 a2094 1 d2100 1 a2100 1 d2109 1 a2109 1 d2155 2 a2156 10 assert(Preamble && "No preamble was built, but OverrideMainBuffer is not null"); auto VFS = FileMgr.getVirtualFileSystem(); Preamble->AddImplicitPreamble(Clang->getInvocation(), VFS, OverrideMainBuffer.get()); // FIXME: there is no way to update VFS if it was changed by // AddImplicitPreamble as FileMgr is accepted as a parameter by this method. // We use on-disk preambles instead and rely on FileMgr's VFS to ensure the // PCH files are always readable. d2188 1 a2188 1 // FIXME: Can we somehow regenerate the stat cache here, or do we need to d2236 1 a2236 1 using SLocRemap = ContinuousRangeMap; d2250 1 a2250 1 for (const auto &SD : Diags) { d2282 1 a2282 1 for (const auto &FixIt : SD.FixIts) { d2291 1 a2291 1 Result.push_back(StoredDiagnostic(SD.Level, SD.ID, d2299 1 a2299 1 d2376 1 a2376 1 d2395 1 a2395 1 /// If \arg Loc is a loaded location from the preamble, returns d2398 1 a2398 1 SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) const { d2416 1 a2416 1 /// If \arg Loc is a local location of the main file but inside the d2419 1 a2419 1 SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) const { d2437 1 a2437 1 bool ASTUnit::isInPreambleFileID(SourceLocation Loc) const { d2441 1 a2441 1 d2444 1 a2444 1 d2448 1 a2448 1 bool ASTUnit::isInMainFileID(SourceLocation Loc) const { d2452 1 a2452 1 d2455 1 a2455 1 d2459 1 a2459 1 SourceLocation ASTUnit::getEndOfPreambleFileID() const { d2463 1 a2463 1 d2465 1 a2465 1 return {}; d2470 1 a2470 1 SourceLocation ASTUnit::getStartOfMainFileID() const { d2474 1 a2474 1 d2476 2 a2477 2 return {}; d2500 1 a2500 1 for (const auto *D : Reader->getModuleFileLevelDecls(Mod)) { d2546 1 a2546 1 bool ASTUnit::isModuleFile() const { @ 1.1.1.13 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file ASTUnit.cpp was added on branch tls-maxphys on 2014-08-19 23:47:28 +0000 @ text @d1 2893 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 2893 //===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // ASTUnit Implementation. // //===----------------------------------------------------------------------===// #include "clang/Frontend/ASTUnit.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclVisitor.h" #include "clang/AST/StmtVisitor.h" #include "clang/AST/TypeOrdering.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Basic/VirtualFileSystem.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/FrontendOptions.h" #include "clang/Frontend/MultiplexConsumer.h" #include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/PreprocessorOptions.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "clang/Serialization/ASTWriter.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/Host.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Mutex.h" #include "llvm/Support/MutexGuard.h" #include "llvm/Support/Path.h" #include "llvm/Support/Timer.h" #include "llvm/Support/raw_ostream.h" #include #include #include using namespace clang; using llvm::TimeRecord; namespace { class SimpleTimer { bool WantTiming; TimeRecord Start; std::string Output; public: explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) { if (WantTiming) Start = TimeRecord::getCurrentTime(); } void setOutput(const Twine &Output) { if (WantTiming) this->Output = Output.str(); } ~SimpleTimer() { if (WantTiming) { TimeRecord Elapsed = TimeRecord::getCurrentTime(); Elapsed -= Start; llvm::errs() << Output << ':'; Elapsed.print(Elapsed, llvm::errs()); llvm::errs() << '\n'; } } }; struct OnDiskData { /// \brief The file in which the precompiled preamble is stored. std::string PreambleFile; /// \brief Temporary files that should be removed when the ASTUnit is /// destroyed. SmallVector TemporaryFiles; /// \brief Erase temporary files. void CleanTemporaryFiles(); /// \brief Erase the preamble file. void CleanPreambleFile(); /// \brief Erase temporary files and the preamble file. void Cleanup(); }; } static llvm::sys::SmartMutex &getOnDiskMutex() { static llvm::sys::SmartMutex M(/* recursive = */ true); return M; } static void cleanupOnDiskMapAtExit(); typedef llvm::DenseMap OnDiskDataMap; static OnDiskDataMap &getOnDiskDataMap() { static OnDiskDataMap M; static bool hasRegisteredAtExit = false; if (!hasRegisteredAtExit) { hasRegisteredAtExit = true; atexit(cleanupOnDiskMapAtExit); } return M; } static void cleanupOnDiskMapAtExit() { // Use the mutex because there can be an alive thread destroying an ASTUnit. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); for (OnDiskDataMap::iterator I = M.begin(), E = M.end(); I != E; ++I) { // We don't worry about freeing the memory associated with OnDiskDataMap. // All we care about is erasing stale files. I->second->Cleanup(); } } static OnDiskData &getOnDiskData(const ASTUnit *AU) { // We require the mutex since we are modifying the structure of the // DenseMap. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); OnDiskData *&D = M[AU]; if (!D) D = new OnDiskData(); return *D; } static void erasePreambleFile(const ASTUnit *AU) { getOnDiskData(AU).CleanPreambleFile(); } static void removeOnDiskEntry(const ASTUnit *AU) { // We require the mutex since we are modifying the structure of the // DenseMap. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); OnDiskDataMap::iterator I = M.find(AU); if (I != M.end()) { I->second->Cleanup(); delete I->second; M.erase(AU); } } static void setPreambleFile(const ASTUnit *AU, StringRef preambleFile) { getOnDiskData(AU).PreambleFile = preambleFile; } static const std::string &getPreambleFile(const ASTUnit *AU) { return getOnDiskData(AU).PreambleFile; } void OnDiskData::CleanTemporaryFiles() { for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) llvm::sys::fs::remove(TemporaryFiles[I]); TemporaryFiles.clear(); } void OnDiskData::CleanPreambleFile() { if (!PreambleFile.empty()) { llvm::sys::fs::remove(PreambleFile); PreambleFile.clear(); } } void OnDiskData::Cleanup() { CleanTemporaryFiles(); CleanPreambleFile(); } struct ASTUnit::ASTWriterData { SmallString<128> Buffer; llvm::BitstreamWriter Stream; ASTWriter Writer; ASTWriterData() : Stream(Buffer), Writer(Stream) { } }; void ASTUnit::clearFileLevelDecls() { llvm::DeleteContainerSeconds(FileDecls); } void ASTUnit::CleanTemporaryFiles() { getOnDiskData(this).CleanTemporaryFiles(); } void ASTUnit::addTemporaryFile(StringRef TempFile) { getOnDiskData(this).TemporaryFiles.push_back(TempFile); } /// \brief After failing to build a precompiled preamble (due to /// errors in the source that occurs in the preamble), the number of /// reparses during which we'll skip even trying to precompile the /// preamble. const unsigned DefaultPreambleRebuildInterval = 5; /// \brief Tracks the number of ASTUnit objects that are currently active. /// /// Used for debugging purposes only. static std::atomic ActiveASTUnitObjects; ASTUnit::ASTUnit(bool _MainFileIsAST) : Reader(nullptr), HadModuleLoaderFatalFailure(false), OnlyLocalDecls(false), CaptureDiagnostics(false), MainFileIsAST(_MainFileIsAST), TUKind(TU_Complete), WantTiming(getenv("LIBCLANG_TIMING")), OwnsRemappedFileBuffers(true), NumStoredDiagnosticsFromDriver(0), PreambleRebuildCounter(0), SavedMainFileBuffer(nullptr), PreambleBuffer(nullptr), NumWarningsInPreamble(0), ShouldCacheCodeCompletionResults(false), IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), CompletionCacheTopLevelHashValue(0), PreambleTopLevelHashValue(0), CurrentTopLevelHashValue(0), UnsafeToFree(false) { if (getenv("LIBCLANG_OBJTRACKING")) fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects); } ASTUnit::~ASTUnit() { // If we loaded from an AST file, balance out the BeginSourceFile call. if (MainFileIsAST && getDiagnostics().getClient()) { getDiagnostics().getClient()->EndSourceFile(); } clearFileLevelDecls(); // Clean up the temporary files and the preamble file. removeOnDiskEntry(this); // Free the buffers associated with remapped files. We are required to // perform this operation here because we explicitly request that the // compiler instance *not* free these buffers for each invocation of the // parser. if (Invocation.get() && OwnsRemappedFileBuffers) { PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); for (const auto &RB : PPOpts.RemappedFileBuffers) delete RB.second; } delete SavedMainFileBuffer; delete PreambleBuffer; ClearCachedCompletionResults(); if (getenv("LIBCLANG_OBJTRACKING")) fprintf(stderr, "--- %u translation units\n", --ActiveASTUnitObjects); } void ASTUnit::setPreprocessor(Preprocessor *pp) { PP = pp; } /// \brief Determine the set of code-completion contexts in which this /// declaration should be shown. static unsigned getDeclShowContexts(const NamedDecl *ND, const LangOptions &LangOpts, bool &IsNestedNameSpecifier) { IsNestedNameSpecifier = false; if (isa(ND)) ND = dyn_cast(ND->getUnderlyingDecl()); if (!ND) return 0; uint64_t Contexts = 0; if (isa(ND) || isa(ND) || isa(ND) || isa(ND)) { // Types can appear in these contexts. if (LangOpts.CPlusPlus || !isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Type) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); // In C++, types can appear in expressions contexts (for functional casts). if (LangOpts.CPlusPlus) Contexts |= (1LL << CodeCompletionContext::CCC_Expression); // In Objective-C, message sends can send interfaces. In Objective-C++, // all types are available due to functional casts. if (LangOpts.CPlusPlus || isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); // In Objective-C, you can only be a subclass of another Objective-C class if (isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_ObjCInterfaceName); // Deal with tag names. if (isa(ND)) { Contexts |= (1LL << CodeCompletionContext::CCC_EnumTag); // Part of the nested-name-specifier in C++0x. if (LangOpts.CPlusPlus11) IsNestedNameSpecifier = true; } else if (const RecordDecl *Record = dyn_cast(ND)) { if (Record->isUnion()) Contexts |= (1LL << CodeCompletionContext::CCC_UnionTag); else Contexts |= (1LL << CodeCompletionContext::CCC_ClassOrStructTag); if (LangOpts.CPlusPlus) IsNestedNameSpecifier = true; } else if (isa(ND)) IsNestedNameSpecifier = true; } else if (isa(ND) || isa(ND)) { // Values can appear in these contexts. Contexts = (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); } else if (isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_ObjCProtocolName); } else if (isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_ObjCCategoryName); } else if (isa(ND) || isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_Namespace); // Part of the nested-name-specifier. IsNestedNameSpecifier = true; } return Contexts; } void ASTUnit::CacheCodeCompletionResults() { if (!TheSema) return; SimpleTimer Timer(WantTiming); Timer.setOutput("Cache global code completions for " + getMainFileName()); // Clear out the previous results. ClearCachedCompletionResults(); // Gather the set of global code completions. typedef CodeCompletionResult Result; SmallVector Results; CachedCompletionAllocator = new GlobalCodeCompletionAllocator; CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator); TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, CCTUInfo, Results); // Translate global code completions into cached completions. llvm::DenseMap CompletionTypes; for (unsigned I = 0, N = Results.size(); I != N; ++I) { switch (Results[I].Kind) { case Result::RK_Declaration: { bool IsNestedNameSpecifier = false; CachedCodeCompletionResult CachedResult; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier); CachedResult.Priority = Results[I].Priority; CachedResult.Kind = Results[I].CursorKind; CachedResult.Availability = Results[I].Availability; // Keep track of the type of this completion in an ASTContext-agnostic // way. QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration); if (UsageType.isNull()) { CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; } else { CanQualType CanUsageType = Ctx->getCanonicalType(UsageType.getUnqualifiedType()); CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType); // Determine whether we have already seen this type. If so, we save // ourselves the work of formatting the type string by using the // temporary, CanQualType-based hash table to find the associated value. unsigned &TypeValue = CompletionTypes[CanUsageType]; if (TypeValue == 0) { TypeValue = CompletionTypes.size(); CachedCompletionTypes[QualType(CanUsageType).getAsString()] = TypeValue; } CachedResult.Type = TypeValue; } CachedCompletionResults.push_back(CachedResult); /// Handle nested-name-specifiers in C++. if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) { // The contexts in which a nested-name-specifier can appear in C++. uint64_t NNSContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_EnumTag) | (1LL << CodeCompletionContext::CCC_UnionTag) | (1LL << CodeCompletionContext::CCC_ClassOrStructTag) | (1LL << CodeCompletionContext::CCC_Type) | (1LL << CodeCompletionContext::CCC_PotentiallyQualifiedName) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); if (isa(Results[I].Declaration) || isa(Results[I].Declaration)) NNSContexts |= (1LL << CodeCompletionContext::CCC_Namespace); if (unsigned RemainingContexts = NNSContexts & ~CachedResult.ShowInContexts) { // If there any contexts where this completion can be a // nested-name-specifier but isn't already an option, create a // nested-name-specifier completion. Results[I].StartsNestedNameSpecifier = true; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = RemainingContexts; CachedResult.Priority = CCP_NestedNameSpecifier; CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; CachedCompletionResults.push_back(CachedResult); } } break; } case Result::RK_Keyword: case Result::RK_Pattern: // Ignore keywords and patterns; we don't care, since they are so // easily regenerated. break; case Result::RK_Macro: { CachedCodeCompletionResult CachedResult; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCInterface) | (1LL << CodeCompletionContext::CCC_ObjCImplementation) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_MacroNameUse) | (1LL << CodeCompletionContext::CCC_PreprocessorExpression) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_OtherWithMacros); CachedResult.Priority = Results[I].Priority; CachedResult.Kind = Results[I].CursorKind; CachedResult.Availability = Results[I].Availability; CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; CachedCompletionResults.push_back(CachedResult); break; } } } // Save the current top-level hash value. CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue; } void ASTUnit::ClearCachedCompletionResults() { CachedCompletionResults.clear(); CachedCompletionTypes.clear(); CachedCompletionAllocator = nullptr; } namespace { /// \brief Gathers information from ASTReader that will be used to initialize /// a Preprocessor. class ASTInfoCollector : public ASTReaderListener { Preprocessor &PP; ASTContext &Context; LangOptions &LangOpt; std::shared_ptr &TargetOpts; IntrusiveRefCntPtr &Target; unsigned &Counter; bool InitializedLanguage; public: ASTInfoCollector(Preprocessor &PP, ASTContext &Context, LangOptions &LangOpt, std::shared_ptr &TargetOpts, IntrusiveRefCntPtr &Target, unsigned &Counter) : PP(PP), Context(Context), LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target), Counter(Counter), InitializedLanguage(false) {} bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain) override { if (InitializedLanguage) return false; LangOpt = LangOpts; InitializedLanguage = true; updated(); return false; } bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain) override { // If we've already initialized the target, don't do it again. if (Target) return false; this->TargetOpts = std::make_shared(TargetOpts); Target = TargetInfo::CreateTargetInfo(PP.getDiagnostics(), this->TargetOpts); updated(); return false; } void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override { Counter = Value; } private: void updated() { if (!Target || !InitializedLanguage) return; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Target->adjust(LangOpt); // Initialize the preprocessor. PP.Initialize(*Target); // Initialize the ASTContext Context.InitBuiltinTypes(*Target); // We didn't have access to the comment options when the ASTContext was // constructed, so register them now. Context.getCommentCommandTraits().registerCommentOptions( LangOpt.CommentOpts); } }; /// \brief Diagnostic consumer that saves each diagnostic it is given. class StoredDiagnosticConsumer : public DiagnosticConsumer { SmallVectorImpl &StoredDiags; SourceManager *SourceMgr; public: explicit StoredDiagnosticConsumer( SmallVectorImpl &StoredDiags) : StoredDiags(StoredDiags), SourceMgr(nullptr) {} void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP = nullptr) override { if (PP) SourceMgr = &PP->getSourceManager(); } void HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info) override; }; /// \brief RAII object that optionally captures diagnostics, if /// there is no diagnostic client to capture them already. class CaptureDroppedDiagnostics { DiagnosticsEngine &Diags; StoredDiagnosticConsumer Client; DiagnosticConsumer *PreviousClient; public: CaptureDroppedDiagnostics(bool RequestCapture, DiagnosticsEngine &Diags, SmallVectorImpl &StoredDiags) : Diags(Diags), Client(StoredDiags), PreviousClient(nullptr) { if (RequestCapture || Diags.getClient() == nullptr) { PreviousClient = Diags.takeClient(); Diags.setClient(&Client); } } ~CaptureDroppedDiagnostics() { if (Diags.getClient() == &Client) { Diags.takeClient(); Diags.setClient(PreviousClient); } } }; } // anonymous namespace void StoredDiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info) { // Default implementation (Warnings/errors count). DiagnosticConsumer::HandleDiagnostic(Level, Info); // Only record the diagnostic if it's part of the source manager we know // about. This effectively drops diagnostics from modules we're building. // FIXME: In the long run, ee don't want to drop source managers from modules. if (!Info.hasSourceManager() || &Info.getSourceManager() == SourceMgr) StoredDiags.push_back(StoredDiagnostic(Level, Info)); } ASTMutationListener *ASTUnit::getASTMutationListener() { if (WriterData) return &WriterData->Writer; return nullptr; } ASTDeserializationListener *ASTUnit::getDeserializationListener() { if (WriterData) return &WriterData->Writer; return nullptr; } llvm::MemoryBuffer *ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) { assert(FileMgr); return FileMgr->getBufferForFile(Filename, ErrorStr); } /// \brief Configure the diagnostics object for use with ASTUnit. void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr &Diags, const char **ArgBegin, const char **ArgEnd, ASTUnit &AST, bool CaptureDiagnostics) { if (!Diags.get()) { // No diagnostics engine was provided, so create our own diagnostics object // with the default options. DiagnosticConsumer *Client = nullptr; if (CaptureDiagnostics) Client = new StoredDiagnosticConsumer(AST.StoredDiagnostics); Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions(), Client, /*ShouldOwnClient=*/true); } else if (CaptureDiagnostics) { Diags->setClient(new StoredDiagnosticConsumer(AST.StoredDiagnostics)); } } ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename, IntrusiveRefCntPtr Diags, const FileSystemOptions &FileSystemOpts, bool OnlyLocalDecls, ArrayRef RemappedFiles, bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, bool UserFilesAreVolatile) { std::unique_ptr AST(new ASTUnit(true)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.get()); ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->Diagnostics = Diags; IntrusiveRefCntPtr VFS = vfs::getRealFileSystem(); AST->FileMgr = new FileManager(FileSystemOpts, VFS); AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->SourceMgr = new SourceManager(AST->getDiagnostics(), AST->getFileManager(), UserFilesAreVolatile); AST->HSOpts = new HeaderSearchOptions(); AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts, AST->getSourceManager(), AST->getDiagnostics(), AST->ASTFileLangOpts, /*Target=*/nullptr)); PreprocessorOptions *PPOpts = new PreprocessorOptions(); for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) PPOpts->addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); // Gather Info for preprocessor construction later on. HeaderSearch &HeaderInfo = *AST->HeaderInfo.get(); unsigned Counter; AST->PP = new Preprocessor(PPOpts, AST->getDiagnostics(), AST->ASTFileLangOpts, AST->getSourceManager(), HeaderInfo, *AST, /*IILookup=*/nullptr, /*OwnsHeaderSearch=*/false); Preprocessor &PP = *AST->PP; AST->Ctx = new ASTContext(AST->ASTFileLangOpts, AST->getSourceManager(), PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo()); ASTContext &Context = *AST->Ctx; bool disableValid = false; if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION")) disableValid = true; AST->Reader = new ASTReader(PP, Context, /*isysroot=*/"", /*DisableValidation=*/disableValid, AllowPCHWithCompilerErrors); AST->Reader->setListener(new ASTInfoCollector(*AST->PP, Context, AST->ASTFileLangOpts, AST->TargetOpts, AST->Target, Counter)); switch (AST->Reader->ReadAST(Filename, serialization::MK_MainFile, SourceLocation(), ASTReader::ARR_None)) { case ASTReader::Success: break; case ASTReader::Failure: case ASTReader::Missing: case ASTReader::OutOfDate: case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch); return nullptr; } AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile(); PP.setCounterValue(Counter); // Attach the AST reader to the AST context as an external AST // source, so that declarations will be deserialized from the // AST file as needed. Context.setExternalSource(AST->Reader); // Create an AST consumer, even though it isn't used. AST->Consumer.reset(new ASTConsumer); // Create a semantic analysis object and tell the AST reader about it. AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer)); AST->TheSema->Initialize(); AST->Reader->InitializeSema(*AST->TheSema); // Tell the diagnostic client that we have started a source file. AST->getDiagnostics().getClient()->BeginSourceFile(Context.getLangOpts(),&PP); return AST.release(); } namespace { /// \brief Preprocessor callback class that updates a hash value with the names /// of all macros that have been defined by the translation unit. class MacroDefinitionTrackerPPCallbacks : public PPCallbacks { unsigned &Hash; public: explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { } void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override { Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash); } }; /// \brief Add the given declaration to the hash of all top-level entities. void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { if (!D) return; DeclContext *DC = D->getDeclContext(); if (!DC) return; if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit())) return; if (NamedDecl *ND = dyn_cast(D)) { if (EnumDecl *EnumD = dyn_cast(D)) { // For an unscoped enum include the enumerators in the hash since they // enter the top-level namespace. if (!EnumD->isScoped()) { for (const auto *EI : EnumD->enumerators()) { if (EI->getIdentifier()) Hash = llvm::HashString(EI->getIdentifier()->getName(), Hash); } } } if (ND->getIdentifier()) Hash = llvm::HashString(ND->getIdentifier()->getName(), Hash); else if (DeclarationName Name = ND->getDeclName()) { std::string NameStr = Name.getAsString(); Hash = llvm::HashString(NameStr, Hash); } return; } if (ImportDecl *ImportD = dyn_cast(D)) { if (Module *Mod = ImportD->getImportedModule()) { std::string ModName = Mod->getFullModuleName(); Hash = llvm::HashString(ModName, Hash); } return; } } class TopLevelDeclTrackerConsumer : public ASTConsumer { ASTUnit &Unit; unsigned &Hash; public: TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash) : Unit(_Unit), Hash(Hash) { Hash = 0; } void handleTopLevelDecl(Decl *D) { if (!D) return; // FIXME: Currently ObjC method declarations are incorrectly being // reported as top-level declarations, even though their DeclContext // is the containing ObjC @@interface/@@implementation. This is a // fundamental problem in the parser right now. if (isa(D)) return; AddTopLevelDeclarationToHash(D, Hash); Unit.addTopLevelDecl(D); handleFileLevelDecl(D); } void handleFileLevelDecl(Decl *D) { Unit.addFileLevelDecl(D); if (NamespaceDecl *NSD = dyn_cast(D)) { for (auto *I : NSD->decls()) handleFileLevelDecl(I); } } bool HandleTopLevelDecl(DeclGroupRef D) override { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) handleTopLevelDecl(*it); return true; } // We're not interested in "interesting" decls. void HandleInterestingDecl(DeclGroupRef) override {} void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) handleTopLevelDecl(*it); } ASTMutationListener *GetASTMutationListener() override { return Unit.getASTMutationListener(); } ASTDeserializationListener *GetASTDeserializationListener() override { return Unit.getDeserializationListener(); } }; class TopLevelDeclTrackerAction : public ASTFrontendAction { public: ASTUnit &Unit; ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { CI.getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue())); return new TopLevelDeclTrackerConsumer(Unit, Unit.getCurrentTopLevelHashValue()); } public: TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} bool hasCodeCompletionSupport() const override { return false; } TranslationUnitKind getTranslationUnitKind() override { return Unit.getTranslationUnitKind(); } }; class PrecompilePreambleAction : public ASTFrontendAction { ASTUnit &Unit; bool HasEmittedPreamblePCH; public: explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit), HasEmittedPreamblePCH(false) {} ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override; bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; } void setHasEmittedPreamblePCH() { HasEmittedPreamblePCH = true; } bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); } bool hasCodeCompletionSupport() const override { return false; } bool hasASTFileSupport() const override { return false; } TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; } }; class PrecompilePreambleConsumer : public PCHGenerator { ASTUnit &Unit; unsigned &Hash; std::vector TopLevelDecls; PrecompilePreambleAction *Action; public: PrecompilePreambleConsumer(ASTUnit &Unit, PrecompilePreambleAction *Action, const Preprocessor &PP, StringRef isysroot, raw_ostream *Out) : PCHGenerator(PP, "", nullptr, isysroot, Out, /*AllowASTWithErrors=*/true), Unit(Unit), Hash(Unit.getCurrentTopLevelHashValue()), Action(Action) { Hash = 0; } bool HandleTopLevelDecl(DeclGroupRef D) override { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { Decl *D = *it; // FIXME: Currently ObjC method declarations are incorrectly being // reported as top-level declarations, even though their DeclContext // is the containing ObjC @@interface/@@implementation. This is a // fundamental problem in the parser right now. if (isa(D)) continue; AddTopLevelDeclarationToHash(D, Hash); TopLevelDecls.push_back(D); } return true; } void HandleTranslationUnit(ASTContext &Ctx) override { PCHGenerator::HandleTranslationUnit(Ctx); if (hasEmittedPCH()) { // Translate the top-level declarations we captured during // parsing into declaration IDs in the precompiled // preamble. This will allow us to deserialize those top-level // declarations when requested. for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I) { Decl *D = TopLevelDecls[I]; // Invalid top-level decls may not have been serialized. if (D->isInvalidDecl()) continue; Unit.addTopLevelDeclFromPreamble(getWriter().getDeclID(D)); } Action->setHasEmittedPreamblePCH(); } } }; } ASTConsumer *PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { std::string Sysroot; std::string OutputFile; raw_ostream *OS = nullptr; if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS)) return nullptr; if (!CI.getFrontendOpts().RelocatablePCH) Sysroot.clear(); CI.getPreprocessor().addPPCallbacks(new MacroDefinitionTrackerPPCallbacks( Unit.getCurrentTopLevelHashValue())); return new PrecompilePreambleConsumer(Unit, this, CI.getPreprocessor(), Sysroot, OS); } static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) { return StoredDiag.getLocation().isValid(); } static void checkAndRemoveNonDriverDiags(SmallVectorImpl &StoredDiags) { // Get rid of stored diagnostics except the ones from the driver which do not // have a source location. StoredDiags.erase( std::remove_if(StoredDiags.begin(), StoredDiags.end(), isNonDriverDiag), StoredDiags.end()); } static void checkAndSanitizeDiags(SmallVectorImpl & StoredDiagnostics, SourceManager &SM) { // The stored diagnostic has the old source manager in it; update // the locations to refer into the new source manager. Since we've // been careful to make sure that the source manager's state // before and after are identical, so that we can reuse the source // location itself. for (unsigned I = 0, N = StoredDiagnostics.size(); I < N; ++I) { if (StoredDiagnostics[I].getLocation().isValid()) { FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SM); StoredDiagnostics[I].setLocation(Loc); } } } /// Parse the source file into a translation unit using the given compiler /// invocation, replacing the current translation unit. /// /// \returns True if a failure occurred that causes the ASTUnit not to /// contain any translation-unit information, false otherwise. bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) { delete SavedMainFileBuffer; SavedMainFileBuffer = nullptr; if (!Invocation) { delete OverrideMainBuffer; return true; } // Create the compiler instance to use for building the AST. std::unique_ptr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); IntrusiveRefCntPtr CCInvocation(new CompilerInvocation(*Invocation)); Clang->setInvocation(CCInvocation.get()); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics that would // otherwise be dropped. Clang->setDiagnostics(&getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); if (!Clang->hasTarget()) { delete OverrideMainBuffer; return true; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().adjust(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Configure the various subsystems. LangOpts = Clang->getInvocation().LangOpts; FileSystemOpts = Clang->getFileSystemOpts(); IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(Clang->getInvocation(), getDiagnostics()); if (!VFS) { delete OverrideMainBuffer; return true; } FileMgr = new FileManager(FileSystemOpts, VFS); SourceMgr = new SourceManager(getDiagnostics(), *FileMgr, UserFilesAreVolatile); TheSema.reset(); Ctx = nullptr; PP = nullptr; Reader = nullptr; // Clear out old caches and data. TopLevelDecls.clear(); clearFileLevelDecls(); CleanTemporaryFiles(); if (!OverrideMainBuffer) { checkAndRemoveNonDriverDiags(StoredDiagnostics); TopLevelDeclsInPreamble.clear(); } // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(&getFileManager()); // Create the source manager. Clang->setSourceManager(&getSourceManager()); // If the main file has been overridden due to the use of a preamble, // make that override happen and introduce the preamble. PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts(); if (OverrideMainBuffer) { PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); PreprocessorOpts.PrecompiledPreambleBytes.second = PreambleEndsAtStartOfLine; PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); PreprocessorOpts.DisablePCHValidation = true; // The stored diagnostic has the old source manager in it; update // the locations to refer into the new source manager. Since we've // been careful to make sure that the source manager's state // before and after are identical, so that we can reuse the source // location itself. checkAndSanitizeDiags(StoredDiagnostics, getSourceManager()); // Keep track of the override buffer; SavedMainFileBuffer = OverrideMainBuffer; } std::unique_ptr Act( new TopLevelDeclTrackerAction(*this)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ActCleanup(Act.get()); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) goto error; if (OverrideMainBuffer) { std::string ModName = getPreambleFile(this); TranslateStoredDiagnostics(getFileManager(), getSourceManager(), PreambleDiagnostics, StoredDiagnostics); } if (!Act->Execute()) goto error; transferASTDataFromCompilerInstance(*Clang); Act->EndSourceFile(); FailedParseDiagnostics.clear(); return false; error: // Remove the overridden buffer we used for the preamble. if (OverrideMainBuffer) { delete OverrideMainBuffer; SavedMainFileBuffer = nullptr; } // Keep the ownership of the data in the ASTUnit because the client may // want to see the diagnostics. transferASTDataFromCompilerInstance(*Clang); FailedParseDiagnostics.swap(StoredDiagnostics); StoredDiagnostics.clear(); NumStoredDiagnosticsFromDriver = 0; return true; } /// \brief Simple function to retrieve a path for a preamble precompiled header. static std::string GetPreamblePCHPath() { // FIXME: This is a hack so that we can override the preamble file during // crash-recovery testing, which is the only case where the preamble files // are not necessarily cleaned up. const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE"); if (TmpFile) return TmpFile; SmallString<128> Path; llvm::sys::fs::createTemporaryFile("preamble", "pch", Path); return Path.str(); } /// \brief Compute the preamble for the main file, providing the source buffer /// that corresponds to the main file along with a pair (bytes, start-of-line) /// that describes the preamble. std::pair > ASTUnit::ComputePreamble(CompilerInvocation &Invocation, unsigned MaxLines, bool &CreatedBuffer) { FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); PreprocessorOptions &PreprocessorOpts = Invocation.getPreprocessorOpts(); CreatedBuffer = false; // Try to determine if the main file has been remapped, either from the // command line (to another file) or directly through the compiler invocation // (to a memory buffer). llvm::MemoryBuffer *Buffer = nullptr; std::string MainFilePath(FrontendOpts.Inputs[0].getFile()); llvm::sys::fs::UniqueID MainFileID; if (!llvm::sys::fs::getUniqueID(MainFilePath, MainFileID)) { // Check whether there is a file-file remapping of the main file for (const auto &RF : PreprocessorOpts.RemappedFiles) { std::string MPath(RF.first); llvm::sys::fs::UniqueID MID; if (!llvm::sys::fs::getUniqueID(MPath, MID)) { if (MainFileID == MID) { // We found a remapping. Try to load the resulting, remapped source. if (CreatedBuffer) { delete Buffer; CreatedBuffer = false; } Buffer = getBufferForFile(RF.second); if (!Buffer) return std::make_pair(nullptr, std::make_pair(0, true)); CreatedBuffer = true; } } } // Check whether there is a file-buffer remapping. It supercedes the // file-file remapping. for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { std::string MPath(RB.first); llvm::sys::fs::UniqueID MID; if (!llvm::sys::fs::getUniqueID(MPath, MID)) { if (MainFileID == MID) { // We found a remapping. if (CreatedBuffer) { delete Buffer; CreatedBuffer = false; } Buffer = const_cast(RB.second); } } } } // If the main source file was not remapped, load it now. if (!Buffer) { Buffer = getBufferForFile(FrontendOpts.Inputs[0].getFile()); if (!Buffer) return std::make_pair(nullptr, std::make_pair(0, true)); CreatedBuffer = true; } return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, *Invocation.getLangOpts(), MaxLines)); } ASTUnit::PreambleFileHash ASTUnit::PreambleFileHash::createForFile(off_t Size, time_t ModTime) { PreambleFileHash Result; Result.Size = Size; Result.ModTime = ModTime; memset(Result.MD5, 0, sizeof(Result.MD5)); return Result; } ASTUnit::PreambleFileHash ASTUnit::PreambleFileHash::createForMemoryBuffer( const llvm::MemoryBuffer *Buffer) { PreambleFileHash Result; Result.Size = Buffer->getBufferSize(); Result.ModTime = 0; llvm::MD5 MD5Ctx; MD5Ctx.update(Buffer->getBuffer().data()); MD5Ctx.final(Result.MD5); return Result; } namespace clang { bool operator==(const ASTUnit::PreambleFileHash &LHS, const ASTUnit::PreambleFileHash &RHS) { return LHS.Size == RHS.Size && LHS.ModTime == RHS.ModTime && memcmp(LHS.MD5, RHS.MD5, sizeof(LHS.MD5)) == 0; } } // namespace clang static std::pair makeStandaloneRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts) { CharSourceRange FileRange = Lexer::makeFileCharRange(Range, SM, LangOpts); unsigned Offset = SM.getFileOffset(FileRange.getBegin()); unsigned EndOffset = SM.getFileOffset(FileRange.getEnd()); return std::make_pair(Offset, EndOffset); } static void makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix, ASTUnit::StandaloneFixIt &OutFix) { OutFix.RemoveRange = makeStandaloneRange(InFix.RemoveRange, SM, LangOpts); OutFix.InsertFromRange = makeStandaloneRange(InFix.InsertFromRange, SM, LangOpts); OutFix.CodeToInsert = InFix.CodeToInsert; OutFix.BeforePreviousInsertions = InFix.BeforePreviousInsertions; } static void makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag, ASTUnit::StandaloneDiagnostic &OutDiag) { OutDiag.ID = InDiag.getID(); OutDiag.Level = InDiag.getLevel(); OutDiag.Message = InDiag.getMessage(); OutDiag.LocOffset = 0; if (InDiag.getLocation().isInvalid()) return; const SourceManager &SM = InDiag.getLocation().getManager(); SourceLocation FileLoc = SM.getFileLoc(InDiag.getLocation()); OutDiag.Filename = SM.getFilename(FileLoc); if (OutDiag.Filename.empty()) return; OutDiag.LocOffset = SM.getFileOffset(FileLoc); for (StoredDiagnostic::range_iterator I = InDiag.range_begin(), E = InDiag.range_end(); I != E; ++I) { OutDiag.Ranges.push_back(makeStandaloneRange(*I, SM, LangOpts)); } for (StoredDiagnostic::fixit_iterator I = InDiag.fixit_begin(), E = InDiag.fixit_end(); I != E; ++I) { ASTUnit::StandaloneFixIt Fix; makeStandaloneFixIt(SM, LangOpts, *I, Fix); OutDiag.FixIts.push_back(Fix); } } /// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing /// the source file. /// /// This routine will compute the preamble of the main source file. If a /// non-trivial preamble is found, it will precompile that preamble into a /// precompiled header so that the precompiled preamble can be used to reduce /// reparsing time. If a precompiled preamble has already been constructed, /// this routine will determine if it is still valid and, if so, avoid /// rebuilding the precompiled preamble. /// /// \param AllowRebuild When true (the default), this routine is /// allowed to rebuild the precompiled preamble if it is found to be /// out-of-date. /// /// \param MaxLines When non-zero, the maximum number of lines that /// can occur within the preamble. /// /// \returns If the precompiled preamble can be used, returns a newly-allocated /// buffer that should be used in place of the main file when doing so. /// Otherwise, returns a NULL pointer. llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble( const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, unsigned MaxLines) { IntrusiveRefCntPtr PreambleInvocation(new CompilerInvocation(PreambleInvocationIn)); FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts(); PreprocessorOptions &PreprocessorOpts = PreambleInvocation->getPreprocessorOpts(); bool CreatedPreambleBuffer = false; std::pair > NewPreamble = ComputePreamble(*PreambleInvocation, MaxLines, CreatedPreambleBuffer); // If ComputePreamble() Take ownership of the preamble buffer. std::unique_ptr OwnedPreambleBuffer; if (CreatedPreambleBuffer) OwnedPreambleBuffer.reset(NewPreamble.first); if (!NewPreamble.second.first) { // We couldn't find a preamble in the main source. Clear out the current // preamble, if we have one. It's obviously no good any more. Preamble.clear(); erasePreambleFile(this); // The next time we actually see a preamble, precompile it. PreambleRebuildCounter = 1; return nullptr; } if (!Preamble.empty()) { // We've previously computed a preamble. Check whether we have the same // preamble now that we did before, and that there's enough space in // the main-file buffer within the precompiled preamble to fit the // new main file. if (Preamble.size() == NewPreamble.second.first && PreambleEndsAtStartOfLine == NewPreamble.second.second && memcmp(Preamble.getBufferStart(), NewPreamble.first->getBufferStart(), NewPreamble.second.first) == 0) { // The preamble has not changed. We may be able to re-use the precompiled // preamble. // Check that none of the files used by the preamble have changed. bool AnyFileChanged = false; // First, make a record of those files that have been overridden via // remapping or unsaved_files. llvm::StringMap OverriddenFiles; for (const auto &R : PreprocessorOpts.RemappedFiles) { if (AnyFileChanged) break; vfs::Status Status; if (FileMgr->getNoncachedStatValue(R.second, Status)) { // If we can't stat the file we're remapping to, assume that something // horrible happened. AnyFileChanged = true; break; } OverriddenFiles[R.first] = PreambleFileHash::createForFile( Status.getSize(), Status.getLastModificationTime().toEpochTime()); } for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { if (AnyFileChanged) break; OverriddenFiles[RB.first] = PreambleFileHash::createForMemoryBuffer(RB.second); } // Check whether anything has changed. for (llvm::StringMap::iterator F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end(); !AnyFileChanged && F != FEnd; ++F) { llvm::StringMap::iterator Overridden = OverriddenFiles.find(F->first()); if (Overridden != OverriddenFiles.end()) { // This file was remapped; check whether the newly-mapped file // matches up with the previous mapping. if (Overridden->second != F->second) AnyFileChanged = true; continue; } // The file was not remapped; check whether it has changed on disk. vfs::Status Status; if (FileMgr->getNoncachedStatValue(F->first(), Status)) { // If we can't stat the file, assume that something horrible happened. AnyFileChanged = true; } else if (Status.getSize() != uint64_t(F->second.Size) || Status.getLastModificationTime().toEpochTime() != uint64_t(F->second.ModTime)) AnyFileChanged = true; } if (!AnyFileChanged) { // Okay! We can re-use the precompiled preamble. // Set the state of the diagnostic object to mimic its state // after parsing the preamble. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), PreambleInvocation->getDiagnosticOpts()); getDiagnostics().setNumWarnings(NumWarningsInPreamble); return llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.first->getBuffer(), FrontendOpts.Inputs[0].getFile()); } } // If we aren't allowed to rebuild the precompiled preamble, just // return now. if (!AllowRebuild) return nullptr; // We can't reuse the previously-computed preamble. Build a new one. Preamble.clear(); PreambleDiagnostics.clear(); erasePreambleFile(this); PreambleRebuildCounter = 1; } else if (!AllowRebuild) { // We aren't allowed to rebuild the precompiled preamble; just // return now. return nullptr; } // If the preamble rebuild counter > 1, it's because we previously // failed to build a preamble and we're not yet ready to try // again. Decrement the counter and return a failure. if (PreambleRebuildCounter > 1) { --PreambleRebuildCounter; return nullptr; } // Create a temporary file for the precompiled preamble. In rare // circumstances, this can fail. std::string PreamblePCHPath = GetPreamblePCHPath(); if (PreamblePCHPath.empty()) { // Try again next time. PreambleRebuildCounter = 1; return nullptr; } // We did not previously compute a preamble, or it can't be reused anyway. SimpleTimer PreambleTimer(WantTiming); PreambleTimer.setOutput("Precompiling preamble"); // Save the preamble text for later; we'll need to compare against it for // subsequent reparses. StringRef MainFilename = FrontendOpts.Inputs[0].getFile(); Preamble.assign(FileMgr->getFile(MainFilename), NewPreamble.first->getBufferStart(), NewPreamble.first->getBufferStart() + NewPreamble.second.first); PreambleEndsAtStartOfLine = NewPreamble.second.second; delete PreambleBuffer; PreambleBuffer = llvm::MemoryBuffer::getMemBufferCopy( NewPreamble.first->getBuffer().slice(0, Preamble.size()), MainFilename); // Remap the main source file to the preamble buffer. StringRef MainFilePath = FrontendOpts.Inputs[0].getFile(); PreprocessorOpts.addRemappedFile(MainFilePath, PreambleBuffer); // Tell the compiler invocation to generate a temporary precompiled header. FrontendOpts.ProgramAction = frontend::GeneratePCH; // FIXME: Generate the precompiled header into memory? FrontendOpts.OutputFile = PreamblePCHPath; PreprocessorOpts.PrecompiledPreambleBytes.first = 0; PreprocessorOpts.PrecompiledPreambleBytes.second = false; // Create the compiler instance to use for building the precompiled preamble. std::unique_ptr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(&*PreambleInvocation); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing all of the diagnostics produced. Clang->setDiagnostics(&getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); if (!Clang->hasTarget()) { llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.RemappedFileBuffers.pop_back(); return nullptr; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().adjust(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Clear out old caches and data. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts()); checkAndRemoveNonDriverDiags(StoredDiagnostics); TopLevelDecls.clear(); TopLevelDeclsInPreamble.clear(); PreambleDiagnostics.clear(); IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(Clang->getInvocation(), getDiagnostics()); if (!VFS) return nullptr; // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS)); // Create the source manager. Clang->setSourceManager(new SourceManager(getDiagnostics(), Clang->getFileManager())); auto PreambleDepCollector = std::make_shared(); Clang->addDependencyCollector(PreambleDepCollector); std::unique_ptr Act; Act.reset(new PrecompilePreambleAction(*this)); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.RemappedFileBuffers.pop_back(); return nullptr; } Act->Execute(); // Transfer any diagnostics generated when parsing the preamble into the set // of preamble diagnostics. for (stored_diag_iterator I = stored_diag_afterDriver_begin(), E = stored_diag_end(); I != E; ++I) { StandaloneDiagnostic Diag; makeStandaloneDiagnostic(Clang->getLangOpts(), *I, Diag); PreambleDiagnostics.push_back(Diag); } Act->EndSourceFile(); checkAndRemoveNonDriverDiags(StoredDiagnostics); if (!Act->hasEmittedPreamblePCH()) { // The preamble PCH failed (e.g. there was a module loading fatal error), // so no precompiled header was generated. Forget that we even tried. // FIXME: Should we leave a note for ourselves to try again? llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); TopLevelDeclsInPreamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.RemappedFileBuffers.pop_back(); return nullptr; } // Keep track of the preamble we precompiled. setPreambleFile(this, FrontendOpts.OutputFile); NumWarningsInPreamble = getDiagnostics().getNumWarnings(); // Keep track of all of the files that the source manager knows about, // so we can verify whether they have changed or not. FilesInPreamble.clear(); SourceManager &SourceMgr = Clang->getSourceManager(); for (auto &Filename : PreambleDepCollector->getDependencies()) { const FileEntry *File = Clang->getFileManager().getFile(Filename); if (!File || File == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())) continue; if (time_t ModTime = File->getModificationTime()) { FilesInPreamble[File->getName()] = PreambleFileHash::createForFile( File->getSize(), ModTime); } else { llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File); FilesInPreamble[File->getName()] = PreambleFileHash::createForMemoryBuffer(Buffer); } } PreambleRebuildCounter = 1; PreprocessorOpts.RemappedFileBuffers.pop_back(); // If the hash of top-level entities differs from the hash of the top-level // entities the last time we rebuilt the preamble, clear out the completion // cache. if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) { CompletionCacheTopLevelHashValue = 0; PreambleTopLevelHashValue = CurrentTopLevelHashValue; } return llvm::MemoryBuffer::getMemBufferCopy(NewPreamble.first->getBuffer(), MainFilename); } void ASTUnit::RealizeTopLevelDeclsFromPreamble() { std::vector Resolved; Resolved.reserve(TopLevelDeclsInPreamble.size()); ExternalASTSource &Source = *getASTContext().getExternalSource(); for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) { // Resolve the declaration ID to an actual declaration, possibly // deserializing the declaration in the process. Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]); if (D) Resolved.push_back(D); } TopLevelDeclsInPreamble.clear(); TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end()); } void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) { // Steal the created target, context, and preprocessor if they have been // created. assert(CI.hasInvocation() && "missing invocation"); LangOpts = CI.getInvocation().LangOpts; TheSema.reset(CI.takeSema()); Consumer.reset(CI.takeASTConsumer()); if (CI.hasASTContext()) Ctx = &CI.getASTContext(); if (CI.hasPreprocessor()) PP = &CI.getPreprocessor(); CI.setSourceManager(nullptr); CI.setFileManager(nullptr); if (CI.hasTarget()) Target = &CI.getTarget(); Reader = CI.getModuleManager(); HadModuleLoaderFatalFailure = CI.hadModuleLoaderFatalFailure(); } StringRef ASTUnit::getMainFileName() const { if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) { const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0]; if (Input.isFile()) return Input.getFile(); else return Input.getBuffer()->getBufferIdentifier(); } if (SourceMgr) { if (const FileEntry * FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID())) return FE->getName(); } return StringRef(); } StringRef ASTUnit::getASTFileName() const { if (!isMainFileAST()) return StringRef(); serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); return Mod.FileName; } ASTUnit *ASTUnit::create(CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool CaptureDiagnostics, bool UserFilesAreVolatile) { std::unique_ptr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; AST->Invocation = CI; AST->FileSystemOpts = CI->getFileSystemOpts(); IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr, UserFilesAreVolatile); return AST.release(); } ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( CompilerInvocation *CI, IntrusiveRefCntPtr Diags, ASTFrontendAction *Action, ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile, std::unique_ptr *ErrAST) { assert(CI && "A CompilerInvocation is required"); std::unique_ptr OwnAST; ASTUnit *AST = Unit; if (!AST) { // Create the AST unit. OwnAST.reset(create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile)); AST = OwnAST.get(); if (!AST) return nullptr; } if (!ResourceFilesPath.empty()) { // Override the resources path. CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; } AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; if (PrecompilePreamble) AST->PreambleRebuildCounter = 2; AST->TUKind = Action ? Action->getTranslationUnitKind() : TU_Complete; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(OwnAST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.get()); // We'll manage file buffers ourselves. CI->getPreprocessorOpts().RetainRemappedFileBuffers = true; CI->getFrontendOpts().DisableFree = false; ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts()); // Create the compiler instance to use for building the AST. std::unique_ptr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(CI); AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics that would // otherwise be dropped. Clang->setDiagnostics(&AST->getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); if (!Clang->hasTarget()) return nullptr; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().adjust(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not supported here!"); // Configure the various subsystems. AST->TheSema.reset(); AST->Ctx = nullptr; AST->PP = nullptr; AST->Reader = nullptr; // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(&AST->getFileManager()); // Create the source manager. Clang->setSourceManager(&AST->getSourceManager()); ASTFrontendAction *Act = Action; std::unique_ptr TrackerAct; if (!Act) { TrackerAct.reset(new TopLevelDeclTrackerAction(*AST)); Act = TrackerAct.get(); } // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ActCleanup(TrackerAct.get()); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { AST->transferASTDataFromCompilerInstance(*Clang); if (OwnAST && ErrAST) ErrAST->swap(OwnAST); return nullptr; } if (Persistent && !TrackerAct) { Clang->getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(AST->getCurrentTopLevelHashValue())); std::vector Consumers; if (Clang->hasASTConsumer()) Consumers.push_back(Clang->takeASTConsumer()); Consumers.push_back(new TopLevelDeclTrackerConsumer(*AST, AST->getCurrentTopLevelHashValue())); Clang->setASTConsumer(new MultiplexConsumer(Consumers)); } if (!Act->Execute()) { AST->transferASTDataFromCompilerInstance(*Clang); if (OwnAST && ErrAST) ErrAST->swap(OwnAST); return nullptr; } // Steal the created target, context, and preprocessor. AST->transferASTDataFromCompilerInstance(*Clang); Act->EndSourceFile(); if (OwnAST) return OwnAST.release(); else return AST; } bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) { if (!Invocation) return true; // We'll manage file buffers ourselves. Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true; Invocation->getFrontendOpts().DisableFree = false; ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); llvm::MemoryBuffer *OverrideMainBuffer = nullptr; if (PrecompilePreamble) { PreambleRebuildCounter = 2; OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); } SimpleTimer ParsingTimer(WantTiming); ParsingTimer.setOutput("Parsing " + getMainFileName()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar MemBufferCleanup(OverrideMainBuffer); return Parse(OverrideMainBuffer); } std::unique_ptr ASTUnit::LoadFromCompilerInvocation( CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile) { // Create the AST unit. std::unique_ptr AST(new ASTUnit(false)); ConfigureDiags(Diags, nullptr, nullptr, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->TUKind = TUKind; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; AST->Invocation = CI; AST->FileSystemOpts = CI->getFileSystemOpts(); IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); AST->UserFilesAreVolatile = UserFilesAreVolatile; // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.get()); if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) return nullptr; return AST; } ASTUnit *ASTUnit::LoadFromCommandLine( const char **ArgBegin, const char **ArgEnd, IntrusiveRefCntPtr Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, ArrayRef RemappedFiles, bool RemappedFilesKeepOriginalName, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies, bool UserFilesAreVolatile, bool ForSerialization, std::unique_ptr *ErrAST) { if (!Diags.get()) { // No diagnostics engine was provided, so create our own diagnostics object // with the default options. Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions()); } SmallVector StoredDiagnostics; IntrusiveRefCntPtr CI; { CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags, StoredDiagnostics); CI = clang::createInvocationFromCommandLine( llvm::makeArrayRef(ArgBegin, ArgEnd), Diags); if (!CI) return nullptr; } // Override any files that need remapping for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); } PreprocessorOptions &PPOpts = CI->getPreprocessorOpts(); PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName; PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors; // Override the resources path. CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies; // Create the AST unit. std::unique_ptr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, ArgBegin, ArgEnd, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; Diags = nullptr; // Zero out now to ease cleanup during crash recovery. AST->FileSystemOpts = CI->getFileSystemOpts(); IntrusiveRefCntPtr VFS = createVFSFromCompilerInvocation(*CI, *Diags); if (!VFS) return nullptr; AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->TUKind = TUKind; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); AST->StoredDiagnostics.swap(StoredDiagnostics); AST->Invocation = CI; if (ForSerialization) AST->WriterData.reset(new ASTWriterData()); CI = nullptr; // Zero out now to ease cleanup during crash recovery. // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) { // Some error occurred, if caller wants to examine diagnostics, pass it the // ASTUnit. if (ErrAST) { AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics); ErrAST->swap(AST); } return nullptr; } return AST.release(); } bool ASTUnit::Reparse(ArrayRef RemappedFiles) { if (!Invocation) return true; clearFileLevelDecls(); SimpleTimer ParsingTimer(WantTiming); ParsingTimer.setOutput("Reparsing " + getMainFileName()); // Remap files. PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); for (const auto &RB : PPOpts.RemappedFileBuffers) delete RB.second; Invocation->getPreprocessorOpts().clearRemappedFiles(); for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); } // If we have a preamble file lying around, or if we might try to // build a precompiled preamble, do so now. llvm::MemoryBuffer *OverrideMainBuffer = nullptr; if (!getPreambleFile(this).empty() || PreambleRebuildCounter > 0) OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); // Clear out the diagnostics state. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); if (OverrideMainBuffer) getDiagnostics().setNumWarnings(NumWarningsInPreamble); // Parse the sources bool Result = Parse(OverrideMainBuffer); // If we're caching global code-completion results, and the top-level // declarations have changed, clear out the code-completion cache. if (!Result && ShouldCacheCodeCompletionResults && CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue) CacheCodeCompletionResults(); // We now need to clear out the completion info related to this translation // unit; it'll be recreated if necessary. CCTUInfo.reset(); return Result; } //----------------------------------------------------------------------------// // Code completion //----------------------------------------------------------------------------// namespace { /// \brief Code completion consumer that combines the cached code-completion /// results from an ASTUnit with the code-completion results provided to it, /// then passes the result on to class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer { uint64_t NormalContexts; ASTUnit &AST; CodeCompleteConsumer &Next; public: AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next, const CodeCompleteOptions &CodeCompleteOpts) : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), AST(AST), Next(Next) { // Compute the set of contexts in which we will look when we don't have // any information about the specific context. NormalContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCInterface) | (1LL << CodeCompletionContext::CCC_ObjCImplementation) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_DotMemberAccess) | (1LL << CodeCompletionContext::CCC_ArrowMemberAccess) | (1LL << CodeCompletionContext::CCC_ObjCPropertyAccess) | (1LL << CodeCompletionContext::CCC_ObjCProtocolName) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_Recovery); if (AST.getASTContext().getLangOpts().CPlusPlus) NormalContexts |= (1LL << CodeCompletionContext::CCC_EnumTag) | (1LL << CodeCompletionContext::CCC_UnionTag) | (1LL << CodeCompletionContext::CCC_ClassOrStructTag); } void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) override; void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates) override { Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates); } CodeCompletionAllocator &getAllocator() override { return Next.getAllocator(); } CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return Next.getCodeCompletionTUInfo(); } }; } /// \brief Helper function that computes which global names are hidden by the /// local code-completion results. static void CalculateHiddenNames(const CodeCompletionContext &Context, CodeCompletionResult *Results, unsigned NumResults, ASTContext &Ctx, llvm::StringSet &HiddenNames){ bool OnlyTagNames = false; switch (Context.getKind()) { case CodeCompletionContext::CCC_Recovery: case CodeCompletionContext::CCC_TopLevel: case CodeCompletionContext::CCC_ObjCInterface: case CodeCompletionContext::CCC_ObjCImplementation: case CodeCompletionContext::CCC_ObjCIvarList: case CodeCompletionContext::CCC_ClassStructUnion: case CodeCompletionContext::CCC_Statement: case CodeCompletionContext::CCC_Expression: case CodeCompletionContext::CCC_ObjCMessageReceiver: case CodeCompletionContext::CCC_DotMemberAccess: case CodeCompletionContext::CCC_ArrowMemberAccess: case CodeCompletionContext::CCC_ObjCPropertyAccess: case CodeCompletionContext::CCC_Namespace: case CodeCompletionContext::CCC_Type: case CodeCompletionContext::CCC_Name: case CodeCompletionContext::CCC_PotentiallyQualifiedName: case CodeCompletionContext::CCC_ParenthesizedExpression: case CodeCompletionContext::CCC_ObjCInterfaceName: break; case CodeCompletionContext::CCC_EnumTag: case CodeCompletionContext::CCC_UnionTag: case CodeCompletionContext::CCC_ClassOrStructTag: OnlyTagNames = true; break; case CodeCompletionContext::CCC_ObjCProtocolName: case CodeCompletionContext::CCC_MacroName: case CodeCompletionContext::CCC_MacroNameUse: case CodeCompletionContext::CCC_PreprocessorExpression: case CodeCompletionContext::CCC_PreprocessorDirective: case CodeCompletionContext::CCC_NaturalLanguage: case CodeCompletionContext::CCC_SelectorName: case CodeCompletionContext::CCC_TypeQualifiers: case CodeCompletionContext::CCC_Other: case CodeCompletionContext::CCC_OtherWithMacros: case CodeCompletionContext::CCC_ObjCInstanceMessage: case CodeCompletionContext::CCC_ObjCClassMessage: case CodeCompletionContext::CCC_ObjCCategoryName: // We're looking for nothing, or we're looking for names that cannot // be hidden. return; } typedef CodeCompletionResult Result; for (unsigned I = 0; I != NumResults; ++I) { if (Results[I].Kind != Result::RK_Declaration) continue; unsigned IDNS = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace(); bool Hiding = false; if (OnlyTagNames) Hiding = (IDNS & Decl::IDNS_Tag); else { unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | Decl::IDNS_Namespace | Decl::IDNS_Ordinary | Decl::IDNS_NonMemberOperator); if (Ctx.getLangOpts().CPlusPlus) HiddenIDNS |= Decl::IDNS_Tag; Hiding = (IDNS & HiddenIDNS); } if (!Hiding) continue; DeclarationName Name = Results[I].Declaration->getDeclName(); if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo()) HiddenNames.insert(Identifier->getName()); else HiddenNames.insert(Name.getAsString()); } } void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) { // Merge the results we were given with the results we cached. bool AddedResult = false; uint64_t InContexts = Context.getKind() == CodeCompletionContext::CCC_Recovery ? NormalContexts : (1LL << Context.getKind()); // Contains the set of names that are hidden by "local" completion results. llvm::StringSet HiddenNames; typedef CodeCompletionResult Result; SmallVector AllResults; for (ASTUnit::cached_completion_iterator C = AST.cached_completion_begin(), CEnd = AST.cached_completion_end(); C != CEnd; ++C) { // If the context we are in matches any of the contexts we are // interested in, we'll add this result. if ((C->ShowInContexts & InContexts) == 0) continue; // If we haven't added any results previously, do so now. if (!AddedResult) { CalculateHiddenNames(Context, Results, NumResults, S.Context, HiddenNames); AllResults.insert(AllResults.end(), Results, Results + NumResults); AddedResult = true; } // Determine whether this global completion result is hidden by a local // completion result. If so, skip it. if (C->Kind != CXCursor_MacroDefinition && HiddenNames.count(C->Completion->getTypedText())) continue; // Adjust priority based on similar type classes. unsigned Priority = C->Priority; CodeCompletionString *Completion = C->Completion; if (!Context.getPreferredType().isNull()) { if (C->Kind == CXCursor_MacroDefinition) { Priority = getMacroUsagePriority(C->Completion->getTypedText(), S.getLangOpts(), Context.getPreferredType()->isAnyPointerType()); } else if (C->Type) { CanQualType Expected = S.Context.getCanonicalType( Context.getPreferredType().getUnqualifiedType()); SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected); if (ExpectedSTC == C->TypeClass) { // We know this type is similar; check for an exact match. llvm::StringMap &CachedCompletionTypes = AST.getCachedCompletionTypes(); llvm::StringMap::iterator Pos = CachedCompletionTypes.find(QualType(Expected).getAsString()); if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type) Priority /= CCF_ExactTypeMatch; else Priority /= CCF_SimilarTypeMatch; } } } // Adjust the completion string, if required. if (C->Kind == CXCursor_MacroDefinition && Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) { // Create a new code-completion string that just contains the // macro name, without its arguments. CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(), CCP_CodePattern, C->Availability); Builder.AddTypedTextChunk(C->Completion->getTypedText()); Priority = CCP_CodePattern; Completion = Builder.TakeString(); } AllResults.push_back(Result(Completion, Priority, C->Kind, C->Availability)); } // If we did not add any cached completion results, just forward the // results we were given to the next consumer. if (!AddedResult) { Next.ProcessCodeCompleteResults(S, Context, Results, NumResults); return; } Next.ProcessCodeCompleteResults(S, Context, AllResults.data(), AllResults.size()); } void ASTUnit::CodeComplete(StringRef File, unsigned Line, unsigned Column, ArrayRef RemappedFiles, bool IncludeMacros, bool IncludeCodePatterns, bool IncludeBriefComments, CodeCompleteConsumer &Consumer, DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, FileManager &FileMgr, SmallVectorImpl &StoredDiagnostics, SmallVectorImpl &OwnedBuffers) { if (!Invocation) return; SimpleTimer CompletionTimer(WantTiming); CompletionTimer.setOutput("Code completion @@ " + File + ":" + Twine(Line) + ":" + Twine(Column)); IntrusiveRefCntPtr CCInvocation(new CompilerInvocation(*Invocation)); FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts(); CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts; PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts(); CodeCompleteOpts.IncludeMacros = IncludeMacros && CachedCompletionResults.empty(); CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns; CodeCompleteOpts.IncludeGlobals = CachedCompletionResults.empty(); CodeCompleteOpts.IncludeBriefComments = IncludeBriefComments; assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion); FrontendOpts.CodeCompletionAt.FileName = File; FrontendOpts.CodeCompletionAt.Line = Line; FrontendOpts.CodeCompletionAt.Column = Column; // Set the language options appropriately. LangOpts = *CCInvocation->getLangOpts(); std::unique_ptr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(&*CCInvocation); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics produced. Clang->setDiagnostics(&Diag); CaptureDroppedDiagnostics Capture(true, Clang->getDiagnostics(), StoredDiagnostics); ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); if (!Clang->hasTarget()) { Clang->setInvocation(nullptr); return; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().adjust(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Use the source and file managers that we were given. Clang->setFileManager(&FileMgr); Clang->setSourceManager(&SourceMgr); // Remap files. PreprocessorOpts.clearRemappedFiles(); PreprocessorOpts.RetainRemappedFileBuffers = true; for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); OwnedBuffers.push_back(RemappedFiles[I].second); } // Use the code completion consumer we were given, but adding any cached // code-completion results. AugmentedCodeCompleteConsumer *AugmentedConsumer = new AugmentedCodeCompleteConsumer(*this, Consumer, CodeCompleteOpts); Clang->setCodeCompletionConsumer(AugmentedConsumer); // If we have a precompiled preamble, try to use it. We only allow // the use of the precompiled preamble if we're if the completion // point is within the main file, after the end of the precompiled // preamble. llvm::MemoryBuffer *OverrideMainBuffer = nullptr; if (!getPreambleFile(this).empty()) { std::string CompleteFilePath(File); llvm::sys::fs::UniqueID CompleteFileID; if (!llvm::sys::fs::getUniqueID(CompleteFilePath, CompleteFileID)) { std::string MainPath(OriginalSourceFile); llvm::sys::fs::UniqueID MainID; if (!llvm::sys::fs::getUniqueID(MainPath, MainID)) { if (CompleteFileID == MainID && Line > 1) OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*CCInvocation, false, Line - 1); } } } // If the main file has been overridden due to the use of a preamble, // make that override happen and introduce the preamble. if (OverrideMainBuffer) { PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); PreprocessorOpts.PrecompiledPreambleBytes.second = PreambleEndsAtStartOfLine; PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); PreprocessorOpts.DisablePCHValidation = true; OwnedBuffers.push_back(OverrideMainBuffer); } else { PreprocessorOpts.PrecompiledPreambleBytes.first = 0; PreprocessorOpts.PrecompiledPreambleBytes.second = false; } // Disable the preprocessing record if modules are not enabled. if (!Clang->getLangOpts().Modules) PreprocessorOpts.DetailedRecord = false; std::unique_ptr Act; Act.reset(new SyntaxOnlyAction); if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { Act->Execute(); Act->EndSourceFile(); } } bool ASTUnit::Save(StringRef File) { if (HadModuleLoaderFatalFailure) return true; // Write to a temporary file and later rename it to the actual file, to avoid // possible race conditions. SmallString<128> TempPath; TempPath = File; TempPath += "-%%%%%%%%"; int fd; if (llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath)) return true; // FIXME: Can we somehow regenerate the stat cache here, or do we need to // unconditionally create a stat cache when we parse the file? llvm::raw_fd_ostream Out(fd, /*shouldClose=*/true); serialize(Out); Out.close(); if (Out.has_error()) { Out.clear_error(); return true; } if (llvm::sys::fs::rename(TempPath.str(), File)) { llvm::sys::fs::remove(TempPath.str()); return true; } return false; } static bool serializeUnit(ASTWriter &Writer, SmallVectorImpl &Buffer, Sema &S, bool hasErrors, raw_ostream &OS) { Writer.WriteAST(S, std::string(), nullptr, "", hasErrors); // Write the generated bitstream to "Out". if (!Buffer.empty()) OS.write(Buffer.data(), Buffer.size()); return false; } bool ASTUnit::serialize(raw_ostream &OS) { bool hasErrors = getDiagnostics().hasErrorOccurred(); if (WriterData) return serializeUnit(WriterData->Writer, WriterData->Buffer, getSema(), hasErrors, OS); SmallString<128> Buffer; llvm::BitstreamWriter Stream(Buffer); ASTWriter Writer(Stream); return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS); } typedef ContinuousRangeMap SLocRemap; void ASTUnit::TranslateStoredDiagnostics( FileManager &FileMgr, SourceManager &SrcMgr, const SmallVectorImpl &Diags, SmallVectorImpl &Out) { // Map the standalone diagnostic into the new source manager. We also need to // remap all the locations to the new view. This includes the diag location, // any associated source ranges, and the source ranges of associated fix-its. // FIXME: There should be a cleaner way to do this. SmallVector Result; Result.reserve(Diags.size()); for (unsigned I = 0, N = Diags.size(); I != N; ++I) { // Rebuild the StoredDiagnostic. const StandaloneDiagnostic &SD = Diags[I]; if (SD.Filename.empty()) continue; const FileEntry *FE = FileMgr.getFile(SD.Filename); if (!FE) continue; FileID FID = SrcMgr.translateFile(FE); SourceLocation FileLoc = SrcMgr.getLocForStartOfFile(FID); if (FileLoc.isInvalid()) continue; SourceLocation L = FileLoc.getLocWithOffset(SD.LocOffset); FullSourceLoc Loc(L, SrcMgr); SmallVector Ranges; Ranges.reserve(SD.Ranges.size()); for (std::vector >::const_iterator I = SD.Ranges.begin(), E = SD.Ranges.end(); I != E; ++I) { SourceLocation BL = FileLoc.getLocWithOffset((*I).first); SourceLocation EL = FileLoc.getLocWithOffset((*I).second); Ranges.push_back(CharSourceRange::getCharRange(BL, EL)); } SmallVector FixIts; FixIts.reserve(SD.FixIts.size()); for (std::vector::const_iterator I = SD.FixIts.begin(), E = SD.FixIts.end(); I != E; ++I) { FixIts.push_back(FixItHint()); FixItHint &FH = FixIts.back(); FH.CodeToInsert = I->CodeToInsert; SourceLocation BL = FileLoc.getLocWithOffset(I->RemoveRange.first); SourceLocation EL = FileLoc.getLocWithOffset(I->RemoveRange.second); FH.RemoveRange = CharSourceRange::getCharRange(BL, EL); } Result.push_back(StoredDiagnostic(SD.Level, SD.ID, SD.Message, Loc, Ranges, FixIts)); } Result.swap(Out); } void ASTUnit::addFileLevelDecl(Decl *D) { assert(D); // We only care about local declarations. if (D->isFromASTFile()) return; SourceManager &SM = *SourceMgr; SourceLocation Loc = D->getLocation(); if (Loc.isInvalid() || !SM.isLocalSourceLocation(Loc)) return; // We only keep track of the file-level declarations of each file. if (!D->getLexicalDeclContext()->isFileContext()) return; SourceLocation FileLoc = SM.getFileLoc(Loc); assert(SM.isLocalSourceLocation(FileLoc)); FileID FID; unsigned Offset; std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); if (FID.isInvalid()) return; LocDeclsTy *&Decls = FileDecls[FID]; if (!Decls) Decls = new LocDeclsTy(); std::pair LocDecl(Offset, D); if (Decls->empty() || Decls->back().first <= Offset) { Decls->push_back(LocDecl); return; } LocDeclsTy::iterator I = std::upper_bound(Decls->begin(), Decls->end(), LocDecl, llvm::less_first()); Decls->insert(I, LocDecl); } void ASTUnit::findFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl &Decls) { if (File.isInvalid()) return; if (SourceMgr->isLoadedFileID(File)) { assert(Ctx->getExternalSource() && "No external source!"); return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length, Decls); } FileDeclsTy::iterator I = FileDecls.find(File); if (I == FileDecls.end()) return; LocDeclsTy &LocDecls = *I->second; if (LocDecls.empty()) return; LocDeclsTy::iterator BeginIt = std::lower_bound(LocDecls.begin(), LocDecls.end(), std::make_pair(Offset, (Decl *)nullptr), llvm::less_first()); if (BeginIt != LocDecls.begin()) --BeginIt; // If we are pointing at a top-level decl inside an objc container, we need // to backtrack until we find it otherwise we will fail to report that the // region overlaps with an objc container. while (BeginIt != LocDecls.begin() && BeginIt->second->isTopLevelDeclInObjCContainer()) --BeginIt; LocDeclsTy::iterator EndIt = std::upper_bound( LocDecls.begin(), LocDecls.end(), std::make_pair(Offset + Length, (Decl *)nullptr), llvm::less_first()); if (EndIt != LocDecls.end()) ++EndIt; for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt) Decls.push_back(DIt->second); } SourceLocation ASTUnit::getLocation(const FileEntry *File, unsigned Line, unsigned Col) const { const SourceManager &SM = getSourceManager(); SourceLocation Loc = SM.translateFileLineCol(File, Line, Col); return SM.getMacroArgExpandedLocation(Loc); } SourceLocation ASTUnit::getLocation(const FileEntry *File, unsigned Offset) const { const SourceManager &SM = getSourceManager(); SourceLocation FileLoc = SM.translateFileLineCol(File, 1, 1); return SM.getMacroArgExpandedLocation(FileLoc.getLocWithOffset(Offset)); } /// \brief If \arg Loc is a loaded location from the preamble, returns /// the corresponding local location of the main file, otherwise it returns /// \arg Loc. SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) { FileID PreambleID; if (SourceMgr) PreambleID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) return Loc; unsigned Offs; if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble.size()) { SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID()); return FileLoc.getLocWithOffset(Offs); } return Loc; } /// \brief If \arg Loc is a local location of the main file but inside the /// preamble chunk, returns the corresponding loaded location from the /// preamble, otherwise it returns \arg Loc. SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) { FileID PreambleID; if (SourceMgr) PreambleID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) return Loc; unsigned Offs; if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) && Offs < Preamble.size()) { SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID); return FileLoc.getLocWithOffset(Offs); } return Loc; } bool ASTUnit::isInPreambleFileID(SourceLocation Loc) { FileID FID; if (SourceMgr) FID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || FID.isInvalid()) return false; return SourceMgr->isInFileID(Loc, FID); } bool ASTUnit::isInMainFileID(SourceLocation Loc) { FileID FID; if (SourceMgr) FID = SourceMgr->getMainFileID(); if (Loc.isInvalid() || FID.isInvalid()) return false; return SourceMgr->isInFileID(Loc, FID); } SourceLocation ASTUnit::getEndOfPreambleFileID() { FileID FID; if (SourceMgr) FID = SourceMgr->getPreambleFileID(); if (FID.isInvalid()) return SourceLocation(); return SourceMgr->getLocForEndOfFile(FID); } SourceLocation ASTUnit::getStartOfMainFileID() { FileID FID; if (SourceMgr) FID = SourceMgr->getMainFileID(); if (FID.isInvalid()) return SourceLocation(); return SourceMgr->getLocForStartOfFile(FID); } std::pair ASTUnit::getLocalPreprocessingEntities() const { if (isMainFileAST()) { serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); return Reader->getModulePreprocessedEntities(Mod); } if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord()) return std::make_pair(PPRec->local_begin(), PPRec->local_end()); return std::make_pair(PreprocessingRecord::iterator(), PreprocessingRecord::iterator()); } bool ASTUnit::visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn) { if (isMainFileAST()) { serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); ASTReader::ModuleDeclIterator MDI, MDE; std::tie(MDI, MDE) = Reader->getModuleFileLevelDecls(Mod); for (; MDI != MDE; ++MDI) { if (!Fn(context, *MDI)) return false; } return true; } for (ASTUnit::top_level_iterator TL = top_level_begin(), TLEnd = top_level_end(); TL != TLEnd; ++TL) { if (!Fn(context, *TL)) return false; } return true; } namespace { struct PCHLocatorInfo { serialization::ModuleFile *Mod; PCHLocatorInfo() : Mod(nullptr) {} }; } static bool PCHLocator(serialization::ModuleFile &M, void *UserData) { PCHLocatorInfo &Info = *static_cast(UserData); switch (M.Kind) { case serialization::MK_Module: return true; // skip dependencies. case serialization::MK_PCH: Info.Mod = &M; return true; // found it. case serialization::MK_Preamble: return false; // look in dependencies. case serialization::MK_MainFile: return false; // look in dependencies. } return true; } const FileEntry *ASTUnit::getPCHFile() { if (!Reader) return nullptr; PCHLocatorInfo Info; Reader->getModuleManager().visit(PCHLocator, &Info); if (Info.Mod) return Info.Mod->File; return nullptr; } bool ASTUnit::isModuleFile() { return isMainFileAST() && !ASTFileLangOpts.CurrentModule.empty(); } void ASTUnit::PreambleData::countLines() const { NumLines = 0; if (empty()) return; for (std::vector::const_iterator I = Buffer.begin(), E = Buffer.end(); I != E; ++I) { if (*I == '\n') ++NumLines; } if (Buffer.back() != '\n') ++NumLines; } #ifndef NDEBUG ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = new llvm::sys::MutexImpl(/*recursive=*/true); } ASTUnit::ConcurrencyState::~ConcurrencyState() { delete static_cast(Mutex); } void ASTUnit::ConcurrencyState::start() { bool acquired = static_cast(Mutex)->tryacquire(); assert(acquired && "Concurrent access to ASTUnit!"); } void ASTUnit::ConcurrencyState::finish() { static_cast(Mutex)->release(); } #else // NDEBUG ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = 0; } ASTUnit::ConcurrencyState::~ConcurrencyState() {} void ASTUnit::ConcurrencyState::start() {} void ASTUnit::ConcurrencyState::finish() {} #endif @ 1.1.1.5.4.1 log @file ASTUnit.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:27 +0000 @ text @d1 2957 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 2957 //===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // ASTUnit Implementation. // //===----------------------------------------------------------------------===// #include "clang/Frontend/ASTUnit.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclVisitor.h" #include "clang/AST/StmtVisitor.h" #include "clang/AST/TypeOrdering.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Basic/VirtualFileSystem.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/FrontendOptions.h" #include "clang/Frontend/MultiplexConsumer.h" #include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/PreprocessorOptions.h" #include "clang/Sema/Sema.h" #include "clang/Serialization/ASTReader.h" #include "clang/Serialization/ASTWriter.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" #include "llvm/Support/Atomic.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/Host.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Mutex.h" #include "llvm/Support/MutexGuard.h" #include "llvm/Support/Path.h" #include "llvm/Support/Timer.h" #include "llvm/Support/raw_ostream.h" #include #include #include using namespace clang; using llvm::TimeRecord; namespace { class SimpleTimer { bool WantTiming; TimeRecord Start; std::string Output; public: explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) { if (WantTiming) Start = TimeRecord::getCurrentTime(); } void setOutput(const Twine &Output) { if (WantTiming) this->Output = Output.str(); } ~SimpleTimer() { if (WantTiming) { TimeRecord Elapsed = TimeRecord::getCurrentTime(); Elapsed -= Start; llvm::errs() << Output << ':'; Elapsed.print(Elapsed, llvm::errs()); llvm::errs() << '\n'; } } }; struct OnDiskData { /// \brief The file in which the precompiled preamble is stored. std::string PreambleFile; /// \brief Temporary files that should be removed when the ASTUnit is /// destroyed. SmallVector TemporaryFiles; /// \brief Erase temporary files. void CleanTemporaryFiles(); /// \brief Erase the preamble file. void CleanPreambleFile(); /// \brief Erase temporary files and the preamble file. void Cleanup(); }; } static llvm::sys::SmartMutex &getOnDiskMutex() { static llvm::sys::SmartMutex M(/* recursive = */ true); return M; } static void cleanupOnDiskMapAtExit(); typedef llvm::DenseMap OnDiskDataMap; static OnDiskDataMap &getOnDiskDataMap() { static OnDiskDataMap M; static bool hasRegisteredAtExit = false; if (!hasRegisteredAtExit) { hasRegisteredAtExit = true; atexit(cleanupOnDiskMapAtExit); } return M; } static void cleanupOnDiskMapAtExit() { // Use the mutex because there can be an alive thread destroying an ASTUnit. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); for (OnDiskDataMap::iterator I = M.begin(), E = M.end(); I != E; ++I) { // We don't worry about freeing the memory associated with OnDiskDataMap. // All we care about is erasing stale files. I->second->Cleanup(); } } static OnDiskData &getOnDiskData(const ASTUnit *AU) { // We require the mutex since we are modifying the structure of the // DenseMap. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); OnDiskData *&D = M[AU]; if (!D) D = new OnDiskData(); return *D; } static void erasePreambleFile(const ASTUnit *AU) { getOnDiskData(AU).CleanPreambleFile(); } static void removeOnDiskEntry(const ASTUnit *AU) { // We require the mutex since we are modifying the structure of the // DenseMap. llvm::MutexGuard Guard(getOnDiskMutex()); OnDiskDataMap &M = getOnDiskDataMap(); OnDiskDataMap::iterator I = M.find(AU); if (I != M.end()) { I->second->Cleanup(); delete I->second; M.erase(AU); } } static void setPreambleFile(const ASTUnit *AU, StringRef preambleFile) { getOnDiskData(AU).PreambleFile = preambleFile; } static const std::string &getPreambleFile(const ASTUnit *AU) { return getOnDiskData(AU).PreambleFile; } void OnDiskData::CleanTemporaryFiles() { for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) llvm::sys::fs::remove(TemporaryFiles[I]); TemporaryFiles.clear(); } void OnDiskData::CleanPreambleFile() { if (!PreambleFile.empty()) { llvm::sys::fs::remove(PreambleFile); PreambleFile.clear(); } } void OnDiskData::Cleanup() { CleanTemporaryFiles(); CleanPreambleFile(); } struct ASTUnit::ASTWriterData { SmallString<128> Buffer; llvm::BitstreamWriter Stream; ASTWriter Writer; ASTWriterData() : Stream(Buffer), Writer(Stream) { } }; void ASTUnit::clearFileLevelDecls() { llvm::DeleteContainerSeconds(FileDecls); } void ASTUnit::CleanTemporaryFiles() { getOnDiskData(this).CleanTemporaryFiles(); } void ASTUnit::addTemporaryFile(StringRef TempFile) { getOnDiskData(this).TemporaryFiles.push_back(TempFile); } /// \brief After failing to build a precompiled preamble (due to /// errors in the source that occurs in the preamble), the number of /// reparses during which we'll skip even trying to precompile the /// preamble. const unsigned DefaultPreambleRebuildInterval = 5; /// \brief Tracks the number of ASTUnit objects that are currently active. /// /// Used for debugging purposes only. static llvm::sys::cas_flag ActiveASTUnitObjects; ASTUnit::ASTUnit(bool _MainFileIsAST) : Reader(0), HadModuleLoaderFatalFailure(false), OnlyLocalDecls(false), CaptureDiagnostics(false), MainFileIsAST(_MainFileIsAST), TUKind(TU_Complete), WantTiming(getenv("LIBCLANG_TIMING")), OwnsRemappedFileBuffers(true), NumStoredDiagnosticsFromDriver(0), PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0), NumWarningsInPreamble(0), ShouldCacheCodeCompletionResults(false), IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), CompletionCacheTopLevelHashValue(0), PreambleTopLevelHashValue(0), CurrentTopLevelHashValue(0), UnsafeToFree(false) { if (getenv("LIBCLANG_OBJTRACKING")) { llvm::sys::AtomicIncrement(&ActiveASTUnitObjects); fprintf(stderr, "+++ %d translation units\n", (int)ActiveASTUnitObjects); } } ASTUnit::~ASTUnit() { // If we loaded from an AST file, balance out the BeginSourceFile call. if (MainFileIsAST && getDiagnostics().getClient()) { getDiagnostics().getClient()->EndSourceFile(); } clearFileLevelDecls(); // Clean up the temporary files and the preamble file. removeOnDiskEntry(this); // Free the buffers associated with remapped files. We are required to // perform this operation here because we explicitly request that the // compiler instance *not* free these buffers for each invocation of the // parser. if (Invocation.getPtr() && OwnsRemappedFileBuffers) { PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); for (PreprocessorOptions::remapped_file_buffer_iterator FB = PPOpts.remapped_file_buffer_begin(), FBEnd = PPOpts.remapped_file_buffer_end(); FB != FBEnd; ++FB) delete FB->second; } delete SavedMainFileBuffer; delete PreambleBuffer; ClearCachedCompletionResults(); if (getenv("LIBCLANG_OBJTRACKING")) { llvm::sys::AtomicDecrement(&ActiveASTUnitObjects); fprintf(stderr, "--- %d translation units\n", (int)ActiveASTUnitObjects); } } void ASTUnit::setPreprocessor(Preprocessor *pp) { PP = pp; } /// \brief Determine the set of code-completion contexts in which this /// declaration should be shown. static unsigned getDeclShowContexts(const NamedDecl *ND, const LangOptions &LangOpts, bool &IsNestedNameSpecifier) { IsNestedNameSpecifier = false; if (isa(ND)) ND = dyn_cast(ND->getUnderlyingDecl()); if (!ND) return 0; uint64_t Contexts = 0; if (isa(ND) || isa(ND) || isa(ND) || isa(ND)) { // Types can appear in these contexts. if (LangOpts.CPlusPlus || !isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Type) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); // In C++, types can appear in expressions contexts (for functional casts). if (LangOpts.CPlusPlus) Contexts |= (1LL << CodeCompletionContext::CCC_Expression); // In Objective-C, message sends can send interfaces. In Objective-C++, // all types are available due to functional casts. if (LangOpts.CPlusPlus || isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); // In Objective-C, you can only be a subclass of another Objective-C class if (isa(ND)) Contexts |= (1LL << CodeCompletionContext::CCC_ObjCInterfaceName); // Deal with tag names. if (isa(ND)) { Contexts |= (1LL << CodeCompletionContext::CCC_EnumTag); // Part of the nested-name-specifier in C++0x. if (LangOpts.CPlusPlus11) IsNestedNameSpecifier = true; } else if (const RecordDecl *Record = dyn_cast(ND)) { if (Record->isUnion()) Contexts |= (1LL << CodeCompletionContext::CCC_UnionTag); else Contexts |= (1LL << CodeCompletionContext::CCC_ClassOrStructTag); if (LangOpts.CPlusPlus) IsNestedNameSpecifier = true; } else if (isa(ND)) IsNestedNameSpecifier = true; } else if (isa(ND) || isa(ND)) { // Values can appear in these contexts. Contexts = (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); } else if (isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_ObjCProtocolName); } else if (isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_ObjCCategoryName); } else if (isa(ND) || isa(ND)) { Contexts = (1LL << CodeCompletionContext::CCC_Namespace); // Part of the nested-name-specifier. IsNestedNameSpecifier = true; } return Contexts; } void ASTUnit::CacheCodeCompletionResults() { if (!TheSema) return; SimpleTimer Timer(WantTiming); Timer.setOutput("Cache global code completions for " + getMainFileName()); // Clear out the previous results. ClearCachedCompletionResults(); // Gather the set of global code completions. typedef CodeCompletionResult Result; SmallVector Results; CachedCompletionAllocator = new GlobalCodeCompletionAllocator; CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator); TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, CCTUInfo, Results); // Translate global code completions into cached completions. llvm::DenseMap CompletionTypes; for (unsigned I = 0, N = Results.size(); I != N; ++I) { switch (Results[I].Kind) { case Result::RK_Declaration: { bool IsNestedNameSpecifier = false; CachedCodeCompletionResult CachedResult; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier); CachedResult.Priority = Results[I].Priority; CachedResult.Kind = Results[I].CursorKind; CachedResult.Availability = Results[I].Availability; // Keep track of the type of this completion in an ASTContext-agnostic // way. QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration); if (UsageType.isNull()) { CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; } else { CanQualType CanUsageType = Ctx->getCanonicalType(UsageType.getUnqualifiedType()); CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType); // Determine whether we have already seen this type. If so, we save // ourselves the work of formatting the type string by using the // temporary, CanQualType-based hash table to find the associated value. unsigned &TypeValue = CompletionTypes[CanUsageType]; if (TypeValue == 0) { TypeValue = CompletionTypes.size(); CachedCompletionTypes[QualType(CanUsageType).getAsString()] = TypeValue; } CachedResult.Type = TypeValue; } CachedCompletionResults.push_back(CachedResult); /// Handle nested-name-specifiers in C++. if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) { // The contexts in which a nested-name-specifier can appear in C++. uint64_t NNSContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_EnumTag) | (1LL << CodeCompletionContext::CCC_UnionTag) | (1LL << CodeCompletionContext::CCC_ClassOrStructTag) | (1LL << CodeCompletionContext::CCC_Type) | (1LL << CodeCompletionContext::CCC_PotentiallyQualifiedName) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); if (isa(Results[I].Declaration) || isa(Results[I].Declaration)) NNSContexts |= (1LL << CodeCompletionContext::CCC_Namespace); if (unsigned RemainingContexts = NNSContexts & ~CachedResult.ShowInContexts) { // If there any contexts where this completion can be a // nested-name-specifier but isn't already an option, create a // nested-name-specifier completion. Results[I].StartsNestedNameSpecifier = true; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = RemainingContexts; CachedResult.Priority = CCP_NestedNameSpecifier; CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; CachedCompletionResults.push_back(CachedResult); } } break; } case Result::RK_Keyword: case Result::RK_Pattern: // Ignore keywords and patterns; we don't care, since they are so // easily regenerated. break; case Result::RK_Macro: { CachedCodeCompletionResult CachedResult; CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, *CachedCompletionAllocator, CCTUInfo, IncludeBriefCommentsInCodeCompletion); CachedResult.ShowInContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCInterface) | (1LL << CodeCompletionContext::CCC_ObjCImplementation) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_ClassStructUnion) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_MacroNameUse) | (1LL << CodeCompletionContext::CCC_PreprocessorExpression) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_OtherWithMacros); CachedResult.Priority = Results[I].Priority; CachedResult.Kind = Results[I].CursorKind; CachedResult.Availability = Results[I].Availability; CachedResult.TypeClass = STC_Void; CachedResult.Type = 0; CachedCompletionResults.push_back(CachedResult); break; } } } // Save the current top-level hash value. CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue; } void ASTUnit::ClearCachedCompletionResults() { CachedCompletionResults.clear(); CachedCompletionTypes.clear(); CachedCompletionAllocator = 0; } namespace { /// \brief Gathers information from ASTReader that will be used to initialize /// a Preprocessor. class ASTInfoCollector : public ASTReaderListener { Preprocessor &PP; ASTContext &Context; LangOptions &LangOpt; IntrusiveRefCntPtr &TargetOpts; IntrusiveRefCntPtr &Target; unsigned &Counter; bool InitializedLanguage; public: ASTInfoCollector(Preprocessor &PP, ASTContext &Context, LangOptions &LangOpt, IntrusiveRefCntPtr &TargetOpts, IntrusiveRefCntPtr &Target, unsigned &Counter) : PP(PP), Context(Context), LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target), Counter(Counter), InitializedLanguage(false) {} virtual bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain) { if (InitializedLanguage) return false; LangOpt = LangOpts; InitializedLanguage = true; updated(); return false; } virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain) { // If we've already initialized the target, don't do it again. if (Target) return false; this->TargetOpts = new TargetOptions(TargetOpts); Target = TargetInfo::CreateTargetInfo(PP.getDiagnostics(), &*this->TargetOpts); updated(); return false; } virtual void ReadCounter(const serialization::ModuleFile &M, unsigned Value) { Counter = Value; } private: void updated() { if (!Target || !InitializedLanguage) return; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Target->setForcedLangOptions(LangOpt); // Initialize the preprocessor. PP.Initialize(*Target); // Initialize the ASTContext Context.InitBuiltinTypes(*Target); // We didn't have access to the comment options when the ASTContext was // constructed, so register them now. Context.getCommentCommandTraits().registerCommentOptions( LangOpt.CommentOpts); } }; /// \brief Diagnostic consumer that saves each diagnostic it is given. class StoredDiagnosticConsumer : public DiagnosticConsumer { SmallVectorImpl &StoredDiags; SourceManager *SourceMgr; public: explicit StoredDiagnosticConsumer( SmallVectorImpl &StoredDiags) : StoredDiags(StoredDiags), SourceMgr(0) { } virtual void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP = 0) { if (PP) SourceMgr = &PP->getSourceManager(); } virtual void HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info); }; /// \brief RAII object that optionally captures diagnostics, if /// there is no diagnostic client to capture them already. class CaptureDroppedDiagnostics { DiagnosticsEngine &Diags; StoredDiagnosticConsumer Client; DiagnosticConsumer *PreviousClient; public: CaptureDroppedDiagnostics(bool RequestCapture, DiagnosticsEngine &Diags, SmallVectorImpl &StoredDiags) : Diags(Diags), Client(StoredDiags), PreviousClient(0) { if (RequestCapture || Diags.getClient() == 0) { PreviousClient = Diags.takeClient(); Diags.setClient(&Client); } } ~CaptureDroppedDiagnostics() { if (Diags.getClient() == &Client) { Diags.takeClient(); Diags.setClient(PreviousClient); } } }; } // anonymous namespace void StoredDiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info) { // Default implementation (Warnings/errors count). DiagnosticConsumer::HandleDiagnostic(Level, Info); // Only record the diagnostic if it's part of the source manager we know // about. This effectively drops diagnostics from modules we're building. // FIXME: In the long run, ee don't want to drop source managers from modules. if (!Info.hasSourceManager() || &Info.getSourceManager() == SourceMgr) StoredDiags.push_back(StoredDiagnostic(Level, Info)); } ASTMutationListener *ASTUnit::getASTMutationListener() { if (WriterData) return &WriterData->Writer; return 0; } ASTDeserializationListener *ASTUnit::getDeserializationListener() { if (WriterData) return &WriterData->Writer; return 0; } llvm::MemoryBuffer *ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) { assert(FileMgr); return FileMgr->getBufferForFile(Filename, ErrorStr); } /// \brief Configure the diagnostics object for use with ASTUnit. void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr &Diags, const char **ArgBegin, const char **ArgEnd, ASTUnit &AST, bool CaptureDiagnostics) { if (!Diags.getPtr()) { // No diagnostics engine was provided, so create our own diagnostics object // with the default options. DiagnosticConsumer *Client = 0; if (CaptureDiagnostics) Client = new StoredDiagnosticConsumer(AST.StoredDiagnostics); Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions(), Client, /*ShouldOwnClient=*/true); } else if (CaptureDiagnostics) { Diags->setClient(new StoredDiagnosticConsumer(AST.StoredDiagnostics)); } } ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename, IntrusiveRefCntPtr Diags, const FileSystemOptions &FileSystemOpts, bool OnlyLocalDecls, ArrayRef RemappedFiles, bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, bool UserFilesAreVolatile) { OwningPtr AST(new ASTUnit(true)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.getPtr()); ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->Diagnostics = Diags; AST->FileMgr = new FileManager(FileSystemOpts); AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->SourceMgr = new SourceManager(AST->getDiagnostics(), AST->getFileManager(), UserFilesAreVolatile); AST->HSOpts = new HeaderSearchOptions(); AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts, AST->getSourceManager(), AST->getDiagnostics(), AST->ASTFileLangOpts, /*Target=*/0)); PreprocessorOptions *PPOpts = new PreprocessorOptions(); for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) PPOpts->addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); // Gather Info for preprocessor construction later on. HeaderSearch &HeaderInfo = *AST->HeaderInfo.get(); unsigned Counter; AST->PP = new Preprocessor(PPOpts, AST->getDiagnostics(), AST->ASTFileLangOpts, /*Target=*/0, AST->getSourceManager(), HeaderInfo, *AST, /*IILookup=*/0, /*OwnsHeaderSearch=*/false, /*DelayInitialization=*/true); Preprocessor &PP = *AST->PP; AST->Ctx = new ASTContext(AST->ASTFileLangOpts, AST->getSourceManager(), /*Target=*/0, PP.getIdentifierTable(), PP.getSelectorTable(), PP.getBuiltinInfo(), /* size_reserve = */0, /*DelayInitialization=*/true); ASTContext &Context = *AST->Ctx; bool disableValid = false; if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION")) disableValid = true; AST->Reader = new ASTReader(PP, Context, /*isysroot=*/"", /*DisableValidation=*/disableValid, AllowPCHWithCompilerErrors); AST->Reader->setListener(new ASTInfoCollector(*AST->PP, Context, AST->ASTFileLangOpts, AST->TargetOpts, AST->Target, Counter)); switch (AST->Reader->ReadAST(Filename, serialization::MK_MainFile, SourceLocation(), ASTReader::ARR_None)) { case ASTReader::Success: break; case ASTReader::Failure: case ASTReader::Missing: case ASTReader::OutOfDate: case ASTReader::VersionMismatch: case ASTReader::ConfigurationMismatch: case ASTReader::HadErrors: AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch); return NULL; } AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile(); PP.setCounterValue(Counter); // Attach the AST reader to the AST context as an external AST // source, so that declarations will be deserialized from the // AST file as needed. Context.setExternalSource(AST->Reader); // Create an AST consumer, even though it isn't used. AST->Consumer.reset(new ASTConsumer); // Create a semantic analysis object and tell the AST reader about it. AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer)); AST->TheSema->Initialize(); AST->Reader->InitializeSema(*AST->TheSema); // Tell the diagnostic client that we have started a source file. AST->getDiagnostics().getClient()->BeginSourceFile(Context.getLangOpts(),&PP); return AST.take(); } namespace { /// \brief Preprocessor callback class that updates a hash value with the names /// of all macros that have been defined by the translation unit. class MacroDefinitionTrackerPPCallbacks : public PPCallbacks { unsigned &Hash; public: explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { } virtual void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) { Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash); } }; /// \brief Add the given declaration to the hash of all top-level entities. void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { if (!D) return; DeclContext *DC = D->getDeclContext(); if (!DC) return; if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit())) return; if (NamedDecl *ND = dyn_cast(D)) { if (EnumDecl *EnumD = dyn_cast(D)) { // For an unscoped enum include the enumerators in the hash since they // enter the top-level namespace. if (!EnumD->isScoped()) { for (EnumDecl::enumerator_iterator EI = EnumD->enumerator_begin(), EE = EnumD->enumerator_end(); EI != EE; ++EI) { if ((*EI)->getIdentifier()) Hash = llvm::HashString((*EI)->getIdentifier()->getName(), Hash); } } } if (ND->getIdentifier()) Hash = llvm::HashString(ND->getIdentifier()->getName(), Hash); else if (DeclarationName Name = ND->getDeclName()) { std::string NameStr = Name.getAsString(); Hash = llvm::HashString(NameStr, Hash); } return; } if (ImportDecl *ImportD = dyn_cast(D)) { if (Module *Mod = ImportD->getImportedModule()) { std::string ModName = Mod->getFullModuleName(); Hash = llvm::HashString(ModName, Hash); } return; } } class TopLevelDeclTrackerConsumer : public ASTConsumer { ASTUnit &Unit; unsigned &Hash; public: TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash) : Unit(_Unit), Hash(Hash) { Hash = 0; } void handleTopLevelDecl(Decl *D) { if (!D) return; // FIXME: Currently ObjC method declarations are incorrectly being // reported as top-level declarations, even though their DeclContext // is the containing ObjC @@interface/@@implementation. This is a // fundamental problem in the parser right now. if (isa(D)) return; AddTopLevelDeclarationToHash(D, Hash); Unit.addTopLevelDecl(D); handleFileLevelDecl(D); } void handleFileLevelDecl(Decl *D) { Unit.addFileLevelDecl(D); if (NamespaceDecl *NSD = dyn_cast(D)) { for (NamespaceDecl::decl_iterator I = NSD->decls_begin(), E = NSD->decls_end(); I != E; ++I) handleFileLevelDecl(*I); } } bool HandleTopLevelDecl(DeclGroupRef D) { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) handleTopLevelDecl(*it); return true; } // We're not interested in "interesting" decls. void HandleInterestingDecl(DeclGroupRef) {} void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) handleTopLevelDecl(*it); } virtual ASTMutationListener *GetASTMutationListener() { return Unit.getASTMutationListener(); } virtual ASTDeserializationListener *GetASTDeserializationListener() { return Unit.getDeserializationListener(); } }; class TopLevelDeclTrackerAction : public ASTFrontendAction { public: ASTUnit &Unit; virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { CI.getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue())); return new TopLevelDeclTrackerConsumer(Unit, Unit.getCurrentTopLevelHashValue()); } public: TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} virtual bool hasCodeCompletionSupport() const { return false; } virtual TranslationUnitKind getTranslationUnitKind() { return Unit.getTranslationUnitKind(); } }; class PrecompilePreambleAction : public ASTFrontendAction { ASTUnit &Unit; bool HasEmittedPreamblePCH; public: explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit), HasEmittedPreamblePCH(false) {} virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, StringRef InFile); bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; } void setHasEmittedPreamblePCH() { HasEmittedPreamblePCH = true; } virtual bool shouldEraseOutputFiles() { return !hasEmittedPreamblePCH(); } virtual bool hasCodeCompletionSupport() const { return false; } virtual bool hasASTFileSupport() const { return false; } virtual TranslationUnitKind getTranslationUnitKind() { return TU_Prefix; } }; class PrecompilePreambleConsumer : public PCHGenerator { ASTUnit &Unit; unsigned &Hash; std::vector TopLevelDecls; PrecompilePreambleAction *Action; public: PrecompilePreambleConsumer(ASTUnit &Unit, PrecompilePreambleAction *Action, const Preprocessor &PP, StringRef isysroot, raw_ostream *Out) : PCHGenerator(PP, "", 0, isysroot, Out, /*AllowASTWithErrors=*/true), Unit(Unit), Hash(Unit.getCurrentTopLevelHashValue()), Action(Action) { Hash = 0; } virtual bool HandleTopLevelDecl(DeclGroupRef D) { for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { Decl *D = *it; // FIXME: Currently ObjC method declarations are incorrectly being // reported as top-level declarations, even though their DeclContext // is the containing ObjC @@interface/@@implementation. This is a // fundamental problem in the parser right now. if (isa(D)) continue; AddTopLevelDeclarationToHash(D, Hash); TopLevelDecls.push_back(D); } return true; } virtual void HandleTranslationUnit(ASTContext &Ctx) { PCHGenerator::HandleTranslationUnit(Ctx); if (hasEmittedPCH()) { // Translate the top-level declarations we captured during // parsing into declaration IDs in the precompiled // preamble. This will allow us to deserialize those top-level // declarations when requested. for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I) { Decl *D = TopLevelDecls[I]; // Invalid top-level decls may not have been serialized. if (D->isInvalidDecl()) continue; Unit.addTopLevelDeclFromPreamble(getWriter().getDeclID(D)); } Action->setHasEmittedPreamblePCH(); } } }; } ASTConsumer *PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { std::string Sysroot; std::string OutputFile; raw_ostream *OS = 0; if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS)) return 0; if (!CI.getFrontendOpts().RelocatablePCH) Sysroot.clear(); CI.getPreprocessor().addPPCallbacks(new MacroDefinitionTrackerPPCallbacks( Unit.getCurrentTopLevelHashValue())); return new PrecompilePreambleConsumer(Unit, this, CI.getPreprocessor(), Sysroot, OS); } static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) { return StoredDiag.getLocation().isValid(); } static void checkAndRemoveNonDriverDiags(SmallVectorImpl &StoredDiags) { // Get rid of stored diagnostics except the ones from the driver which do not // have a source location. StoredDiags.erase( std::remove_if(StoredDiags.begin(), StoredDiags.end(), isNonDriverDiag), StoredDiags.end()); } static void checkAndSanitizeDiags(SmallVectorImpl & StoredDiagnostics, SourceManager &SM) { // The stored diagnostic has the old source manager in it; update // the locations to refer into the new source manager. Since we've // been careful to make sure that the source manager's state // before and after are identical, so that we can reuse the source // location itself. for (unsigned I = 0, N = StoredDiagnostics.size(); I < N; ++I) { if (StoredDiagnostics[I].getLocation().isValid()) { FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SM); StoredDiagnostics[I].setLocation(Loc); } } } /// Parse the source file into a translation unit using the given compiler /// invocation, replacing the current translation unit. /// /// \returns True if a failure occurred that causes the ASTUnit not to /// contain any translation-unit information, false otherwise. bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) { delete SavedMainFileBuffer; SavedMainFileBuffer = 0; if (!Invocation) { delete OverrideMainBuffer; return true; } // Create the compiler instance to use for building the AST. OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); IntrusiveRefCntPtr CCInvocation(new CompilerInvocation(*Invocation)); Clang->setInvocation(CCInvocation.getPtr()); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics that would // otherwise be dropped. Clang->setDiagnostics(&getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) { delete OverrideMainBuffer; return true; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Configure the various subsystems. // FIXME: Should we retain the previous file manager? LangOpts = &Clang->getLangOpts(); FileSystemOpts = Clang->getFileSystemOpts(); FileMgr = new FileManager(FileSystemOpts); SourceMgr = new SourceManager(getDiagnostics(), *FileMgr, UserFilesAreVolatile); TheSema.reset(); Ctx = 0; PP = 0; Reader = 0; // Clear out old caches and data. TopLevelDecls.clear(); clearFileLevelDecls(); CleanTemporaryFiles(); if (!OverrideMainBuffer) { checkAndRemoveNonDriverDiags(StoredDiagnostics); TopLevelDeclsInPreamble.clear(); } // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(&getFileManager()); // Create the source manager. Clang->setSourceManager(&getSourceManager()); // If the main file has been overridden due to the use of a preamble, // make that override happen and introduce the preamble. PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts(); if (OverrideMainBuffer) { PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); PreprocessorOpts.PrecompiledPreambleBytes.second = PreambleEndsAtStartOfLine; PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); PreprocessorOpts.DisablePCHValidation = true; // The stored diagnostic has the old source manager in it; update // the locations to refer into the new source manager. Since we've // been careful to make sure that the source manager's state // before and after are identical, so that we can reuse the source // location itself. checkAndSanitizeDiags(StoredDiagnostics, getSourceManager()); // Keep track of the override buffer; SavedMainFileBuffer = OverrideMainBuffer; } OwningPtr Act( new TopLevelDeclTrackerAction(*this)); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ActCleanup(Act.get()); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) goto error; if (OverrideMainBuffer) { std::string ModName = getPreambleFile(this); TranslateStoredDiagnostics(getFileManager(), getSourceManager(), PreambleDiagnostics, StoredDiagnostics); } if (!Act->Execute()) goto error; transferASTDataFromCompilerInstance(*Clang); Act->EndSourceFile(); FailedParseDiagnostics.clear(); return false; error: // Remove the overridden buffer we used for the preamble. if (OverrideMainBuffer) { delete OverrideMainBuffer; SavedMainFileBuffer = 0; } // Keep the ownership of the data in the ASTUnit because the client may // want to see the diagnostics. transferASTDataFromCompilerInstance(*Clang); FailedParseDiagnostics.swap(StoredDiagnostics); StoredDiagnostics.clear(); NumStoredDiagnosticsFromDriver = 0; return true; } /// \brief Simple function to retrieve a path for a preamble precompiled header. static std::string GetPreamblePCHPath() { // FIXME: This is a hack so that we can override the preamble file during // crash-recovery testing, which is the only case where the preamble files // are not necessarily cleaned up. const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE"); if (TmpFile) return TmpFile; SmallString<128> Path; llvm::sys::fs::createTemporaryFile("preamble", "pch", Path); return Path.str(); } /// \brief Compute the preamble for the main file, providing the source buffer /// that corresponds to the main file along with a pair (bytes, start-of-line) /// that describes the preamble. std::pair > ASTUnit::ComputePreamble(CompilerInvocation &Invocation, unsigned MaxLines, bool &CreatedBuffer) { FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); PreprocessorOptions &PreprocessorOpts = Invocation.getPreprocessorOpts(); CreatedBuffer = false; // Try to determine if the main file has been remapped, either from the // command line (to another file) or directly through the compiler invocation // (to a memory buffer). llvm::MemoryBuffer *Buffer = 0; std::string MainFilePath(FrontendOpts.Inputs[0].getFile()); llvm::sys::fs::UniqueID MainFileID; if (!llvm::sys::fs::getUniqueID(MainFilePath, MainFileID)) { // Check whether there is a file-file remapping of the main file for (PreprocessorOptions::remapped_file_iterator M = PreprocessorOpts.remapped_file_begin(), E = PreprocessorOpts.remapped_file_end(); M != E; ++M) { std::string MPath(M->first); llvm::sys::fs::UniqueID MID; if (!llvm::sys::fs::getUniqueID(MPath, MID)) { if (MainFileID == MID) { // We found a remapping. Try to load the resulting, remapped source. if (CreatedBuffer) { delete Buffer; CreatedBuffer = false; } Buffer = getBufferForFile(M->second); if (!Buffer) return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true)); CreatedBuffer = true; } } } // Check whether there is a file-buffer remapping. It supercedes the // file-file remapping. for (PreprocessorOptions::remapped_file_buffer_iterator M = PreprocessorOpts.remapped_file_buffer_begin(), E = PreprocessorOpts.remapped_file_buffer_end(); M != E; ++M) { std::string MPath(M->first); llvm::sys::fs::UniqueID MID; if (!llvm::sys::fs::getUniqueID(MPath, MID)) { if (MainFileID == MID) { // We found a remapping. if (CreatedBuffer) { delete Buffer; CreatedBuffer = false; } Buffer = const_cast(M->second); } } } } // If the main source file was not remapped, load it now. if (!Buffer) { Buffer = getBufferForFile(FrontendOpts.Inputs[0].getFile()); if (!Buffer) return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true)); CreatedBuffer = true; } return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, *Invocation.getLangOpts(), MaxLines)); } static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old, unsigned NewSize, StringRef NewName) { llvm::MemoryBuffer *Result = llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName); memcpy(const_cast(Result->getBufferStart()), Old->getBufferStart(), Old->getBufferSize()); memset(const_cast(Result->getBufferStart()) + Old->getBufferSize(), ' ', NewSize - Old->getBufferSize() - 1); const_cast(Result->getBufferEnd())[-1] = '\n'; return Result; } ASTUnit::PreambleFileHash ASTUnit::PreambleFileHash::createForFile(off_t Size, time_t ModTime) { PreambleFileHash Result; Result.Size = Size; Result.ModTime = ModTime; memset(Result.MD5, 0, sizeof(Result.MD5)); return Result; } ASTUnit::PreambleFileHash ASTUnit::PreambleFileHash::createForMemoryBuffer( const llvm::MemoryBuffer *Buffer) { PreambleFileHash Result; Result.Size = Buffer->getBufferSize(); Result.ModTime = 0; llvm::MD5 MD5Ctx; MD5Ctx.update(Buffer->getBuffer().data()); MD5Ctx.final(Result.MD5); return Result; } namespace clang { bool operator==(const ASTUnit::PreambleFileHash &LHS, const ASTUnit::PreambleFileHash &RHS) { return LHS.Size == RHS.Size && LHS.ModTime == RHS.ModTime && memcmp(LHS.MD5, RHS.MD5, sizeof(LHS.MD5)) == 0; } } // namespace clang static std::pair makeStandaloneRange(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts) { CharSourceRange FileRange = Lexer::makeFileCharRange(Range, SM, LangOpts); unsigned Offset = SM.getFileOffset(FileRange.getBegin()); unsigned EndOffset = SM.getFileOffset(FileRange.getEnd()); return std::make_pair(Offset, EndOffset); } static void makeStandaloneFixIt(const SourceManager &SM, const LangOptions &LangOpts, const FixItHint &InFix, ASTUnit::StandaloneFixIt &OutFix) { OutFix.RemoveRange = makeStandaloneRange(InFix.RemoveRange, SM, LangOpts); OutFix.InsertFromRange = makeStandaloneRange(InFix.InsertFromRange, SM, LangOpts); OutFix.CodeToInsert = InFix.CodeToInsert; OutFix.BeforePreviousInsertions = InFix.BeforePreviousInsertions; } static void makeStandaloneDiagnostic(const LangOptions &LangOpts, const StoredDiagnostic &InDiag, ASTUnit::StandaloneDiagnostic &OutDiag) { OutDiag.ID = InDiag.getID(); OutDiag.Level = InDiag.getLevel(); OutDiag.Message = InDiag.getMessage(); OutDiag.LocOffset = 0; if (InDiag.getLocation().isInvalid()) return; const SourceManager &SM = InDiag.getLocation().getManager(); SourceLocation FileLoc = SM.getFileLoc(InDiag.getLocation()); OutDiag.Filename = SM.getFilename(FileLoc); if (OutDiag.Filename.empty()) return; OutDiag.LocOffset = SM.getFileOffset(FileLoc); for (StoredDiagnostic::range_iterator I = InDiag.range_begin(), E = InDiag.range_end(); I != E; ++I) { OutDiag.Ranges.push_back(makeStandaloneRange(*I, SM, LangOpts)); } for (StoredDiagnostic::fixit_iterator I = InDiag.fixit_begin(), E = InDiag.fixit_end(); I != E; ++I) { ASTUnit::StandaloneFixIt Fix; makeStandaloneFixIt(SM, LangOpts, *I, Fix); OutDiag.FixIts.push_back(Fix); } } /// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing /// the source file. /// /// This routine will compute the preamble of the main source file. If a /// non-trivial preamble is found, it will precompile that preamble into a /// precompiled header so that the precompiled preamble can be used to reduce /// reparsing time. If a precompiled preamble has already been constructed, /// this routine will determine if it is still valid and, if so, avoid /// rebuilding the precompiled preamble. /// /// \param AllowRebuild When true (the default), this routine is /// allowed to rebuild the precompiled preamble if it is found to be /// out-of-date. /// /// \param MaxLines When non-zero, the maximum number of lines that /// can occur within the preamble. /// /// \returns If the precompiled preamble can be used, returns a newly-allocated /// buffer that should be used in place of the main file when doing so. /// Otherwise, returns a NULL pointer. llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble( const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, unsigned MaxLines) { IntrusiveRefCntPtr PreambleInvocation(new CompilerInvocation(PreambleInvocationIn)); FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts(); PreprocessorOptions &PreprocessorOpts = PreambleInvocation->getPreprocessorOpts(); bool CreatedPreambleBuffer = false; std::pair > NewPreamble = ComputePreamble(*PreambleInvocation, MaxLines, CreatedPreambleBuffer); // If ComputePreamble() Take ownership of the preamble buffer. OwningPtr OwnedPreambleBuffer; if (CreatedPreambleBuffer) OwnedPreambleBuffer.reset(NewPreamble.first); if (!NewPreamble.second.first) { // We couldn't find a preamble in the main source. Clear out the current // preamble, if we have one. It's obviously no good any more. Preamble.clear(); erasePreambleFile(this); // The next time we actually see a preamble, precompile it. PreambleRebuildCounter = 1; return 0; } if (!Preamble.empty()) { // We've previously computed a preamble. Check whether we have the same // preamble now that we did before, and that there's enough space in // the main-file buffer within the precompiled preamble to fit the // new main file. if (Preamble.size() == NewPreamble.second.first && PreambleEndsAtStartOfLine == NewPreamble.second.second && NewPreamble.first->getBufferSize() < PreambleReservedSize-2 && memcmp(Preamble.getBufferStart(), NewPreamble.first->getBufferStart(), NewPreamble.second.first) == 0) { // The preamble has not changed. We may be able to re-use the precompiled // preamble. // Check that none of the files used by the preamble have changed. bool AnyFileChanged = false; // First, make a record of those files that have been overridden via // remapping or unsaved_files. llvm::StringMap OverriddenFiles; for (PreprocessorOptions::remapped_file_iterator R = PreprocessorOpts.remapped_file_begin(), REnd = PreprocessorOpts.remapped_file_end(); !AnyFileChanged && R != REnd; ++R) { vfs::Status Status; if (FileMgr->getNoncachedStatValue(R->second, Status)) { // If we can't stat the file we're remapping to, assume that something // horrible happened. AnyFileChanged = true; break; } OverriddenFiles[R->first] = PreambleFileHash::createForFile( Status.getSize(), Status.getLastModificationTime().toEpochTime()); } for (PreprocessorOptions::remapped_file_buffer_iterator R = PreprocessorOpts.remapped_file_buffer_begin(), REnd = PreprocessorOpts.remapped_file_buffer_end(); !AnyFileChanged && R != REnd; ++R) { OverriddenFiles[R->first] = PreambleFileHash::createForMemoryBuffer(R->second); } // Check whether anything has changed. for (llvm::StringMap::iterator F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end(); !AnyFileChanged && F != FEnd; ++F) { llvm::StringMap::iterator Overridden = OverriddenFiles.find(F->first()); if (Overridden != OverriddenFiles.end()) { // This file was remapped; check whether the newly-mapped file // matches up with the previous mapping. if (Overridden->second != F->second) AnyFileChanged = true; continue; } // The file was not remapped; check whether it has changed on disk. vfs::Status Status; if (FileMgr->getNoncachedStatValue(F->first(), Status)) { // If we can't stat the file, assume that something horrible happened. AnyFileChanged = true; } else if (Status.getSize() != uint64_t(F->second.Size) || Status.getLastModificationTime().toEpochTime() != uint64_t(F->second.ModTime)) AnyFileChanged = true; } if (!AnyFileChanged) { // Okay! We can re-use the precompiled preamble. // Set the state of the diagnostic object to mimic its state // after parsing the preamble. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), PreambleInvocation->getDiagnosticOpts()); getDiagnostics().setNumWarnings(NumWarningsInPreamble); // Create a version of the main file buffer that is padded to // buffer size we reserved when creating the preamble. return CreatePaddedMainFileBuffer(NewPreamble.first, PreambleReservedSize, FrontendOpts.Inputs[0].getFile()); } } // If we aren't allowed to rebuild the precompiled preamble, just // return now. if (!AllowRebuild) return 0; // We can't reuse the previously-computed preamble. Build a new one. Preamble.clear(); PreambleDiagnostics.clear(); erasePreambleFile(this); PreambleRebuildCounter = 1; } else if (!AllowRebuild) { // We aren't allowed to rebuild the precompiled preamble; just // return now. return 0; } // If the preamble rebuild counter > 1, it's because we previously // failed to build a preamble and we're not yet ready to try // again. Decrement the counter and return a failure. if (PreambleRebuildCounter > 1) { --PreambleRebuildCounter; return 0; } // Create a temporary file for the precompiled preamble. In rare // circumstances, this can fail. std::string PreamblePCHPath = GetPreamblePCHPath(); if (PreamblePCHPath.empty()) { // Try again next time. PreambleRebuildCounter = 1; return 0; } // We did not previously compute a preamble, or it can't be reused anyway. SimpleTimer PreambleTimer(WantTiming); PreambleTimer.setOutput("Precompiling preamble"); // Create a new buffer that stores the preamble. The buffer also contains // extra space for the original contents of the file (which will be present // when we actually parse the file) along with more room in case the file // grows. PreambleReservedSize = NewPreamble.first->getBufferSize(); if (PreambleReservedSize < 4096) PreambleReservedSize = 8191; else PreambleReservedSize *= 2; // Save the preamble text for later; we'll need to compare against it for // subsequent reparses. StringRef MainFilename = FrontendOpts.Inputs[0].getFile(); Preamble.assign(FileMgr->getFile(MainFilename), NewPreamble.first->getBufferStart(), NewPreamble.first->getBufferStart() + NewPreamble.second.first); PreambleEndsAtStartOfLine = NewPreamble.second.second; delete PreambleBuffer; PreambleBuffer = llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize, FrontendOpts.Inputs[0].getFile()); memcpy(const_cast(PreambleBuffer->getBufferStart()), NewPreamble.first->getBufferStart(), Preamble.size()); memset(const_cast(PreambleBuffer->getBufferStart()) + Preamble.size(), ' ', PreambleReservedSize - Preamble.size() - 1); const_cast(PreambleBuffer->getBufferEnd())[-1] = '\n'; // Remap the main source file to the preamble buffer. StringRef MainFilePath = FrontendOpts.Inputs[0].getFile(); PreprocessorOpts.addRemappedFile(MainFilePath, PreambleBuffer); // Tell the compiler invocation to generate a temporary precompiled header. FrontendOpts.ProgramAction = frontend::GeneratePCH; // FIXME: Generate the precompiled header into memory? FrontendOpts.OutputFile = PreamblePCHPath; PreprocessorOpts.PrecompiledPreambleBytes.first = 0; PreprocessorOpts.PrecompiledPreambleBytes.second = false; // Create the compiler instance to use for building the precompiled preamble. OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(&*PreambleInvocation); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing all of the diagnostics produced. Clang->setDiagnostics(&getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) { llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); return 0; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Clear out old caches and data. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts()); checkAndRemoveNonDriverDiags(StoredDiagnostics); TopLevelDecls.clear(); TopLevelDeclsInPreamble.clear(); PreambleDiagnostics.clear(); // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(new FileManager(Clang->getFileSystemOpts())); // Create the source manager. Clang->setSourceManager(new SourceManager(getDiagnostics(), Clang->getFileManager())); OwningPtr Act; Act.reset(new PrecompilePreambleAction(*this)); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); return 0; } Act->Execute(); // Transfer any diagnostics generated when parsing the preamble into the set // of preamble diagnostics. for (stored_diag_iterator I = stored_diag_afterDriver_begin(), E = stored_diag_end(); I != E; ++I) { StandaloneDiagnostic Diag; makeStandaloneDiagnostic(Clang->getLangOpts(), *I, Diag); PreambleDiagnostics.push_back(Diag); } Act->EndSourceFile(); checkAndRemoveNonDriverDiags(StoredDiagnostics); if (!Act->hasEmittedPreamblePCH()) { // The preamble PCH failed (e.g. there was a module loading fatal error), // so no precompiled header was generated. Forget that we even tried. // FIXME: Should we leave a note for ourselves to try again? llvm::sys::fs::remove(FrontendOpts.OutputFile); Preamble.clear(); TopLevelDeclsInPreamble.clear(); PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); return 0; } // Keep track of the preamble we precompiled. setPreambleFile(this, FrontendOpts.OutputFile); NumWarningsInPreamble = getDiagnostics().getNumWarnings(); // Keep track of all of the files that the source manager knows about, // so we can verify whether they have changed or not. FilesInPreamble.clear(); SourceManager &SourceMgr = Clang->getSourceManager(); const llvm::MemoryBuffer *MainFileBuffer = SourceMgr.getBuffer(SourceMgr.getMainFileID()); for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(), FEnd = SourceMgr.fileinfo_end(); F != FEnd; ++F) { const FileEntry *File = F->second->OrigEntry; if (!File) continue; const llvm::MemoryBuffer *Buffer = F->second->getRawBuffer(); if (Buffer == MainFileBuffer) continue; if (time_t ModTime = File->getModificationTime()) { FilesInPreamble[File->getName()] = PreambleFileHash::createForFile( F->second->getSize(), ModTime); } else { assert(F->second->getSize() == Buffer->getBufferSize()); FilesInPreamble[File->getName()] = PreambleFileHash::createForMemoryBuffer(Buffer); } } PreambleRebuildCounter = 1; PreprocessorOpts.eraseRemappedFile( PreprocessorOpts.remapped_file_buffer_end() - 1); // If the hash of top-level entities differs from the hash of the top-level // entities the last time we rebuilt the preamble, clear out the completion // cache. if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) { CompletionCacheTopLevelHashValue = 0; PreambleTopLevelHashValue = CurrentTopLevelHashValue; } return CreatePaddedMainFileBuffer(NewPreamble.first, PreambleReservedSize, FrontendOpts.Inputs[0].getFile()); } void ASTUnit::RealizeTopLevelDeclsFromPreamble() { std::vector Resolved; Resolved.reserve(TopLevelDeclsInPreamble.size()); ExternalASTSource &Source = *getASTContext().getExternalSource(); for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) { // Resolve the declaration ID to an actual declaration, possibly // deserializing the declaration in the process. Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]); if (D) Resolved.push_back(D); } TopLevelDeclsInPreamble.clear(); TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end()); } void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) { // Steal the created target, context, and preprocessor. TheSema.reset(CI.takeSema()); Consumer.reset(CI.takeASTConsumer()); Ctx = &CI.getASTContext(); PP = &CI.getPreprocessor(); CI.setSourceManager(0); CI.setFileManager(0); Target = &CI.getTarget(); Reader = CI.getModuleManager(); HadModuleLoaderFatalFailure = CI.hadModuleLoaderFatalFailure(); } StringRef ASTUnit::getMainFileName() const { if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) { const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0]; if (Input.isFile()) return Input.getFile(); else return Input.getBuffer()->getBufferIdentifier(); } if (SourceMgr) { if (const FileEntry * FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID())) return FE->getName(); } return StringRef(); } StringRef ASTUnit::getASTFileName() const { if (!isMainFileAST()) return StringRef(); serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); return Mod.FileName; } ASTUnit *ASTUnit::create(CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool CaptureDiagnostics, bool UserFilesAreVolatile) { OwningPtr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; AST->Invocation = CI; AST->FileSystemOpts = CI->getFileSystemOpts(); AST->FileMgr = new FileManager(AST->FileSystemOpts); AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr, UserFilesAreVolatile); return AST.take(); } ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(CompilerInvocation *CI, IntrusiveRefCntPtr Diags, ASTFrontendAction *Action, ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile, OwningPtr *ErrAST) { assert(CI && "A CompilerInvocation is required"); OwningPtr OwnAST; ASTUnit *AST = Unit; if (!AST) { // Create the AST unit. OwnAST.reset(create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile)); AST = OwnAST.get(); } if (!ResourceFilesPath.empty()) { // Override the resources path. CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; } AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; if (PrecompilePreamble) AST->PreambleRebuildCounter = 2; AST->TUKind = Action ? Action->getTranslationUnitKind() : TU_Complete; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(OwnAST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.getPtr()); // We'll manage file buffers ourselves. CI->getPreprocessorOpts().RetainRemappedFileBuffers = true; CI->getFrontendOpts().DisableFree = false; ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts()); // Create the compiler instance to use for building the AST. OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(CI); AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics that would // otherwise be dropped. Clang->setDiagnostics(&AST->getDiagnostics()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) return 0; // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not supported here!"); // Configure the various subsystems. AST->TheSema.reset(); AST->Ctx = 0; AST->PP = 0; AST->Reader = 0; // Create a file manager object to provide access to and cache the filesystem. Clang->setFileManager(&AST->getFileManager()); // Create the source manager. Clang->setSourceManager(&AST->getSourceManager()); ASTFrontendAction *Act = Action; OwningPtr TrackerAct; if (!Act) { TrackerAct.reset(new TopLevelDeclTrackerAction(*AST)); Act = TrackerAct.get(); } // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ActCleanup(TrackerAct.get()); if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { AST->transferASTDataFromCompilerInstance(*Clang); if (OwnAST && ErrAST) ErrAST->swap(OwnAST); return 0; } if (Persistent && !TrackerAct) { Clang->getPreprocessor().addPPCallbacks( new MacroDefinitionTrackerPPCallbacks(AST->getCurrentTopLevelHashValue())); std::vector Consumers; if (Clang->hasASTConsumer()) Consumers.push_back(Clang->takeASTConsumer()); Consumers.push_back(new TopLevelDeclTrackerConsumer(*AST, AST->getCurrentTopLevelHashValue())); Clang->setASTConsumer(new MultiplexConsumer(Consumers)); } if (!Act->Execute()) { AST->transferASTDataFromCompilerInstance(*Clang); if (OwnAST && ErrAST) ErrAST->swap(OwnAST); return 0; } // Steal the created target, context, and preprocessor. AST->transferASTDataFromCompilerInstance(*Clang); Act->EndSourceFile(); if (OwnAST) return OwnAST.take(); else return AST; } bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) { if (!Invocation) return true; // We'll manage file buffers ourselves. Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true; Invocation->getFrontendOpts().DisableFree = false; ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); llvm::MemoryBuffer *OverrideMainBuffer = 0; if (PrecompilePreamble) { PreambleRebuildCounter = 2; OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); } SimpleTimer ParsingTimer(WantTiming); ParsingTimer.setOutput("Parsing " + getMainFileName()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar MemBufferCleanup(OverrideMainBuffer); return Parse(OverrideMainBuffer); } ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI, IntrusiveRefCntPtr Diags, bool OnlyLocalDecls, bool CaptureDiagnostics, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile) { // Create the AST unit. OwningPtr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->TUKind = TUKind; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; AST->Invocation = CI; AST->FileSystemOpts = CI->getFileSystemOpts(); AST->FileMgr = new FileManager(AST->FileSystemOpts); AST->UserFilesAreVolatile = UserFilesAreVolatile; // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > DiagCleanup(Diags.getPtr()); return AST->LoadFromCompilerInvocation(PrecompilePreamble)? 0 : AST.take(); } ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin, const char **ArgEnd, IntrusiveRefCntPtr Diags, StringRef ResourceFilesPath, bool OnlyLocalDecls, bool CaptureDiagnostics, ArrayRef RemappedFiles, bool RemappedFilesKeepOriginalName, bool PrecompilePreamble, TranslationUnitKind TUKind, bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies, bool UserFilesAreVolatile, bool ForSerialization, OwningPtr *ErrAST) { if (!Diags.getPtr()) { // No diagnostics engine was provided, so create our own diagnostics object // with the default options. Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions()); } SmallVector StoredDiagnostics; IntrusiveRefCntPtr CI; { CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags, StoredDiagnostics); CI = clang::createInvocationFromCommandLine( llvm::makeArrayRef(ArgBegin, ArgEnd), Diags); if (!CI) return 0; } // Override any files that need remapping for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); } PreprocessorOptions &PPOpts = CI->getPreprocessorOpts(); PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName; PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors; // Override the resources path. CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies; // Create the AST unit. OwningPtr AST; AST.reset(new ASTUnit(false)); ConfigureDiags(Diags, ArgBegin, ArgEnd, *AST, CaptureDiagnostics); AST->Diagnostics = Diags; Diags = 0; // Zero out now to ease cleanup during crash recovery. AST->FileSystemOpts = CI->getFileSystemOpts(); AST->FileMgr = new FileManager(AST->FileSystemOpts); AST->OnlyLocalDecls = OnlyLocalDecls; AST->CaptureDiagnostics = CaptureDiagnostics; AST->TUKind = TUKind; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->IncludeBriefCommentsInCodeCompletion = IncludeBriefCommentsInCodeCompletion; AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); AST->StoredDiagnostics.swap(StoredDiagnostics); AST->Invocation = CI; if (ForSerialization) AST->WriterData.reset(new ASTWriterData()); CI = 0; // Zero out now to ease cleanup during crash recovery. // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); if (AST->LoadFromCompilerInvocation(PrecompilePreamble)) { // Some error occurred, if caller wants to examine diagnostics, pass it the // ASTUnit. if (ErrAST) { AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics); ErrAST->swap(AST); } return 0; } return AST.take(); } bool ASTUnit::Reparse(ArrayRef RemappedFiles) { if (!Invocation) return true; clearFileLevelDecls(); SimpleTimer ParsingTimer(WantTiming); ParsingTimer.setOutput("Reparsing " + getMainFileName()); // Remap files. PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); for (PreprocessorOptions::remapped_file_buffer_iterator R = PPOpts.remapped_file_buffer_begin(), REnd = PPOpts.remapped_file_buffer_end(); R != REnd; ++R) { delete R->second; } Invocation->getPreprocessorOpts().clearRemappedFiles(); for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); } // If we have a preamble file lying around, or if we might try to // build a precompiled preamble, do so now. llvm::MemoryBuffer *OverrideMainBuffer = 0; if (!getPreambleFile(this).empty() || PreambleRebuildCounter > 0) OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); // Clear out the diagnostics state. getDiagnostics().Reset(); ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); if (OverrideMainBuffer) getDiagnostics().setNumWarnings(NumWarningsInPreamble); // Parse the sources bool Result = Parse(OverrideMainBuffer); // If we're caching global code-completion results, and the top-level // declarations have changed, clear out the code-completion cache. if (!Result && ShouldCacheCodeCompletionResults && CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue) CacheCodeCompletionResults(); // We now need to clear out the completion info related to this translation // unit; it'll be recreated if necessary. CCTUInfo.reset(); return Result; } //----------------------------------------------------------------------------// // Code completion //----------------------------------------------------------------------------// namespace { /// \brief Code completion consumer that combines the cached code-completion /// results from an ASTUnit with the code-completion results provided to it, /// then passes the result on to class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer { uint64_t NormalContexts; ASTUnit &AST; CodeCompleteConsumer &Next; public: AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next, const CodeCompleteOptions &CodeCompleteOpts) : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), AST(AST), Next(Next) { // Compute the set of contexts in which we will look when we don't have // any information about the specific context. NormalContexts = (1LL << CodeCompletionContext::CCC_TopLevel) | (1LL << CodeCompletionContext::CCC_ObjCInterface) | (1LL << CodeCompletionContext::CCC_ObjCImplementation) | (1LL << CodeCompletionContext::CCC_ObjCIvarList) | (1LL << CodeCompletionContext::CCC_Statement) | (1LL << CodeCompletionContext::CCC_Expression) | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) | (1LL << CodeCompletionContext::CCC_DotMemberAccess) | (1LL << CodeCompletionContext::CCC_ArrowMemberAccess) | (1LL << CodeCompletionContext::CCC_ObjCPropertyAccess) | (1LL << CodeCompletionContext::CCC_ObjCProtocolName) | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) | (1LL << CodeCompletionContext::CCC_Recovery); if (AST.getASTContext().getLangOpts().CPlusPlus) NormalContexts |= (1LL << CodeCompletionContext::CCC_EnumTag) | (1LL << CodeCompletionContext::CCC_UnionTag) | (1LL << CodeCompletionContext::CCC_ClassOrStructTag); } virtual void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults); virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates) { Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates); } virtual CodeCompletionAllocator &getAllocator() { return Next.getAllocator(); } virtual CodeCompletionTUInfo &getCodeCompletionTUInfo() { return Next.getCodeCompletionTUInfo(); } }; } /// \brief Helper function that computes which global names are hidden by the /// local code-completion results. static void CalculateHiddenNames(const CodeCompletionContext &Context, CodeCompletionResult *Results, unsigned NumResults, ASTContext &Ctx, llvm::StringSet &HiddenNames){ bool OnlyTagNames = false; switch (Context.getKind()) { case CodeCompletionContext::CCC_Recovery: case CodeCompletionContext::CCC_TopLevel: case CodeCompletionContext::CCC_ObjCInterface: case CodeCompletionContext::CCC_ObjCImplementation: case CodeCompletionContext::CCC_ObjCIvarList: case CodeCompletionContext::CCC_ClassStructUnion: case CodeCompletionContext::CCC_Statement: case CodeCompletionContext::CCC_Expression: case CodeCompletionContext::CCC_ObjCMessageReceiver: case CodeCompletionContext::CCC_DotMemberAccess: case CodeCompletionContext::CCC_ArrowMemberAccess: case CodeCompletionContext::CCC_ObjCPropertyAccess: case CodeCompletionContext::CCC_Namespace: case CodeCompletionContext::CCC_Type: case CodeCompletionContext::CCC_Name: case CodeCompletionContext::CCC_PotentiallyQualifiedName: case CodeCompletionContext::CCC_ParenthesizedExpression: case CodeCompletionContext::CCC_ObjCInterfaceName: break; case CodeCompletionContext::CCC_EnumTag: case CodeCompletionContext::CCC_UnionTag: case CodeCompletionContext::CCC_ClassOrStructTag: OnlyTagNames = true; break; case CodeCompletionContext::CCC_ObjCProtocolName: case CodeCompletionContext::CCC_MacroName: case CodeCompletionContext::CCC_MacroNameUse: case CodeCompletionContext::CCC_PreprocessorExpression: case CodeCompletionContext::CCC_PreprocessorDirective: case CodeCompletionContext::CCC_NaturalLanguage: case CodeCompletionContext::CCC_SelectorName: case CodeCompletionContext::CCC_TypeQualifiers: case CodeCompletionContext::CCC_Other: case CodeCompletionContext::CCC_OtherWithMacros: case CodeCompletionContext::CCC_ObjCInstanceMessage: case CodeCompletionContext::CCC_ObjCClassMessage: case CodeCompletionContext::CCC_ObjCCategoryName: // We're looking for nothing, or we're looking for names that cannot // be hidden. return; } typedef CodeCompletionResult Result; for (unsigned I = 0; I != NumResults; ++I) { if (Results[I].Kind != Result::RK_Declaration) continue; unsigned IDNS = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace(); bool Hiding = false; if (OnlyTagNames) Hiding = (IDNS & Decl::IDNS_Tag); else { unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | Decl::IDNS_Namespace | Decl::IDNS_Ordinary | Decl::IDNS_NonMemberOperator); if (Ctx.getLangOpts().CPlusPlus) HiddenIDNS |= Decl::IDNS_Tag; Hiding = (IDNS & HiddenIDNS); } if (!Hiding) continue; DeclarationName Name = Results[I].Declaration->getDeclName(); if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo()) HiddenNames.insert(Identifier->getName()); else HiddenNames.insert(Name.getAsString()); } } void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) { // Merge the results we were given with the results we cached. bool AddedResult = false; uint64_t InContexts = Context.getKind() == CodeCompletionContext::CCC_Recovery ? NormalContexts : (1LL << Context.getKind()); // Contains the set of names that are hidden by "local" completion results. llvm::StringSet HiddenNames; typedef CodeCompletionResult Result; SmallVector AllResults; for (ASTUnit::cached_completion_iterator C = AST.cached_completion_begin(), CEnd = AST.cached_completion_end(); C != CEnd; ++C) { // If the context we are in matches any of the contexts we are // interested in, we'll add this result. if ((C->ShowInContexts & InContexts) == 0) continue; // If we haven't added any results previously, do so now. if (!AddedResult) { CalculateHiddenNames(Context, Results, NumResults, S.Context, HiddenNames); AllResults.insert(AllResults.end(), Results, Results + NumResults); AddedResult = true; } // Determine whether this global completion result is hidden by a local // completion result. If so, skip it. if (C->Kind != CXCursor_MacroDefinition && HiddenNames.count(C->Completion->getTypedText())) continue; // Adjust priority based on similar type classes. unsigned Priority = C->Priority; CodeCompletionString *Completion = C->Completion; if (!Context.getPreferredType().isNull()) { if (C->Kind == CXCursor_MacroDefinition) { Priority = getMacroUsagePriority(C->Completion->getTypedText(), S.getLangOpts(), Context.getPreferredType()->isAnyPointerType()); } else if (C->Type) { CanQualType Expected = S.Context.getCanonicalType( Context.getPreferredType().getUnqualifiedType()); SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected); if (ExpectedSTC == C->TypeClass) { // We know this type is similar; check for an exact match. llvm::StringMap &CachedCompletionTypes = AST.getCachedCompletionTypes(); llvm::StringMap::iterator Pos = CachedCompletionTypes.find(QualType(Expected).getAsString()); if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type) Priority /= CCF_ExactTypeMatch; else Priority /= CCF_SimilarTypeMatch; } } } // Adjust the completion string, if required. if (C->Kind == CXCursor_MacroDefinition && Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) { // Create a new code-completion string that just contains the // macro name, without its arguments. CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(), CCP_CodePattern, C->Availability); Builder.AddTypedTextChunk(C->Completion->getTypedText()); Priority = CCP_CodePattern; Completion = Builder.TakeString(); } AllResults.push_back(Result(Completion, Priority, C->Kind, C->Availability)); } // If we did not add any cached completion results, just forward the // results we were given to the next consumer. if (!AddedResult) { Next.ProcessCodeCompleteResults(S, Context, Results, NumResults); return; } Next.ProcessCodeCompleteResults(S, Context, AllResults.data(), AllResults.size()); } void ASTUnit::CodeComplete(StringRef File, unsigned Line, unsigned Column, ArrayRef RemappedFiles, bool IncludeMacros, bool IncludeCodePatterns, bool IncludeBriefComments, CodeCompleteConsumer &Consumer, DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, FileManager &FileMgr, SmallVectorImpl &StoredDiagnostics, SmallVectorImpl &OwnedBuffers) { if (!Invocation) return; SimpleTimer CompletionTimer(WantTiming); CompletionTimer.setOutput("Code completion @@ " + File + ":" + Twine(Line) + ":" + Twine(Column)); IntrusiveRefCntPtr CCInvocation(new CompilerInvocation(*Invocation)); FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts(); CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts; PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts(); CodeCompleteOpts.IncludeMacros = IncludeMacros && CachedCompletionResults.empty(); CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns; CodeCompleteOpts.IncludeGlobals = CachedCompletionResults.empty(); CodeCompleteOpts.IncludeBriefComments = IncludeBriefComments; assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion); FrontendOpts.CodeCompletionAt.FileName = File; FrontendOpts.CodeCompletionAt.Line = Line; FrontendOpts.CodeCompletionAt.Column = Column; // Set the language options appropriately. LangOpts = *CCInvocation->getLangOpts(); OwningPtr Clang(new CompilerInstance()); // Recover resources if we crash before exiting this method. llvm::CrashRecoveryContextCleanupRegistrar CICleanup(Clang.get()); Clang->setInvocation(&*CCInvocation); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); // Set up diagnostics, capturing any diagnostics produced. Clang->setDiagnostics(&Diag); CaptureDroppedDiagnostics Capture(true, Clang->getDiagnostics(), StoredDiagnostics); ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts()); // Create the target instance. Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), &Clang->getTargetOpts())); if (!Clang->hasTarget()) { Clang->setInvocation(0); return; } // Inform the target of the language options. // // FIXME: We shouldn't need to do this, the target should be immutable once // created. This complexity should be lifted elsewhere. Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); assert(Clang->getFrontendOpts().Inputs.size() == 1 && "Invocation must have exactly one source file!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && "FIXME: AST inputs not yet supported here!"); assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && "IR inputs not support here!"); // Use the source and file managers that we were given. Clang->setFileManager(&FileMgr); Clang->setSourceManager(&SourceMgr); // Remap files. PreprocessorOpts.clearRemappedFiles(); PreprocessorOpts.RetainRemappedFileBuffers = true; for (unsigned I = 0, N = RemappedFiles.size(); I != N; ++I) { PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, RemappedFiles[I].second); OwnedBuffers.push_back(RemappedFiles[I].second); } // Use the code completion consumer we were given, but adding any cached // code-completion results. AugmentedCodeCompleteConsumer *AugmentedConsumer = new AugmentedCodeCompleteConsumer(*this, Consumer, CodeCompleteOpts); Clang->setCodeCompletionConsumer(AugmentedConsumer); // If we have a precompiled preamble, try to use it. We only allow // the use of the precompiled preamble if we're if the completion // point is within the main file, after the end of the precompiled // preamble. llvm::MemoryBuffer *OverrideMainBuffer = 0; if (!getPreambleFile(this).empty()) { std::string CompleteFilePath(File); llvm::sys::fs::UniqueID CompleteFileID; if (!llvm::sys::fs::getUniqueID(CompleteFilePath, CompleteFileID)) { std::string MainPath(OriginalSourceFile); llvm::sys::fs::UniqueID MainID; if (!llvm::sys::fs::getUniqueID(MainPath, MainID)) { if (CompleteFileID == MainID && Line > 1) OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*CCInvocation, false, Line - 1); } } } // If the main file has been overridden due to the use of a preamble, // make that override happen and introduce the preamble. if (OverrideMainBuffer) { PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); PreprocessorOpts.PrecompiledPreambleBytes.second = PreambleEndsAtStartOfLine; PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); PreprocessorOpts.DisablePCHValidation = true; OwnedBuffers.push_back(OverrideMainBuffer); } else { PreprocessorOpts.PrecompiledPreambleBytes.first = 0; PreprocessorOpts.PrecompiledPreambleBytes.second = false; } // Disable the preprocessing record if modules are not enabled. if (!Clang->getLangOpts().Modules) PreprocessorOpts.DetailedRecord = false; OwningPtr Act; Act.reset(new SyntaxOnlyAction); if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { Act->Execute(); Act->EndSourceFile(); } } bool ASTUnit::Save(StringRef File) { if (HadModuleLoaderFatalFailure) return true; // Write to a temporary file and later rename it to the actual file, to avoid // possible race conditions. SmallString<128> TempPath; TempPath = File; TempPath += "-%%%%%%%%"; int fd; if (llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath)) return true; // FIXME: Can we somehow regenerate the stat cache here, or do we need to // unconditionally create a stat cache when we parse the file? llvm::raw_fd_ostream Out(fd, /*shouldClose=*/true); serialize(Out); Out.close(); if (Out.has_error()) { Out.clear_error(); return true; } if (llvm::sys::fs::rename(TempPath.str(), File)) { llvm::sys::fs::remove(TempPath.str()); return true; } return false; } static bool serializeUnit(ASTWriter &Writer, SmallVectorImpl &Buffer, Sema &S, bool hasErrors, raw_ostream &OS) { Writer.WriteAST(S, std::string(), 0, "", hasErrors); // Write the generated bitstream to "Out". if (!Buffer.empty()) OS.write(Buffer.data(), Buffer.size()); return false; } bool ASTUnit::serialize(raw_ostream &OS) { bool hasErrors = getDiagnostics().hasErrorOccurred(); if (WriterData) return serializeUnit(WriterData->Writer, WriterData->Buffer, getSema(), hasErrors, OS); SmallString<128> Buffer; llvm::BitstreamWriter Stream(Buffer); ASTWriter Writer(Stream); return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS); } typedef ContinuousRangeMap SLocRemap; void ASTUnit::TranslateStoredDiagnostics( FileManager &FileMgr, SourceManager &SrcMgr, const SmallVectorImpl &Diags, SmallVectorImpl &Out) { // Map the standalone diagnostic into the new source manager. We also need to // remap all the locations to the new view. This includes the diag location, // any associated source ranges, and the source ranges of associated fix-its. // FIXME: There should be a cleaner way to do this. SmallVector Result; Result.reserve(Diags.size()); for (unsigned I = 0, N = Diags.size(); I != N; ++I) { // Rebuild the StoredDiagnostic. const StandaloneDiagnostic &SD = Diags[I]; if (SD.Filename.empty()) continue; const FileEntry *FE = FileMgr.getFile(SD.Filename); if (!FE) continue; FileID FID = SrcMgr.translateFile(FE); SourceLocation FileLoc = SrcMgr.getLocForStartOfFile(FID); if (FileLoc.isInvalid()) continue; SourceLocation L = FileLoc.getLocWithOffset(SD.LocOffset); FullSourceLoc Loc(L, SrcMgr); SmallVector Ranges; Ranges.reserve(SD.Ranges.size()); for (std::vector >::const_iterator I = SD.Ranges.begin(), E = SD.Ranges.end(); I != E; ++I) { SourceLocation BL = FileLoc.getLocWithOffset((*I).first); SourceLocation EL = FileLoc.getLocWithOffset((*I).second); Ranges.push_back(CharSourceRange::getCharRange(BL, EL)); } SmallVector FixIts; FixIts.reserve(SD.FixIts.size()); for (std::vector::const_iterator I = SD.FixIts.begin(), E = SD.FixIts.end(); I != E; ++I) { FixIts.push_back(FixItHint()); FixItHint &FH = FixIts.back(); FH.CodeToInsert = I->CodeToInsert; SourceLocation BL = FileLoc.getLocWithOffset(I->RemoveRange.first); SourceLocation EL = FileLoc.getLocWithOffset(I->RemoveRange.second); FH.RemoveRange = CharSourceRange::getCharRange(BL, EL); } Result.push_back(StoredDiagnostic(SD.Level, SD.ID, SD.Message, Loc, Ranges, FixIts)); } Result.swap(Out); } void ASTUnit::addFileLevelDecl(Decl *D) { assert(D); // We only care about local declarations. if (D->isFromASTFile()) return; SourceManager &SM = *SourceMgr; SourceLocation Loc = D->getLocation(); if (Loc.isInvalid() || !SM.isLocalSourceLocation(Loc)) return; // We only keep track of the file-level declarations of each file. if (!D->getLexicalDeclContext()->isFileContext()) return; SourceLocation FileLoc = SM.getFileLoc(Loc); assert(SM.isLocalSourceLocation(FileLoc)); FileID FID; unsigned Offset; llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); if (FID.isInvalid()) return; LocDeclsTy *&Decls = FileDecls[FID]; if (!Decls) Decls = new LocDeclsTy(); std::pair LocDecl(Offset, D); if (Decls->empty() || Decls->back().first <= Offset) { Decls->push_back(LocDecl); return; } LocDeclsTy::iterator I = std::upper_bound(Decls->begin(), Decls->end(), LocDecl, llvm::less_first()); Decls->insert(I, LocDecl); } void ASTUnit::findFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl &Decls) { if (File.isInvalid()) return; if (SourceMgr->isLoadedFileID(File)) { assert(Ctx->getExternalSource() && "No external source!"); return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length, Decls); } FileDeclsTy::iterator I = FileDecls.find(File); if (I == FileDecls.end()) return; LocDeclsTy &LocDecls = *I->second; if (LocDecls.empty()) return; LocDeclsTy::iterator BeginIt = std::lower_bound(LocDecls.begin(), LocDecls.end(), std::make_pair(Offset, (Decl *)0), llvm::less_first()); if (BeginIt != LocDecls.begin()) --BeginIt; // If we are pointing at a top-level decl inside an objc container, we need // to backtrack until we find it otherwise we will fail to report that the // region overlaps with an objc container. while (BeginIt != LocDecls.begin() && BeginIt->second->isTopLevelDeclInObjCContainer()) --BeginIt; LocDeclsTy::iterator EndIt = std::upper_bound( LocDecls.begin(), LocDecls.end(), std::make_pair(Offset + Length, (Decl *)0), llvm::less_first()); if (EndIt != LocDecls.end()) ++EndIt; for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt) Decls.push_back(DIt->second); } SourceLocation ASTUnit::getLocation(const FileEntry *File, unsigned Line, unsigned Col) const { const SourceManager &SM = getSourceManager(); SourceLocation Loc = SM.translateFileLineCol(File, Line, Col); return SM.getMacroArgExpandedLocation(Loc); } SourceLocation ASTUnit::getLocation(const FileEntry *File, unsigned Offset) const { const SourceManager &SM = getSourceManager(); SourceLocation FileLoc = SM.translateFileLineCol(File, 1, 1); return SM.getMacroArgExpandedLocation(FileLoc.getLocWithOffset(Offset)); } /// \brief If \arg Loc is a loaded location from the preamble, returns /// the corresponding local location of the main file, otherwise it returns /// \arg Loc. SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) { FileID PreambleID; if (SourceMgr) PreambleID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) return Loc; unsigned Offs; if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble.size()) { SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID()); return FileLoc.getLocWithOffset(Offs); } return Loc; } /// \brief If \arg Loc is a local location of the main file but inside the /// preamble chunk, returns the corresponding loaded location from the /// preamble, otherwise it returns \arg Loc. SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) { FileID PreambleID; if (SourceMgr) PreambleID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) return Loc; unsigned Offs; if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) && Offs < Preamble.size()) { SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID); return FileLoc.getLocWithOffset(Offs); } return Loc; } bool ASTUnit::isInPreambleFileID(SourceLocation Loc) { FileID FID; if (SourceMgr) FID = SourceMgr->getPreambleFileID(); if (Loc.isInvalid() || FID.isInvalid()) return false; return SourceMgr->isInFileID(Loc, FID); } bool ASTUnit::isInMainFileID(SourceLocation Loc) { FileID FID; if (SourceMgr) FID = SourceMgr->getMainFileID(); if (Loc.isInvalid() || FID.isInvalid()) return false; return SourceMgr->isInFileID(Loc, FID); } SourceLocation ASTUnit::getEndOfPreambleFileID() { FileID FID; if (SourceMgr) FID = SourceMgr->getPreambleFileID(); if (FID.isInvalid()) return SourceLocation(); return SourceMgr->getLocForEndOfFile(FID); } SourceLocation ASTUnit::getStartOfMainFileID() { FileID FID; if (SourceMgr) FID = SourceMgr->getMainFileID(); if (FID.isInvalid()) return SourceLocation(); return SourceMgr->getLocForStartOfFile(FID); } std::pair ASTUnit::getLocalPreprocessingEntities() const { if (isMainFileAST()) { serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); return Reader->getModulePreprocessedEntities(Mod); } if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord()) return std::make_pair(PPRec->local_begin(), PPRec->local_end()); return std::make_pair(PreprocessingRecord::iterator(), PreprocessingRecord::iterator()); } bool ASTUnit::visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn) { if (isMainFileAST()) { serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); ASTReader::ModuleDeclIterator MDI, MDE; llvm::tie(MDI, MDE) = Reader->getModuleFileLevelDecls(Mod); for (; MDI != MDE; ++MDI) { if (!Fn(context, *MDI)) return false; } return true; } for (ASTUnit::top_level_iterator TL = top_level_begin(), TLEnd = top_level_end(); TL != TLEnd; ++TL) { if (!Fn(context, *TL)) return false; } return true; } namespace { struct PCHLocatorInfo { serialization::ModuleFile *Mod; PCHLocatorInfo() : Mod(0) {} }; } static bool PCHLocator(serialization::ModuleFile &M, void *UserData) { PCHLocatorInfo &Info = *static_cast(UserData); switch (M.Kind) { case serialization::MK_Module: return true; // skip dependencies. case serialization::MK_PCH: Info.Mod = &M; return true; // found it. case serialization::MK_Preamble: return false; // look in dependencies. case serialization::MK_MainFile: return false; // look in dependencies. } return true; } const FileEntry *ASTUnit::getPCHFile() { if (!Reader) return 0; PCHLocatorInfo Info; Reader->getModuleManager().visit(PCHLocator, &Info); if (Info.Mod) return Info.Mod->File; return 0; } bool ASTUnit::isModuleFile() { return isMainFileAST() && !ASTFileLangOpts.CurrentModule.empty(); } void ASTUnit::PreambleData::countLines() const { NumLines = 0; if (empty()) return; for (std::vector::const_iterator I = Buffer.begin(), E = Buffer.end(); I != E; ++I) { if (*I == '\n') ++NumLines; } if (Buffer.back() != '\n') ++NumLines; } #ifndef NDEBUG ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = new llvm::sys::MutexImpl(/*recursive=*/true); } ASTUnit::ConcurrencyState::~ConcurrencyState() { delete static_cast(Mutex); } void ASTUnit::ConcurrencyState::start() { bool acquired = static_cast(Mutex)->tryacquire(); assert(acquired && "Concurrent access to ASTUnit!"); } void ASTUnit::ConcurrencyState::finish() { static_cast(Mutex)->release(); } #else // NDEBUG ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = 0; } ASTUnit::ConcurrencyState::~ConcurrencyState() {} void ASTUnit::ConcurrencyState::start() {} void ASTUnit::ConcurrencyState::finish() {} #endif @