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