Home | History | Annotate | Download | only in libclang 
      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   ArrayRef<CXUnsavedFile> unsaved_files;
    476   CXTranslationUnit *out_TU;
    477   unsigned TU_options;
    478   CXErrorCode &result;
    479 };
    480 
    481 } // anonymous namespace
    482 
    483 static void clang_indexSourceFile_Impl(void *UserData) {
    484   const IndexSourceFileInfo *ITUI =
    485       static_cast<IndexSourceFileInfo *>(UserData);
    486   CXIndexAction cxIdxAction = ITUI->idxAction;
    487   CXClientData client_data = ITUI->client_data;
    488   IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
    489   unsigned index_callbacks_size = ITUI->index_callbacks_size;
    490   unsigned index_options = ITUI->index_options;
    491   const char *source_filename = ITUI->source_filename;
    492   const char * const *command_line_args = ITUI->command_line_args;
    493   int num_command_line_args = ITUI->num_command_line_args;
    494   CXTranslationUnit *out_TU  = ITUI->out_TU;
    495   unsigned TU_options = ITUI->TU_options;
    496 
    497   if (out_TU)
    498     *out_TU = nullptr;
    499   bool requestedToGetTU = (out_TU != nullptr);
    500 
    501   if (!cxIdxAction) {
    502     ITUI->result = CXError_InvalidArguments;
    503     return;
    504   }
    505   if (!client_index_callbacks || index_callbacks_size == 0) {
    506     ITUI->result = CXError_InvalidArguments;
    507     return;
    508   }
    509 
    510   IndexerCallbacks CB;
    511   memset(&CB, 0, sizeof(CB));
    512   unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
    513                                   ? index_callbacks_size : sizeof(CB);
    514   memcpy(&CB, client_index_callbacks, ClientCBSize);
    515 
    516   IndexSessionData *IdxSession = static_cast<IndexSessionData *>(cxIdxAction);
    517   CIndexer *CXXIdx = static_cast<CIndexer *>(IdxSession->CIdx);
    518 
    519   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
    520     setThreadBackgroundPriority();
    521 
    522   bool CaptureDiagnostics = !Logger::isLoggingEnabled();
    523 
    524   CaptureDiagnosticConsumer *CaptureDiag = nullptr;
    525   if (CaptureDiagnostics)
    526     CaptureDiag = new CaptureDiagnosticConsumer();
    527 
    528   // Configure the diagnostics.
    529   IntrusiveRefCntPtr<DiagnosticsEngine>
    530     Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions,
    531                                               CaptureDiag,
    532                                               /*ShouldOwnClient=*/true));
    533 
    534   // Recover resources if we crash before exiting this function.
    535   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
    536     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
    537     DiagCleanup(Diags.get());
    538 
    539   std::unique_ptr<std::vector<const char *>> Args(
    540       new std::vector<const char *>());
    541 
    542   // Recover resources if we crash before exiting this method.
    543   llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
    544     ArgsCleanup(Args.get());
    545 
    546   Args->insert(Args->end(), command_line_args,
    547                command_line_args + num_command_line_args);
    548 
    549   // The 'source_filename' argument is optional.  If the caller does not
    550   // specify it then it is assumed that the source file is specified
    551   // in the actual argument list.
    552   // Put the source file after command_line_args otherwise if '-x' flag is
    553   // present it will be unused.
    554   if (source_filename)
    555     Args->push_back(source_filename);
    556 
    557   IntrusiveRefCntPtr<CompilerInvocation>
    558     CInvok(createInvocationFromCommandLine(*Args, Diags));
    559 
    560   if (!CInvok)
    561     return;
    562 
    563   // Recover resources if we crash before exiting this function.
    564   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInvocation,
    565     llvm::CrashRecoveryContextReleaseRefCleanup<CompilerInvocation> >
    566     CInvokCleanup(CInvok.get());
    567 
    568   if (CInvok->getFrontendOpts().Inputs.empty())
    569     return;
    570 
    571   typedef SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 8> MemBufferOwner;
    572   std::unique_ptr<MemBufferOwner> BufOwner(new MemBufferOwner);
    573 
    574   // Recover resources if we crash before exiting this method.
    575   llvm::CrashRecoveryContextCleanupRegistrar<MemBufferOwner> BufOwnerCleanup(
    576       BufOwner.get());
    577 
    578   for (auto &UF : ITUI->unsaved_files) {
    579     llvm::MemoryBuffer *MB =
    580         llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
    581     BufOwner->push_back(std::unique_ptr<llvm::MemoryBuffer>(MB));
    582     CInvok->getPreprocessorOpts().addRemappedFile(UF.Filename, MB);
    583   }
    584 
    585   // Since libclang is primarily used by batch tools dealing with
    586   // (often very broken) source code, where spell-checking can have a
    587   // significant negative impact on performance (particularly when
    588   // precompiled headers are involved), we disable it.
    589   CInvok->getLangOpts()->SpellChecking = false;
    590 
    591   if (index_options & CXIndexOpt_SuppressWarnings)
    592     CInvok->getDiagnosticOpts().IgnoreWarnings = true;
    593 
    594   ASTUnit *Unit = ASTUnit::create(CInvok.get(), Diags,
    595                                   CaptureDiagnostics,
    596                                   /*UserFilesAreVolatile=*/true);
    597   if (!Unit) {
    598     ITUI->result = CXError_InvalidArguments;
    599     return;
    600   }
    601 
    602   std::unique_ptr<CXTUOwner> CXTU(
    603       new CXTUOwner(MakeCXTranslationUnit(CXXIdx, Unit)));
    604 
    605   // Recover resources if we crash before exiting this method.
    606   llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner>
    607     CXTUCleanup(CXTU.get());
    608 
    609   // Enable the skip-parsed-bodies optimization only for C++; this may be
    610   // revisited.
    611   bool SkipBodies = (index_options & CXIndexOpt_SkipParsedBodiesInSession) &&
    612       CInvok->getLangOpts()->CPlusPlus;
    613   if (SkipBodies)
    614     CInvok->getFrontendOpts().SkipFunctionBodies = true;
    615 
    616   std::unique_ptr<IndexingFrontendAction> IndexAction;
    617   IndexAction.reset(new IndexingFrontendAction(client_data, CB,
    618                                                index_options, CXTU->getTU(),
    619                         SkipBodies ? IdxSession->SkipBodyData.get() : nullptr));
    620 
    621   // Recover resources if we crash before exiting this method.
    622   llvm::CrashRecoveryContextCleanupRegistrar<IndexingFrontendAction>
    623     IndexActionCleanup(IndexAction.get());
    624 
    625   bool Persistent = requestedToGetTU;
    626   bool OnlyLocalDecls = false;
    627   bool PrecompilePreamble = false;
    628   bool CacheCodeCompletionResults = false;
    629   PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts();
    630   PPOpts.AllowPCHWithCompilerErrors = true;
    631 
    632   if (requestedToGetTU) {
    633     OnlyLocalDecls = CXXIdx->getOnlyLocalDecls();
    634     PrecompilePreamble = TU_options & CXTranslationUnit_PrecompiledPreamble;
    635     // FIXME: Add a flag for modules.
    636     CacheCodeCompletionResults
    637       = TU_options & CXTranslationUnit_CacheCompletionResults;
    638   }
    639 
    640   if (TU_options & CXTranslationUnit_DetailedPreprocessingRecord) {
    641     PPOpts.DetailedRecord = true;
    642   }
    643 
    644   if (!requestedToGetTU && !CInvok->getLangOpts()->Modules)
    645     PPOpts.DetailedRecord = false;
    646 
    647   DiagnosticErrorTrap DiagTrap(*Diags);
    648   bool Success = ASTUnit::LoadFromCompilerInvocationAction(CInvok.get(), Diags,
    649                                                        IndexAction.get(),
    650                                                        Unit,
    651                                                        Persistent,
    652                                                 CXXIdx->getClangResourcesPath(),
    653                                                        OnlyLocalDecls,
    654                                                        CaptureDiagnostics,
    655                                                        PrecompilePreamble,
    656                                                     CacheCodeCompletionResults,
    657                                  /*IncludeBriefCommentsInCodeCompletion=*/false,
    658                                                  /*UserFilesAreVolatile=*/true);
    659   if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics())
    660     printDiagsToStderr(Unit);
    661 
    662   if (isASTReadError(Unit)) {
    663     ITUI->result = CXError_ASTReadError;
    664     return;
    665   }
    666 
    667   if (!Success)
    668     return;
    669 
    670   if (out_TU)
    671     *out_TU = CXTU->takeTU();
    672 
    673   ITUI->result = CXError_Success;
    674 }
    675 
    676 //===----------------------------------------------------------------------===//
    677 // clang_indexTranslationUnit Implementation
    678 //===----------------------------------------------------------------------===//
    679 
    680 namespace {
    681 
    682 struct IndexTranslationUnitInfo {
    683   CXIndexAction idxAction;
    684   CXClientData client_data;
    685   IndexerCallbacks *index_callbacks;
    686   unsigned index_callbacks_size;
    687   unsigned index_options;
    688   CXTranslationUnit TU;
    689   int result;
    690 };
    691 
    692 } // anonymous namespace
    693 
    694 static void indexPreprocessingRecord(ASTUnit &Unit, IndexingContext &IdxCtx) {
    695   Preprocessor &PP = Unit.getPreprocessor();
    696   if (!PP.getPreprocessingRecord())
    697     return;
    698 
    699   // FIXME: Only deserialize inclusion directives.
    700 
    701   PreprocessingRecord::iterator I, E;
    702   std::tie(I, E) = Unit.getLocalPreprocessingEntities();
    703 
    704   bool isModuleFile = Unit.isModuleFile();
    705   for (; I != E; ++I) {
    706     PreprocessedEntity *PPE = *I;
    707 
    708     if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
    709       SourceLocation Loc = ID->getSourceRange().getBegin();
    710       // Modules have synthetic main files as input, give an invalid location
    711       // if the location points to such a file.
    712       if (isModuleFile && Unit.isInMainFileID(Loc))
    713         Loc = SourceLocation();
    714       IdxCtx.ppIncludedFile(Loc, ID->getFileName(),
    715                             ID->getFile(),
    716                             ID->getKind() == InclusionDirective::Import,
    717                             !ID->wasInQuotes(), ID->importedModule());
    718     }
    719   }
    720 }
    721 
    722 static bool topLevelDeclVisitor(void *context, const Decl *D) {
    723   IndexingContext &IdxCtx = *static_cast<IndexingContext*>(context);
    724   IdxCtx.indexTopLevelDecl(D);
    725   if (IdxCtx.shouldAbort())
    726     return false;
    727   return true;
    728 }
    729 
    730 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IdxCtx) {
    731   Unit.visitLocalTopLevelDecls(&IdxCtx, topLevelDeclVisitor);
    732 }
    733 
    734 static void indexDiagnostics(CXTranslationUnit TU, IndexingContext &IdxCtx) {
    735   if (!IdxCtx.hasDiagnosticCallback())
    736     return;
    737 
    738   CXDiagnosticSetImpl *DiagSet = cxdiag::lazyCreateDiags(TU);
    739   IdxCtx.handleDiagnosticSet(DiagSet);
    740 }
    741 
    742 static void clang_indexTranslationUnit_Impl(void *UserData) {
    743   IndexTranslationUnitInfo *ITUI =
    744     static_cast<IndexTranslationUnitInfo*>(UserData);
    745   CXTranslationUnit TU = ITUI->TU;
    746   CXClientData client_data = ITUI->client_data;
    747   IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
    748   unsigned index_callbacks_size = ITUI->index_callbacks_size;
    749   unsigned index_options = ITUI->index_options;
    750 
    751   // Set up the initial return value.
    752   ITUI->result = CXError_Failure;
    753 
    754   // Check arguments.
    755   if (isNotUsableTU(TU)) {
    756     LOG_BAD_TU(TU);
    757     ITUI->result = CXError_InvalidArguments;
    758     return;
    759   }
    760   if (!client_index_callbacks || index_callbacks_size == 0) {
    761     ITUI->result = CXError_InvalidArguments;
    762     return;
    763   }
    764 
    765   CIndexer *CXXIdx = TU->CIdx;
    766   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
    767     setThreadBackgroundPriority();
    768 
    769   IndexerCallbacks CB;
    770   memset(&CB, 0, sizeof(CB));
    771   unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
    772                                   ? index_callbacks_size : sizeof(CB);
    773   memcpy(&CB, client_index_callbacks, ClientCBSize);
    774 
    775   std::unique_ptr<IndexingContext> IndexCtx;
    776   IndexCtx.reset(new IndexingContext(client_data, CB, index_options, TU));
    777 
    778   // Recover resources if we crash before exiting this method.
    779   llvm::CrashRecoveryContextCleanupRegistrar<IndexingContext>
    780     IndexCtxCleanup(IndexCtx.get());
    781 
    782   std::unique_ptr<IndexingConsumer> IndexConsumer;
    783   IndexConsumer.reset(new IndexingConsumer(*IndexCtx, nullptr));
    784 
    785   // Recover resources if we crash before exiting this method.
    786   llvm::CrashRecoveryContextCleanupRegistrar<IndexingConsumer>
    787     IndexConsumerCleanup(IndexConsumer.get());
    788 
    789   ASTUnit *Unit = cxtu::getASTUnit(TU);
    790   if (!Unit)
    791     return;
    792 
    793   ASTUnit::ConcurrencyCheck Check(*Unit);
    794 
    795   if (const FileEntry *PCHFile = Unit->getPCHFile())
    796     IndexCtx->importedPCH(PCHFile);
    797 
    798   FileManager &FileMgr = Unit->getFileManager();
    799 
    800   if (Unit->getOriginalSourceFileName().empty())
    801     IndexCtx->enteredMainFile(nullptr);
    802   else
    803     IndexCtx->enteredMainFile(FileMgr.getFile(Unit->getOriginalSourceFileName()));
    804 
    805   IndexConsumer->Initialize(Unit->getASTContext());
    806 
    807   indexPreprocessingRecord(*Unit, *IndexCtx);
    808   indexTranslationUnit(*Unit, *IndexCtx);
    809   indexDiagnostics(TU, *IndexCtx);
    810 
    811   ITUI->result = CXError_Success;
    812 }
    813 
    814 //===----------------------------------------------------------------------===//
    815 // libclang public APIs.
    816 //===----------------------------------------------------------------------===//
    817 
    818 extern "C" {
    819 
    820 int clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
    821   return CXIdxEntity_ObjCClass <= K && K <= CXIdxEntity_ObjCCategory;
    822 }
    823 
    824 const CXIdxObjCContainerDeclInfo *
    825 clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *DInfo) {
    826   if (!DInfo)
    827     return nullptr;
    828 
    829   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
    830   if (const ObjCContainerDeclInfo *
    831         ContInfo = dyn_cast<ObjCContainerDeclInfo>(DI))
    832     return &ContInfo->ObjCContDeclInfo;
    833 
    834   return nullptr;
    835 }
    836 
    837 const CXIdxObjCInterfaceDeclInfo *
    838 clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo *DInfo) {
    839   if (!DInfo)
    840     return nullptr;
    841 
    842   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
    843   if (const ObjCInterfaceDeclInfo *
    844         InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
    845     return &InterInfo->ObjCInterDeclInfo;
    846 
    847   return nullptr;
    848 }
    849 
    850 const CXIdxObjCCategoryDeclInfo *
    851 clang_index_getObjCCategoryDeclInfo(const CXIdxDeclInfo *DInfo){
    852   if (!DInfo)
    853     return nullptr;
    854 
    855   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
    856   if (const ObjCCategoryDeclInfo *
    857         CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
    858     return &CatInfo->ObjCCatDeclInfo;
    859 
    860   return nullptr;
    861 }
    862 
    863 const CXIdxObjCProtocolRefListInfo *
    864 clang_index_getObjCProtocolRefListInfo(const CXIdxDeclInfo *DInfo) {
    865   if (!DInfo)
    866     return nullptr;
    867 
    868   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
    869 
    870   if (const ObjCInterfaceDeclInfo *
    871         InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
    872     return InterInfo->ObjCInterDeclInfo.protocols;
    873 
    874   if (const ObjCProtocolDeclInfo *
    875         ProtInfo = dyn_cast<ObjCProtocolDeclInfo>(DI))
    876     return &ProtInfo->ObjCProtoRefListInfo;
    877 
    878   if (const ObjCCategoryDeclInfo *CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
    879     return CatInfo->ObjCCatDeclInfo.protocols;
    880 
    881   return nullptr;
    882 }
    883 
    884 const CXIdxObjCPropertyDeclInfo *
    885 clang_index_getObjCPropertyDeclInfo(const CXIdxDeclInfo *DInfo) {
    886   if (!DInfo)
    887     return nullptr;
    888 
    889   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
    890   if (const ObjCPropertyDeclInfo *PropInfo = dyn_cast<ObjCPropertyDeclInfo>(DI))
    891     return &PropInfo->ObjCPropDeclInfo;
    892 
    893   return nullptr;
    894 }
    895 
    896 const CXIdxIBOutletCollectionAttrInfo *
    897 clang_index_getIBOutletCollectionAttrInfo(const CXIdxAttrInfo *AInfo) {
    898   if (!AInfo)
    899     return nullptr;
    900 
    901   const AttrInfo *DI = static_cast<const AttrInfo *>(AInfo);
    902   if (const IBOutletCollectionInfo *
    903         IBInfo = dyn_cast<IBOutletCollectionInfo>(DI))
    904     return &IBInfo->IBCollInfo;
    905 
    906   return nullptr;
    907 }
    908 
    909 const CXIdxCXXClassDeclInfo *
    910 clang_index_getCXXClassDeclInfo(const CXIdxDeclInfo *DInfo) {
    911   if (!DInfo)
    912     return nullptr;
    913 
    914   const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
    915   if (const CXXClassDeclInfo *ClassInfo = dyn_cast<CXXClassDeclInfo>(DI))
    916     return &ClassInfo->CXXClassInfo;
    917 
    918   return nullptr;
    919 }
    920 
    921 CXIdxClientContainer
    922 clang_index_getClientContainer(const CXIdxContainerInfo *info) {
    923   if (!info)
    924     return nullptr;
    925   const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
    926   return Container->IndexCtx->getClientContainerForDC(Container->DC);
    927 }
    928 
    929 void clang_index_setClientContainer(const CXIdxContainerInfo *info,
    930                                     CXIdxClientContainer client) {
    931   if (!info)
    932     return;
    933   const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
    934   Container->IndexCtx->addContainerInMap(Container->DC, client);
    935 }
    936 
    937 CXIdxClientEntity clang_index_getClientEntity(const CXIdxEntityInfo *info) {
    938   if (!info)
    939     return nullptr;
    940   const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
    941   return Entity->IndexCtx->getClientEntity(Entity->Dcl);
    942 }
    943 
    944 void clang_index_setClientEntity(const CXIdxEntityInfo *info,
    945                                  CXIdxClientEntity client) {
    946   if (!info)
    947     return;
    948   const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
    949   Entity->IndexCtx->setClientEntity(Entity->Dcl, client);
    950 }
    951 
    952 CXIndexAction clang_IndexAction_create(CXIndex CIdx) {
    953   return new IndexSessionData(CIdx);
    954 }
    955 
    956 void clang_IndexAction_dispose(CXIndexAction idxAction) {
    957   if (idxAction)
    958     delete static_cast<IndexSessionData *>(idxAction);
    959 }
    960 
    961 int clang_indexSourceFile(CXIndexAction idxAction,
    962                           CXClientData client_data,
    963                           IndexerCallbacks *index_callbacks,
    964                           unsigned index_callbacks_size,
    965                           unsigned index_options,
    966                           const char *source_filename,
    967                           const char * const *command_line_args,
    968                           int num_command_line_args,
    969                           struct CXUnsavedFile *unsaved_files,
    970                           unsigned num_unsaved_files,
    971                           CXTranslationUnit *out_TU,
    972                           unsigned TU_options) {
    973   LOG_FUNC_SECTION {
    974     *Log << source_filename << ": ";
    975     for (int i = 0; i != num_command_line_args; ++i)
    976       *Log << command_line_args[i] << " ";
    977   }
    978 
    979   if (num_unsaved_files && !unsaved_files)
    980     return CXError_InvalidArguments;
    981 
    982   CXErrorCode result = CXError_Failure;
    983   IndexSourceFileInfo ITUI = {
    984       idxAction,
    985       client_data,
    986       index_callbacks,
    987       index_callbacks_size,
    988       index_options,
    989       source_filename,
    990       command_line_args,
    991       num_command_line_args,
    992       llvm::makeArrayRef(unsaved_files, num_unsaved_files),
    993       out_TU,
    994       TU_options,
    995       result};
    996 
    997   if (getenv("LIBCLANG_NOTHREADS")) {
    998     clang_indexSourceFile_Impl(&ITUI);
    999     return 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 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 = nullptr;
   1071   if (file)   *file = nullptr;
   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