ASTUnit.cpp revision 223017 
1//===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// ASTUnit Implementation.
11//
12//===----------------------------------------------------------------------===//
13
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/ArgList.h"
24#include "clang/Driver/Options.h"
25#include "clang/Driver/Tool.h"
26#include "clang/Frontend/CompilerInstance.h"
27#include "clang/Frontend/FrontendActions.h"
28#include "clang/Frontend/FrontendDiagnostic.h"
29#include "clang/Frontend/FrontendOptions.h"
30#include "clang/Frontend/Utils.h"
31#include "clang/Serialization/ASTReader.h"
32#include "clang/Serialization/ASTSerializationListener.h"
33#include "clang/Serialization/ASTWriter.h"
34#include "clang/Lex/HeaderSearch.h"
35#include "clang/Lex/Preprocessor.h"
36#include "clang/Basic/TargetOptions.h"
37#include "clang/Basic/TargetInfo.h"
38#include "clang/Basic/Diagnostic.h"
39#include "llvm/ADT/ArrayRef.h"
40#include "llvm/ADT/StringExtras.h"
41#include "llvm/ADT/StringSet.h"
42#include "llvm/Support/Atomic.h"
43#include "llvm/Support/MemoryBuffer.h"
44#include "llvm/Support/Host.h"
45#include "llvm/Support/Path.h"
46#include "llvm/Support/raw_ostream.h"
47#include "llvm/Support/Timer.h"
48#include "llvm/Support/CrashRecoveryContext.h"
49#include <cstdlib>
50#include <cstdio>
51#include <sys/stat.h>
52using namespace clang;
53
54using llvm::TimeRecord;
55
56namespace {
57  class SimpleTimer {
58    bool WantTiming;
59    TimeRecord Start;
60    std::string Output;
61
62  public:
63    explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) {
64      if (WantTiming)
65        Start = TimeRecord::getCurrentTime();
66    }
67
68    void setOutput(const llvm::Twine &Output) {
69      if (WantTiming)
70        this->Output = Output.str();
71    }
72
73    ~SimpleTimer() {
74      if (WantTiming) {
75        TimeRecord Elapsed = TimeRecord::getCurrentTime();
76        Elapsed -= Start;
77        llvm::errs() << Output << ':';
78        Elapsed.print(Elapsed, llvm::errs());
79        llvm::errs() << '\n';
80      }
81    }
82  };
83}
84
85/// \brief After failing to build a precompiled preamble (due to
86/// errors in the source that occurs in the preamble), the number of
87/// reparses during which we'll skip even trying to precompile the
88/// preamble.
89const unsigned DefaultPreambleRebuildInterval = 5;
90
91/// \brief Tracks the number of ASTUnit objects that are currently active.
92///
93/// Used for debugging purposes only.
94static llvm::sys::cas_flag ActiveASTUnitObjects;
95
96ASTUnit::ASTUnit(bool _MainFileIsAST)
97  : OnlyLocalDecls(false), CaptureDiagnostics(false),
98    MainFileIsAST(_MainFileIsAST),
99    CompleteTranslationUnit(true), WantTiming(getenv("LIBCLANG_TIMING")),
100    OwnsRemappedFileBuffers(true),
101    NumStoredDiagnosticsFromDriver(0),
102    ConcurrencyCheckValue(CheckUnlocked),
103    PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0),
104    ShouldCacheCodeCompletionResults(false),
105    NestedMacroInstantiations(true),
106    CompletionCacheTopLevelHashValue(0),
107    PreambleTopLevelHashValue(0),
108    CurrentTopLevelHashValue(0),
109    UnsafeToFree(false) {
110  if (getenv("LIBCLANG_OBJTRACKING")) {
111    llvm::sys::AtomicIncrement(&ActiveASTUnitObjects);
112    fprintf(stderr, "+++ %d translation units\n", ActiveASTUnitObjects);
113  }
114}
115
116ASTUnit::~ASTUnit() {
117  ConcurrencyCheckValue = CheckLocked;
118  CleanTemporaryFiles();
119  if (!PreambleFile.empty())
120    llvm::sys::Path(PreambleFile).eraseFromDisk();
121
122  // Free the buffers associated with remapped files. We are required to
123  // perform this operation here because we explicitly request that the
124  // compiler instance *not* free these buffers for each invocation of the
125  // parser.
126  if (Invocation.getPtr() && OwnsRemappedFileBuffers) {
127    PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
128    for (PreprocessorOptions::remapped_file_buffer_iterator
129           FB = PPOpts.remapped_file_buffer_begin(),
130           FBEnd = PPOpts.remapped_file_buffer_end();
131         FB != FBEnd;
132         ++FB)
133      delete FB->second;
134  }
135
136  delete SavedMainFileBuffer;
137  delete PreambleBuffer;
138
139  ClearCachedCompletionResults();
140
141  if (getenv("LIBCLANG_OBJTRACKING")) {
142    llvm::sys::AtomicDecrement(&ActiveASTUnitObjects);
143    fprintf(stderr, "--- %d translation units\n", ActiveASTUnitObjects);
144  }
145}
146
147void ASTUnit::CleanTemporaryFiles() {
148  for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
149    TemporaryFiles[I].eraseFromDisk();
150  TemporaryFiles.clear();
151}
152
153/// \brief Determine the set of code-completion contexts in which this
154/// declaration should be shown.
155static unsigned getDeclShowContexts(NamedDecl *ND,
156                                    const LangOptions &LangOpts,
157                                    bool &IsNestedNameSpecifier) {
158  IsNestedNameSpecifier = false;
159
160  if (isa<UsingShadowDecl>(ND))
161    ND = dyn_cast<NamedDecl>(ND->getUnderlyingDecl());
162  if (!ND)
163    return 0;
164
165  unsigned Contexts = 0;
166  if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||
167      isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) {
168    // Types can appear in these contexts.
169    if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))
170      Contexts |= (1 << (CodeCompletionContext::CCC_TopLevel - 1))
171                | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
172                | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
173                | (1 << (CodeCompletionContext::CCC_Statement - 1))
174                | (1 << (CodeCompletionContext::CCC_Type - 1))
175              | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1));
176
177    // In C++, types can appear in expressions contexts (for functional casts).
178    if (LangOpts.CPlusPlus)
179      Contexts |= (1 << (CodeCompletionContext::CCC_Expression - 1));
180
181    // In Objective-C, message sends can send interfaces. In Objective-C++,
182    // all types are available due to functional casts.
183    if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))
184      Contexts |= (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
185
186    // Deal with tag names.
187    if (isa<EnumDecl>(ND)) {
188      Contexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1));
189
190      // Part of the nested-name-specifier in C++0x.
191      if (LangOpts.CPlusPlus0x)
192        IsNestedNameSpecifier = true;
193    } else if (RecordDecl *Record = dyn_cast<RecordDecl>(ND)) {
194      if (Record->isUnion())
195        Contexts |= (1 << (CodeCompletionContext::CCC_UnionTag - 1));
196      else
197        Contexts |= (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
198
199      if (LangOpts.CPlusPlus)
200        IsNestedNameSpecifier = true;
201    } else if (isa<ClassTemplateDecl>(ND))
202      IsNestedNameSpecifier = true;
203  } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
204    // Values can appear in these contexts.
205    Contexts = (1 << (CodeCompletionContext::CCC_Statement - 1))
206             | (1 << (CodeCompletionContext::CCC_Expression - 1))
207             | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1))
208             | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
209  } else if (isa<ObjCProtocolDecl>(ND)) {
210    Contexts = (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1));
211  } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {
212    Contexts = (1 << (CodeCompletionContext::CCC_Namespace - 1));
213
214    // Part of the nested-name-specifier.
215    IsNestedNameSpecifier = true;
216  }
217
218  return Contexts;
219}
220
221void ASTUnit::CacheCodeCompletionResults() {
222  if (!TheSema)
223    return;
224
225  SimpleTimer Timer(WantTiming);
226  Timer.setOutput("Cache global code completions for " + getMainFileName());
227
228  // Clear out the previous results.
229  ClearCachedCompletionResults();
230
231  // Gather the set of global code completions.
232  typedef CodeCompletionResult Result;
233  llvm::SmallVector<Result, 8> Results;
234  CachedCompletionAllocator = new GlobalCodeCompletionAllocator;
235  TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, Results);
236
237  // Translate global code completions into cached completions.
238  llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
239
240  for (unsigned I = 0, N = Results.size(); I != N; ++I) {
241    switch (Results[I].Kind) {
242    case Result::RK_Declaration: {
243      bool IsNestedNameSpecifier = false;
244      CachedCodeCompletionResult CachedResult;
245      CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema,
246                                                    *CachedCompletionAllocator);
247      CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration,
248                                                        Ctx->getLangOptions(),
249                                                        IsNestedNameSpecifier);
250      CachedResult.Priority = Results[I].Priority;
251      CachedResult.Kind = Results[I].CursorKind;
252      CachedResult.Availability = Results[I].Availability;
253
254      // Keep track of the type of this completion in an ASTContext-agnostic
255      // way.
256      QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration);
257      if (UsageType.isNull()) {
258        CachedResult.TypeClass = STC_Void;
259        CachedResult.Type = 0;
260      } else {
261        CanQualType CanUsageType
262          = Ctx->getCanonicalType(UsageType.getUnqualifiedType());
263        CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType);
264
265        // Determine whether we have already seen this type. If so, we save
266        // ourselves the work of formatting the type string by using the
267        // temporary, CanQualType-based hash table to find the associated value.
268        unsigned &TypeValue = CompletionTypes[CanUsageType];
269        if (TypeValue == 0) {
270          TypeValue = CompletionTypes.size();
271          CachedCompletionTypes[QualType(CanUsageType).getAsString()]
272            = TypeValue;
273        }
274
275        CachedResult.Type = TypeValue;
276      }
277
278      CachedCompletionResults.push_back(CachedResult);
279
280      /// Handle nested-name-specifiers in C++.
281      if (TheSema->Context.getLangOptions().CPlusPlus &&
282          IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) {
283        // The contexts in which a nested-name-specifier can appear in C++.
284        unsigned NNSContexts
285          = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
286          | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
287          | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
288          | (1 << (CodeCompletionContext::CCC_Statement - 1))
289          | (1 << (CodeCompletionContext::CCC_Expression - 1))
290          | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
291          | (1 << (CodeCompletionContext::CCC_EnumTag - 1))
292          | (1 << (CodeCompletionContext::CCC_UnionTag - 1))
293          | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1))
294          | (1 << (CodeCompletionContext::CCC_Type - 1))
295          | (1 << (CodeCompletionContext::CCC_PotentiallyQualifiedName - 1))
296          | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1));
297
298        if (isa<NamespaceDecl>(Results[I].Declaration) ||
299            isa<NamespaceAliasDecl>(Results[I].Declaration))
300          NNSContexts |= (1 << (CodeCompletionContext::CCC_Namespace - 1));
301
302        if (unsigned RemainingContexts
303                                = NNSContexts & ~CachedResult.ShowInContexts) {
304          // If there any contexts where this completion can be a
305          // nested-name-specifier but isn't already an option, create a
306          // nested-name-specifier completion.
307          Results[I].StartsNestedNameSpecifier = true;
308          CachedResult.Completion
309            = Results[I].CreateCodeCompletionString(*TheSema,
310                                                    *CachedCompletionAllocator);
311          CachedResult.ShowInContexts = RemainingContexts;
312          CachedResult.Priority = CCP_NestedNameSpecifier;
313          CachedResult.TypeClass = STC_Void;
314          CachedResult.Type = 0;
315          CachedCompletionResults.push_back(CachedResult);
316        }
317      }
318      break;
319    }
320
321    case Result::RK_Keyword:
322    case Result::RK_Pattern:
323      // Ignore keywords and patterns; we don't care, since they are so
324      // easily regenerated.
325      break;
326
327    case Result::RK_Macro: {
328      CachedCodeCompletionResult CachedResult;
329      CachedResult.Completion
330        = Results[I].CreateCodeCompletionString(*TheSema,
331                                                *CachedCompletionAllocator);
332      CachedResult.ShowInContexts
333        = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
334        | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1))
335        | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1))
336        | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
337        | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
338        | (1 << (CodeCompletionContext::CCC_Statement - 1))
339        | (1 << (CodeCompletionContext::CCC_Expression - 1))
340        | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
341        | (1 << (CodeCompletionContext::CCC_MacroNameUse - 1))
342        | (1 << (CodeCompletionContext::CCC_PreprocessorExpression - 1))
343        | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1))
344        | (1 << (CodeCompletionContext::CCC_OtherWithMacros - 1));
345
346      CachedResult.Priority = Results[I].Priority;
347      CachedResult.Kind = Results[I].CursorKind;
348      CachedResult.Availability = Results[I].Availability;
349      CachedResult.TypeClass = STC_Void;
350      CachedResult.Type = 0;
351      CachedCompletionResults.push_back(CachedResult);
352      break;
353    }
354    }
355  }
356
357  // Save the current top-level hash value.
358  CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;
359}
360
361void ASTUnit::ClearCachedCompletionResults() {
362  CachedCompletionResults.clear();
363  CachedCompletionTypes.clear();
364  CachedCompletionAllocator = 0;
365}
366
367namespace {
368
369/// \brief Gathers information from ASTReader that will be used to initialize
370/// a Preprocessor.
371class ASTInfoCollector : public ASTReaderListener {
372  LangOptions &LangOpt;
373  HeaderSearch &HSI;
374  std::string &TargetTriple;
375  std::string &Predefines;
376  unsigned &Counter;
377
378  unsigned NumHeaderInfos;
379
380public:
381  ASTInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI,
382                   std::string &TargetTriple, std::string &Predefines,
383                   unsigned &Counter)
384    : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple),
385      Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {}
386
387  virtual bool ReadLanguageOptions(const LangOptions &LangOpts) {
388    LangOpt = LangOpts;
389    return false;
390  }
391
392  virtual bool ReadTargetTriple(llvm::StringRef Triple) {
393    TargetTriple = Triple;
394    return false;
395  }
396
397  virtual bool ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
398                                    llvm::StringRef OriginalFileName,
399                                    std::string &SuggestedPredefines,
400                                    FileManager &FileMgr) {
401    Predefines = Buffers[0].Data;
402    for (unsigned I = 1, N = Buffers.size(); I != N; ++I) {
403      Predefines += Buffers[I].Data;
404    }
405    return false;
406  }
407
408  virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI, unsigned ID) {
409    HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++);
410  }
411
412  virtual void ReadCounter(unsigned Value) {
413    Counter = Value;
414  }
415};
416
417class StoredDiagnosticClient : public DiagnosticClient {
418  llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags;
419
420public:
421  explicit StoredDiagnosticClient(
422                          llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
423    : StoredDiags(StoredDiags) { }
424
425  virtual void HandleDiagnostic(Diagnostic::Level Level,
426                                const DiagnosticInfo &Info);
427};
428
429/// \brief RAII object that optionally captures diagnostics, if
430/// there is no diagnostic client to capture them already.
431class CaptureDroppedDiagnostics {
432  Diagnostic &Diags;
433  StoredDiagnosticClient Client;
434  DiagnosticClient *PreviousClient;
435
436public:
437  CaptureDroppedDiagnostics(bool RequestCapture, Diagnostic &Diags,
438                          llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
439    : Diags(Diags), Client(StoredDiags), PreviousClient(0)
440  {
441    if (RequestCapture || Diags.getClient() == 0) {
442      PreviousClient = Diags.takeClient();
443      Diags.setClient(&Client);
444    }
445  }
446
447  ~CaptureDroppedDiagnostics() {
448    if (Diags.getClient() == &Client) {
449      Diags.takeClient();
450      Diags.setClient(PreviousClient);
451    }
452  }
453};
454
455} // anonymous namespace
456
457void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level,
458                                              const DiagnosticInfo &Info) {
459  // Default implementation (Warnings/errors count).
460  DiagnosticClient::HandleDiagnostic(Level, Info);
461
462  StoredDiags.push_back(StoredDiagnostic(Level, Info));
463}
464
465const std::string &ASTUnit::getOriginalSourceFileName() {
466  return OriginalSourceFile;
467}
468
469const std::string &ASTUnit::getASTFileName() {
470  assert(isMainFileAST() && "Not an ASTUnit from an AST file!");
471  return static_cast<ASTReader *>(Ctx->getExternalSource())->getFileName();
472}
473
474llvm::MemoryBuffer *ASTUnit::getBufferForFile(llvm::StringRef Filename,
475                                              std::string *ErrorStr) {
476  assert(FileMgr);
477  return FileMgr->getBufferForFile(Filename, ErrorStr);
478}
479
480/// \brief Configure the diagnostics object for use with ASTUnit.
481void ASTUnit::ConfigureDiags(llvm::IntrusiveRefCntPtr<Diagnostic> &Diags,
482                             const char **ArgBegin, const char **ArgEnd,
483                             ASTUnit &AST, bool CaptureDiagnostics) {
484  if (!Diags.getPtr()) {
485    // No diagnostics engine was provided, so create our own diagnostics object
486    // with the default options.
487    DiagnosticOptions DiagOpts;
488    DiagnosticClient *Client = 0;
489    if (CaptureDiagnostics)
490      Client = new StoredDiagnosticClient(AST.StoredDiagnostics);
491    Diags = CompilerInstance::createDiagnostics(DiagOpts, ArgEnd- ArgBegin,
492                                                ArgBegin, Client);
493  } else if (CaptureDiagnostics) {
494    Diags->setClient(new StoredDiagnosticClient(AST.StoredDiagnostics));
495  }
496}
497
498ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename,
499                                  llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
500                                  const FileSystemOptions &FileSystemOpts,
501                                  bool OnlyLocalDecls,
502                                  RemappedFile *RemappedFiles,
503                                  unsigned NumRemappedFiles,
504                                  bool CaptureDiagnostics) {
505  llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true));
506
507  // Recover resources if we crash before exiting this method.
508  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
509    ASTUnitCleanup(AST.get());
510  llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic,
511    llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> >
512    DiagCleanup(Diags.getPtr());
513
514  ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics);
515
516  AST->OnlyLocalDecls = OnlyLocalDecls;
517  AST->CaptureDiagnostics = CaptureDiagnostics;
518  AST->Diagnostics = Diags;
519  AST->FileMgr = new FileManager(FileSystemOpts);
520  AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
521                                     AST->getFileManager());
522  AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager()));
523
524  for (unsigned I = 0; I != NumRemappedFiles; ++I) {
525    FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
526    if (const llvm::MemoryBuffer *
527          memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
528      // Create the file entry for the file that we're mapping from.
529      const FileEntry *FromFile
530        = AST->getFileManager().getVirtualFile(RemappedFiles[I].first,
531                                               memBuf->getBufferSize(),
532                                               0);
533      if (!FromFile) {
534        AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file)
535          << RemappedFiles[I].first;
536        delete memBuf;
537        continue;
538      }
539
540      // Override the contents of the "from" file with the contents of
541      // the "to" file.
542      AST->getSourceManager().overrideFileContents(FromFile, memBuf);
543
544    } else {
545      const char *fname = fileOrBuf.get<const char *>();
546      const FileEntry *ToFile = AST->FileMgr->getFile(fname);
547      if (!ToFile) {
548        AST->getDiagnostics().Report(diag::err_fe_remap_missing_to_file)
549        << RemappedFiles[I].first << fname;
550        continue;
551      }
552
553      // Create the file entry for the file that we're mapping from.
554      const FileEntry *FromFile
555        = AST->getFileManager().getVirtualFile(RemappedFiles[I].first,
556                                               ToFile->getSize(),
557                                               0);
558      if (!FromFile) {
559        AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file)
560          << RemappedFiles[I].first;
561        delete memBuf;
562        continue;
563      }
564
565      // Override the contents of the "from" file with the contents of
566      // the "to" file.
567      AST->getSourceManager().overrideFileContents(FromFile, ToFile);
568    }
569  }
570
571  // Gather Info for preprocessor construction later on.
572
573  LangOptions LangInfo;
574  HeaderSearch &HeaderInfo = *AST->HeaderInfo.get();
575  std::string TargetTriple;
576  std::string Predefines;
577  unsigned Counter;
578
579  llvm::OwningPtr<ASTReader> Reader;
580
581  Reader.reset(new ASTReader(AST->getSourceManager(), AST->getFileManager(),
582                             AST->getDiagnostics()));
583
584  // Recover resources if we crash before exiting this method.
585  llvm::CrashRecoveryContextCleanupRegistrar<ASTReader>
586    ReaderCleanup(Reader.get());
587
588  Reader->setListener(new ASTInfoCollector(LangInfo, HeaderInfo, TargetTriple,
589                                           Predefines, Counter));
590
591  switch (Reader->ReadAST(Filename, ASTReader::MainFile)) {
592  case ASTReader::Success:
593    break;
594
595  case ASTReader::Failure:
596  case ASTReader::IgnorePCH:
597    AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
598    return NULL;
599  }
600
601  AST->OriginalSourceFile = Reader->getOriginalSourceFile();
602
603  // AST file loaded successfully. Now create the preprocessor.
604
605  // Get information about the target being compiled for.
606  //
607  // FIXME: This is broken, we should store the TargetOptions in the AST file.
608  TargetOptions TargetOpts;
609  TargetOpts.ABI = "";
610  TargetOpts.CXXABI = "";
611  TargetOpts.CPU = "";
612  TargetOpts.Features.clear();
613  TargetOpts.Triple = TargetTriple;
614  AST->Target = TargetInfo::CreateTargetInfo(AST->getDiagnostics(),
615                                             TargetOpts);
616  AST->PP = new Preprocessor(AST->getDiagnostics(), LangInfo, *AST->Target,
617                             AST->getSourceManager(), HeaderInfo);
618  Preprocessor &PP = *AST->PP;
619
620  PP.setPredefines(Reader->getSuggestedPredefines());
621  PP.setCounterValue(Counter);
622  Reader->setPreprocessor(PP);
623
624  // Create and initialize the ASTContext.
625
626  AST->Ctx = new ASTContext(LangInfo,
627                            AST->getSourceManager(),
628                            *AST->Target,
629                            PP.getIdentifierTable(),
630                            PP.getSelectorTable(),
631                            PP.getBuiltinInfo(),
632                            /* size_reserve = */0);
633  ASTContext &Context = *AST->Ctx;
634
635  Reader->InitializeContext(Context);
636
637  // Attach the AST reader to the AST context as an external AST
638  // source, so that declarations will be deserialized from the
639  // AST file as needed.
640  ASTReader *ReaderPtr = Reader.get();
641  llvm::OwningPtr<ExternalASTSource> Source(Reader.take());
642
643  // Unregister the cleanup for ASTReader.  It will get cleaned up
644  // by the ASTUnit cleanup.
645  ReaderCleanup.unregister();
646
647  Context.setExternalSource(Source);
648
649  // Create an AST consumer, even though it isn't used.
650  AST->Consumer.reset(new ASTConsumer);
651
652  // Create a semantic analysis object and tell the AST reader about it.
653  AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer));
654  AST->TheSema->Initialize();
655  ReaderPtr->InitializeSema(*AST->TheSema);
656
657  return AST.take();
658}
659
660namespace {
661
662/// \brief Preprocessor callback class that updates a hash value with the names
663/// of all macros that have been defined by the translation unit.
664class MacroDefinitionTrackerPPCallbacks : public PPCallbacks {
665  unsigned &Hash;
666
667public:
668  explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { }
669
670  virtual void MacroDefined(const Token &MacroNameTok, const MacroInfo *MI) {
671    Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash);
672  }
673};
674
675/// \brief Add the given declaration to the hash of all top-level entities.
676void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) {
677  if (!D)
678    return;
679
680  DeclContext *DC = D->getDeclContext();
681  if (!DC)
682    return;
683
684  if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit()))
685    return;
686
687  if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
688    if (ND->getIdentifier())
689      Hash = llvm::HashString(ND->getIdentifier()->getName(), Hash);
690    else if (DeclarationName Name = ND->getDeclName()) {
691      std::string NameStr = Name.getAsString();
692      Hash = llvm::HashString(NameStr, Hash);
693    }
694    return;
695  }
696
697  if (ObjCForwardProtocolDecl *Forward
698      = dyn_cast<ObjCForwardProtocolDecl>(D)) {
699    for (ObjCForwardProtocolDecl::protocol_iterator
700         P = Forward->protocol_begin(),
701         PEnd = Forward->protocol_end();
702         P != PEnd; ++P)
703      AddTopLevelDeclarationToHash(*P, Hash);
704    return;
705  }
706
707  if (ObjCClassDecl *Class = llvm::dyn_cast<ObjCClassDecl>(D)) {
708    for (ObjCClassDecl::iterator I = Class->begin(), IEnd = Class->end();
709         I != IEnd; ++I)
710      AddTopLevelDeclarationToHash(I->getInterface(), Hash);
711    return;
712  }
713}
714
715class TopLevelDeclTrackerConsumer : public ASTConsumer {
716  ASTUnit &Unit;
717  unsigned &Hash;
718
719public:
720  TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash)
721    : Unit(_Unit), Hash(Hash) {
722    Hash = 0;
723  }
724
725  void HandleTopLevelDecl(DeclGroupRef D) {
726    for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) {
727      Decl *D = *it;
728      // FIXME: Currently ObjC method declarations are incorrectly being
729      // reported as top-level declarations, even though their DeclContext
730      // is the containing ObjC @interface/@implementation.  This is a
731      // fundamental problem in the parser right now.
732      if (isa<ObjCMethodDecl>(D))
733        continue;
734
735      AddTopLevelDeclarationToHash(D, Hash);
736      Unit.addTopLevelDecl(D);
737    }
738  }
739
740  // We're not interested in "interesting" decls.
741  void HandleInterestingDecl(DeclGroupRef) {}
742};
743
744class TopLevelDeclTrackerAction : public ASTFrontendAction {
745public:
746  ASTUnit &Unit;
747
748  virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
749                                         llvm::StringRef InFile) {
750    CI.getPreprocessor().addPPCallbacks(
751     new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue()));
752    return new TopLevelDeclTrackerConsumer(Unit,
753                                           Unit.getCurrentTopLevelHashValue());
754  }
755
756public:
757  TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
758
759  virtual bool hasCodeCompletionSupport() const { return false; }
760  virtual bool usesCompleteTranslationUnit()  {
761    return Unit.isCompleteTranslationUnit();
762  }
763};
764
765class PrecompilePreambleConsumer : public PCHGenerator,
766                                   public ASTSerializationListener {
767  ASTUnit &Unit;
768  unsigned &Hash;
769  std::vector<Decl *> TopLevelDecls;
770
771public:
772  PrecompilePreambleConsumer(ASTUnit &Unit,
773                             const Preprocessor &PP, bool Chaining,
774                             const char *isysroot, llvm::raw_ostream *Out)
775    : PCHGenerator(PP, "", Chaining, isysroot, Out), Unit(Unit),
776      Hash(Unit.getCurrentTopLevelHashValue()) {
777    Hash = 0;
778  }
779
780  virtual void HandleTopLevelDecl(DeclGroupRef D) {
781    for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) {
782      Decl *D = *it;
783      // FIXME: Currently ObjC method declarations are incorrectly being
784      // reported as top-level declarations, even though their DeclContext
785      // is the containing ObjC @interface/@implementation.  This is a
786      // fundamental problem in the parser right now.
787      if (isa<ObjCMethodDecl>(D))
788        continue;
789      AddTopLevelDeclarationToHash(D, Hash);
790      TopLevelDecls.push_back(D);
791    }
792  }
793
794  virtual void HandleTranslationUnit(ASTContext &Ctx) {
795    PCHGenerator::HandleTranslationUnit(Ctx);
796    if (!Unit.getDiagnostics().hasErrorOccurred()) {
797      // Translate the top-level declarations we captured during
798      // parsing into declaration IDs in the precompiled
799      // preamble. This will allow us to deserialize those top-level
800      // declarations when requested.
801      for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I)
802        Unit.addTopLevelDeclFromPreamble(
803                                      getWriter().getDeclID(TopLevelDecls[I]));
804    }
805  }
806
807  virtual void SerializedPreprocessedEntity(PreprocessedEntity *Entity,
808                                            uint64_t Offset) {
809    Unit.addPreprocessedEntityFromPreamble(Offset);
810  }
811
812  virtual ASTSerializationListener *GetASTSerializationListener() {
813    return this;
814  }
815};
816
817class PrecompilePreambleAction : public ASTFrontendAction {
818  ASTUnit &Unit;
819
820public:
821  explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit) {}
822
823  virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
824                                         llvm::StringRef InFile) {
825    std::string Sysroot;
826    std::string OutputFile;
827    llvm::raw_ostream *OS = 0;
828    bool Chaining;
829    if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot,
830                                                       OutputFile,
831                                                       OS, Chaining))
832      return 0;
833
834    const char *isysroot = CI.getFrontendOpts().RelocatablePCH ?
835                             Sysroot.c_str() : 0;
836    CI.getPreprocessor().addPPCallbacks(
837     new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue()));
838    return new PrecompilePreambleConsumer(Unit, CI.getPreprocessor(), Chaining,
839                                          isysroot, OS);
840  }
841
842  virtual bool hasCodeCompletionSupport() const { return false; }
843  virtual bool hasASTFileSupport() const { return false; }
844  virtual bool usesCompleteTranslationUnit() { return false; }
845};
846
847}
848
849/// Parse the source file into a translation unit using the given compiler
850/// invocation, replacing the current translation unit.
851///
852/// \returns True if a failure occurred that causes the ASTUnit not to
853/// contain any translation-unit information, false otherwise.
854bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) {
855  delete SavedMainFileBuffer;
856  SavedMainFileBuffer = 0;
857
858  if (!Invocation) {
859    delete OverrideMainBuffer;
860    return true;
861  }
862
863  // Create the compiler instance to use for building the AST.
864  llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
865
866  // Recover resources if we crash before exiting this method.
867  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
868    CICleanup(Clang.get());
869
870  Clang->setInvocation(&*Invocation);
871  OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
872
873  // Set up diagnostics, capturing any diagnostics that would
874  // otherwise be dropped.
875  Clang->setDiagnostics(&getDiagnostics());
876
877  // Create the target instance.
878  Clang->getTargetOpts().Features = TargetFeatures;
879  Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
880                   Clang->getTargetOpts()));
881  if (!Clang->hasTarget()) {
882    delete OverrideMainBuffer;
883    return true;
884  }
885
886  // Inform the target of the language options.
887  //
888  // FIXME: We shouldn't need to do this, the target should be immutable once
889  // created. This complexity should be lifted elsewhere.
890  Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
891
892  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
893         "Invocation must have exactly one source file!");
894  assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
895         "FIXME: AST inputs not yet supported here!");
896  assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
897         "IR inputs not support here!");
898
899  // Configure the various subsystems.
900  // FIXME: Should we retain the previous file manager?
901  FileSystemOpts = Clang->getFileSystemOpts();
902  FileMgr = new FileManager(FileSystemOpts);
903  SourceMgr = new SourceManager(getDiagnostics(), *FileMgr);
904  TheSema.reset();
905  Ctx = 0;
906  PP = 0;
907
908  // Clear out old caches and data.
909  TopLevelDecls.clear();
910  PreprocessedEntities.clear();
911  CleanTemporaryFiles();
912  PreprocessedEntitiesByFile.clear();
913
914  if (!OverrideMainBuffer) {
915    StoredDiagnostics.erase(
916                    StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver,
917                            StoredDiagnostics.end());
918    TopLevelDeclsInPreamble.clear();
919    PreprocessedEntitiesInPreamble.clear();
920  }
921
922  // Create a file manager object to provide access to and cache the filesystem.
923  Clang->setFileManager(&getFileManager());
924
925  // Create the source manager.
926  Clang->setSourceManager(&getSourceManager());
927
928  // If the main file has been overridden due to the use of a preamble,
929  // make that override happen and introduce the preamble.
930  PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts();
931  PreprocessorOpts.DetailedRecordIncludesNestedMacroInstantiations
932    = NestedMacroInstantiations;
933  std::string PriorImplicitPCHInclude;
934  if (OverrideMainBuffer) {
935    PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
936    PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
937    PreprocessorOpts.PrecompiledPreambleBytes.second
938                                                    = PreambleEndsAtStartOfLine;
939    PriorImplicitPCHInclude = PreprocessorOpts.ImplicitPCHInclude;
940    PreprocessorOpts.ImplicitPCHInclude = PreambleFile;
941    PreprocessorOpts.DisablePCHValidation = true;
942
943    // The stored diagnostic has the old source manager in it; update
944    // the locations to refer into the new source manager. Since we've
945    // been careful to make sure that the source manager's state
946    // before and after are identical, so that we can reuse the source
947    // location itself.
948    for (unsigned I = NumStoredDiagnosticsFromDriver,
949                  N = StoredDiagnostics.size();
950         I < N; ++I) {
951      FullSourceLoc Loc(StoredDiagnostics[I].getLocation(),
952                        getSourceManager());
953      StoredDiagnostics[I].setLocation(Loc);
954    }
955
956    // Keep track of the override buffer;
957    SavedMainFileBuffer = OverrideMainBuffer;
958  } else {
959    PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
960    PreprocessorOpts.PrecompiledPreambleBytes.second = false;
961  }
962
963  llvm::OwningPtr<TopLevelDeclTrackerAction> Act(
964    new TopLevelDeclTrackerAction(*this));
965
966  // Recover resources if we crash before exiting this method.
967  llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
968    ActCleanup(Act.get());
969
970  if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second,
971                            Clang->getFrontendOpts().Inputs[0].first))
972    goto error;
973
974  Act->Execute();
975
976  // Steal the created target, context, and preprocessor.
977  TheSema.reset(Clang->takeSema());
978  Consumer.reset(Clang->takeASTConsumer());
979  Ctx = &Clang->getASTContext();
980  PP = &Clang->getPreprocessor();
981  Clang->setSourceManager(0);
982  Clang->setFileManager(0);
983  Target = &Clang->getTarget();
984
985  Act->EndSourceFile();
986
987  // Remove the overridden buffer we used for the preamble.
988  if (OverrideMainBuffer) {
989    PreprocessorOpts.eraseRemappedFile(
990                               PreprocessorOpts.remapped_file_buffer_end() - 1);
991    PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude;
992  }
993
994  return false;
995
996error:
997  // Remove the overridden buffer we used for the preamble.
998  if (OverrideMainBuffer) {
999    PreprocessorOpts.eraseRemappedFile(
1000                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1001    PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude;
1002    delete OverrideMainBuffer;
1003    SavedMainFileBuffer = 0;
1004  }
1005
1006  StoredDiagnostics.clear();
1007  return true;
1008}
1009
1010/// \brief Simple function to retrieve a path for a preamble precompiled header.
1011static std::string GetPreamblePCHPath() {
1012  // FIXME: This is lame; sys::Path should provide this function (in particular,
1013  // it should know how to find the temporary files dir).
1014  // FIXME: This is really lame. I copied this code from the Driver!
1015  // FIXME: This is a hack so that we can override the preamble file during
1016  // crash-recovery testing, which is the only case where the preamble files
1017  // are not necessarily cleaned up.
1018  const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE");
1019  if (TmpFile)
1020    return TmpFile;
1021
1022  std::string Error;
1023  const char *TmpDir = ::getenv("TMPDIR");
1024  if (!TmpDir)
1025    TmpDir = ::getenv("TEMP");
1026  if (!TmpDir)
1027    TmpDir = ::getenv("TMP");
1028#ifdef LLVM_ON_WIN32
1029  if (!TmpDir)
1030    TmpDir = ::getenv("USERPROFILE");
1031#endif
1032  if (!TmpDir)
1033    TmpDir = "/tmp";
1034  llvm::sys::Path P(TmpDir);
1035  P.createDirectoryOnDisk(true);
1036  P.appendComponent("preamble");
1037  P.appendSuffix("pch");
1038  if (P.createTemporaryFileOnDisk())
1039    return std::string();
1040
1041  return P.str();
1042}
1043
1044/// \brief Compute the preamble for the main file, providing the source buffer
1045/// that corresponds to the main file along with a pair (bytes, start-of-line)
1046/// that describes the preamble.
1047std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> >
1048ASTUnit::ComputePreamble(CompilerInvocation &Invocation,
1049                         unsigned MaxLines, bool &CreatedBuffer) {
1050  FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
1051  PreprocessorOptions &PreprocessorOpts = Invocation.getPreprocessorOpts();
1052  CreatedBuffer = false;
1053
1054  // Try to determine if the main file has been remapped, either from the
1055  // command line (to another file) or directly through the compiler invocation
1056  // (to a memory buffer).
1057  llvm::MemoryBuffer *Buffer = 0;
1058  llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
1059  if (const llvm::sys::FileStatus *MainFileStatus = MainFilePath.getFileStatus()) {
1060    // Check whether there is a file-file remapping of the main file
1061    for (PreprocessorOptions::remapped_file_iterator
1062          M = PreprocessorOpts.remapped_file_begin(),
1063          E = PreprocessorOpts.remapped_file_end();
1064         M != E;
1065         ++M) {
1066      llvm::sys::PathWithStatus MPath(M->first);
1067      if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
1068        if (MainFileStatus->uniqueID == MStatus->uniqueID) {
1069          // We found a remapping. Try to load the resulting, remapped source.
1070          if (CreatedBuffer) {
1071            delete Buffer;
1072            CreatedBuffer = false;
1073          }
1074
1075          Buffer = getBufferForFile(M->second);
1076          if (!Buffer)
1077            return std::make_pair((llvm::MemoryBuffer*)0,
1078                                  std::make_pair(0, true));
1079          CreatedBuffer = true;
1080        }
1081      }
1082    }
1083
1084    // Check whether there is a file-buffer remapping. It supercedes the
1085    // file-file remapping.
1086    for (PreprocessorOptions::remapped_file_buffer_iterator
1087           M = PreprocessorOpts.remapped_file_buffer_begin(),
1088           E = PreprocessorOpts.remapped_file_buffer_end();
1089         M != E;
1090         ++M) {
1091      llvm::sys::PathWithStatus MPath(M->first);
1092      if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
1093        if (MainFileStatus->uniqueID == MStatus->uniqueID) {
1094          // We found a remapping.
1095          if (CreatedBuffer) {
1096            delete Buffer;
1097            CreatedBuffer = false;
1098          }
1099
1100          Buffer = const_cast<llvm::MemoryBuffer *>(M->second);
1101        }
1102      }
1103    }
1104  }
1105
1106  // If the main source file was not remapped, load it now.
1107  if (!Buffer) {
1108    Buffer = getBufferForFile(FrontendOpts.Inputs[0].second);
1109    if (!Buffer)
1110      return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true));
1111
1112    CreatedBuffer = true;
1113  }
1114
1115  return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, MaxLines));
1116}
1117
1118static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old,
1119                                                      unsigned NewSize,
1120                                                      llvm::StringRef NewName) {
1121  llvm::MemoryBuffer *Result
1122    = llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName);
1123  memcpy(const_cast<char*>(Result->getBufferStart()),
1124         Old->getBufferStart(), Old->getBufferSize());
1125  memset(const_cast<char*>(Result->getBufferStart()) + Old->getBufferSize(),
1126         ' ', NewSize - Old->getBufferSize() - 1);
1127  const_cast<char*>(Result->getBufferEnd())[-1] = '\n';
1128
1129  return Result;
1130}
1131
1132/// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing
1133/// the source file.
1134///
1135/// This routine will compute the preamble of the main source file. If a
1136/// non-trivial preamble is found, it will precompile that preamble into a
1137/// precompiled header so that the precompiled preamble can be used to reduce
1138/// reparsing time. If a precompiled preamble has already been constructed,
1139/// this routine will determine if it is still valid and, if so, avoid
1140/// rebuilding the precompiled preamble.
1141///
1142/// \param AllowRebuild When true (the default), this routine is
1143/// allowed to rebuild the precompiled preamble if it is found to be
1144/// out-of-date.
1145///
1146/// \param MaxLines When non-zero, the maximum number of lines that
1147/// can occur within the preamble.
1148///
1149/// \returns If the precompiled preamble can be used, returns a newly-allocated
1150/// buffer that should be used in place of the main file when doing so.
1151/// Otherwise, returns a NULL pointer.
1152llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble(
1153                                          CompilerInvocation PreambleInvocation,
1154                                                           bool AllowRebuild,
1155                                                           unsigned MaxLines) {
1156  FrontendOptions &FrontendOpts = PreambleInvocation.getFrontendOpts();
1157  PreprocessorOptions &PreprocessorOpts
1158    = PreambleInvocation.getPreprocessorOpts();
1159
1160  bool CreatedPreambleBuffer = false;
1161  std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > NewPreamble
1162    = ComputePreamble(PreambleInvocation, MaxLines, CreatedPreambleBuffer);
1163
1164  // If ComputePreamble() Take ownership of the
1165  llvm::OwningPtr<llvm::MemoryBuffer> OwnedPreambleBuffer;
1166  if (CreatedPreambleBuffer)
1167    OwnedPreambleBuffer.reset(NewPreamble.first);
1168
1169  if (!NewPreamble.second.first) {
1170    // We couldn't find a preamble in the main source. Clear out the current
1171    // preamble, if we have one. It's obviously no good any more.
1172    Preamble.clear();
1173    if (!PreambleFile.empty()) {
1174      llvm::sys::Path(PreambleFile).eraseFromDisk();
1175      PreambleFile.clear();
1176    }
1177
1178    // The next time we actually see a preamble, precompile it.
1179    PreambleRebuildCounter = 1;
1180    return 0;
1181  }
1182
1183  if (!Preamble.empty()) {
1184    // We've previously computed a preamble. Check whether we have the same
1185    // preamble now that we did before, and that there's enough space in
1186    // the main-file buffer within the precompiled preamble to fit the
1187    // new main file.
1188    if (Preamble.size() == NewPreamble.second.first &&
1189        PreambleEndsAtStartOfLine == NewPreamble.second.second &&
1190        NewPreamble.first->getBufferSize() < PreambleReservedSize-2 &&
1191        memcmp(&Preamble[0], NewPreamble.first->getBufferStart(),
1192               NewPreamble.second.first) == 0) {
1193      // The preamble has not changed. We may be able to re-use the precompiled
1194      // preamble.
1195
1196      // Check that none of the files used by the preamble have changed.
1197      bool AnyFileChanged = false;
1198
1199      // First, make a record of those files that have been overridden via
1200      // remapping or unsaved_files.
1201      llvm::StringMap<std::pair<off_t, time_t> > OverriddenFiles;
1202      for (PreprocessorOptions::remapped_file_iterator
1203                R = PreprocessorOpts.remapped_file_begin(),
1204             REnd = PreprocessorOpts.remapped_file_end();
1205           !AnyFileChanged && R != REnd;
1206           ++R) {
1207        struct stat StatBuf;
1208        if (FileMgr->getNoncachedStatValue(R->second, StatBuf)) {
1209          // If we can't stat the file we're remapping to, assume that something
1210          // horrible happened.
1211          AnyFileChanged = true;
1212          break;
1213        }
1214
1215        OverriddenFiles[R->first] = std::make_pair(StatBuf.st_size,
1216                                                   StatBuf.st_mtime);
1217      }
1218      for (PreprocessorOptions::remapped_file_buffer_iterator
1219                R = PreprocessorOpts.remapped_file_buffer_begin(),
1220             REnd = PreprocessorOpts.remapped_file_buffer_end();
1221           !AnyFileChanged && R != REnd;
1222           ++R) {
1223        // FIXME: Should we actually compare the contents of file->buffer
1224        // remappings?
1225        OverriddenFiles[R->first] = std::make_pair(R->second->getBufferSize(),
1226                                                   0);
1227      }
1228
1229      // Check whether anything has changed.
1230      for (llvm::StringMap<std::pair<off_t, time_t> >::iterator
1231             F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end();
1232           !AnyFileChanged && F != FEnd;
1233           ++F) {
1234        llvm::StringMap<std::pair<off_t, time_t> >::iterator Overridden
1235          = OverriddenFiles.find(F->first());
1236        if (Overridden != OverriddenFiles.end()) {
1237          // This file was remapped; check whether the newly-mapped file
1238          // matches up with the previous mapping.
1239          if (Overridden->second != F->second)
1240            AnyFileChanged = true;
1241          continue;
1242        }
1243
1244        // The file was not remapped; check whether it has changed on disk.
1245        struct stat StatBuf;
1246        if (FileMgr->getNoncachedStatValue(F->first(), StatBuf)) {
1247          // If we can't stat the file, assume that something horrible happened.
1248          AnyFileChanged = true;
1249        } else if (StatBuf.st_size != F->second.first ||
1250                   StatBuf.st_mtime != F->second.second)
1251          AnyFileChanged = true;
1252      }
1253
1254      if (!AnyFileChanged) {
1255        // Okay! We can re-use the precompiled preamble.
1256
1257        // Set the state of the diagnostic object to mimic its state
1258        // after parsing the preamble.
1259        // FIXME: This won't catch any #pragma push warning changes that
1260        // have occurred in the preamble.
1261        getDiagnostics().Reset();
1262        ProcessWarningOptions(getDiagnostics(),
1263                              PreambleInvocation.getDiagnosticOpts());
1264        getDiagnostics().setNumWarnings(NumWarningsInPreamble);
1265        if (StoredDiagnostics.size() > NumStoredDiagnosticsInPreamble)
1266          StoredDiagnostics.erase(
1267            StoredDiagnostics.begin() + NumStoredDiagnosticsInPreamble,
1268                                  StoredDiagnostics.end());
1269
1270        // Create a version of the main file buffer that is padded to
1271        // buffer size we reserved when creating the preamble.
1272        return CreatePaddedMainFileBuffer(NewPreamble.first,
1273                                          PreambleReservedSize,
1274                                          FrontendOpts.Inputs[0].second);
1275      }
1276    }
1277
1278    // If we aren't allowed to rebuild the precompiled preamble, just
1279    // return now.
1280    if (!AllowRebuild)
1281      return 0;
1282
1283    // We can't reuse the previously-computed preamble. Build a new one.
1284    Preamble.clear();
1285    llvm::sys::Path(PreambleFile).eraseFromDisk();
1286    PreambleRebuildCounter = 1;
1287  } else if (!AllowRebuild) {
1288    // We aren't allowed to rebuild the precompiled preamble; just
1289    // return now.
1290    return 0;
1291  }
1292
1293  // If the preamble rebuild counter > 1, it's because we previously
1294  // failed to build a preamble and we're not yet ready to try
1295  // again. Decrement the counter and return a failure.
1296  if (PreambleRebuildCounter > 1) {
1297    --PreambleRebuildCounter;
1298    return 0;
1299  }
1300
1301  // Create a temporary file for the precompiled preamble. In rare
1302  // circumstances, this can fail.
1303  std::string PreamblePCHPath = GetPreamblePCHPath();
1304  if (PreamblePCHPath.empty()) {
1305    // Try again next time.
1306    PreambleRebuildCounter = 1;
1307    return 0;
1308  }
1309
1310  // We did not previously compute a preamble, or it can't be reused anyway.
1311  SimpleTimer PreambleTimer(WantTiming);
1312  PreambleTimer.setOutput("Precompiling preamble");
1313
1314  // Create a new buffer that stores the preamble. The buffer also contains
1315  // extra space for the original contents of the file (which will be present
1316  // when we actually parse the file) along with more room in case the file
1317  // grows.
1318  PreambleReservedSize = NewPreamble.first->getBufferSize();
1319  if (PreambleReservedSize < 4096)
1320    PreambleReservedSize = 8191;
1321  else
1322    PreambleReservedSize *= 2;
1323
1324  // Save the preamble text for later; we'll need to compare against it for
1325  // subsequent reparses.
1326  Preamble.assign(NewPreamble.first->getBufferStart(),
1327                  NewPreamble.first->getBufferStart()
1328                                                  + NewPreamble.second.first);
1329  PreambleEndsAtStartOfLine = NewPreamble.second.second;
1330
1331  delete PreambleBuffer;
1332  PreambleBuffer
1333    = llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize,
1334                                                FrontendOpts.Inputs[0].second);
1335  memcpy(const_cast<char*>(PreambleBuffer->getBufferStart()),
1336         NewPreamble.first->getBufferStart(), Preamble.size());
1337  memset(const_cast<char*>(PreambleBuffer->getBufferStart()) + Preamble.size(),
1338         ' ', PreambleReservedSize - Preamble.size() - 1);
1339  const_cast<char*>(PreambleBuffer->getBufferEnd())[-1] = '\n';
1340
1341  // Remap the main source file to the preamble buffer.
1342  llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
1343  PreprocessorOpts.addRemappedFile(MainFilePath.str(), PreambleBuffer);
1344
1345  // Tell the compiler invocation to generate a temporary precompiled header.
1346  FrontendOpts.ProgramAction = frontend::GeneratePCH;
1347  FrontendOpts.ChainedPCH = true;
1348  // FIXME: Generate the precompiled header into memory?
1349  FrontendOpts.OutputFile = PreamblePCHPath;
1350  PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
1351  PreprocessorOpts.PrecompiledPreambleBytes.second = false;
1352
1353  // Create the compiler instance to use for building the precompiled preamble.
1354  llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
1355
1356  // Recover resources if we crash before exiting this method.
1357  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1358    CICleanup(Clang.get());
1359
1360  Clang->setInvocation(&PreambleInvocation);
1361  OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
1362
1363  // Set up diagnostics, capturing all of the diagnostics produced.
1364  Clang->setDiagnostics(&getDiagnostics());
1365
1366  // Create the target instance.
1367  Clang->getTargetOpts().Features = TargetFeatures;
1368  Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
1369                                               Clang->getTargetOpts()));
1370  if (!Clang->hasTarget()) {
1371    llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1372    Preamble.clear();
1373    PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1374    PreprocessorOpts.eraseRemappedFile(
1375                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1376    return 0;
1377  }
1378
1379  // Inform the target of the language options.
1380  //
1381  // FIXME: We shouldn't need to do this, the target should be immutable once
1382  // created. This complexity should be lifted elsewhere.
1383  Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
1384
1385  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1386         "Invocation must have exactly one source file!");
1387  assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
1388         "FIXME: AST inputs not yet supported here!");
1389  assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
1390         "IR inputs not support here!");
1391
1392  // Clear out old caches and data.
1393  getDiagnostics().Reset();
1394  ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts());
1395  StoredDiagnostics.erase(
1396                    StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver,
1397                          StoredDiagnostics.end());
1398  TopLevelDecls.clear();
1399  TopLevelDeclsInPreamble.clear();
1400  PreprocessedEntities.clear();
1401  PreprocessedEntitiesInPreamble.clear();
1402
1403  // Create a file manager object to provide access to and cache the filesystem.
1404  Clang->setFileManager(new FileManager(Clang->getFileSystemOpts()));
1405
1406  // Create the source manager.
1407  Clang->setSourceManager(new SourceManager(getDiagnostics(),
1408                                            Clang->getFileManager()));
1409
1410  llvm::OwningPtr<PrecompilePreambleAction> Act;
1411  Act.reset(new PrecompilePreambleAction(*this));
1412  if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second,
1413                            Clang->getFrontendOpts().Inputs[0].first)) {
1414    llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1415    Preamble.clear();
1416    PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1417    PreprocessorOpts.eraseRemappedFile(
1418                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1419    return 0;
1420  }
1421
1422  Act->Execute();
1423  Act->EndSourceFile();
1424
1425  if (Diagnostics->hasErrorOccurred()) {
1426    // There were errors parsing the preamble, so no precompiled header was
1427    // generated. Forget that we even tried.
1428    // FIXME: Should we leave a note for ourselves to try again?
1429    llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
1430    Preamble.clear();
1431    TopLevelDeclsInPreamble.clear();
1432    PreprocessedEntities.clear();
1433    PreprocessedEntitiesInPreamble.clear();
1434    PreambleRebuildCounter = DefaultPreambleRebuildInterval;
1435    PreprocessorOpts.eraseRemappedFile(
1436                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1437    return 0;
1438  }
1439
1440  // Keep track of the preamble we precompiled.
1441  PreambleFile = FrontendOpts.OutputFile;
1442  NumStoredDiagnosticsInPreamble = StoredDiagnostics.size();
1443  NumWarningsInPreamble = getDiagnostics().getNumWarnings();
1444
1445  // Keep track of all of the files that the source manager knows about,
1446  // so we can verify whether they have changed or not.
1447  FilesInPreamble.clear();
1448  SourceManager &SourceMgr = Clang->getSourceManager();
1449  const llvm::MemoryBuffer *MainFileBuffer
1450    = SourceMgr.getBuffer(SourceMgr.getMainFileID());
1451  for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(),
1452                                     FEnd = SourceMgr.fileinfo_end();
1453       F != FEnd;
1454       ++F) {
1455    const FileEntry *File = F->second->OrigEntry;
1456    if (!File || F->second->getRawBuffer() == MainFileBuffer)
1457      continue;
1458
1459    FilesInPreamble[File->getName()]
1460      = std::make_pair(F->second->getSize(), File->getModificationTime());
1461  }
1462
1463  PreambleRebuildCounter = 1;
1464  PreprocessorOpts.eraseRemappedFile(
1465                               PreprocessorOpts.remapped_file_buffer_end() - 1);
1466
1467  // If the hash of top-level entities differs from the hash of the top-level
1468  // entities the last time we rebuilt the preamble, clear out the completion
1469  // cache.
1470  if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) {
1471    CompletionCacheTopLevelHashValue = 0;
1472    PreambleTopLevelHashValue = CurrentTopLevelHashValue;
1473  }
1474
1475  return CreatePaddedMainFileBuffer(NewPreamble.first,
1476                                    PreambleReservedSize,
1477                                    FrontendOpts.Inputs[0].second);
1478}
1479
1480void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
1481  std::vector<Decl *> Resolved;
1482  Resolved.reserve(TopLevelDeclsInPreamble.size());
1483  ExternalASTSource &Source = *getASTContext().getExternalSource();
1484  for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) {
1485    // Resolve the declaration ID to an actual declaration, possibly
1486    // deserializing the declaration in the process.
1487    Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]);
1488    if (D)
1489      Resolved.push_back(D);
1490  }
1491  TopLevelDeclsInPreamble.clear();
1492  TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
1493}
1494
1495void ASTUnit::RealizePreprocessedEntitiesFromPreamble() {
1496  if (!PP)
1497    return;
1498
1499  PreprocessingRecord *PPRec = PP->getPreprocessingRecord();
1500  if (!PPRec)
1501    return;
1502
1503  ExternalPreprocessingRecordSource *External = PPRec->getExternalSource();
1504  if (!External)
1505    return;
1506
1507  for (unsigned I = 0, N = PreprocessedEntitiesInPreamble.size(); I != N; ++I) {
1508    if (PreprocessedEntity *PE
1509          = External->ReadPreprocessedEntityAtOffset(
1510                                            PreprocessedEntitiesInPreamble[I]))
1511      PreprocessedEntities.push_back(PE);
1512  }
1513
1514  if (PreprocessedEntities.empty())
1515    return;
1516
1517  PreprocessedEntities.insert(PreprocessedEntities.end(),
1518                              PPRec->begin(true), PPRec->end(true));
1519}
1520
1521ASTUnit::pp_entity_iterator ASTUnit::pp_entity_begin() {
1522  if (!PreprocessedEntitiesInPreamble.empty() &&
1523      PreprocessedEntities.empty())
1524    RealizePreprocessedEntitiesFromPreamble();
1525
1526  if (PreprocessedEntities.empty())
1527    if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord())
1528      return PPRec->begin(true);
1529
1530  return PreprocessedEntities.begin();
1531}
1532
1533ASTUnit::pp_entity_iterator ASTUnit::pp_entity_end() {
1534  if (!PreprocessedEntitiesInPreamble.empty() &&
1535      PreprocessedEntities.empty())
1536    RealizePreprocessedEntitiesFromPreamble();
1537
1538  if (PreprocessedEntities.empty())
1539    if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord())
1540      return PPRec->end(true);
1541
1542  return PreprocessedEntities.end();
1543}
1544
1545unsigned ASTUnit::getMaxPCHLevel() const {
1546  if (!getOnlyLocalDecls())
1547    return Decl::MaxPCHLevel;
1548
1549  return 0;
1550}
1551
1552llvm::StringRef ASTUnit::getMainFileName() const {
1553  return Invocation->getFrontendOpts().Inputs[0].second;
1554}
1555
1556ASTUnit *ASTUnit::create(CompilerInvocation *CI,
1557                         llvm::IntrusiveRefCntPtr<Diagnostic> Diags) {
1558  llvm::OwningPtr<ASTUnit> AST;
1559  AST.reset(new ASTUnit(false));
1560  ConfigureDiags(Diags, 0, 0, *AST, /*CaptureDiagnostics=*/false);
1561  AST->Diagnostics = Diags;
1562  AST->Invocation = CI;
1563  AST->FileSystemOpts = CI->getFileSystemOpts();
1564  AST->FileMgr = new FileManager(AST->FileSystemOpts);
1565  AST->SourceMgr = new SourceManager(*Diags, *AST->FileMgr);
1566
1567  return AST.take();
1568}
1569
1570ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(CompilerInvocation *CI,
1571                                   llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
1572                                             ASTFrontendAction *Action) {
1573  assert(CI && "A CompilerInvocation is required");
1574
1575  // Create the AST unit.
1576  llvm::OwningPtr<ASTUnit> AST;
1577  AST.reset(new ASTUnit(false));
1578  ConfigureDiags(Diags, 0, 0, *AST, /*CaptureDiagnostics*/false);
1579  AST->Diagnostics = Diags;
1580  AST->OnlyLocalDecls = false;
1581  AST->CaptureDiagnostics = false;
1582  AST->CompleteTranslationUnit = Action ? Action->usesCompleteTranslationUnit()
1583                                        : true;
1584  AST->ShouldCacheCodeCompletionResults = false;
1585  AST->Invocation = CI;
1586
1587  // Recover resources if we crash before exiting this method.
1588  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1589    ASTUnitCleanup(AST.get());
1590  llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic,
1591    llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> >
1592    DiagCleanup(Diags.getPtr());
1593
1594  // We'll manage file buffers ourselves.
1595  CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1596  CI->getFrontendOpts().DisableFree = false;
1597  ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts());
1598
1599  // Save the target features.
1600  AST->TargetFeatures = CI->getTargetOpts().Features;
1601
1602  // Create the compiler instance to use for building the AST.
1603  llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
1604
1605  // Recover resources if we crash before exiting this method.
1606  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
1607    CICleanup(Clang.get());
1608
1609  Clang->setInvocation(CI);
1610  AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
1611
1612  // Set up diagnostics, capturing any diagnostics that would
1613  // otherwise be dropped.
1614  Clang->setDiagnostics(&AST->getDiagnostics());
1615
1616  // Create the target instance.
1617  Clang->getTargetOpts().Features = AST->TargetFeatures;
1618  Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
1619                   Clang->getTargetOpts()));
1620  if (!Clang->hasTarget())
1621    return 0;
1622
1623  // Inform the target of the language options.
1624  //
1625  // FIXME: We shouldn't need to do this, the target should be immutable once
1626  // created. This complexity should be lifted elsewhere.
1627  Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
1628
1629  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
1630         "Invocation must have exactly one source file!");
1631  assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
1632         "FIXME: AST inputs not yet supported here!");
1633  assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
1634         "IR inputs not supported here!");
1635
1636  // Configure the various subsystems.
1637  AST->FileSystemOpts = Clang->getFileSystemOpts();
1638  AST->FileMgr = new FileManager(AST->FileSystemOpts);
1639  AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr);
1640  AST->TheSema.reset();
1641  AST->Ctx = 0;
1642  AST->PP = 0;
1643
1644  // Create a file manager object to provide access to and cache the filesystem.
1645  Clang->setFileManager(&AST->getFileManager());
1646
1647  // Create the source manager.
1648  Clang->setSourceManager(&AST->getSourceManager());
1649
1650  ASTFrontendAction *Act = Action;
1651
1652  llvm::OwningPtr<TopLevelDeclTrackerAction> TrackerAct;
1653  if (!Act) {
1654    TrackerAct.reset(new TopLevelDeclTrackerAction(*AST));
1655    Act = TrackerAct.get();
1656  }
1657
1658  // Recover resources if we crash before exiting this method.
1659  llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
1660    ActCleanup(TrackerAct.get());
1661
1662  if (!Act->BeginSourceFile(*Clang.get(),
1663                            Clang->getFrontendOpts().Inputs[0].second,
1664                            Clang->getFrontendOpts().Inputs[0].first))
1665    return 0;
1666
1667  Act->Execute();
1668
1669  // Steal the created target, context, and preprocessor.
1670  AST->TheSema.reset(Clang->takeSema());
1671  AST->Consumer.reset(Clang->takeASTConsumer());
1672  AST->Ctx = &Clang->getASTContext();
1673  AST->PP = &Clang->getPreprocessor();
1674  Clang->setSourceManager(0);
1675  Clang->setFileManager(0);
1676  AST->Target = &Clang->getTarget();
1677
1678  Act->EndSourceFile();
1679
1680  return AST.take();
1681}
1682
1683bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) {
1684  if (!Invocation)
1685    return true;
1686
1687  // We'll manage file buffers ourselves.
1688  Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true;
1689  Invocation->getFrontendOpts().DisableFree = false;
1690  ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1691
1692  // Save the target features.
1693  TargetFeatures = Invocation->getTargetOpts().Features;
1694
1695  llvm::MemoryBuffer *OverrideMainBuffer = 0;
1696  if (PrecompilePreamble) {
1697    PreambleRebuildCounter = 2;
1698    OverrideMainBuffer
1699      = getMainBufferWithPrecompiledPreamble(*Invocation);
1700  }
1701
1702  SimpleTimer ParsingTimer(WantTiming);
1703  ParsingTimer.setOutput("Parsing " + getMainFileName());
1704
1705  // Recover resources if we crash before exiting this method.
1706  llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
1707    MemBufferCleanup(OverrideMainBuffer);
1708
1709  return Parse(OverrideMainBuffer);
1710}
1711
1712ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI,
1713                                   llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
1714                                             bool OnlyLocalDecls,
1715                                             bool CaptureDiagnostics,
1716                                             bool PrecompilePreamble,
1717                                             bool CompleteTranslationUnit,
1718                                             bool CacheCodeCompletionResults,
1719                                             bool NestedMacroInstantiations) {
1720  // Create the AST unit.
1721  llvm::OwningPtr<ASTUnit> AST;
1722  AST.reset(new ASTUnit(false));
1723  ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics);
1724  AST->Diagnostics = Diags;
1725  AST->OnlyLocalDecls = OnlyLocalDecls;
1726  AST->CaptureDiagnostics = CaptureDiagnostics;
1727  AST->CompleteTranslationUnit = CompleteTranslationUnit;
1728  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1729  AST->Invocation = CI;
1730  AST->NestedMacroInstantiations = NestedMacroInstantiations;
1731
1732  // Recover resources if we crash before exiting this method.
1733  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1734    ASTUnitCleanup(AST.get());
1735  llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic,
1736    llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> >
1737    DiagCleanup(Diags.getPtr());
1738
1739  return AST->LoadFromCompilerInvocation(PrecompilePreamble)? 0 : AST.take();
1740}
1741
1742ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin,
1743                                      const char **ArgEnd,
1744                                    llvm::IntrusiveRefCntPtr<Diagnostic> Diags,
1745                                      llvm::StringRef ResourceFilesPath,
1746                                      bool OnlyLocalDecls,
1747                                      bool CaptureDiagnostics,
1748                                      RemappedFile *RemappedFiles,
1749                                      unsigned NumRemappedFiles,
1750                                      bool RemappedFilesKeepOriginalName,
1751                                      bool PrecompilePreamble,
1752                                      bool CompleteTranslationUnit,
1753                                      bool CacheCodeCompletionResults,
1754                                      bool CXXPrecompilePreamble,
1755                                      bool CXXChainedPCH,
1756                                      bool NestedMacroInstantiations) {
1757  if (!Diags.getPtr()) {
1758    // No diagnostics engine was provided, so create our own diagnostics object
1759    // with the default options.
1760    DiagnosticOptions DiagOpts;
1761    Diags = CompilerInstance::createDiagnostics(DiagOpts, ArgEnd - ArgBegin,
1762                                                ArgBegin);
1763  }
1764
1765  llvm::SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
1766
1767  llvm::IntrusiveRefCntPtr<CompilerInvocation> CI;
1768
1769  {
1770    CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags,
1771                                      StoredDiagnostics);
1772
1773    CI = clang::createInvocationFromCommandLine(
1774                        llvm::ArrayRef<const char *>(ArgBegin, ArgEnd-ArgBegin),
1775                        Diags);
1776    if (!CI)
1777      return 0;
1778  }
1779
1780  // Override any files that need remapping
1781  for (unsigned I = 0; I != NumRemappedFiles; ++I) {
1782    FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
1783    if (const llvm::MemoryBuffer *
1784            memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
1785      CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, memBuf);
1786    } else {
1787      const char *fname = fileOrBuf.get<const char *>();
1788      CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, fname);
1789    }
1790  }
1791  CI->getPreprocessorOpts().RemappedFilesKeepOriginalName =
1792                                                  RemappedFilesKeepOriginalName;
1793
1794  // Override the resources path.
1795  CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
1796
1797  // Check whether we should precompile the preamble and/or use chained PCH.
1798  // FIXME: This is a temporary hack while we debug C++ chained PCH.
1799  if (CI->getLangOpts().CPlusPlus) {
1800    PrecompilePreamble = PrecompilePreamble && CXXPrecompilePreamble;
1801
1802    if (PrecompilePreamble && !CXXChainedPCH &&
1803        !CI->getPreprocessorOpts().ImplicitPCHInclude.empty())
1804      PrecompilePreamble = false;
1805  }
1806
1807  // Create the AST unit.
1808  llvm::OwningPtr<ASTUnit> AST;
1809  AST.reset(new ASTUnit(false));
1810  ConfigureDiags(Diags, ArgBegin, ArgEnd, *AST, CaptureDiagnostics);
1811  AST->Diagnostics = Diags;
1812
1813  AST->FileSystemOpts = CI->getFileSystemOpts();
1814  AST->FileMgr = new FileManager(AST->FileSystemOpts);
1815  AST->OnlyLocalDecls = OnlyLocalDecls;
1816  AST->CaptureDiagnostics = CaptureDiagnostics;
1817  AST->CompleteTranslationUnit = CompleteTranslationUnit;
1818  AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
1819  AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
1820  AST->NumStoredDiagnosticsInPreamble = StoredDiagnostics.size();
1821  AST->StoredDiagnostics.swap(StoredDiagnostics);
1822  AST->Invocation = CI;
1823  AST->NestedMacroInstantiations = NestedMacroInstantiations;
1824
1825  // Recover resources if we crash before exiting this method.
1826  llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
1827    ASTUnitCleanup(AST.get());
1828  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInvocation,
1829    llvm::CrashRecoveryContextReleaseRefCleanup<CompilerInvocation> >
1830    CICleanup(CI.getPtr());
1831  llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic,
1832    llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> >
1833    DiagCleanup(Diags.getPtr());
1834
1835  return AST->LoadFromCompilerInvocation(PrecompilePreamble) ? 0 : AST.take();
1836}
1837
1838bool ASTUnit::Reparse(RemappedFile *RemappedFiles, unsigned NumRemappedFiles) {
1839  if (!Invocation)
1840    return true;
1841
1842  SimpleTimer ParsingTimer(WantTiming);
1843  ParsingTimer.setOutput("Reparsing " + getMainFileName());
1844
1845  // Remap files.
1846  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1847  PPOpts.DisableStatCache = true;
1848  for (PreprocessorOptions::remapped_file_buffer_iterator
1849         R = PPOpts.remapped_file_buffer_begin(),
1850         REnd = PPOpts.remapped_file_buffer_end();
1851       R != REnd;
1852       ++R) {
1853    delete R->second;
1854  }
1855  Invocation->getPreprocessorOpts().clearRemappedFiles();
1856  for (unsigned I = 0; I != NumRemappedFiles; ++I) {
1857    FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
1858    if (const llvm::MemoryBuffer *
1859            memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
1860      Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
1861                                                        memBuf);
1862    } else {
1863      const char *fname = fileOrBuf.get<const char *>();
1864      Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
1865                                                        fname);
1866    }
1867  }
1868
1869  // If we have a preamble file lying around, or if we might try to
1870  // build a precompiled preamble, do so now.
1871  llvm::MemoryBuffer *OverrideMainBuffer = 0;
1872  if (!PreambleFile.empty() || PreambleRebuildCounter > 0)
1873    OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation);
1874
1875  // Clear out the diagnostics state.
1876  if (!OverrideMainBuffer) {
1877    getDiagnostics().Reset();
1878    ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
1879  }
1880
1881  // Parse the sources
1882  bool Result = Parse(OverrideMainBuffer);
1883
1884  // If we're caching global code-completion results, and the top-level
1885  // declarations have changed, clear out the code-completion cache.
1886  if (!Result && ShouldCacheCodeCompletionResults &&
1887      CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
1888    CacheCodeCompletionResults();
1889
1890  return Result;
1891}
1892
1893//----------------------------------------------------------------------------//
1894// Code completion
1895//----------------------------------------------------------------------------//
1896
1897namespace {
1898  /// \brief Code completion consumer that combines the cached code-completion
1899  /// results from an ASTUnit with the code-completion results provided to it,
1900  /// then passes the result on to
1901  class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer {
1902    unsigned NormalContexts;
1903    ASTUnit &AST;
1904    CodeCompleteConsumer &Next;
1905
1906  public:
1907    AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next,
1908                                  bool IncludeMacros, bool IncludeCodePatterns,
1909                                  bool IncludeGlobals)
1910      : CodeCompleteConsumer(IncludeMacros, IncludeCodePatterns, IncludeGlobals,
1911                             Next.isOutputBinary()), AST(AST), Next(Next)
1912    {
1913      // Compute the set of contexts in which we will look when we don't have
1914      // any information about the specific context.
1915      NormalContexts
1916        = (1 << (CodeCompletionContext::CCC_TopLevel - 1))
1917        | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1))
1918        | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1))
1919        | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
1920        | (1 << (CodeCompletionContext::CCC_Statement - 1))
1921        | (1 << (CodeCompletionContext::CCC_Expression - 1))
1922        | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
1923        | (1 << (CodeCompletionContext::CCC_MemberAccess - 1))
1924        | (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1))
1925        | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1))
1926        | (1 << (CodeCompletionContext::CCC_Recovery - 1));
1927
1928      if (AST.getASTContext().getLangOptions().CPlusPlus)
1929        NormalContexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1))
1930                    | (1 << (CodeCompletionContext::CCC_UnionTag - 1))
1931                    | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
1932    }
1933
1934    virtual void ProcessCodeCompleteResults(Sema &S,
1935                                            CodeCompletionContext Context,
1936                                            CodeCompletionResult *Results,
1937                                            unsigned NumResults);
1938
1939    virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
1940                                           OverloadCandidate *Candidates,
1941                                           unsigned NumCandidates) {
1942      Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates);
1943    }
1944
1945    virtual CodeCompletionAllocator &getAllocator() {
1946      return Next.getAllocator();
1947    }
1948  };
1949}
1950
1951/// \brief Helper function that computes which global names are hidden by the
1952/// local code-completion results.
1953static void CalculateHiddenNames(const CodeCompletionContext &Context,
1954                                 CodeCompletionResult *Results,
1955                                 unsigned NumResults,
1956                                 ASTContext &Ctx,
1957                          llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){
1958  bool OnlyTagNames = false;
1959  switch (Context.getKind()) {
1960  case CodeCompletionContext::CCC_Recovery:
1961  case CodeCompletionContext::CCC_TopLevel:
1962  case CodeCompletionContext::CCC_ObjCInterface:
1963  case CodeCompletionContext::CCC_ObjCImplementation:
1964  case CodeCompletionContext::CCC_ObjCIvarList:
1965  case CodeCompletionContext::CCC_ClassStructUnion:
1966  case CodeCompletionContext::CCC_Statement:
1967  case CodeCompletionContext::CCC_Expression:
1968  case CodeCompletionContext::CCC_ObjCMessageReceiver:
1969  case CodeCompletionContext::CCC_MemberAccess:
1970  case CodeCompletionContext::CCC_Namespace:
1971  case CodeCompletionContext::CCC_Type:
1972  case CodeCompletionContext::CCC_Name:
1973  case CodeCompletionContext::CCC_PotentiallyQualifiedName:
1974  case CodeCompletionContext::CCC_ParenthesizedExpression:
1975    break;
1976
1977  case CodeCompletionContext::CCC_EnumTag:
1978  case CodeCompletionContext::CCC_UnionTag:
1979  case CodeCompletionContext::CCC_ClassOrStructTag:
1980    OnlyTagNames = true;
1981    break;
1982
1983  case CodeCompletionContext::CCC_ObjCProtocolName:
1984  case CodeCompletionContext::CCC_MacroName:
1985  case CodeCompletionContext::CCC_MacroNameUse:
1986  case CodeCompletionContext::CCC_PreprocessorExpression:
1987  case CodeCompletionContext::CCC_PreprocessorDirective:
1988  case CodeCompletionContext::CCC_NaturalLanguage:
1989  case CodeCompletionContext::CCC_SelectorName:
1990  case CodeCompletionContext::CCC_TypeQualifiers:
1991  case CodeCompletionContext::CCC_Other:
1992  case CodeCompletionContext::CCC_OtherWithMacros:
1993    // We're looking for nothing, or we're looking for names that cannot
1994    // be hidden.
1995    return;
1996  }
1997
1998  typedef CodeCompletionResult Result;
1999  for (unsigned I = 0; I != NumResults; ++I) {
2000    if (Results[I].Kind != Result::RK_Declaration)
2001      continue;
2002
2003    unsigned IDNS
2004      = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
2005
2006    bool Hiding = false;
2007    if (OnlyTagNames)
2008      Hiding = (IDNS & Decl::IDNS_Tag);
2009    else {
2010      unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member |
2011                             Decl::IDNS_Namespace | Decl::IDNS_Ordinary |
2012                             Decl::IDNS_NonMemberOperator);
2013      if (Ctx.getLangOptions().CPlusPlus)
2014        HiddenIDNS |= Decl::IDNS_Tag;
2015      Hiding = (IDNS & HiddenIDNS);
2016    }
2017
2018    if (!Hiding)
2019      continue;
2020
2021    DeclarationName Name = Results[I].Declaration->getDeclName();
2022    if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo())
2023      HiddenNames.insert(Identifier->getName());
2024    else
2025      HiddenNames.insert(Name.getAsString());
2026  }
2027}
2028
2029
2030void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S,
2031                                            CodeCompletionContext Context,
2032                                            CodeCompletionResult *Results,
2033                                            unsigned NumResults) {
2034  // Merge the results we were given with the results we cached.
2035  bool AddedResult = false;
2036  unsigned InContexts
2037    = (Context.getKind() == CodeCompletionContext::CCC_Recovery? NormalContexts
2038                                            : (1 << (Context.getKind() - 1)));
2039
2040  // Contains the set of names that are hidden by "local" completion results.
2041  llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
2042  typedef CodeCompletionResult Result;
2043  llvm::SmallVector<Result, 8> AllResults;
2044  for (ASTUnit::cached_completion_iterator
2045            C = AST.cached_completion_begin(),
2046         CEnd = AST.cached_completion_end();
2047       C != CEnd; ++C) {
2048    // If the context we are in matches any of the contexts we are
2049    // interested in, we'll add this result.
2050    if ((C->ShowInContexts & InContexts) == 0)
2051      continue;
2052
2053    // If we haven't added any results previously, do so now.
2054    if (!AddedResult) {
2055      CalculateHiddenNames(Context, Results, NumResults, S.Context,
2056                           HiddenNames);
2057      AllResults.insert(AllResults.end(), Results, Results + NumResults);
2058      AddedResult = true;
2059    }
2060
2061    // Determine whether this global completion result is hidden by a local
2062    // completion result. If so, skip it.
2063    if (C->Kind != CXCursor_MacroDefinition &&
2064        HiddenNames.count(C->Completion->getTypedText()))
2065      continue;
2066
2067    // Adjust priority based on similar type classes.
2068    unsigned Priority = C->Priority;
2069    CXCursorKind CursorKind = C->Kind;
2070    CodeCompletionString *Completion = C->Completion;
2071    if (!Context.getPreferredType().isNull()) {
2072      if (C->Kind == CXCursor_MacroDefinition) {
2073        Priority = getMacroUsagePriority(C->Completion->getTypedText(),
2074                                         S.getLangOptions(),
2075                               Context.getPreferredType()->isAnyPointerType());
2076      } else if (C->Type) {
2077        CanQualType Expected
2078          = S.Context.getCanonicalType(
2079                               Context.getPreferredType().getUnqualifiedType());
2080        SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected);
2081        if (ExpectedSTC == C->TypeClass) {
2082          // We know this type is similar; check for an exact match.
2083          llvm::StringMap<unsigned> &CachedCompletionTypes
2084            = AST.getCachedCompletionTypes();
2085          llvm::StringMap<unsigned>::iterator Pos
2086            = CachedCompletionTypes.find(QualType(Expected).getAsString());
2087          if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)
2088            Priority /= CCF_ExactTypeMatch;
2089          else
2090            Priority /= CCF_SimilarTypeMatch;
2091        }
2092      }
2093    }
2094
2095    // Adjust the completion string, if required.
2096    if (C->Kind == CXCursor_MacroDefinition &&
2097        Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) {
2098      // Create a new code-completion string that just contains the
2099      // macro name, without its arguments.
2100      CodeCompletionBuilder Builder(getAllocator(), CCP_CodePattern,
2101                                    C->Availability);
2102      Builder.AddTypedTextChunk(C->Completion->getTypedText());
2103      CursorKind = CXCursor_NotImplemented;
2104      Priority = CCP_CodePattern;
2105      Completion = Builder.TakeString();
2106    }
2107
2108    AllResults.push_back(Result(Completion, Priority, CursorKind,
2109                                C->Availability));
2110  }
2111
2112  // If we did not add any cached completion results, just forward the
2113  // results we were given to the next consumer.
2114  if (!AddedResult) {
2115    Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
2116    return;
2117  }
2118
2119  Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
2120                                  AllResults.size());
2121}
2122
2123
2124
2125void ASTUnit::CodeComplete(llvm::StringRef File, unsigned Line, unsigned Column,
2126                           RemappedFile *RemappedFiles,
2127                           unsigned NumRemappedFiles,
2128                           bool IncludeMacros,
2129                           bool IncludeCodePatterns,
2130                           CodeCompleteConsumer &Consumer,
2131                           Diagnostic &Diag, LangOptions &LangOpts,
2132                           SourceManager &SourceMgr, FileManager &FileMgr,
2133                   llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
2134             llvm::SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) {
2135  if (!Invocation)
2136    return;
2137
2138  SimpleTimer CompletionTimer(WantTiming);
2139  CompletionTimer.setOutput("Code completion @ " + File + ":" +
2140                            llvm::Twine(Line) + ":" + llvm::Twine(Column));
2141
2142  llvm::IntrusiveRefCntPtr<CompilerInvocation>
2143    CCInvocation(new CompilerInvocation(*Invocation));
2144
2145  FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
2146  PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts();
2147
2148  FrontendOpts.ShowMacrosInCodeCompletion
2149    = IncludeMacros && CachedCompletionResults.empty();
2150  FrontendOpts.ShowCodePatternsInCodeCompletion = IncludeCodePatterns;
2151  FrontendOpts.ShowGlobalSymbolsInCodeCompletion
2152    = CachedCompletionResults.empty();
2153  FrontendOpts.CodeCompletionAt.FileName = File;
2154  FrontendOpts.CodeCompletionAt.Line = Line;
2155  FrontendOpts.CodeCompletionAt.Column = Column;
2156
2157  // Set the language options appropriately.
2158  LangOpts = CCInvocation->getLangOpts();
2159
2160  llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
2161
2162  // Recover resources if we crash before exiting this method.
2163  llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
2164    CICleanup(Clang.get());
2165
2166  Clang->setInvocation(&*CCInvocation);
2167  OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
2168
2169  // Set up diagnostics, capturing any diagnostics produced.
2170  Clang->setDiagnostics(&Diag);
2171  ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts());
2172  CaptureDroppedDiagnostics Capture(true,
2173                                    Clang->getDiagnostics(),
2174                                    StoredDiagnostics);
2175
2176  // Create the target instance.
2177  Clang->getTargetOpts().Features = TargetFeatures;
2178  Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
2179                                               Clang->getTargetOpts()));
2180  if (!Clang->hasTarget()) {
2181    Clang->setInvocation(0);
2182    return;
2183  }
2184
2185  // Inform the target of the language options.
2186  //
2187  // FIXME: We shouldn't need to do this, the target should be immutable once
2188  // created. This complexity should be lifted elsewhere.
2189  Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
2190
2191  assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
2192         "Invocation must have exactly one source file!");
2193  assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
2194         "FIXME: AST inputs not yet supported here!");
2195  assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
2196         "IR inputs not support here!");
2197
2198
2199  // Use the source and file managers that we were given.
2200  Clang->setFileManager(&FileMgr);
2201  Clang->setSourceManager(&SourceMgr);
2202
2203  // Remap files.
2204  PreprocessorOpts.clearRemappedFiles();
2205  PreprocessorOpts.RetainRemappedFileBuffers = true;
2206  for (unsigned I = 0; I != NumRemappedFiles; ++I) {
2207    FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
2208    if (const llvm::MemoryBuffer *
2209            memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
2210      PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, memBuf);
2211      OwnedBuffers.push_back(memBuf);
2212    } else {
2213      const char *fname = fileOrBuf.get<const char *>();
2214      PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, fname);
2215    }
2216  }
2217
2218  // Use the code completion consumer we were given, but adding any cached
2219  // code-completion results.
2220  AugmentedCodeCompleteConsumer *AugmentedConsumer
2221    = new AugmentedCodeCompleteConsumer(*this, Consumer,
2222                                        FrontendOpts.ShowMacrosInCodeCompletion,
2223                                FrontendOpts.ShowCodePatternsInCodeCompletion,
2224                                FrontendOpts.ShowGlobalSymbolsInCodeCompletion);
2225  Clang->setCodeCompletionConsumer(AugmentedConsumer);
2226
2227  // If we have a precompiled preamble, try to use it. We only allow
2228  // the use of the precompiled preamble if we're if the completion
2229  // point is within the main file, after the end of the precompiled
2230  // preamble.
2231  llvm::MemoryBuffer *OverrideMainBuffer = 0;
2232  if (!PreambleFile.empty()) {
2233    using llvm::sys::FileStatus;
2234    llvm::sys::PathWithStatus CompleteFilePath(File);
2235    llvm::sys::PathWithStatus MainPath(OriginalSourceFile);
2236    if (const FileStatus *CompleteFileStatus = CompleteFilePath.getFileStatus())
2237      if (const FileStatus *MainStatus = MainPath.getFileStatus())
2238        if (CompleteFileStatus->getUniqueID() == MainStatus->getUniqueID())
2239          OverrideMainBuffer
2240            = getMainBufferWithPrecompiledPreamble(*CCInvocation, false,
2241                                                   Line - 1);
2242  }
2243
2244  // If the main file has been overridden due to the use of a preamble,
2245  // make that override happen and introduce the preamble.
2246  PreprocessorOpts.DisableStatCache = true;
2247  StoredDiagnostics.insert(StoredDiagnostics.end(),
2248                           this->StoredDiagnostics.begin(),
2249             this->StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver);
2250  if (OverrideMainBuffer) {
2251    PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
2252    PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
2253    PreprocessorOpts.PrecompiledPreambleBytes.second
2254                                                    = PreambleEndsAtStartOfLine;
2255    PreprocessorOpts.ImplicitPCHInclude = PreambleFile;
2256    PreprocessorOpts.DisablePCHValidation = true;
2257
2258    // The stored diagnostics have the old source manager. Copy them
2259    // to our output set of stored diagnostics, updating the source
2260    // manager to the one we were given.
2261    for (unsigned I = NumStoredDiagnosticsFromDriver,
2262                  N = this->StoredDiagnostics.size();
2263         I < N; ++I) {
2264      StoredDiagnostics.push_back(this->StoredDiagnostics[I]);
2265      FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SourceMgr);
2266      StoredDiagnostics[I].setLocation(Loc);
2267    }
2268
2269    OwnedBuffers.push_back(OverrideMainBuffer);
2270  } else {
2271    PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
2272    PreprocessorOpts.PrecompiledPreambleBytes.second = false;
2273  }
2274
2275  // Disable the preprocessing record
2276  PreprocessorOpts.DetailedRecord = false;
2277
2278  llvm::OwningPtr<SyntaxOnlyAction> Act;
2279  Act.reset(new SyntaxOnlyAction);
2280  if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second,
2281                           Clang->getFrontendOpts().Inputs[0].first)) {
2282    Act->Execute();
2283    Act->EndSourceFile();
2284  }
2285}
2286
2287bool ASTUnit::Save(llvm::StringRef File) {
2288  if (getDiagnostics().hasErrorOccurred())
2289    return true;
2290
2291  // FIXME: Can we somehow regenerate the stat cache here, or do we need to
2292  // unconditionally create a stat cache when we parse the file?
2293  std::string ErrorInfo;
2294  llvm::raw_fd_ostream Out(File.str().c_str(), ErrorInfo,
2295                           llvm::raw_fd_ostream::F_Binary);
2296  if (!ErrorInfo.empty() || Out.has_error())
2297    return true;
2298
2299  serialize(Out);
2300  Out.close();
2301  return Out.has_error();
2302}
2303
2304bool ASTUnit::serialize(llvm::raw_ostream &OS) {
2305  if (getDiagnostics().hasErrorOccurred())
2306    return true;
2307
2308  std::vector<unsigned char> Buffer;
2309  llvm::BitstreamWriter Stream(Buffer);
2310  ASTWriter Writer(Stream);
2311  Writer.WriteAST(getSema(), 0, std::string(), 0);
2312
2313  // Write the generated bitstream to "Out".
2314  if (!Buffer.empty())
2315    OS.write((char *)&Buffer.front(), Buffer.size());
2316
2317  return false;
2318}
2319