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