1 //===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // ASTUnit Implementation.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Frontend/ASTUnit.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/DeclVisitor.h"
18 #include "clang/AST/TypeOrdering.h"
19 #include "clang/AST/StmtVisitor.h"
20 #include "clang/Driver/Compilation.h"
21 #include "clang/Driver/Driver.h"
22 #include "clang/Driver/Job.h"
23 #include "clang/Driver/Tool.h"
24 #include "clang/Frontend/CompilerInstance.h"
25 #include "clang/Frontend/FrontendActions.h"
26 #include "clang/Frontend/FrontendDiagnostic.h"
27 #include "clang/Frontend/FrontendOptions.h"
28 #include "clang/Serialization/ASTReader.h"
29 #include "clang/Serialization/ASTWriter.h"
30 #include "clang/Lex/HeaderSearch.h"
31 #include "clang/Lex/Preprocessor.h"
32 #include "clang/Basic/TargetOptions.h"
33 #include "clang/Basic/TargetInfo.h"
34 #include "clang/Basic/Diagnostic.h"
35 #include "llvm/ADT/StringSet.h"
36 #include "llvm/Support/MemoryBuffer.h"
37 #include "llvm/System/Host.h"
38 #include "llvm/System/Path.h"
39 #include "llvm/Support/raw_ostream.h"
40 #include "llvm/Support/Timer.h"
44 using namespace clang;
46 /// \brief After failing to build a precompiled preamble (due to
47 /// errors in the source that occurs in the preamble), the number of
48 /// reparses during which we'll skip even trying to precompile the
50 const unsigned DefaultPreambleRebuildInterval = 5;
52 ASTUnit::ASTUnit(bool _MainFileIsAST)
53 : CaptureDiagnostics(false), MainFileIsAST(_MainFileIsAST),
54 CompleteTranslationUnit(true), ConcurrencyCheckValue(CheckUnlocked),
55 PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0),
56 ShouldCacheCodeCompletionResults(false),
57 NumTopLevelDeclsAtLastCompletionCache(0),
58 CacheCodeCompletionCoolDown(0),
63 ConcurrencyCheckValue = CheckLocked;
64 CleanTemporaryFiles();
65 if (!PreambleFile.empty())
66 llvm::sys::Path(PreambleFile).eraseFromDisk();
68 // Free the buffers associated with remapped files. We are required to
69 // perform this operation here because we explicitly request that the
70 // compiler instance *not* free these buffers for each invocation of the
72 if (Invocation.get()) {
73 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
74 for (PreprocessorOptions::remapped_file_buffer_iterator
75 FB = PPOpts.remapped_file_buffer_begin(),
76 FBEnd = PPOpts.remapped_file_buffer_end();
82 delete SavedMainFileBuffer;
83 delete PreambleBuffer;
85 ClearCachedCompletionResults();
87 for (unsigned I = 0, N = Timers.size(); I != N; ++I)
91 void ASTUnit::CleanTemporaryFiles() {
92 for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
93 TemporaryFiles[I].eraseFromDisk();
94 TemporaryFiles.clear();
97 /// \brief Determine the set of code-completion contexts in which this
98 /// declaration should be shown.
99 static unsigned getDeclShowContexts(NamedDecl *ND,
100 const LangOptions &LangOpts,
101 bool &IsNestedNameSpecifier) {
102 IsNestedNameSpecifier = false;
104 if (isa<UsingShadowDecl>(ND))
105 ND = dyn_cast<NamedDecl>(ND->getUnderlyingDecl());
109 unsigned Contexts = 0;
110 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||
111 isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) {
112 // Types can appear in these contexts.
113 if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))
114 Contexts |= (1 << (CodeCompletionContext::CCC_TopLevel - 1))
115 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
116 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
117 | (1 << (CodeCompletionContext::CCC_Statement - 1))
118 | (1 << (CodeCompletionContext::CCC_Type - 1));
120 // In C++, types can appear in expressions contexts (for functional casts).
121 if (LangOpts.CPlusPlus)
122 Contexts |= (1 << (CodeCompletionContext::CCC_Expression - 1));
124 // In Objective-C, message sends can send interfaces. In Objective-C++,
125 // all types are available due to functional casts.
126 if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))
127 Contexts |= (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
129 // Deal with tag names.
130 if (isa<EnumDecl>(ND)) {
131 Contexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1));
133 // Part of the nested-name-specifier in C++0x.
134 if (LangOpts.CPlusPlus0x)
135 IsNestedNameSpecifier = true;
136 } else if (RecordDecl *Record = dyn_cast<RecordDecl>(ND)) {
137 if (Record->isUnion())
138 Contexts |= (1 << (CodeCompletionContext::CCC_UnionTag - 1));
140 Contexts |= (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
142 if (LangOpts.CPlusPlus)
143 IsNestedNameSpecifier = true;
144 } else if (isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND))
145 IsNestedNameSpecifier = true;
146 } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
147 // Values can appear in these contexts.
148 Contexts = (1 << (CodeCompletionContext::CCC_Statement - 1))
149 | (1 << (CodeCompletionContext::CCC_Expression - 1))
150 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
151 } else if (isa<ObjCProtocolDecl>(ND)) {
152 Contexts = (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1));
153 } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {
154 Contexts = (1 << (CodeCompletionContext::CCC_Namespace - 1));
156 // Part of the nested-name-specifier.
157 IsNestedNameSpecifier = true;
163 void ASTUnit::CacheCodeCompletionResults() {
167 llvm::Timer *CachingTimer = 0;
168 if (TimerGroup.get()) {
169 CachingTimer = new llvm::Timer("Cache global code completions",
171 CachingTimer->startTimer();
172 Timers.push_back(CachingTimer);
175 // Clear out the previous results.
176 ClearCachedCompletionResults();
178 // Gather the set of global code completions.
179 typedef CodeCompletionResult Result;
180 llvm::SmallVector<Result, 8> Results;
181 TheSema->GatherGlobalCodeCompletions(Results);
183 // Translate global code completions into cached completions.
184 llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
186 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
187 switch (Results[I].Kind) {
188 case Result::RK_Declaration: {
189 bool IsNestedNameSpecifier = false;
190 CachedCodeCompletionResult CachedResult;
191 CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema);
192 CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration,
193 Ctx->getLangOptions(),
194 IsNestedNameSpecifier);
195 CachedResult.Priority = Results[I].Priority;
196 CachedResult.Kind = Results[I].CursorKind;
197 CachedResult.Availability = Results[I].Availability;
199 // Keep track of the type of this completion in an ASTContext-agnostic
201 QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration);
202 if (UsageType.isNull()) {
203 CachedResult.TypeClass = STC_Void;
204 CachedResult.Type = 0;
206 CanQualType CanUsageType
207 = Ctx->getCanonicalType(UsageType.getUnqualifiedType());
208 CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType);
210 // Determine whether we have already seen this type. If so, we save
211 // ourselves the work of formatting the type string by using the
212 // temporary, CanQualType-based hash table to find the associated value.
213 unsigned &TypeValue = CompletionTypes[CanUsageType];
214 if (TypeValue == 0) {
215 TypeValue = CompletionTypes.size();
216 CachedCompletionTypes[QualType(CanUsageType).getAsString()]
220 CachedResult.Type = TypeValue;
223 CachedCompletionResults.push_back(CachedResult);
225 /// Handle nested-name-specifiers in C++.
226 if (TheSema->Context.getLangOptions().CPlusPlus &&
227 IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) {
228 // The contexts in which a nested-name-specifier can appear in C++.
230 = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
231 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
232 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
233 | (1 << (CodeCompletionContext::CCC_Statement - 1))
234 | (1 << (CodeCompletionContext::CCC_Expression - 1))
235 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
236 | (1 << (CodeCompletionContext::CCC_EnumTag - 1))
237 | (1 << (CodeCompletionContext::CCC_UnionTag - 1))
238 | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1))
239 | (1 << (CodeCompletionContext::CCC_Type - 1))
240 | (1 << (CodeCompletionContext::CCC_PotentiallyQualifiedName - 1));
242 if (isa<NamespaceDecl>(Results[I].Declaration) ||
243 isa<NamespaceAliasDecl>(Results[I].Declaration))
244 NNSContexts |= (1 << (CodeCompletionContext::CCC_Namespace - 1));
246 if (unsigned RemainingContexts
247 = NNSContexts & ~CachedResult.ShowInContexts) {
248 // If there any contexts where this completion can be a
249 // nested-name-specifier but isn't already an option, create a
250 // nested-name-specifier completion.
251 Results[I].StartsNestedNameSpecifier = true;
252 CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema);
253 CachedResult.ShowInContexts = RemainingContexts;
254 CachedResult.Priority = CCP_NestedNameSpecifier;
255 CachedResult.TypeClass = STC_Void;
256 CachedResult.Type = 0;
257 CachedCompletionResults.push_back(CachedResult);
263 case Result::RK_Keyword:
264 case Result::RK_Pattern:
265 // Ignore keywords and patterns; we don't care, since they are so
266 // easily regenerated.
269 case Result::RK_Macro: {
270 CachedCodeCompletionResult CachedResult;
271 CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema);
272 CachedResult.ShowInContexts
273 = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
274 | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1))
275 | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1))
276 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
277 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
278 | (1 << (CodeCompletionContext::CCC_Statement - 1))
279 | (1 << (CodeCompletionContext::CCC_Expression - 1))
280 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
281 | (1 << (CodeCompletionContext::CCC_MacroNameUse - 1))
282 | (1 << (CodeCompletionContext::CCC_PreprocessorExpression - 1));
284 CachedResult.Priority = Results[I].Priority;
285 CachedResult.Kind = Results[I].CursorKind;
286 CachedResult.Availability = Results[I].Availability;
287 CachedResult.TypeClass = STC_Void;
288 CachedResult.Type = 0;
289 CachedCompletionResults.push_back(CachedResult);
293 Results[I].Destroy();
297 CachingTimer->stopTimer();
299 // Make a note of the state when we performed this caching.
300 NumTopLevelDeclsAtLastCompletionCache = top_level_size();
301 CacheCodeCompletionCoolDown = 15;
304 void ASTUnit::ClearCachedCompletionResults() {
305 for (unsigned I = 0, N = CachedCompletionResults.size(); I != N; ++I)
306 delete CachedCompletionResults[I].Completion;
307 CachedCompletionResults.clear();
308 CachedCompletionTypes.clear();
313 /// \brief Gathers information from ASTReader that will be used to initialize
315 class ASTInfoCollector : public ASTReaderListener {
316 LangOptions &LangOpt;
318 std::string &TargetTriple;
319 std::string &Predefines;
322 unsigned NumHeaderInfos;
325 ASTInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI,
326 std::string &TargetTriple, std::string &Predefines,
328 : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple),
329 Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {}
331 virtual bool ReadLanguageOptions(const LangOptions &LangOpts) {
336 virtual bool ReadTargetTriple(llvm::StringRef Triple) {
337 TargetTriple = Triple;
341 virtual bool ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
342 llvm::StringRef OriginalFileName,
343 std::string &SuggestedPredefines) {
344 Predefines = Buffers[0].Data;
345 for (unsigned I = 1, N = Buffers.size(); I != N; ++I) {
346 Predefines += Buffers[I].Data;
351 virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI, unsigned ID) {
352 HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++);
355 virtual void ReadCounter(unsigned Value) {
360 class StoredDiagnosticClient : public DiagnosticClient {
361 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags;
364 explicit StoredDiagnosticClient(
365 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
366 : StoredDiags(StoredDiags) { }
368 virtual void HandleDiagnostic(Diagnostic::Level Level,
369 const DiagnosticInfo &Info);
372 /// \brief RAII object that optionally captures diagnostics, if
373 /// there is no diagnostic client to capture them already.
374 class CaptureDroppedDiagnostics {
376 StoredDiagnosticClient Client;
377 DiagnosticClient *PreviousClient;
380 CaptureDroppedDiagnostics(bool RequestCapture, Diagnostic &Diags,
381 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
382 : Diags(Diags), Client(StoredDiags), PreviousClient(0)
384 if (RequestCapture || Diags.getClient() == 0) {
385 PreviousClient = Diags.takeClient();
386 Diags.setClient(&Client);
390 ~CaptureDroppedDiagnostics() {
391 if (Diags.getClient() == &Client) {
393 Diags.setClient(PreviousClient);
398 } // anonymous namespace
400 void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level,
401 const DiagnosticInfo &Info) {
402 StoredDiags.push_back(StoredDiagnostic(Level, Info));
405 const std::string &ASTUnit::getOriginalSourceFileName() {
406 return OriginalSourceFile;
409 const std::string &ASTUnit::getASTFileName() {
410 assert(isMainFileAST() && "Not an ASTUnit from an AST file!");
411 return static_cast<ASTReader *>(Ctx->getExternalSource())->getFileName();
414 ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename,
415 llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
417 RemappedFile *RemappedFiles,
418 unsigned NumRemappedFiles,
419 bool CaptureDiagnostics) {
420 llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true));
422 if (!Diags.getPtr()) {
423 // No diagnostics engine was provided, so create our own diagnostics object
424 // with the default options.
425 DiagnosticOptions DiagOpts;
426 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0);
429 AST->CaptureDiagnostics = CaptureDiagnostics;
430 AST->OnlyLocalDecls = OnlyLocalDecls;
431 AST->Diagnostics = Diags;
432 AST->FileMgr.reset(new FileManager);
433 AST->SourceMgr.reset(new SourceManager(AST->getDiagnostics()));
434 AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager()));
436 // If requested, capture diagnostics in the ASTUnit.
437 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, AST->getDiagnostics(),
438 AST->StoredDiagnostics);
440 for (unsigned I = 0; I != NumRemappedFiles; ++I) {
441 // Create the file entry for the file that we're mapping from.
442 const FileEntry *FromFile
443 = AST->getFileManager().getVirtualFile(RemappedFiles[I].first,
444 RemappedFiles[I].second->getBufferSize(),
447 AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file)
448 << RemappedFiles[I].first;
449 delete RemappedFiles[I].second;
453 // Override the contents of the "from" file with the contents of
455 AST->getSourceManager().overrideFileContents(FromFile,
456 RemappedFiles[I].second);
459 // Gather Info for preprocessor construction later on.
461 LangOptions LangInfo;
462 HeaderSearch &HeaderInfo = *AST->HeaderInfo.get();
463 std::string TargetTriple;
464 std::string Predefines;
467 llvm::OwningPtr<ASTReader> Reader;
469 Reader.reset(new ASTReader(AST->getSourceManager(), AST->getFileManager(),
470 AST->getDiagnostics()));
471 Reader->setListener(new ASTInfoCollector(LangInfo, HeaderInfo, TargetTriple,
472 Predefines, Counter));
474 switch (Reader->ReadAST(Filename)) {
475 case ASTReader::Success:
478 case ASTReader::Failure:
479 case ASTReader::IgnorePCH:
480 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
484 AST->OriginalSourceFile = Reader->getOriginalSourceFile();
486 // AST file loaded successfully. Now create the preprocessor.
488 // Get information about the target being compiled for.
490 // FIXME: This is broken, we should store the TargetOptions in the AST file.
491 TargetOptions TargetOpts;
493 TargetOpts.CXXABI = "";
495 TargetOpts.Features.clear();
496 TargetOpts.Triple = TargetTriple;
497 AST->Target.reset(TargetInfo::CreateTargetInfo(AST->getDiagnostics(),
499 AST->PP.reset(new Preprocessor(AST->getDiagnostics(), LangInfo,
501 AST->getSourceManager(), HeaderInfo));
502 Preprocessor &PP = *AST->PP.get();
504 PP.setPredefines(Reader->getSuggestedPredefines());
505 PP.setCounterValue(Counter);
506 Reader->setPreprocessor(PP);
508 // Create and initialize the ASTContext.
510 AST->Ctx.reset(new ASTContext(LangInfo,
511 AST->getSourceManager(),
513 PP.getIdentifierTable(),
514 PP.getSelectorTable(),
516 /* size_reserve = */0));
517 ASTContext &Context = *AST->Ctx.get();
519 Reader->InitializeContext(Context);
521 // Attach the AST reader to the AST context as an external AST
522 // source, so that declarations will be deserialized from the
523 // AST file as needed.
524 ASTReader *ReaderPtr = Reader.get();
525 llvm::OwningPtr<ExternalASTSource> Source(Reader.take());
526 Context.setExternalSource(Source);
528 // Create an AST consumer, even though it isn't used.
529 AST->Consumer.reset(new ASTConsumer);
531 // Create a semantic analysis object and tell the AST reader about it.
532 AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer));
533 AST->TheSema->Initialize();
534 ReaderPtr->InitializeSema(*AST->TheSema);
541 class TopLevelDeclTrackerConsumer : public ASTConsumer {
545 TopLevelDeclTrackerConsumer(ASTUnit &_Unit) : Unit(_Unit) {}
547 void HandleTopLevelDecl(DeclGroupRef D) {
548 for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) {
550 // FIXME: Currently ObjC method declarations are incorrectly being
551 // reported as top-level declarations, even though their DeclContext
552 // is the containing ObjC @interface/@implementation. This is a
553 // fundamental problem in the parser right now.
554 if (isa<ObjCMethodDecl>(D))
556 Unit.addTopLevelDecl(D);
560 // We're not interested in "interesting" decls.
561 void HandleInterestingDecl(DeclGroupRef) {}
564 class TopLevelDeclTrackerAction : public ASTFrontendAction {
568 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
569 llvm::StringRef InFile) {
570 return new TopLevelDeclTrackerConsumer(Unit);
574 TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
576 virtual bool hasCodeCompletionSupport() const { return false; }
577 virtual bool usesCompleteTranslationUnit() {
578 return Unit.isCompleteTranslationUnit();
582 class PrecompilePreambleConsumer : public PCHGenerator {
584 std::vector<Decl *> TopLevelDecls;
587 PrecompilePreambleConsumer(ASTUnit &Unit,
588 const Preprocessor &PP, bool Chaining,
589 const char *isysroot, llvm::raw_ostream *Out)
590 : PCHGenerator(PP, Chaining, isysroot, Out), Unit(Unit) { }
592 virtual void HandleTopLevelDecl(DeclGroupRef D) {
593 for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) {
595 // FIXME: Currently ObjC method declarations are incorrectly being
596 // reported as top-level declarations, even though their DeclContext
597 // is the containing ObjC @interface/@implementation. This is a
598 // fundamental problem in the parser right now.
599 if (isa<ObjCMethodDecl>(D))
601 TopLevelDecls.push_back(D);
605 virtual void HandleTranslationUnit(ASTContext &Ctx) {
606 PCHGenerator::HandleTranslationUnit(Ctx);
607 if (!Unit.getDiagnostics().hasErrorOccurred()) {
608 // Translate the top-level declarations we captured during
609 // parsing into declaration IDs in the precompiled
610 // preamble. This will allow us to deserialize those top-level
611 // declarations when requested.
612 for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I)
613 Unit.addTopLevelDeclFromPreamble(
614 getWriter().getDeclID(TopLevelDecls[I]));
619 class PrecompilePreambleAction : public ASTFrontendAction {
623 explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit) {}
625 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
626 llvm::StringRef InFile) {
628 llvm::raw_ostream *OS = 0;
630 if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot,
634 const char *isysroot = CI.getFrontendOpts().RelocatablePCH ?
636 return new PrecompilePreambleConsumer(Unit, CI.getPreprocessor(), Chaining,
640 virtual bool hasCodeCompletionSupport() const { return false; }
641 virtual bool hasASTFileSupport() const { return false; }
642 virtual bool usesCompleteTranslationUnit() { return false; }
647 /// Parse the source file into a translation unit using the given compiler
648 /// invocation, replacing the current translation unit.
650 /// \returns True if a failure occurred that causes the ASTUnit not to
651 /// contain any translation-unit information, false otherwise.
652 bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) {
653 delete SavedMainFileBuffer;
654 SavedMainFileBuffer = 0;
656 if (!Invocation.get()) {
657 delete OverrideMainBuffer;
661 // Create the compiler instance to use for building the AST.
662 CompilerInstance Clang;
663 Clang.setInvocation(Invocation.take());
664 OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second;
666 // Set up diagnostics, capturing any diagnostics that would
667 // otherwise be dropped.
668 Clang.setDiagnostics(&getDiagnostics());
669 CaptureDroppedDiagnostics Capture(CaptureDiagnostics,
673 // Create the target instance.
674 Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(),
675 Clang.getTargetOpts()));
676 if (!Clang.hasTarget()) {
677 delete OverrideMainBuffer;
681 // Inform the target of the language options.
683 // FIXME: We shouldn't need to do this, the target should be immutable once
684 // created. This complexity should be lifted elsewhere.
685 Clang.getTarget().setForcedLangOptions(Clang.getLangOpts());
687 assert(Clang.getFrontendOpts().Inputs.size() == 1 &&
688 "Invocation must have exactly one source file!");
689 assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST &&
690 "FIXME: AST inputs not yet supported here!");
691 assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
692 "IR inputs not support here!");
694 // Configure the various subsystems.
695 // FIXME: Should we retain the previous file manager?
696 FileMgr.reset(new FileManager);
697 SourceMgr.reset(new SourceManager(getDiagnostics()));
702 // Clear out old caches and data.
703 TopLevelDecls.clear();
704 CleanTemporaryFiles();
705 PreprocessedEntitiesByFile.clear();
707 if (!OverrideMainBuffer) {
708 StoredDiagnostics.clear();
709 TopLevelDeclsInPreamble.clear();
712 // Create a file manager object to provide access to and cache the filesystem.
713 Clang.setFileManager(&getFileManager());
715 // Create the source manager.
716 Clang.setSourceManager(&getSourceManager());
718 // If the main file has been overridden due to the use of a preamble,
719 // make that override happen and introduce the preamble.
720 PreprocessorOptions &PreprocessorOpts = Clang.getPreprocessorOpts();
721 std::string PriorImplicitPCHInclude;
722 if (OverrideMainBuffer) {
723 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
724 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
725 PreprocessorOpts.PrecompiledPreambleBytes.second
726 = PreambleEndsAtStartOfLine;
727 PriorImplicitPCHInclude = PreprocessorOpts.ImplicitPCHInclude;
728 PreprocessorOpts.ImplicitPCHInclude = PreambleFile;
729 PreprocessorOpts.DisablePCHValidation = true;
731 // Keep track of the override buffer;
732 SavedMainFileBuffer = OverrideMainBuffer;
734 // The stored diagnostic has the old source manager in it; update
735 // the locations to refer into the new source manager. Since we've
736 // been careful to make sure that the source manager's state
737 // before and after are identical, so that we can reuse the source
739 for (unsigned I = 0, N = StoredDiagnostics.size(); I != N; ++I) {
740 FullSourceLoc Loc(StoredDiagnostics[I].getLocation(),
742 StoredDiagnostics[I].setLocation(Loc);
745 PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
746 PreprocessorOpts.PrecompiledPreambleBytes.second = false;
749 llvm::OwningPtr<TopLevelDeclTrackerAction> Act;
750 Act.reset(new TopLevelDeclTrackerAction(*this));
751 if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second,
752 Clang.getFrontendOpts().Inputs[0].first))
757 // Steal the created target, context, and preprocessor, and take back the
758 // source and file managers.
759 TheSema.reset(Clang.takeSema());
760 Consumer.reset(Clang.takeASTConsumer());
761 Ctx.reset(Clang.takeASTContext());
762 PP.reset(Clang.takePreprocessor());
763 Clang.takeSourceManager();
764 Clang.takeFileManager();
765 Target.reset(Clang.takeTarget());
767 Act->EndSourceFile();
769 // Remove the overridden buffer we used for the preamble.
770 if (OverrideMainBuffer) {
771 PreprocessorOpts.eraseRemappedFile(
772 PreprocessorOpts.remapped_file_buffer_end() - 1);
773 PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude;
776 Invocation.reset(Clang.takeInvocation());
778 // If we were asked to cache code-completion results and don't have any
779 // results yet, do so now.
780 if (ShouldCacheCodeCompletionResults && CachedCompletionResults.empty())
781 CacheCodeCompletionResults();
786 // Remove the overridden buffer we used for the preamble.
787 if (OverrideMainBuffer) {
788 PreprocessorOpts.eraseRemappedFile(
789 PreprocessorOpts.remapped_file_buffer_end() - 1);
790 PreprocessorOpts.DisablePCHValidation = true;
791 PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude;
792 delete OverrideMainBuffer;
795 Clang.takeSourceManager();
796 Clang.takeFileManager();
797 Invocation.reset(Clang.takeInvocation());
801 /// \brief Simple function to retrieve a path for a preamble precompiled header.
802 static std::string GetPreamblePCHPath() {
803 // FIXME: This is lame; sys::Path should provide this function (in particular,
804 // it should know how to find the temporary files dir).
805 // FIXME: This is really lame. I copied this code from the Driver!
807 const char *TmpDir = ::getenv("TMPDIR");
809 TmpDir = ::getenv("TEMP");
811 TmpDir = ::getenv("TMP");
814 llvm::sys::Path P(TmpDir);
815 P.appendComponent("preamble");
816 P.appendSuffix("pch");
817 if (P.createTemporaryFileOnDisk())
818 return std::string();
823 /// \brief Compute the preamble for the main file, providing the source buffer
824 /// that corresponds to the main file along with a pair (bytes, start-of-line)
825 /// that describes the preamble.
826 std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> >
827 ASTUnit::ComputePreamble(CompilerInvocation &Invocation,
828 unsigned MaxLines, bool &CreatedBuffer) {
829 FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
830 PreprocessorOptions &PreprocessorOpts
831 = Invocation.getPreprocessorOpts();
832 CreatedBuffer = false;
834 // Try to determine if the main file has been remapped, either from the
835 // command line (to another file) or directly through the compiler invocation
836 // (to a memory buffer).
837 llvm::MemoryBuffer *Buffer = 0;
838 llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
839 if (const llvm::sys::FileStatus *MainFileStatus = MainFilePath.getFileStatus()) {
840 // Check whether there is a file-file remapping of the main file
841 for (PreprocessorOptions::remapped_file_iterator
842 M = PreprocessorOpts.remapped_file_begin(),
843 E = PreprocessorOpts.remapped_file_end();
846 llvm::sys::PathWithStatus MPath(M->first);
847 if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
848 if (MainFileStatus->uniqueID == MStatus->uniqueID) {
849 // We found a remapping. Try to load the resulting, remapped source.
852 CreatedBuffer = false;
855 Buffer = llvm::MemoryBuffer::getFile(M->second);
857 return std::make_pair((llvm::MemoryBuffer*)0,
858 std::make_pair(0, true));
859 CreatedBuffer = true;
861 // Remove this remapping. We've captured the buffer already.
862 M = PreprocessorOpts.eraseRemappedFile(M);
863 E = PreprocessorOpts.remapped_file_end();
870 // Check whether there is a file-buffer remapping. It supercedes the
871 // file-file remapping.
872 for (PreprocessorOptions::remapped_file_buffer_iterator
873 M = PreprocessorOpts.remapped_file_buffer_begin(),
874 E = PreprocessorOpts.remapped_file_buffer_end();
877 llvm::sys::PathWithStatus MPath(M->first);
878 if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
879 if (MainFileStatus->uniqueID == MStatus->uniqueID) {
880 // We found a remapping.
883 CreatedBuffer = false;
886 Buffer = const_cast<llvm::MemoryBuffer *>(M->second);
888 // Remove this remapping. We've captured the buffer already.
889 M = PreprocessorOpts.eraseRemappedFile(M);
890 E = PreprocessorOpts.remapped_file_buffer_end();
898 // If the main source file was not remapped, load it now.
900 Buffer = llvm::MemoryBuffer::getFile(FrontendOpts.Inputs[0].second);
902 return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true));
904 CreatedBuffer = true;
907 return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, MaxLines));
910 static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old,
913 llvm::StringRef NewName) {
914 llvm::MemoryBuffer *Result
915 = llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName);
916 memcpy(const_cast<char*>(Result->getBufferStart()),
917 Old->getBufferStart(), Old->getBufferSize());
918 memset(const_cast<char*>(Result->getBufferStart()) + Old->getBufferSize(),
919 ' ', NewSize - Old->getBufferSize() - 1);
920 const_cast<char*>(Result->getBufferEnd())[-1] = '\n';
928 /// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing
931 /// This routine will compute the preamble of the main source file. If a
932 /// non-trivial preamble is found, it will precompile that preamble into a
933 /// precompiled header so that the precompiled preamble can be used to reduce
934 /// reparsing time. If a precompiled preamble has already been constructed,
935 /// this routine will determine if it is still valid and, if so, avoid
936 /// rebuilding the precompiled preamble.
938 /// \param AllowRebuild When true (the default), this routine is
939 /// allowed to rebuild the precompiled preamble if it is found to be
942 /// \param MaxLines When non-zero, the maximum number of lines that
943 /// can occur within the preamble.
945 /// \returns If the precompiled preamble can be used, returns a newly-allocated
946 /// buffer that should be used in place of the main file when doing so.
947 /// Otherwise, returns a NULL pointer.
948 llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble(
949 CompilerInvocation PreambleInvocation,
952 FrontendOptions &FrontendOpts = PreambleInvocation.getFrontendOpts();
953 PreprocessorOptions &PreprocessorOpts
954 = PreambleInvocation.getPreprocessorOpts();
956 bool CreatedPreambleBuffer = false;
957 std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > NewPreamble
958 = ComputePreamble(PreambleInvocation, MaxLines, CreatedPreambleBuffer);
960 if (!NewPreamble.second.first) {
961 // We couldn't find a preamble in the main source. Clear out the current
962 // preamble, if we have one. It's obviously no good any more.
964 if (!PreambleFile.empty()) {
965 llvm::sys::Path(PreambleFile).eraseFromDisk();
966 PreambleFile.clear();
968 if (CreatedPreambleBuffer)
969 delete NewPreamble.first;
971 // The next time we actually see a preamble, precompile it.
972 PreambleRebuildCounter = 1;
976 if (!Preamble.empty()) {
977 // We've previously computed a preamble. Check whether we have the same
978 // preamble now that we did before, and that there's enough space in
979 // the main-file buffer within the precompiled preamble to fit the
981 if (Preamble.size() == NewPreamble.second.first &&
982 PreambleEndsAtStartOfLine == NewPreamble.second.second &&
983 NewPreamble.first->getBufferSize() < PreambleReservedSize-2 &&
984 memcmp(&Preamble[0], NewPreamble.first->getBufferStart(),
985 NewPreamble.second.first) == 0) {
986 // The preamble has not changed. We may be able to re-use the precompiled
989 // Check that none of the files used by the preamble have changed.
990 bool AnyFileChanged = false;
992 // First, make a record of those files that have been overridden via
993 // remapping or unsaved_files.
994 llvm::StringMap<std::pair<off_t, time_t> > OverriddenFiles;
995 for (PreprocessorOptions::remapped_file_iterator
996 R = PreprocessorOpts.remapped_file_begin(),
997 REnd = PreprocessorOpts.remapped_file_end();
998 !AnyFileChanged && R != REnd;
1000 struct stat StatBuf;
1001 if (stat(R->second.c_str(), &StatBuf)) {
1002 // If we can't stat the file we're remapping to, assume that something
1003 // horrible happened.
1004 AnyFileChanged = true;
1008 OverriddenFiles[R->first] = std::make_pair(StatBuf.st_size,
1011 for (PreprocessorOptions::remapped_file_buffer_iterator
1012 R = PreprocessorOpts.remapped_file_buffer_begin(),
1013 REnd = PreprocessorOpts.remapped_file_buffer_end();
1014 !AnyFileChanged && R != REnd;
1016 // FIXME: Should we actually compare the contents of file->buffer
1018 OverriddenFiles[R->first] = std::make_pair(R->second->getBufferSize(),
1022 // Check whether anything has changed.
1023 for (llvm::StringMap<std::pair<off_t, time_t> >::iterator
1024 F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end();
1025 !AnyFileChanged && F != FEnd;
1027 llvm::StringMap<std::pair<off_t, time_t> >::iterator Overridden
1028 = OverriddenFiles.find(F->first());
1029 if (Overridden != OverriddenFiles.end()) {
1030 // This file was remapped; check whether the newly-mapped file
1031 // matches up with the previous mapping.
1032 if (Overridden->second != F->second)
1033 AnyFileChanged = true;
1037 // The file was not remapped; check whether it has changed on disk.
1038 struct stat StatBuf;
1039 if (stat(F->first(), &StatBuf)) {
1040 // If we can't stat the file, assume that something horrible happened.
1041 AnyFileChanged = true;
1042 } else if (StatBuf.st_size != F->second.first ||
1043 StatBuf.st_mtime != F->second.second)
1044 AnyFileChanged = true;
1047 if (!AnyFileChanged) {
1048 // Okay! We can re-use the precompiled preamble.
1050 // Set the state of the diagnostic object to mimic its state
1051 // after parsing the preamble.
1052 getDiagnostics().Reset();
1053 getDiagnostics().setNumWarnings(NumWarningsInPreamble);
1054 if (StoredDiagnostics.size() > NumStoredDiagnosticsInPreamble)
1055 StoredDiagnostics.erase(
1056 StoredDiagnostics.begin() + NumStoredDiagnosticsInPreamble,
1057 StoredDiagnostics.end());
1059 // Create a version of the main file buffer that is padded to
1060 // buffer size we reserved when creating the preamble.
1061 return CreatePaddedMainFileBuffer(NewPreamble.first,
1062 CreatedPreambleBuffer,
1063 PreambleReservedSize,
1064 FrontendOpts.Inputs[0].second);
1068 // If we aren't allowed to rebuild the precompiled preamble, just
1073 // We can't reuse the previously-computed preamble. Build a new one.
1075 llvm::sys::Path(PreambleFile).eraseFromDisk();
1076 PreambleRebuildCounter = 1;
1077 } else if (!AllowRebuild) {
1078 // We aren't allowed to rebuild the precompiled preamble; just
1083 // If the preamble rebuild counter > 1, it's because we previously
1084 // failed to build a preamble and we're not yet ready to try
1085 // again. Decrement the counter and return a failure.
1086 if (PreambleRebuildCounter > 1) {
1087 --PreambleRebuildCounter;
1091 // We did not previously compute a preamble, or it can't be reused anyway.
1092 llvm::Timer *PreambleTimer = 0;
1093 if (TimerGroup.get()) {
1094 PreambleTimer = new llvm::Timer("Precompiling preamble", *TimerGroup);
1095 PreambleTimer->startTimer();
1096 Timers.push_back(PreambleTimer);
1099 // Create a new buffer that stores the preamble. The buffer also contains
1100 // extra space for the original contents of the file (which will be present
1101 // when we actually parse the file) along with more room in case the file
1103 PreambleReservedSize = NewPreamble.first->getBufferSize();
1104 if (PreambleReservedSize < 4096)
1105 PreambleReservedSize = 8191;
1107 PreambleReservedSize *= 2;
1109 // Save the preamble text for later; we'll need to compare against it for
1110 // subsequent reparses.
1111 Preamble.assign(NewPreamble.first->getBufferStart(),
1112 NewPreamble.first->getBufferStart()
1113 + NewPreamble.second.first);
1114 PreambleEndsAtStartOfLine = NewPreamble.second.second;
1116 delete PreambleBuffer;
1118 = llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize,
1119 FrontendOpts.Inputs[0].second);
1120 memcpy(const_cast<char*>(PreambleBuffer->getBufferStart()),
1121 NewPreamble.first->getBufferStart(), Preamble.size());
1122 memset(const_cast<char*>(PreambleBuffer->getBufferStart()) + Preamble.size(),
1123 ' ', PreambleReservedSize - Preamble.size() - 1);
1124 const_cast<char*>(PreambleBuffer->getBufferEnd())[-1] = '\n';
1126 // Remap the main source file to the preamble buffer.
1127 llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
1128 PreprocessorOpts.addRemappedFile(MainFilePath.str(), PreambleBuffer);
1130 // Tell the compiler invocation to generate a temporary precompiled header.
1131 FrontendOpts.ProgramAction = frontend::GeneratePCH;
1132 // FIXME: Set ChainedPCH unconditionally, once it is ready.
1133 if (::getenv("LIBCLANG_CHAINING"))
1134 FrontendOpts.ChainedPCH = true;
1135 // FIXME: Generate the precompiled header into memory?
1136 FrontendOpts.OutputFile = GetPreamblePCHPath();
1138 // Create the compiler instance to use for building the precompiled preamble.
1139 CompilerInstance Clang;
1140 Clang.setInvocation(&PreambleInvocation);
1141 OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second;
1143 // Set up diagnostics, capturing all of the diagnostics produced.
1144 Clang.setDiagnostics(&getDiagnostics());
1145 CaptureDroppedDiagnostics Capture(CaptureDiagnostics,
1149 // Create the target instance.
1150 Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(),
1151 Clang.getTargetOpts()));
1152 if (!Clang.hasTarget()) {
1153 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1155 if (CreatedPreambleBuffer)
1156 delete NewPreamble.first;
1158 PreambleTimer->stopTimer();
1159 PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1160 PreprocessorOpts.eraseRemappedFile(
1161 PreprocessorOpts.remapped_file_buffer_end() - 1);
1165 // Inform the target of the language options.
1167 // FIXME: We shouldn't need to do this, the target should be immutable once
1168 // created. This complexity should be lifted elsewhere.
1169 Clang.getTarget().setForcedLangOptions(Clang.getLangOpts());
1171 assert(Clang.getFrontendOpts().Inputs.size() == 1 &&
1172 "Invocation must have exactly one source file!");
1173 assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST &&
1174 "FIXME: AST inputs not yet supported here!");
1175 assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
1176 "IR inputs not support here!");
1178 // Clear out old caches and data.
1179 StoredDiagnostics.clear();
1180 TopLevelDecls.clear();
1181 TopLevelDeclsInPreamble.clear();
1183 // Create a file manager object to provide access to and cache the filesystem.
1184 Clang.setFileManager(new FileManager);
1186 // Create the source manager.
1187 Clang.setSourceManager(new SourceManager(getDiagnostics()));
1189 llvm::OwningPtr<PrecompilePreambleAction> Act;
1190 Act.reset(new PrecompilePreambleAction(*this));
1191 if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second,
1192 Clang.getFrontendOpts().Inputs[0].first)) {
1193 Clang.takeInvocation();
1194 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1196 if (CreatedPreambleBuffer)
1197 delete NewPreamble.first;
1199 PreambleTimer->stopTimer();
1200 PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1201 PreprocessorOpts.eraseRemappedFile(
1202 PreprocessorOpts.remapped_file_buffer_end() - 1);
1207 Act->EndSourceFile();
1208 Clang.takeInvocation();
1210 if (Diagnostics->hasErrorOccurred()) {
1211 // There were errors parsing the preamble, so no precompiled header was
1212 // generated. Forget that we even tried.
1213 // FIXME: Should we leave a note for ourselves to try again?
1214 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1216 if (CreatedPreambleBuffer)
1217 delete NewPreamble.first;
1219 PreambleTimer->stopTimer();
1220 TopLevelDeclsInPreamble.clear();
1221 PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1222 PreprocessorOpts.eraseRemappedFile(
1223 PreprocessorOpts.remapped_file_buffer_end() - 1);
1227 // Keep track of the preamble we precompiled.
1228 PreambleFile = FrontendOpts.OutputFile;
1229 NumStoredDiagnosticsInPreamble = StoredDiagnostics.size();
1230 NumWarningsInPreamble = getDiagnostics().getNumWarnings();
1232 // Keep track of all of the files that the source manager knows about,
1233 // so we can verify whether they have changed or not.
1234 FilesInPreamble.clear();
1235 SourceManager &SourceMgr = Clang.getSourceManager();
1236 const llvm::MemoryBuffer *MainFileBuffer
1237 = SourceMgr.getBuffer(SourceMgr.getMainFileID());
1238 for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(),
1239 FEnd = SourceMgr.fileinfo_end();
1242 const FileEntry *File = F->second->Entry;
1243 if (!File || F->second->getRawBuffer() == MainFileBuffer)
1246 FilesInPreamble[File->getName()]
1247 = std::make_pair(F->second->getSize(), File->getModificationTime());
1251 PreambleTimer->stopTimer();
1253 PreambleRebuildCounter = 1;
1254 PreprocessorOpts.eraseRemappedFile(
1255 PreprocessorOpts.remapped_file_buffer_end() - 1);
1256 return CreatePaddedMainFileBuffer(NewPreamble.first,
1257 CreatedPreambleBuffer,
1258 PreambleReservedSize,
1259 FrontendOpts.Inputs[0].second);
1262 void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1263 std::vector<Decl *> Resolved;
1264 Resolved.reserve(TopLevelDeclsInPreamble.size());
1265 ExternalASTSource &Source = *getASTContext().getExternalSource();
1266 for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) {
1267 // Resolve the declaration ID to an actual declaration, possibly
1268 // deserializing the declaration in the process.
1269 Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]);
1271 Resolved.push_back(D);
1273 TopLevelDeclsInPreamble.clear();
1274 TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1277 unsigned ASTUnit::getMaxPCHLevel() const {
1278 if (!getOnlyLocalDecls())
1279 return Decl::MaxPCHLevel;
1281 unsigned Result = 0;
1282 if (isMainFileAST() || SavedMainFileBuffer)
1287 ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI,
1288 llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
1289 bool OnlyLocalDecls,
1290 bool CaptureDiagnostics,
1291 bool PrecompilePreamble,
1292 bool CompleteTranslationUnit,
1293 bool CacheCodeCompletionResults) {
1294 if (!Diags.getPtr()) {
1295 // No diagnostics engine was provided, so create our own diagnostics object
1296 // with the default options.
1297 DiagnosticOptions DiagOpts;
1298 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0);
1301 // Create the AST unit.
1302 llvm::OwningPtr<ASTUnit> AST;
1303 AST.reset(new ASTUnit(false));
1304 AST->Diagnostics = Diags;
1305 AST->CaptureDiagnostics = CaptureDiagnostics;
1306 AST->OnlyLocalDecls = OnlyLocalDecls;
1307 AST->CompleteTranslationUnit = CompleteTranslationUnit;
1308 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1309 AST->Invocation.reset(CI);
1310 CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1312 if (getenv("LIBCLANG_TIMING"))
1313 AST->TimerGroup.reset(
1314 new llvm::TimerGroup(CI->getFrontendOpts().Inputs[0].second));
1317 llvm::MemoryBuffer *OverrideMainBuffer = 0;
1318 // FIXME: When C++ PCH is ready, allow use of it for a precompiled preamble.
1319 if (PrecompilePreamble && !CI->getLangOpts().CPlusPlus) {
1320 AST->PreambleRebuildCounter = 1;
1322 = AST->getMainBufferWithPrecompiledPreamble(*AST->Invocation);
1325 llvm::Timer *ParsingTimer = 0;
1326 if (AST->TimerGroup.get()) {
1327 ParsingTimer = new llvm::Timer("Initial parse", *AST->TimerGroup);
1328 ParsingTimer->startTimer();
1329 AST->Timers.push_back(ParsingTimer);
1332 bool Failed = AST->Parse(OverrideMainBuffer);
1334 ParsingTimer->stopTimer();
1336 return Failed? 0 : AST.take();
1339 ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin,
1340 const char **ArgEnd,
1341 llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
1342 llvm::StringRef ResourceFilesPath,
1343 bool OnlyLocalDecls,
1344 RemappedFile *RemappedFiles,
1345 unsigned NumRemappedFiles,
1346 bool CaptureDiagnostics,
1347 bool PrecompilePreamble,
1348 bool CompleteTranslationUnit,
1349 bool CacheCodeCompletionResults) {
1350 bool CreatedDiagnosticsObject = false;
1352 if (!Diags.getPtr()) {
1353 // No diagnostics engine was provided, so create our own diagnostics object
1354 // with the default options.
1355 DiagnosticOptions DiagOpts;
1356 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0);
1357 CreatedDiagnosticsObject = true;
1360 llvm::SmallVector<const char *, 16> Args;
1361 Args.push_back("<clang>"); // FIXME: Remove dummy argument.
1362 Args.insert(Args.end(), ArgBegin, ArgEnd);
1364 // FIXME: Find a cleaner way to force the driver into restricted modes. We
1365 // also want to force it to use clang.
1366 Args.push_back("-fsyntax-only");
1368 // FIXME: We shouldn't have to pass in the path info.
1369 driver::Driver TheDriver("clang", llvm::sys::getHostTriple(),
1370 "a.out", false, false, *Diags);
1372 // Don't check that inputs exist, they have been remapped.
1373 TheDriver.setCheckInputsExist(false);
1375 llvm::OwningPtr<driver::Compilation> C(
1376 TheDriver.BuildCompilation(Args.size(), Args.data()));
1378 // We expect to get back exactly one command job, if we didn't something
1380 const driver::JobList &Jobs = C->getJobs();
1381 if (Jobs.size() != 1 || !isa<driver::Command>(Jobs.begin())) {
1382 llvm::SmallString<256> Msg;
1383 llvm::raw_svector_ostream OS(Msg);
1384 C->PrintJob(OS, C->getJobs(), "; ", true);
1385 Diags->Report(diag::err_fe_expected_compiler_job) << OS.str();
1389 const driver::Command *Cmd = cast<driver::Command>(*Jobs.begin());
1390 if (llvm::StringRef(Cmd->getCreator().getName()) != "clang") {
1391 Diags->Report(diag::err_fe_expected_clang_command);
1395 const driver::ArgStringList &CCArgs = Cmd->getArguments();
1396 llvm::OwningPtr<CompilerInvocation> CI(new CompilerInvocation);
1397 CompilerInvocation::CreateFromArgs(*CI,
1398 const_cast<const char **>(CCArgs.data()),
1399 const_cast<const char **>(CCArgs.data()) +
1403 // Override any files that need remapping
1404 for (unsigned I = 0; I != NumRemappedFiles; ++I)
1405 CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
1406 RemappedFiles[I].second);
1408 // Override the resources path.
1409 CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
1411 CI->getFrontendOpts().DisableFree = false;
1412 return LoadFromCompilerInvocation(CI.take(), Diags, OnlyLocalDecls,
1413 CaptureDiagnostics, PrecompilePreamble,
1414 CompleteTranslationUnit,
1415 CacheCodeCompletionResults);
1418 bool ASTUnit::Reparse(RemappedFile *RemappedFiles, unsigned NumRemappedFiles) {
1419 if (!Invocation.get())
1422 llvm::Timer *ReparsingTimer = 0;
1423 if (TimerGroup.get()) {
1424 ReparsingTimer = new llvm::Timer("Reparse", *TimerGroup);
1425 ReparsingTimer->startTimer();
1426 Timers.push_back(ReparsingTimer);
1430 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1431 for (PreprocessorOptions::remapped_file_buffer_iterator
1432 R = PPOpts.remapped_file_buffer_begin(),
1433 REnd = PPOpts.remapped_file_buffer_end();
1438 Invocation->getPreprocessorOpts().clearRemappedFiles();
1439 for (unsigned I = 0; I != NumRemappedFiles; ++I)
1440 Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
1441 RemappedFiles[I].second);
1443 // If we have a preamble file lying around, or if we might try to
1444 // build a precompiled preamble, do so now.
1445 llvm::MemoryBuffer *OverrideMainBuffer = 0;
1446 if (!PreambleFile.empty() || PreambleRebuildCounter > 0)
1447 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation);
1449 // Clear out the diagnostics state.
1450 if (!OverrideMainBuffer)
1451 getDiagnostics().Reset();
1453 // Parse the sources
1454 bool Result = Parse(OverrideMainBuffer);
1456 ReparsingTimer->stopTimer();
1458 if (ShouldCacheCodeCompletionResults) {
1459 if (CacheCodeCompletionCoolDown > 0)
1460 --CacheCodeCompletionCoolDown;
1461 else if (top_level_size() != NumTopLevelDeclsAtLastCompletionCache)
1462 CacheCodeCompletionResults();
1468 //----------------------------------------------------------------------------//
1470 //----------------------------------------------------------------------------//
1473 /// \brief Code completion consumer that combines the cached code-completion
1474 /// results from an ASTUnit with the code-completion results provided to it,
1475 /// then passes the result on to
1476 class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer {
1477 unsigned NormalContexts;
1479 CodeCompleteConsumer &Next;
1482 AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next,
1483 bool IncludeMacros, bool IncludeCodePatterns,
1484 bool IncludeGlobals)
1485 : CodeCompleteConsumer(IncludeMacros, IncludeCodePatterns, IncludeGlobals,
1486 Next.isOutputBinary()), AST(AST), Next(Next)
1488 // Compute the set of contexts in which we will look when we don't have
1489 // any information about the specific context.
1491 = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
1492 | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1))
1493 | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1))
1494 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
1495 | (1 << (CodeCompletionContext::CCC_Statement - 1))
1496 | (1 << (CodeCompletionContext::CCC_Expression - 1))
1497 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
1498 | (1 << (CodeCompletionContext::CCC_MemberAccess - 1))
1499 | (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1));
1501 if (AST.getASTContext().getLangOptions().CPlusPlus)
1502 NormalContexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1))
1503 | (1 << (CodeCompletionContext::CCC_UnionTag - 1))
1504 | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
1507 virtual void ProcessCodeCompleteResults(Sema &S,
1508 CodeCompletionContext Context,
1509 CodeCompletionResult *Results,
1510 unsigned NumResults);
1512 virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
1513 OverloadCandidate *Candidates,
1514 unsigned NumCandidates) {
1515 Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates);
1520 /// \brief Helper function that computes which global names are hidden by the
1521 /// local code-completion results.
1522 void CalculateHiddenNames(const CodeCompletionContext &Context,
1523 CodeCompletionResult *Results,
1524 unsigned NumResults,
1526 llvm::StringSet<> &HiddenNames) {
1527 bool OnlyTagNames = false;
1528 switch (Context.getKind()) {
1529 case CodeCompletionContext::CCC_Other:
1530 case CodeCompletionContext::CCC_TopLevel:
1531 case CodeCompletionContext::CCC_ObjCInterface:
1532 case CodeCompletionContext::CCC_ObjCImplementation:
1533 case CodeCompletionContext::CCC_ObjCIvarList:
1534 case CodeCompletionContext::CCC_ClassStructUnion:
1535 case CodeCompletionContext::CCC_Statement:
1536 case CodeCompletionContext::CCC_Expression:
1537 case CodeCompletionContext::CCC_ObjCMessageReceiver:
1538 case CodeCompletionContext::CCC_MemberAccess:
1539 case CodeCompletionContext::CCC_Namespace:
1540 case CodeCompletionContext::CCC_Type:
1541 case CodeCompletionContext::CCC_Name:
1542 case CodeCompletionContext::CCC_PotentiallyQualifiedName:
1545 case CodeCompletionContext::CCC_EnumTag:
1546 case CodeCompletionContext::CCC_UnionTag:
1547 case CodeCompletionContext::CCC_ClassOrStructTag:
1548 OnlyTagNames = true;
1551 case CodeCompletionContext::CCC_ObjCProtocolName:
1552 case CodeCompletionContext::CCC_MacroName:
1553 case CodeCompletionContext::CCC_MacroNameUse:
1554 case CodeCompletionContext::CCC_PreprocessorExpression:
1555 case CodeCompletionContext::CCC_PreprocessorDirective:
1556 case CodeCompletionContext::CCC_NaturalLanguage:
1557 case CodeCompletionContext::CCC_SelectorName:
1558 case CodeCompletionContext::CCC_TypeQualifiers:
1559 // We're looking for nothing, or we're looking for names that cannot
1564 typedef CodeCompletionResult Result;
1565 for (unsigned I = 0; I != NumResults; ++I) {
1566 if (Results[I].Kind != Result::RK_Declaration)
1570 = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
1572 bool Hiding = false;
1574 Hiding = (IDNS & Decl::IDNS_Tag);
1576 unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member |
1577 Decl::IDNS_Namespace | Decl::IDNS_Ordinary |
1578 Decl::IDNS_NonMemberOperator);
1579 if (Ctx.getLangOptions().CPlusPlus)
1580 HiddenIDNS |= Decl::IDNS_Tag;
1581 Hiding = (IDNS & HiddenIDNS);
1587 DeclarationName Name = Results[I].Declaration->getDeclName();
1588 if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo())
1589 HiddenNames.insert(Identifier->getName());
1591 HiddenNames.insert(Name.getAsString());
1596 void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S,
1597 CodeCompletionContext Context,
1598 CodeCompletionResult *Results,
1599 unsigned NumResults) {
1600 // Merge the results we were given with the results we cached.
1601 bool AddedResult = false;
1603 = (Context.getKind() == CodeCompletionContext::CCC_Other? NormalContexts
1604 : (1 << (Context.getKind() - 1)));
1606 // Contains the set of names that are hidden by "local" completion results.
1607 llvm::StringSet<> HiddenNames;
1608 llvm::SmallVector<CodeCompletionString *, 4> StringsToDestroy;
1609 typedef CodeCompletionResult Result;
1610 llvm::SmallVector<Result, 8> AllResults;
1611 for (ASTUnit::cached_completion_iterator
1612 C = AST.cached_completion_begin(),
1613 CEnd = AST.cached_completion_end();
1615 // If the context we are in matches any of the contexts we are
1616 // interested in, we'll add this result.
1617 if ((C->ShowInContexts & InContexts) == 0)
1620 // If we haven't added any results previously, do so now.
1622 CalculateHiddenNames(Context, Results, NumResults, S.Context,
1624 AllResults.insert(AllResults.end(), Results, Results + NumResults);
1628 // Determine whether this global completion result is hidden by a local
1629 // completion result. If so, skip it.
1630 if (C->Kind != CXCursor_MacroDefinition &&
1631 HiddenNames.count(C->Completion->getTypedText()))
1634 // Adjust priority based on similar type classes.
1635 unsigned Priority = C->Priority;
1636 CXCursorKind CursorKind = C->Kind;
1637 CodeCompletionString *Completion = C->Completion;
1638 if (!Context.getPreferredType().isNull()) {
1639 if (C->Kind == CXCursor_MacroDefinition) {
1640 Priority = getMacroUsagePriority(C->Completion->getTypedText(),
1641 Context.getPreferredType()->isAnyPointerType());
1642 } else if (C->Type) {
1643 CanQualType Expected
1644 = S.Context.getCanonicalType(
1645 Context.getPreferredType().getUnqualifiedType());
1646 SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected);
1647 if (ExpectedSTC == C->TypeClass) {
1648 // We know this type is similar; check for an exact match.
1649 llvm::StringMap<unsigned> &CachedCompletionTypes
1650 = AST.getCachedCompletionTypes();
1651 llvm::StringMap<unsigned>::iterator Pos
1652 = CachedCompletionTypes.find(QualType(Expected).getAsString());
1653 if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)
1654 Priority /= CCF_ExactTypeMatch;
1656 Priority /= CCF_SimilarTypeMatch;
1661 // Adjust the completion string, if required.
1662 if (C->Kind == CXCursor_MacroDefinition &&
1663 Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) {
1664 // Create a new code-completion string that just contains the
1665 // macro name, without its arguments.
1666 Completion = new CodeCompletionString;
1667 Completion->AddTypedTextChunk(C->Completion->getTypedText());
1668 StringsToDestroy.push_back(Completion);
1669 CursorKind = CXCursor_NotImplemented;
1670 Priority = CCP_CodePattern;
1673 AllResults.push_back(Result(Completion, Priority, CursorKind,
1677 // If we did not add any cached completion results, just forward the
1678 // results we were given to the next consumer.
1680 Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
1684 Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
1687 for (unsigned I = 0, N = StringsToDestroy.size(); I != N; ++I)
1688 delete StringsToDestroy[I];
1693 void ASTUnit::CodeComplete(llvm::StringRef File, unsigned Line, unsigned Column,
1694 RemappedFile *RemappedFiles,
1695 unsigned NumRemappedFiles,
1697 bool IncludeCodePatterns,
1698 CodeCompleteConsumer &Consumer,
1699 Diagnostic &Diag, LangOptions &LangOpts,
1700 SourceManager &SourceMgr, FileManager &FileMgr,
1701 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
1702 llvm::SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) {
1703 if (!Invocation.get())
1706 llvm::Timer *CompletionTimer = 0;
1707 if (TimerGroup.get()) {
1708 llvm::SmallString<128> TimerName;
1709 llvm::raw_svector_ostream TimerNameOut(TimerName);
1710 TimerNameOut << "Code completion @ " << File << ":" << Line << ":"
1712 CompletionTimer = new llvm::Timer(TimerNameOut.str(), *TimerGroup);
1713 CompletionTimer->startTimer();
1714 Timers.push_back(CompletionTimer);
1717 CompilerInvocation CCInvocation(*Invocation);
1718 FrontendOptions &FrontendOpts = CCInvocation.getFrontendOpts();
1719 PreprocessorOptions &PreprocessorOpts = CCInvocation.getPreprocessorOpts();
1721 FrontendOpts.ShowMacrosInCodeCompletion
1722 = IncludeMacros && CachedCompletionResults.empty();
1723 FrontendOpts.ShowCodePatternsInCodeCompletion = IncludeCodePatterns;
1724 FrontendOpts.ShowGlobalSymbolsInCodeCompletion
1725 = CachedCompletionResults.empty();
1726 FrontendOpts.CodeCompletionAt.FileName = File;
1727 FrontendOpts.CodeCompletionAt.Line = Line;
1728 FrontendOpts.CodeCompletionAt.Column = Column;
1730 // Turn on spell-checking when performing code completion. It leads
1731 // to better results.
1732 unsigned SpellChecking = CCInvocation.getLangOpts().SpellChecking;
1733 CCInvocation.getLangOpts().SpellChecking = 1;
1735 // Set the language options appropriately.
1736 LangOpts = CCInvocation.getLangOpts();
1738 CompilerInstance Clang;
1739 Clang.setInvocation(&CCInvocation);
1740 OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second;
1742 // Set up diagnostics, capturing any diagnostics produced.
1743 Clang.setDiagnostics(&Diag);
1744 CaptureDroppedDiagnostics Capture(true,
1745 Clang.getDiagnostics(),
1748 // Create the target instance.
1749 Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(),
1750 Clang.getTargetOpts()));
1751 if (!Clang.hasTarget()) {
1752 Clang.takeInvocation();
1753 CCInvocation.getLangOpts().SpellChecking = SpellChecking;
1757 // Inform the target of the language options.
1759 // FIXME: We shouldn't need to do this, the target should be immutable once
1760 // created. This complexity should be lifted elsewhere.
1761 Clang.getTarget().setForcedLangOptions(Clang.getLangOpts());
1763 assert(Clang.getFrontendOpts().Inputs.size() == 1 &&
1764 "Invocation must have exactly one source file!");
1765 assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST &&
1766 "FIXME: AST inputs not yet supported here!");
1767 assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
1768 "IR inputs not support here!");
1771 // Use the source and file managers that we were given.
1772 Clang.setFileManager(&FileMgr);
1773 Clang.setSourceManager(&SourceMgr);
1776 PreprocessorOpts.clearRemappedFiles();
1777 PreprocessorOpts.RetainRemappedFileBuffers = true;
1778 for (unsigned I = 0; I != NumRemappedFiles; ++I) {
1779 PreprocessorOpts.addRemappedFile(RemappedFiles[I].first,
1780 RemappedFiles[I].second);
1781 OwnedBuffers.push_back(RemappedFiles[I].second);
1784 // Use the code completion consumer we were given, but adding any cached
1785 // code-completion results.
1786 AugmentedCodeCompleteConsumer
1787 AugmentedConsumer(*this, Consumer, FrontendOpts.ShowMacrosInCodeCompletion,
1788 FrontendOpts.ShowCodePatternsInCodeCompletion,
1789 FrontendOpts.ShowGlobalSymbolsInCodeCompletion);
1790 Clang.setCodeCompletionConsumer(&AugmentedConsumer);
1792 // If we have a precompiled preamble, try to use it. We only allow
1793 // the use of the precompiled preamble if we're if the completion
1794 // point is within the main file, after the end of the precompiled
1796 llvm::MemoryBuffer *OverrideMainBuffer = 0;
1797 if (!PreambleFile.empty()) {
1798 using llvm::sys::FileStatus;
1799 llvm::sys::PathWithStatus CompleteFilePath(File);
1800 llvm::sys::PathWithStatus MainPath(OriginalSourceFile);
1801 if (const FileStatus *CompleteFileStatus = CompleteFilePath.getFileStatus())
1802 if (const FileStatus *MainStatus = MainPath.getFileStatus())
1803 if (CompleteFileStatus->getUniqueID() == MainStatus->getUniqueID())
1805 = getMainBufferWithPrecompiledPreamble(CCInvocation, false,
1809 // If the main file has been overridden due to the use of a preamble,
1810 // make that override happen and introduce the preamble.
1811 if (OverrideMainBuffer) {
1812 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
1813 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
1814 PreprocessorOpts.PrecompiledPreambleBytes.second
1815 = PreambleEndsAtStartOfLine;
1816 PreprocessorOpts.ImplicitPCHInclude = PreambleFile;
1817 PreprocessorOpts.DisablePCHValidation = true;
1819 // The stored diagnostics have the old source manager. Copy them
1820 // to our output set of stored diagnostics, updating the source
1821 // manager to the one we were given.
1822 for (unsigned I = 0, N = this->StoredDiagnostics.size(); I != N; ++I) {
1823 StoredDiagnostics.push_back(this->StoredDiagnostics[I]);
1824 FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SourceMgr);
1825 StoredDiagnostics[I].setLocation(Loc);
1828 OwnedBuffers.push_back(OverrideMainBuffer);
1830 PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
1831 PreprocessorOpts.PrecompiledPreambleBytes.second = false;
1834 llvm::OwningPtr<SyntaxOnlyAction> Act;
1835 Act.reset(new SyntaxOnlyAction);
1836 if (Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second,
1837 Clang.getFrontendOpts().Inputs[0].first)) {
1839 Act->EndSourceFile();
1842 if (CompletionTimer)
1843 CompletionTimer->stopTimer();
1845 // Steal back our resources.
1846 Clang.takeFileManager();
1847 Clang.takeSourceManager();
1848 Clang.takeInvocation();
1849 Clang.takeCodeCompletionConsumer();
1850 CCInvocation.getLangOpts().SpellChecking = SpellChecking;
1853 bool ASTUnit::Save(llvm::StringRef File) {
1854 if (getDiagnostics().hasErrorOccurred())
1857 // FIXME: Can we somehow regenerate the stat cache here, or do we need to
1858 // unconditionally create a stat cache when we parse the file?
1859 std::string ErrorInfo;
1860 llvm::raw_fd_ostream Out(File.str().c_str(), ErrorInfo,
1861 llvm::raw_fd_ostream::F_Binary);
1862 if (!ErrorInfo.empty() || Out.has_error())
1865 std::vector<unsigned char> Buffer;
1866 llvm::BitstreamWriter Stream(Buffer);
1867 ASTWriter Writer(Stream);
1868 Writer.WriteAST(getSema(), 0, 0);
1870 // Write the generated bitstream to "Out".
1871 if (!Buffer.empty())
1872 Out.write((char *)&Buffer.front(), Buffer.size());
1874 return Out.has_error();