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