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