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