1 //===- CIndexHigh.cpp - Higher level API functions ------------------------===//
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 #include "IndexingContext.h"
11 #include "CIndexDiagnostic.h"
12 #include "CIndexer.h"
13 #include "CLog.h"
14 #include "CXCursor.h"
15 #include "CXSourceLocation.h"
16 #include "CXString.h"
17 #include "CXTranslationUnit.h"
18 #include "clang/AST/ASTConsumer.h"
19 #include "clang/AST/DeclVisitor.h"
20 #include "clang/Frontend/ASTUnit.h"
21 #include "clang/Frontend/CompilerInstance.h"
22 #include "clang/Frontend/CompilerInvocation.h"
23 #include "clang/Frontend/FrontendAction.h"
24 #include "clang/Frontend/Utils.h"
25 #include "clang/Lex/HeaderSearch.h"
26 #include "clang/Lex/PPCallbacks.h"
27 #include "clang/Lex/PPConditionalDirectiveRecord.h"
28 #include "clang/Lex/Preprocessor.h"
29 #include "clang/Sema/SemaConsumer.h"
30 #include "llvm/Support/CrashRecoveryContext.h"
31 #include "llvm/Support/MemoryBuffer.h"
32 #include "llvm/Support/Mutex.h"
33 #include "llvm/Support/MutexGuard.h"
34 #include <cstdio>
35 
36 using namespace clang;
37 using namespace cxtu;
38 using namespace cxindex;
39 
40 static void indexDiagnostics(CXTranslationUnit TU, IndexingContext &IdxCtx);
41 
42 namespace {
43 
44 //===----------------------------------------------------------------------===//
45 // Skip Parsed Bodies
46 //===----------------------------------------------------------------------===//
47 
48 #ifdef LLVM_ON_WIN32
49 
50 // FIXME: On windows it is disabled since current implementation depends on
51 // file inodes.
52 
53 class SessionSkipBodyData { };
54 
55 class TUSkipBodyControl {
56 public:
57   TUSkipBodyControl(SessionSkipBodyData &sessionData,
58                     PPConditionalDirectiveRecord &ppRec,
59                     Preprocessor &pp) { }
60   bool isParsed(SourceLocation Loc, FileID FID, const FileEntry *FE) {
61     return false;
62   }
63   void finished() { }
64 };
65 
66 #else
67 
68 /// \brief A "region" in source code identified by the file/offset of the
69 /// preprocessor conditional directive that it belongs to.
70 /// Multiple, non-consecutive ranges can be parts of the same region.
71 ///
72 /// As an example of different regions separated by preprocessor directives:
73 ///
74 /// \code
75 ///   #1
76 /// #ifdef BLAH
77 ///   #2
78 /// #ifdef CAKE
79 ///   #3
80 /// #endif
81 ///   #2
82 /// #endif
83 ///   #1
84 /// \endcode
85 ///
86 /// There are 3 regions, with non-consecutive parts:
87 ///   #1 is identified as the beginning of the file
88 ///   #2 is identified as the location of "#ifdef BLAH"
89 ///   #3 is identified as the location of "#ifdef CAKE"
90 ///
91 class PPRegion {
92   llvm::sys::fs::UniqueID UniqueID;
93   time_t ModTime;
94   unsigned Offset;
95 public:
96   PPRegion() : UniqueID(0, 0), ModTime(), Offset() {}
97   PPRegion(llvm::sys::fs::UniqueID UniqueID, unsigned offset, time_t modTime)
98       : UniqueID(UniqueID), ModTime(modTime), Offset(offset) {}
99 
100   const llvm::sys::fs::UniqueID &getUniqueID() const { return UniqueID; }
101   unsigned getOffset() const { return Offset; }
102   time_t getModTime() const { return ModTime; }
103 
104   bool isInvalid() const { return *this == PPRegion(); }
105 
106   friend bool operator==(const PPRegion &lhs, const PPRegion &rhs) {
107     return lhs.UniqueID == rhs.UniqueID && lhs.Offset == rhs.Offset &&
108            lhs.ModTime == rhs.ModTime;
109   }
110 };
111 
112 typedef llvm::DenseSet<PPRegion> PPRegionSetTy;
113 
114 } // end anonymous namespace
115 
116 namespace llvm {
117   template <> struct isPodLike<PPRegion> {
118     static const bool value = true;
119   };
120 
121   template <>
122   struct DenseMapInfo<PPRegion> {
123     static inline PPRegion getEmptyKey() {
124       return PPRegion(llvm::sys::fs::UniqueID(0, 0), unsigned(-1), 0);
125     }
126     static inline PPRegion getTombstoneKey() {
127       return PPRegion(llvm::sys::fs::UniqueID(0, 0), unsigned(-2), 0);
128     }
129 
130     static unsigned getHashValue(const PPRegion &S) {
131       llvm::FoldingSetNodeID ID;
132       const llvm::sys::fs::UniqueID &UniqueID = S.getUniqueID();
133       ID.AddInteger(UniqueID.getFile());
134       ID.AddInteger(UniqueID.getDevice());
135       ID.AddInteger(S.getOffset());
136       ID.AddInteger(S.getModTime());
137       return ID.ComputeHash();
138     }
139 
140     static bool isEqual(const PPRegion &LHS, const PPRegion &RHS) {
141       return LHS == RHS;
142     }
143   };
144 }
145 
146 namespace {
147 
148 class SessionSkipBodyData {
149   llvm::sys::Mutex Mux;
150   PPRegionSetTy ParsedRegions;
151 
152 public:
153   SessionSkipBodyData() : Mux(/*recursive=*/false) {}
154   ~SessionSkipBodyData() {
155     //llvm::errs() << "RegionData: " << Skipped.size() << " - " << Skipped.getMemorySize() << "\n";
156   }
157 
158   void copyTo(PPRegionSetTy &Set) {
159     llvm::MutexGuard MG(Mux);
160     Set = ParsedRegions;
161   }
162 
163   void update(ArrayRef<PPRegion> Regions) {
164     llvm::MutexGuard MG(Mux);
165     ParsedRegions.insert(Regions.begin(), Regions.end());
166   }
167 };
168 
169 class TUSkipBodyControl {
170   SessionSkipBodyData &SessionData;
171   PPConditionalDirectiveRecord &PPRec;
172   Preprocessor &PP;
173 
174   PPRegionSetTy ParsedRegions;
175   SmallVector<PPRegion, 32> NewParsedRegions;
176   PPRegion LastRegion;
177   bool LastIsParsed;
178 
179 public:
180   TUSkipBodyControl(SessionSkipBodyData &sessionData,
181                     PPConditionalDirectiveRecord &ppRec,
182                     Preprocessor &pp)
183     : SessionData(sessionData), PPRec(ppRec), PP(pp) {
184     SessionData.copyTo(ParsedRegions);
185   }
186 
187   bool isParsed(SourceLocation Loc, FileID FID, const FileEntry *FE) {
188     PPRegion region = getRegion(Loc, FID, FE);
189     if (region.isInvalid())
190       return false;
191 
192     // Check common case, consecutive functions in the same region.
193     if (LastRegion == region)
194       return LastIsParsed;
195 
196     LastRegion = region;
197     LastIsParsed = ParsedRegions.count(region);
198     if (!LastIsParsed)
199       NewParsedRegions.push_back(region);
200     return LastIsParsed;
201   }
202 
203   void finished() {
204     SessionData.update(NewParsedRegions);
205   }
206 
207 private:
208   PPRegion getRegion(SourceLocation Loc, FileID FID, const FileEntry *FE) {
209     SourceLocation RegionLoc = PPRec.findConditionalDirectiveRegionLoc(Loc);
210     if (RegionLoc.isInvalid()) {
211       if (isParsedOnceInclude(FE)) {
212         const llvm::sys::fs::UniqueID &ID = FE->getUniqueID();
213         return PPRegion(ID, 0, FE->getModificationTime());
214       }
215       return PPRegion();
216     }
217 
218     const SourceManager &SM = PPRec.getSourceManager();
219     assert(RegionLoc.isFileID());
220     FileID RegionFID;
221     unsigned RegionOffset;
222     std::tie(RegionFID, RegionOffset) = SM.getDecomposedLoc(RegionLoc);
223 
224     if (RegionFID != FID) {
225       if (isParsedOnceInclude(FE)) {
226         const llvm::sys::fs::UniqueID &ID = FE->getUniqueID();
227         return PPRegion(ID, 0, FE->getModificationTime());
228       }
229       return PPRegion();
230     }
231 
232     const llvm::sys::fs::UniqueID &ID = FE->getUniqueID();
233     return PPRegion(ID, RegionOffset, FE->getModificationTime());
234   }
235 
236   bool isParsedOnceInclude(const FileEntry *FE) {
237     return PP.getHeaderSearchInfo().isFileMultipleIncludeGuarded(FE);
238   }
239 };
240 
241 #endif
242 
243 //===----------------------------------------------------------------------===//
244 // IndexPPCallbacks
245 //===----------------------------------------------------------------------===//
246 
247 class IndexPPCallbacks : public PPCallbacks {
248   Preprocessor &PP;
249   IndexingContext &IndexCtx;
250   bool IsMainFileEntered;
251 
252 public:
253   IndexPPCallbacks(Preprocessor &PP, IndexingContext &indexCtx)
254     : PP(PP), IndexCtx(indexCtx), IsMainFileEntered(false) { }
255 
256   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
257                  SrcMgr::CharacteristicKind FileType, FileID PrevFID) override {
258     if (IsMainFileEntered)
259       return;
260 
261     SourceManager &SM = PP.getSourceManager();
262     SourceLocation MainFileLoc = SM.getLocForStartOfFile(SM.getMainFileID());
263 
264     if (Loc == MainFileLoc && Reason == PPCallbacks::EnterFile) {
265       IsMainFileEntered = true;
266       IndexCtx.enteredMainFile(SM.getFileEntryForID(SM.getMainFileID()));
267     }
268   }
269 
270   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
271                           StringRef FileName, bool IsAngled,
272                           CharSourceRange FilenameRange, const FileEntry *File,
273                           StringRef SearchPath, StringRef RelativePath,
274                           const Module *Imported) override {
275     bool isImport = (IncludeTok.is(tok::identifier) &&
276             IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import);
277     IndexCtx.ppIncludedFile(HashLoc, FileName, File, isImport, IsAngled,
278                             Imported);
279   }
280 
281   /// MacroDefined - This hook is called whenever a macro definition is seen.
282   void MacroDefined(const Token &Id, const MacroDirective *MD) override {}
283 
284   /// MacroUndefined - This hook is called whenever a macro #undef is seen.
285   /// MI is released immediately following this callback.
286   void MacroUndefined(const Token &MacroNameTok,
287                       const MacroDirective *MD) override {}
288 
289   /// MacroExpands - This is called by when a macro invocation is found.
290   void MacroExpands(const Token &MacroNameTok, const MacroDirective *MD,
291                     SourceRange Range, const MacroArgs *Args) override {}
292 
293   /// SourceRangeSkipped - This hook is called when a source range is skipped.
294   /// \param Range The SourceRange that was skipped. The range begins at the
295   /// #if/#else directive and ends after the #endif/#else directive.
296   void SourceRangeSkipped(SourceRange Range) override {}
297 };
298 
299 //===----------------------------------------------------------------------===//
300 // IndexingConsumer
301 //===----------------------------------------------------------------------===//
302 
303 class IndexingConsumer : public ASTConsumer {
304   IndexingContext &IndexCtx;
305   TUSkipBodyControl *SKCtrl;
306 
307 public:
308   IndexingConsumer(IndexingContext &indexCtx, TUSkipBodyControl *skCtrl)
309     : IndexCtx(indexCtx), SKCtrl(skCtrl) { }
310 
311   // ASTConsumer Implementation
312 
313   void Initialize(ASTContext &Context) override {
314     IndexCtx.setASTContext(Context);
315     IndexCtx.startedTranslationUnit();
316   }
317 
318   void HandleTranslationUnit(ASTContext &Ctx) override {
319     if (SKCtrl)
320       SKCtrl->finished();
321   }
322 
323   bool HandleTopLevelDecl(DeclGroupRef DG) override {
324     IndexCtx.indexDeclGroupRef(DG);
325     return !IndexCtx.shouldAbort();
326   }
327 
328   /// \brief Handle the specified top-level declaration that occurred inside
329   /// and ObjC container.
330   void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override {
331     // They will be handled after the interface is seen first.
332     IndexCtx.addTUDeclInObjCContainer(D);
333   }
334 
335   /// \brief This is called by the AST reader when deserializing things.
336   /// The default implementation forwards to HandleTopLevelDecl but we don't
337   /// care about them when indexing, so have an empty definition.
338   void HandleInterestingDecl(DeclGroupRef D) override {}
339 
340   void HandleTagDeclDefinition(TagDecl *D) override {
341     if (!IndexCtx.shouldIndexImplicitTemplateInsts())
342       return;
343 
344     if (IndexCtx.isTemplateImplicitInstantiation(D))
345       IndexCtx.indexDecl(D);
346   }
347 
348   void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D) override {
349     if (!IndexCtx.shouldIndexImplicitTemplateInsts())
350       return;
351 
352     IndexCtx.indexDecl(D);
353   }
354 
355   bool shouldSkipFunctionBody(Decl *D) override {
356     if (!SKCtrl) {
357       // Always skip bodies.
358       return true;
359     }
360 
361     const SourceManager &SM = IndexCtx.getASTContext().getSourceManager();
362     SourceLocation Loc = D->getLocation();
363     if (Loc.isMacroID())
364       return false;
365     if (SM.isInSystemHeader(Loc))
366       return true; // always skip bodies from system headers.
367 
368     FileID FID;
369     unsigned Offset;
370     std::tie(FID, Offset) = SM.getDecomposedLoc(Loc);
371     // Don't skip bodies from main files; this may be revisited.
372     if (SM.getMainFileID() == FID)
373       return false;
374     const FileEntry *FE = SM.getFileEntryForID(FID);
375     if (!FE)
376       return false;
377 
378     return SKCtrl->isParsed(Loc, FID, FE);
379   }
380 };
381 
382 //===----------------------------------------------------------------------===//
383 // CaptureDiagnosticConsumer
384 //===----------------------------------------------------------------------===//
385 
386 class CaptureDiagnosticConsumer : public DiagnosticConsumer {
387   SmallVector<StoredDiagnostic, 4> Errors;
388 public:
389 
390   void HandleDiagnostic(DiagnosticsEngine::Level level,
391                         const Diagnostic &Info) override {
392     if (level >= DiagnosticsEngine::Error)
393       Errors.push_back(StoredDiagnostic(level, Info));
394   }
395 };
396 
397 //===----------------------------------------------------------------------===//
398 // IndexingFrontendAction
399 //===----------------------------------------------------------------------===//
400 
401 class IndexingFrontendAction : public ASTFrontendAction {
402   IndexingContext IndexCtx;
403   CXTranslationUnit CXTU;
404 
405   SessionSkipBodyData *SKData;
406   std::unique_ptr<TUSkipBodyControl> SKCtrl;
407 
408 public:
409   IndexingFrontendAction(CXClientData clientData,
410                          IndexerCallbacks &indexCallbacks,
411                          unsigned indexOptions,
412                          CXTranslationUnit cxTU,
413                          SessionSkipBodyData *skData)
414     : IndexCtx(clientData, indexCallbacks, indexOptions, cxTU),
415       CXTU(cxTU), SKData(skData) { }
416 
417   ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
418                                  StringRef InFile) override {
419     PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
420 
421     if (!PPOpts.ImplicitPCHInclude.empty()) {
422       IndexCtx.importedPCH(
423                         CI.getFileManager().getFile(PPOpts.ImplicitPCHInclude));
424     }
425 
426     IndexCtx.setASTContext(CI.getASTContext());
427     Preprocessor &PP = CI.getPreprocessor();
428     PP.addPPCallbacks(new IndexPPCallbacks(PP, IndexCtx));
429     IndexCtx.setPreprocessor(PP);
430 
431     if (SKData) {
432       PPConditionalDirectiveRecord *
433         PPRec = new PPConditionalDirectiveRecord(PP.getSourceManager());
434       PP.addPPCallbacks(PPRec);
435       SKCtrl.reset(new TUSkipBodyControl(*SKData, *PPRec, PP));
436     }
437 
438     return new IndexingConsumer(IndexCtx, SKCtrl.get());
439   }
440 
441   void EndSourceFileAction() override {
442     indexDiagnostics(CXTU, IndexCtx);
443   }
444 
445   TranslationUnitKind getTranslationUnitKind() override {
446     if (IndexCtx.shouldIndexImplicitTemplateInsts())
447       return TU_Complete;
448     else
449       return TU_Prefix;
450   }
451   bool hasCodeCompletionSupport() const override { return false; }
452 };
453 
454 //===----------------------------------------------------------------------===//
455 // clang_indexSourceFileUnit Implementation
456 //===----------------------------------------------------------------------===//
457 
458 struct IndexSessionData {
459   CXIndex CIdx;
460   std::unique_ptr<SessionSkipBodyData> SkipBodyData;
461 
462   explicit IndexSessionData(CXIndex cIdx)
463     : CIdx(cIdx), SkipBodyData(new SessionSkipBodyData) {}
464 };
465 
466 struct IndexSourceFileInfo {
467   CXIndexAction idxAction;
468   CXClientData client_data;
469   IndexerCallbacks *index_callbacks;
470   unsigned index_callbacks_size;
471   unsigned index_options;
472   const char *source_filename;
473   const char *const *command_line_args;
474   int num_command_line_args;
475   struct CXUnsavedFile *unsaved_files;
476   unsigned num_unsaved_files;
477   CXTranslationUnit *out_TU;
478   unsigned TU_options;
479   int result;
480 };
481 
482 struct MemBufferOwner {
483   SmallVector<const llvm::MemoryBuffer *, 8> Buffers;
484 
485   ~MemBufferOwner() {
486     for (SmallVectorImpl<const llvm::MemoryBuffer *>::iterator
487            I = Buffers.begin(), E = Buffers.end(); I != E; ++I)
488       delete *I;
489   }
490 };
491 
492 } // anonymous namespace
493 
494 static void clang_indexSourceFile_Impl(void *UserData) {
495   IndexSourceFileInfo *ITUI =
496     static_cast<IndexSourceFileInfo*>(UserData);
497   CXIndexAction cxIdxAction = ITUI->idxAction;
498   CXClientData client_data = ITUI->client_data;
499   IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
500   unsigned index_callbacks_size = ITUI->index_callbacks_size;
501   unsigned index_options = ITUI->index_options;
502   const char *source_filename = ITUI->source_filename;
503   const char * const *command_line_args = ITUI->command_line_args;
504   int num_command_line_args = ITUI->num_command_line_args;
505   struct CXUnsavedFile *unsaved_files = ITUI->unsaved_files;
506   unsigned num_unsaved_files = ITUI->num_unsaved_files;
507   CXTranslationUnit *out_TU  = ITUI->out_TU;
508   unsigned TU_options = ITUI->TU_options;
509 
510   // Set up the initial return value.
511   ITUI->result = CXError_Failure;
512 
513   if (out_TU)
514     *out_TU = 0;
515   bool requestedToGetTU = (out_TU != 0);
516 
517   if (!cxIdxAction) {
518     ITUI->result = CXError_InvalidArguments;
519     return;
520   }
521   if (!client_index_callbacks || index_callbacks_size == 0) {
522     ITUI->result = CXError_InvalidArguments;
523     return;
524   }
525 
526   IndexerCallbacks CB;
527   memset(&CB, 0, sizeof(CB));
528   unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
529                                   ? index_callbacks_size : sizeof(CB);
530   memcpy(&CB, client_index_callbacks, ClientCBSize);
531 
532   IndexSessionData *IdxSession = static_cast<IndexSessionData *>(cxIdxAction);
533   CIndexer *CXXIdx = static_cast<CIndexer *>(IdxSession->CIdx);
534 
535   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
536     setThreadBackgroundPriority();
537 
538   bool CaptureDiagnostics = !Logger::isLoggingEnabled();
539 
540   CaptureDiagnosticConsumer *CaptureDiag = 0;
541   if (CaptureDiagnostics)
542     CaptureDiag = new CaptureDiagnosticConsumer();
543 
544   // Configure the diagnostics.
545   IntrusiveRefCntPtr<DiagnosticsEngine>
546     Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions,
547                                               CaptureDiag,
548                                               /*ShouldOwnClient=*/true));
549 
550   // Recover resources if we crash before exiting this function.
551   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
552     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
553     DiagCleanup(Diags.getPtr());
554 
555   std::unique_ptr<std::vector<const char *>> Args(
556       new std::vector<const char *>());
557 
558   // Recover resources if we crash before exiting this method.
559   llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
560     ArgsCleanup(Args.get());
561 
562   Args->insert(Args->end(), command_line_args,
563                command_line_args + num_command_line_args);
564 
565   // The 'source_filename' argument is optional.  If the caller does not
566   // specify it then it is assumed that the source file is specified
567   // in the actual argument list.
568   // Put the source file after command_line_args otherwise if '-x' flag is
569   // present it will be unused.
570   if (source_filename)
571     Args->push_back(source_filename);
572 
573   IntrusiveRefCntPtr<CompilerInvocation>
574     CInvok(createInvocationFromCommandLine(*Args, Diags));
575 
576   if (!CInvok)
577     return;
578 
579   // Recover resources if we crash before exiting this function.
580   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInvocation,
581     llvm::CrashRecoveryContextReleaseRefCleanup<CompilerInvocation> >
582     CInvokCleanup(CInvok.getPtr());
583 
584   if (CInvok->getFrontendOpts().Inputs.empty())
585     return;
586 
587   std::unique_ptr<MemBufferOwner> BufOwner(new MemBufferOwner());
588 
589   // Recover resources if we crash before exiting this method.
590   llvm::CrashRecoveryContextCleanupRegistrar<MemBufferOwner>
591     BufOwnerCleanup(BufOwner.get());
592 
593   for (unsigned I = 0; I != num_unsaved_files; ++I) {
594     StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
595     const llvm::MemoryBuffer *Buffer
596       = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
597     CInvok->getPreprocessorOpts().addRemappedFile(unsaved_files[I].Filename, Buffer);
598     BufOwner->Buffers.push_back(Buffer);
599   }
600 
601   // Since libclang is primarily used by batch tools dealing with
602   // (often very broken) source code, where spell-checking can have a
603   // significant negative impact on performance (particularly when
604   // precompiled headers are involved), we disable it.
605   CInvok->getLangOpts()->SpellChecking = false;
606 
607   if (index_options & CXIndexOpt_SuppressWarnings)
608     CInvok->getDiagnosticOpts().IgnoreWarnings = true;
609 
610   ASTUnit *Unit = ASTUnit::create(CInvok.getPtr(), Diags,
611                                   CaptureDiagnostics,
612                                   /*UserFilesAreVolatile=*/true);
613   std::unique_ptr<CXTUOwner> CXTU(
614       new CXTUOwner(MakeCXTranslationUnit(CXXIdx, Unit)));
615 
616   // Recover resources if we crash before exiting this method.
617   llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner>
618     CXTUCleanup(CXTU.get());
619 
620   // Enable the skip-parsed-bodies optimization only for C++; this may be
621   // revisited.
622   bool SkipBodies = (index_options & CXIndexOpt_SkipParsedBodiesInSession) &&
623       CInvok->getLangOpts()->CPlusPlus;
624   if (SkipBodies)
625     CInvok->getFrontendOpts().SkipFunctionBodies = true;
626 
627   std::unique_ptr<IndexingFrontendAction> IndexAction;
628   IndexAction.reset(new IndexingFrontendAction(client_data, CB,
629                                                index_options, CXTU->getTU(),
630                               SkipBodies ? IdxSession->SkipBodyData.get() : 0));
631 
632   // Recover resources if we crash before exiting this method.
633   llvm::CrashRecoveryContextCleanupRegistrar<IndexingFrontendAction>
634     IndexActionCleanup(IndexAction.get());
635 
636   bool Persistent = requestedToGetTU;
637   bool OnlyLocalDecls = false;
638   bool PrecompilePreamble = false;
639   bool CacheCodeCompletionResults = false;
640   PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts();
641   PPOpts.AllowPCHWithCompilerErrors = true;
642 
643   if (requestedToGetTU) {
644     OnlyLocalDecls = CXXIdx->getOnlyLocalDecls();
645     PrecompilePreamble = TU_options & CXTranslationUnit_PrecompiledPreamble;
646     // FIXME: Add a flag for modules.
647     CacheCodeCompletionResults
648       = TU_options & CXTranslationUnit_CacheCompletionResults;
649   }
650 
651   if (TU_options & CXTranslationUnit_DetailedPreprocessingRecord) {
652     PPOpts.DetailedRecord = true;
653   }
654 
655   if (!requestedToGetTU && !CInvok->getLangOpts()->Modules)
656     PPOpts.DetailedRecord = false;
657 
658   DiagnosticErrorTrap DiagTrap(*Diags);
659   bool Success = ASTUnit::LoadFromCompilerInvocationAction(CInvok.getPtr(), Diags,
660                                                        IndexAction.get(),
661                                                        Unit,
662                                                        Persistent,
663                                                 CXXIdx->getClangResourcesPath(),
664                                                        OnlyLocalDecls,
665                                                        CaptureDiagnostics,
666                                                        PrecompilePreamble,
667                                                     CacheCodeCompletionResults,
668                                  /*IncludeBriefCommentsInCodeCompletion=*/false,
669                                                  /*UserFilesAreVolatile=*/true);
670   if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics())
671     printDiagsToStderr(Unit);
672 
673   if (isASTReadError(Unit)) {
674     ITUI->result = CXError_ASTReadError;
675     return;
676   }
677 
678   if (!Success)
679     return;
680 
681   if (out_TU)
682     *out_TU = CXTU->takeTU();
683 
684   ITUI->result = CXError_Success;
685 }
686 
687 //===----------------------------------------------------------------------===//
688 // clang_indexTranslationUnit Implementation
689 //===----------------------------------------------------------------------===//
690 
691 namespace {
692 
693 struct IndexTranslationUnitInfo {
694   CXIndexAction idxAction;
695   CXClientData client_data;
696   IndexerCallbacks *index_callbacks;
697   unsigned index_callbacks_size;
698   unsigned index_options;
699   CXTranslationUnit TU;
700   int result;
701 };
702 
703 } // anonymous namespace
704 
705 static void indexPreprocessingRecord(ASTUnit &Unit, IndexingContext &IdxCtx) {
706   Preprocessor &PP = Unit.getPreprocessor();
707   if (!PP.getPreprocessingRecord())
708     return;
709 
710   // FIXME: Only deserialize inclusion directives.
711 
712   PreprocessingRecord::iterator I, E;
713   std::tie(I, E) = Unit.getLocalPreprocessingEntities();
714 
715   bool isModuleFile = Unit.isModuleFile();
716   for (; I != E; ++I) {
717     PreprocessedEntity *PPE = *I;
718 
719     if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
720       SourceLocation Loc = ID->getSourceRange().getBegin();
721       // Modules have synthetic main files as input, give an invalid location
722       // if the location points to such a file.
723       if (isModuleFile && Unit.isInMainFileID(Loc))
724         Loc = SourceLocation();
725       IdxCtx.ppIncludedFile(Loc, ID->getFileName(),
726                             ID->getFile(),
727                             ID->getKind() == InclusionDirective::Import,
728                             !ID->wasInQuotes(), ID->importedModule());
729     }
730   }
731 }
732 
733 static bool topLevelDeclVisitor(void *context, const Decl *D) {
734   IndexingContext &IdxCtx = *static_cast<IndexingContext*>(context);
735   IdxCtx.indexTopLevelDecl(D);
736   if (IdxCtx.shouldAbort())
737     return false;
738   return true;
739 }
740 
741 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IdxCtx) {
742   Unit.visitLocalTopLevelDecls(&IdxCtx, topLevelDeclVisitor);
743 }
744 
745 static void indexDiagnostics(CXTranslationUnit TU, IndexingContext &IdxCtx) {
746   if (!IdxCtx.hasDiagnosticCallback())
747     return;
748 
749   CXDiagnosticSetImpl *DiagSet = cxdiag::lazyCreateDiags(TU);
750   IdxCtx.handleDiagnosticSet(DiagSet);
751 }
752 
753 static void clang_indexTranslationUnit_Impl(void *UserData) {
754   IndexTranslationUnitInfo *ITUI =
755     static_cast<IndexTranslationUnitInfo*>(UserData);
756   CXTranslationUnit TU = ITUI->TU;
757   CXClientData client_data = ITUI->client_data;
758   IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
759   unsigned index_callbacks_size = ITUI->index_callbacks_size;
760   unsigned index_options = ITUI->index_options;
761 
762   // Set up the initial return value.
763   ITUI->result = CXError_Failure;
764 
765   // Check arguments.
766   if (isNotUsableTU(TU)) {
767     LOG_BAD_TU(TU);
768     ITUI->result = CXError_InvalidArguments;
769     return;
770   }
771   if (!client_index_callbacks || index_callbacks_size == 0) {
772     ITUI->result = CXError_InvalidArguments;
773     return;
774   }
775 
776   CIndexer *CXXIdx = TU->CIdx;
777   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
778     setThreadBackgroundPriority();
779 
780   IndexerCallbacks CB;
781   memset(&CB, 0, sizeof(CB));
782   unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
783                                   ? index_callbacks_size : sizeof(CB);
784   memcpy(&CB, client_index_callbacks, ClientCBSize);
785 
786   std::unique_ptr<IndexingContext> IndexCtx;
787   IndexCtx.reset(new IndexingContext(client_data, CB, index_options, TU));
788 
789   // Recover resources if we crash before exiting this method.
790   llvm::CrashRecoveryContextCleanupRegistrar<IndexingContext>
791     IndexCtxCleanup(IndexCtx.get());
792 
793   std::unique_ptr<IndexingConsumer> IndexConsumer;
794   IndexConsumer.reset(new IndexingConsumer(*IndexCtx, 0));
795 
796   // Recover resources if we crash before exiting this method.
797   llvm::CrashRecoveryContextCleanupRegistrar<IndexingConsumer>
798     IndexConsumerCleanup(IndexConsumer.get());
799 
800   ASTUnit *Unit = cxtu::getASTUnit(TU);
801   if (!Unit)
802     return;
803 
804   ASTUnit::ConcurrencyCheck Check(*Unit);
805 
806   if (const FileEntry *PCHFile = Unit->getPCHFile())
807     IndexCtx->importedPCH(PCHFile);
808 
809   FileManager &FileMgr = Unit->getFileManager();
810 
811   if (Unit->getOriginalSourceFileName().empty())
812     IndexCtx->enteredMainFile(0);
813   else
814     IndexCtx->enteredMainFile(FileMgr.getFile(Unit->getOriginalSourceFileName()));
815 
816   IndexConsumer->Initialize(Unit->getASTContext());
817 
818   indexPreprocessingRecord(*Unit, *IndexCtx);
819   indexTranslationUnit(*Unit, *IndexCtx);
820   indexDiagnostics(TU, *IndexCtx);
821 
822   ITUI->result = CXError_Success;
823 }
824 
825 //===----------------------------------------------------------------------===//
826 // libclang public APIs.
827 //===----------------------------------------------------------------------===//
828 
829 extern "C" {
830 
831 int clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
832   return CXIdxEntity_ObjCClass <= K && K <= CXIdxEntity_ObjCCategory;
833 }
834 
835 const CXIdxObjCContainerDeclInfo *
836 clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *DInfo) {
837   if (!DInfo)
838     return 0;
839 
840   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
841   if (const ObjCContainerDeclInfo *
842         ContInfo = dyn_cast<ObjCContainerDeclInfo>(DI))
843     return &ContInfo->ObjCContDeclInfo;
844 
845   return 0;
846 }
847 
848 const CXIdxObjCInterfaceDeclInfo *
849 clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo *DInfo) {
850   if (!DInfo)
851     return 0;
852 
853   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
854   if (const ObjCInterfaceDeclInfo *
855         InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
856     return &InterInfo->ObjCInterDeclInfo;
857 
858   return 0;
859 }
860 
861 const CXIdxObjCCategoryDeclInfo *
862 clang_index_getObjCCategoryDeclInfo(const CXIdxDeclInfo *DInfo){
863   if (!DInfo)
864     return 0;
865 
866   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
867   if (const ObjCCategoryDeclInfo *
868         CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
869     return &CatInfo->ObjCCatDeclInfo;
870 
871   return 0;
872 }
873 
874 const CXIdxObjCProtocolRefListInfo *
875 clang_index_getObjCProtocolRefListInfo(const CXIdxDeclInfo *DInfo) {
876   if (!DInfo)
877     return 0;
878 
879   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
880 
881   if (const ObjCInterfaceDeclInfo *
882         InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
883     return InterInfo->ObjCInterDeclInfo.protocols;
884 
885   if (const ObjCProtocolDeclInfo *
886         ProtInfo = dyn_cast<ObjCProtocolDeclInfo>(DI))
887     return &ProtInfo->ObjCProtoRefListInfo;
888 
889   if (const ObjCCategoryDeclInfo *CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
890     return CatInfo->ObjCCatDeclInfo.protocols;
891 
892   return 0;
893 }
894 
895 const CXIdxObjCPropertyDeclInfo *
896 clang_index_getObjCPropertyDeclInfo(const CXIdxDeclInfo *DInfo) {
897   if (!DInfo)
898     return 0;
899 
900   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
901   if (const ObjCPropertyDeclInfo *PropInfo = dyn_cast<ObjCPropertyDeclInfo>(DI))
902     return &PropInfo->ObjCPropDeclInfo;
903 
904   return 0;
905 }
906 
907 const CXIdxIBOutletCollectionAttrInfo *
908 clang_index_getIBOutletCollectionAttrInfo(const CXIdxAttrInfo *AInfo) {
909   if (!AInfo)
910     return 0;
911 
912   const AttrInfo *DI = static_cast<const AttrInfo *>(AInfo);
913   if (const IBOutletCollectionInfo *
914         IBInfo = dyn_cast<IBOutletCollectionInfo>(DI))
915     return &IBInfo->IBCollInfo;
916 
917   return 0;
918 }
919 
920 const CXIdxCXXClassDeclInfo *
921 clang_index_getCXXClassDeclInfo(const CXIdxDeclInfo *DInfo) {
922   if (!DInfo)
923     return 0;
924 
925   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
926   if (const CXXClassDeclInfo *ClassInfo = dyn_cast<CXXClassDeclInfo>(DI))
927     return &ClassInfo->CXXClassInfo;
928 
929   return 0;
930 }
931 
932 CXIdxClientContainer
933 clang_index_getClientContainer(const CXIdxContainerInfo *info) {
934   if (!info)
935     return 0;
936   const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
937   return Container->IndexCtx->getClientContainerForDC(Container->DC);
938 }
939 
940 void clang_index_setClientContainer(const CXIdxContainerInfo *info,
941                                     CXIdxClientContainer client) {
942   if (!info)
943     return;
944   const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
945   Container->IndexCtx->addContainerInMap(Container->DC, client);
946 }
947 
948 CXIdxClientEntity clang_index_getClientEntity(const CXIdxEntityInfo *info) {
949   if (!info)
950     return 0;
951   const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
952   return Entity->IndexCtx->getClientEntity(Entity->Dcl);
953 }
954 
955 void clang_index_setClientEntity(const CXIdxEntityInfo *info,
956                                  CXIdxClientEntity client) {
957   if (!info)
958     return;
959   const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
960   Entity->IndexCtx->setClientEntity(Entity->Dcl, client);
961 }
962 
963 CXIndexAction clang_IndexAction_create(CXIndex CIdx) {
964   return new IndexSessionData(CIdx);
965 }
966 
967 void clang_IndexAction_dispose(CXIndexAction idxAction) {
968   if (idxAction)
969     delete static_cast<IndexSessionData *>(idxAction);
970 }
971 
972 int clang_indexSourceFile(CXIndexAction idxAction,
973                           CXClientData client_data,
974                           IndexerCallbacks *index_callbacks,
975                           unsigned index_callbacks_size,
976                           unsigned index_options,
977                           const char *source_filename,
978                           const char * const *command_line_args,
979                           int num_command_line_args,
980                           struct CXUnsavedFile *unsaved_files,
981                           unsigned num_unsaved_files,
982                           CXTranslationUnit *out_TU,
983                           unsigned TU_options) {
984   LOG_FUNC_SECTION {
985     *Log << source_filename << ": ";
986     for (int i = 0; i != num_command_line_args; ++i)
987       *Log << command_line_args[i] << " ";
988   }
989 
990   IndexSourceFileInfo ITUI = { idxAction, client_data, index_callbacks,
991                                index_callbacks_size, index_options,
992                                source_filename, command_line_args,
993                                num_command_line_args, unsaved_files,
994                                num_unsaved_files, out_TU, TU_options,
995                                CXError_Failure };
996 
997   if (getenv("LIBCLANG_NOTHREADS")) {
998     clang_indexSourceFile_Impl(&ITUI);
999     return ITUI.result;
1000   }
1001 
1002   llvm::CrashRecoveryContext CRC;
1003 
1004   if (!RunSafely(CRC, clang_indexSourceFile_Impl, &ITUI)) {
1005     fprintf(stderr, "libclang: crash detected during indexing source file: {\n");
1006     fprintf(stderr, "  'source_filename' : '%s'\n", source_filename);
1007     fprintf(stderr, "  'command_line_args' : [");
1008     for (int i = 0; i != num_command_line_args; ++i) {
1009       if (i)
1010         fprintf(stderr, ", ");
1011       fprintf(stderr, "'%s'", command_line_args[i]);
1012     }
1013     fprintf(stderr, "],\n");
1014     fprintf(stderr, "  'unsaved_files' : [");
1015     for (unsigned i = 0; i != num_unsaved_files; ++i) {
1016       if (i)
1017         fprintf(stderr, ", ");
1018       fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
1019               unsaved_files[i].Length);
1020     }
1021     fprintf(stderr, "],\n");
1022     fprintf(stderr, "  'options' : %d,\n", TU_options);
1023     fprintf(stderr, "}\n");
1024 
1025     return 1;
1026   } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
1027     if (out_TU)
1028       PrintLibclangResourceUsage(*out_TU);
1029   }
1030 
1031   return ITUI.result;
1032 }
1033 
1034 int clang_indexTranslationUnit(CXIndexAction idxAction,
1035                                CXClientData client_data,
1036                                IndexerCallbacks *index_callbacks,
1037                                unsigned index_callbacks_size,
1038                                unsigned index_options,
1039                                CXTranslationUnit TU) {
1040   LOG_FUNC_SECTION {
1041     *Log << TU;
1042   }
1043 
1044   IndexTranslationUnitInfo ITUI = { idxAction, client_data, index_callbacks,
1045                                     index_callbacks_size, index_options, TU,
1046                                     0 };
1047 
1048   if (getenv("LIBCLANG_NOTHREADS")) {
1049     clang_indexTranslationUnit_Impl(&ITUI);
1050     return ITUI.result;
1051   }
1052 
1053   llvm::CrashRecoveryContext CRC;
1054 
1055   if (!RunSafely(CRC, clang_indexTranslationUnit_Impl, &ITUI)) {
1056     fprintf(stderr, "libclang: crash detected during indexing TU\n");
1057 
1058     return 1;
1059   }
1060 
1061   return ITUI.result;
1062 }
1063 
1064 void clang_indexLoc_getFileLocation(CXIdxLoc location,
1065                                     CXIdxClientFile *indexFile,
1066                                     CXFile *file,
1067                                     unsigned *line,
1068                                     unsigned *column,
1069                                     unsigned *offset) {
1070   if (indexFile) *indexFile = 0;
1071   if (file)   *file = 0;
1072   if (line)   *line = 0;
1073   if (column) *column = 0;
1074   if (offset) *offset = 0;
1075 
1076   SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
1077   if (!location.ptr_data[0] || Loc.isInvalid())
1078     return;
1079 
1080   IndexingContext &IndexCtx =
1081       *static_cast<IndexingContext*>(location.ptr_data[0]);
1082   IndexCtx.translateLoc(Loc, indexFile, file, line, column, offset);
1083 }
1084 
1085 CXSourceLocation clang_indexLoc_getCXSourceLocation(CXIdxLoc location) {
1086   SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
1087   if (!location.ptr_data[0] || Loc.isInvalid())
1088     return clang_getNullLocation();
1089 
1090   IndexingContext &IndexCtx =
1091       *static_cast<IndexingContext*>(location.ptr_data[0]);
1092   return cxloc::translateSourceLocation(IndexCtx.getASTContext(), Loc);
1093 }
1094 
1095 } // end: extern "C"
1096 
1097