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:
TUSkipBodyControl(SessionSkipBodyData & sessionData,PPConditionalDirectiveRecord & ppRec,Preprocessor & pp)57 TUSkipBodyControl(SessionSkipBodyData &sessionData,
58 PPConditionalDirectiveRecord &ppRec,
59 Preprocessor &pp) { }
isParsed(SourceLocation Loc,FileID FID,const FileEntry * FE)60 bool isParsed(SourceLocation Loc, FileID FID, const FileEntry *FE) {
61 return false;
62 }
finished()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:
IndexPPCallbacks(Preprocessor & PP,IndexingContext & indexCtx)253 IndexPPCallbacks(Preprocessor &PP, IndexingContext &indexCtx)
254 : PP(PP), IndexCtx(indexCtx), IsMainFileEntered(false) { }
255
FileChanged(SourceLocation Loc,FileChangeReason Reason,SrcMgr::CharacteristicKind FileType,FileID PrevFID)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
InclusionDirective(SourceLocation HashLoc,const Token & IncludeTok,StringRef FileName,bool IsAngled,CharSourceRange FilenameRange,const FileEntry * File,StringRef SearchPath,StringRef RelativePath,const Module * Imported)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.
MacroDefined(const Token & Id,const MacroDirective * MD)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.
MacroUndefined(const Token & MacroNameTok,const MacroDirective * MD)286 void MacroUndefined(const Token &MacroNameTok,
287 const MacroDirective *MD) override {}
288
289 /// MacroExpands - This is called by when a macro invocation is found.
MacroExpands(const Token & MacroNameTok,const MacroDirective * MD,SourceRange Range,const MacroArgs * Args)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.
SourceRangeSkipped(SourceRange Range)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:
IndexingConsumer(IndexingContext & indexCtx,TUSkipBodyControl * skCtrl)308 IndexingConsumer(IndexingContext &indexCtx, TUSkipBodyControl *skCtrl)
309 : IndexCtx(indexCtx), SKCtrl(skCtrl) { }
310
311 // ASTConsumer Implementation
312
Initialize(ASTContext & Context)313 void Initialize(ASTContext &Context) override {
314 IndexCtx.setASTContext(Context);
315 IndexCtx.startedTranslationUnit();
316 }
317
HandleTranslationUnit(ASTContext & Ctx)318 void HandleTranslationUnit(ASTContext &Ctx) override {
319 if (SKCtrl)
320 SKCtrl->finished();
321 }
322
HandleTopLevelDecl(DeclGroupRef DG)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.
HandleTopLevelDeclInObjCContainer(DeclGroupRef D)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.
HandleInterestingDecl(DeclGroupRef D)338 void HandleInterestingDecl(DeclGroupRef D) override {}
339
HandleTagDeclDefinition(TagDecl * D)340 void HandleTagDeclDefinition(TagDecl *D) override {
341 if (!IndexCtx.shouldIndexImplicitTemplateInsts())
342 return;
343
344 if (IndexCtx.isTemplateImplicitInstantiation(D))
345 IndexCtx.indexDecl(D);
346 }
347
HandleCXXImplicitFunctionInstantiation(FunctionDecl * D)348 void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D) override {
349 if (!IndexCtx.shouldIndexImplicitTemplateInsts())
350 return;
351
352 IndexCtx.indexDecl(D);
353 }
354
shouldSkipFunctionBody(Decl * D)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
HandleDiagnostic(DiagnosticsEngine::Level level,const Diagnostic & Info)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:
IndexingFrontendAction(CXClientData clientData,IndexerCallbacks & indexCallbacks,unsigned indexOptions,CXTranslationUnit cxTU,SessionSkipBodyData * skData)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
CreateASTConsumer(CompilerInstance & CI,StringRef InFile)417 std::unique_ptr<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(llvm::make_unique<IndexPPCallbacks>(PP, IndexCtx));
429 IndexCtx.setPreprocessor(PP);
430
431 if (SKData) {
432 auto *PPRec = new PPConditionalDirectiveRecord(PP.getSourceManager());
433 PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(PPRec));
434 SKCtrl = llvm::make_unique<TUSkipBodyControl>(*SKData, *PPRec, PP);
435 }
436
437 return llvm::make_unique<IndexingConsumer>(IndexCtx, SKCtrl.get());
438 }
439
EndSourceFileAction()440 void EndSourceFileAction() override {
441 indexDiagnostics(CXTU, IndexCtx);
442 }
443
getTranslationUnitKind()444 TranslationUnitKind getTranslationUnitKind() override {
445 if (IndexCtx.shouldIndexImplicitTemplateInsts())
446 return TU_Complete;
447 else
448 return TU_Prefix;
449 }
hasCodeCompletionSupport() const450 bool hasCodeCompletionSupport() const override { return false; }
451 };
452
453 //===----------------------------------------------------------------------===//
454 // clang_indexSourceFileUnit Implementation
455 //===----------------------------------------------------------------------===//
456
457 struct IndexSessionData {
458 CXIndex CIdx;
459 std::unique_ptr<SessionSkipBodyData> SkipBodyData;
460
IndexSessionData__anonf48f73600111::IndexSessionData461 explicit IndexSessionData(CXIndex cIdx)
462 : CIdx(cIdx), SkipBodyData(new SessionSkipBodyData) {}
463 };
464
465 struct IndexSourceFileInfo {
466 CXIndexAction idxAction;
467 CXClientData client_data;
468 IndexerCallbacks *index_callbacks;
469 unsigned index_callbacks_size;
470 unsigned index_options;
471 const char *source_filename;
472 const char *const *command_line_args;
473 int num_command_line_args;
474 ArrayRef<CXUnsavedFile> unsaved_files;
475 CXTranslationUnit *out_TU;
476 unsigned TU_options;
477 CXErrorCode &result;
478 };
479
480 } // anonymous namespace
481
clang_indexSourceFile_Impl(void * UserData)482 static void clang_indexSourceFile_Impl(void *UserData) {
483 const IndexSourceFileInfo *ITUI =
484 static_cast<IndexSourceFileInfo *>(UserData);
485 CXIndexAction cxIdxAction = ITUI->idxAction;
486 CXClientData client_data = ITUI->client_data;
487 IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
488 unsigned index_callbacks_size = ITUI->index_callbacks_size;
489 unsigned index_options = ITUI->index_options;
490 const char *source_filename = ITUI->source_filename;
491 const char * const *command_line_args = ITUI->command_line_args;
492 int num_command_line_args = ITUI->num_command_line_args;
493 CXTranslationUnit *out_TU = ITUI->out_TU;
494 unsigned TU_options = ITUI->TU_options;
495
496 if (out_TU)
497 *out_TU = nullptr;
498 bool requestedToGetTU = (out_TU != nullptr);
499
500 if (!cxIdxAction) {
501 ITUI->result = CXError_InvalidArguments;
502 return;
503 }
504 if (!client_index_callbacks || index_callbacks_size == 0) {
505 ITUI->result = CXError_InvalidArguments;
506 return;
507 }
508
509 IndexerCallbacks CB;
510 memset(&CB, 0, sizeof(CB));
511 unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
512 ? index_callbacks_size : sizeof(CB);
513 memcpy(&CB, client_index_callbacks, ClientCBSize);
514
515 IndexSessionData *IdxSession = static_cast<IndexSessionData *>(cxIdxAction);
516 CIndexer *CXXIdx = static_cast<CIndexer *>(IdxSession->CIdx);
517
518 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
519 setThreadBackgroundPriority();
520
521 bool CaptureDiagnostics = !Logger::isLoggingEnabled();
522
523 CaptureDiagnosticConsumer *CaptureDiag = nullptr;
524 if (CaptureDiagnostics)
525 CaptureDiag = new CaptureDiagnosticConsumer();
526
527 // Configure the diagnostics.
528 IntrusiveRefCntPtr<DiagnosticsEngine>
529 Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions,
530 CaptureDiag,
531 /*ShouldOwnClient=*/true));
532
533 // Recover resources if we crash before exiting this function.
534 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
535 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
536 DiagCleanup(Diags.get());
537
538 std::unique_ptr<std::vector<const char *>> Args(
539 new std::vector<const char *>());
540
541 // Recover resources if we crash before exiting this method.
542 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
543 ArgsCleanup(Args.get());
544
545 Args->insert(Args->end(), command_line_args,
546 command_line_args + num_command_line_args);
547
548 // The 'source_filename' argument is optional. If the caller does not
549 // specify it then it is assumed that the source file is specified
550 // in the actual argument list.
551 // Put the source file after command_line_args otherwise if '-x' flag is
552 // present it will be unused.
553 if (source_filename)
554 Args->push_back(source_filename);
555
556 IntrusiveRefCntPtr<CompilerInvocation>
557 CInvok(createInvocationFromCommandLine(*Args, Diags));
558
559 if (!CInvok)
560 return;
561
562 // Recover resources if we crash before exiting this function.
563 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInvocation,
564 llvm::CrashRecoveryContextReleaseRefCleanup<CompilerInvocation> >
565 CInvokCleanup(CInvok.get());
566
567 if (CInvok->getFrontendOpts().Inputs.empty())
568 return;
569
570 typedef SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 8> MemBufferOwner;
571 std::unique_ptr<MemBufferOwner> BufOwner(new MemBufferOwner);
572
573 // Recover resources if we crash before exiting this method.
574 llvm::CrashRecoveryContextCleanupRegistrar<MemBufferOwner> BufOwnerCleanup(
575 BufOwner.get());
576
577 for (auto &UF : ITUI->unsaved_files) {
578 std::unique_ptr<llvm::MemoryBuffer> MB =
579 llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
580 CInvok->getPreprocessorOpts().addRemappedFile(UF.Filename, MB.get());
581 BufOwner->push_back(std::move(MB));
582 }
583
584 // Since libclang is primarily used by batch tools dealing with
585 // (often very broken) source code, where spell-checking can have a
586 // significant negative impact on performance (particularly when
587 // precompiled headers are involved), we disable it.
588 CInvok->getLangOpts()->SpellChecking = false;
589
590 if (index_options & CXIndexOpt_SuppressWarnings)
591 CInvok->getDiagnosticOpts().IgnoreWarnings = true;
592
593 ASTUnit *Unit = ASTUnit::create(CInvok.get(), Diags,
594 CaptureDiagnostics,
595 /*UserFilesAreVolatile=*/true);
596 if (!Unit) {
597 ITUI->result = CXError_InvalidArguments;
598 return;
599 }
600
601 std::unique_ptr<CXTUOwner> CXTU(
602 new CXTUOwner(MakeCXTranslationUnit(CXXIdx, Unit)));
603
604 // Recover resources if we crash before exiting this method.
605 llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner>
606 CXTUCleanup(CXTU.get());
607
608 // Enable the skip-parsed-bodies optimization only for C++; this may be
609 // revisited.
610 bool SkipBodies = (index_options & CXIndexOpt_SkipParsedBodiesInSession) &&
611 CInvok->getLangOpts()->CPlusPlus;
612 if (SkipBodies)
613 CInvok->getFrontendOpts().SkipFunctionBodies = true;
614
615 std::unique_ptr<IndexingFrontendAction> IndexAction;
616 IndexAction.reset(new IndexingFrontendAction(client_data, CB,
617 index_options, CXTU->getTU(),
618 SkipBodies ? IdxSession->SkipBodyData.get() : nullptr));
619
620 // Recover resources if we crash before exiting this method.
621 llvm::CrashRecoveryContextCleanupRegistrar<IndexingFrontendAction>
622 IndexActionCleanup(IndexAction.get());
623
624 bool Persistent = requestedToGetTU;
625 bool OnlyLocalDecls = false;
626 bool PrecompilePreamble = false;
627 bool CacheCodeCompletionResults = false;
628 PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts();
629 PPOpts.AllowPCHWithCompilerErrors = true;
630
631 if (requestedToGetTU) {
632 OnlyLocalDecls = CXXIdx->getOnlyLocalDecls();
633 PrecompilePreamble = TU_options & CXTranslationUnit_PrecompiledPreamble;
634 // FIXME: Add a flag for modules.
635 CacheCodeCompletionResults
636 = TU_options & CXTranslationUnit_CacheCompletionResults;
637 }
638
639 if (TU_options & CXTranslationUnit_DetailedPreprocessingRecord) {
640 PPOpts.DetailedRecord = true;
641 }
642
643 if (!requestedToGetTU && !CInvok->getLangOpts()->Modules)
644 PPOpts.DetailedRecord = false;
645
646 DiagnosticErrorTrap DiagTrap(*Diags);
647 bool Success = ASTUnit::LoadFromCompilerInvocationAction(CInvok.get(), Diags,
648 IndexAction.get(),
649 Unit,
650 Persistent,
651 CXXIdx->getClangResourcesPath(),
652 OnlyLocalDecls,
653 CaptureDiagnostics,
654 PrecompilePreamble,
655 CacheCodeCompletionResults,
656 /*IncludeBriefCommentsInCodeCompletion=*/false,
657 /*UserFilesAreVolatile=*/true);
658 if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics())
659 printDiagsToStderr(Unit);
660
661 if (isASTReadError(Unit)) {
662 ITUI->result = CXError_ASTReadError;
663 return;
664 }
665
666 if (!Success)
667 return;
668
669 if (out_TU)
670 *out_TU = CXTU->takeTU();
671
672 ITUI->result = CXError_Success;
673 }
674
675 //===----------------------------------------------------------------------===//
676 // clang_indexTranslationUnit Implementation
677 //===----------------------------------------------------------------------===//
678
679 namespace {
680
681 struct IndexTranslationUnitInfo {
682 CXIndexAction idxAction;
683 CXClientData client_data;
684 IndexerCallbacks *index_callbacks;
685 unsigned index_callbacks_size;
686 unsigned index_options;
687 CXTranslationUnit TU;
688 int result;
689 };
690
691 } // anonymous namespace
692
indexPreprocessingRecord(ASTUnit & Unit,IndexingContext & IdxCtx)693 static void indexPreprocessingRecord(ASTUnit &Unit, IndexingContext &IdxCtx) {
694 Preprocessor &PP = Unit.getPreprocessor();
695 if (!PP.getPreprocessingRecord())
696 return;
697
698 // FIXME: Only deserialize inclusion directives.
699
700 PreprocessingRecord::iterator I, E;
701 std::tie(I, E) = Unit.getLocalPreprocessingEntities();
702
703 bool isModuleFile = Unit.isModuleFile();
704 for (; I != E; ++I) {
705 PreprocessedEntity *PPE = *I;
706
707 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
708 SourceLocation Loc = ID->getSourceRange().getBegin();
709 // Modules have synthetic main files as input, give an invalid location
710 // if the location points to such a file.
711 if (isModuleFile && Unit.isInMainFileID(Loc))
712 Loc = SourceLocation();
713 IdxCtx.ppIncludedFile(Loc, ID->getFileName(),
714 ID->getFile(),
715 ID->getKind() == InclusionDirective::Import,
716 !ID->wasInQuotes(), ID->importedModule());
717 }
718 }
719 }
720
topLevelDeclVisitor(void * context,const Decl * D)721 static bool topLevelDeclVisitor(void *context, const Decl *D) {
722 IndexingContext &IdxCtx = *static_cast<IndexingContext*>(context);
723 IdxCtx.indexTopLevelDecl(D);
724 if (IdxCtx.shouldAbort())
725 return false;
726 return true;
727 }
728
indexTranslationUnit(ASTUnit & Unit,IndexingContext & IdxCtx)729 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IdxCtx) {
730 Unit.visitLocalTopLevelDecls(&IdxCtx, topLevelDeclVisitor);
731 }
732
indexDiagnostics(CXTranslationUnit TU,IndexingContext & IdxCtx)733 static void indexDiagnostics(CXTranslationUnit TU, IndexingContext &IdxCtx) {
734 if (!IdxCtx.hasDiagnosticCallback())
735 return;
736
737 CXDiagnosticSetImpl *DiagSet = cxdiag::lazyCreateDiags(TU);
738 IdxCtx.handleDiagnosticSet(DiagSet);
739 }
740
clang_indexTranslationUnit_Impl(void * UserData)741 static void clang_indexTranslationUnit_Impl(void *UserData) {
742 IndexTranslationUnitInfo *ITUI =
743 static_cast<IndexTranslationUnitInfo*>(UserData);
744 CXTranslationUnit TU = ITUI->TU;
745 CXClientData client_data = ITUI->client_data;
746 IndexerCallbacks *client_index_callbacks = ITUI->index_callbacks;
747 unsigned index_callbacks_size = ITUI->index_callbacks_size;
748 unsigned index_options = ITUI->index_options;
749
750 // Set up the initial return value.
751 ITUI->result = CXError_Failure;
752
753 // Check arguments.
754 if (isNotUsableTU(TU)) {
755 LOG_BAD_TU(TU);
756 ITUI->result = CXError_InvalidArguments;
757 return;
758 }
759 if (!client_index_callbacks || index_callbacks_size == 0) {
760 ITUI->result = CXError_InvalidArguments;
761 return;
762 }
763
764 CIndexer *CXXIdx = TU->CIdx;
765 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
766 setThreadBackgroundPriority();
767
768 IndexerCallbacks CB;
769 memset(&CB, 0, sizeof(CB));
770 unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
771 ? index_callbacks_size : sizeof(CB);
772 memcpy(&CB, client_index_callbacks, ClientCBSize);
773
774 std::unique_ptr<IndexingContext> IndexCtx;
775 IndexCtx.reset(new IndexingContext(client_data, CB, index_options, TU));
776
777 // Recover resources if we crash before exiting this method.
778 llvm::CrashRecoveryContextCleanupRegistrar<IndexingContext>
779 IndexCtxCleanup(IndexCtx.get());
780
781 std::unique_ptr<IndexingConsumer> IndexConsumer;
782 IndexConsumer.reset(new IndexingConsumer(*IndexCtx, nullptr));
783
784 // Recover resources if we crash before exiting this method.
785 llvm::CrashRecoveryContextCleanupRegistrar<IndexingConsumer>
786 IndexConsumerCleanup(IndexConsumer.get());
787
788 ASTUnit *Unit = cxtu::getASTUnit(TU);
789 if (!Unit)
790 return;
791
792 ASTUnit::ConcurrencyCheck Check(*Unit);
793
794 if (const FileEntry *PCHFile = Unit->getPCHFile())
795 IndexCtx->importedPCH(PCHFile);
796
797 FileManager &FileMgr = Unit->getFileManager();
798
799 if (Unit->getOriginalSourceFileName().empty())
800 IndexCtx->enteredMainFile(nullptr);
801 else
802 IndexCtx->enteredMainFile(FileMgr.getFile(Unit->getOriginalSourceFileName()));
803
804 IndexConsumer->Initialize(Unit->getASTContext());
805
806 indexPreprocessingRecord(*Unit, *IndexCtx);
807 indexTranslationUnit(*Unit, *IndexCtx);
808 indexDiagnostics(TU, *IndexCtx);
809
810 ITUI->result = CXError_Success;
811 }
812
813 //===----------------------------------------------------------------------===//
814 // libclang public APIs.
815 //===----------------------------------------------------------------------===//
816
817 extern "C" {
818
clang_index_isEntityObjCContainerKind(CXIdxEntityKind K)819 int clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
820 return CXIdxEntity_ObjCClass <= K && K <= CXIdxEntity_ObjCCategory;
821 }
822
823 const CXIdxObjCContainerDeclInfo *
clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo * DInfo)824 clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *DInfo) {
825 if (!DInfo)
826 return nullptr;
827
828 const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
829 if (const ObjCContainerDeclInfo *
830 ContInfo = dyn_cast<ObjCContainerDeclInfo>(DI))
831 return &ContInfo->ObjCContDeclInfo;
832
833 return nullptr;
834 }
835
836 const CXIdxObjCInterfaceDeclInfo *
clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo * DInfo)837 clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo *DInfo) {
838 if (!DInfo)
839 return nullptr;
840
841 const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
842 if (const ObjCInterfaceDeclInfo *
843 InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
844 return &InterInfo->ObjCInterDeclInfo;
845
846 return nullptr;
847 }
848
849 const CXIdxObjCCategoryDeclInfo *
clang_index_getObjCCategoryDeclInfo(const CXIdxDeclInfo * DInfo)850 clang_index_getObjCCategoryDeclInfo(const CXIdxDeclInfo *DInfo){
851 if (!DInfo)
852 return nullptr;
853
854 const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
855 if (const ObjCCategoryDeclInfo *
856 CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
857 return &CatInfo->ObjCCatDeclInfo;
858
859 return nullptr;
860 }
861
862 const CXIdxObjCProtocolRefListInfo *
clang_index_getObjCProtocolRefListInfo(const CXIdxDeclInfo * DInfo)863 clang_index_getObjCProtocolRefListInfo(const CXIdxDeclInfo *DInfo) {
864 if (!DInfo)
865 return nullptr;
866
867 const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
868
869 if (const ObjCInterfaceDeclInfo *
870 InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
871 return InterInfo->ObjCInterDeclInfo.protocols;
872
873 if (const ObjCProtocolDeclInfo *
874 ProtInfo = dyn_cast<ObjCProtocolDeclInfo>(DI))
875 return &ProtInfo->ObjCProtoRefListInfo;
876
877 if (const ObjCCategoryDeclInfo *CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
878 return CatInfo->ObjCCatDeclInfo.protocols;
879
880 return nullptr;
881 }
882
883 const CXIdxObjCPropertyDeclInfo *
clang_index_getObjCPropertyDeclInfo(const CXIdxDeclInfo * DInfo)884 clang_index_getObjCPropertyDeclInfo(const CXIdxDeclInfo *DInfo) {
885 if (!DInfo)
886 return nullptr;
887
888 const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
889 if (const ObjCPropertyDeclInfo *PropInfo = dyn_cast<ObjCPropertyDeclInfo>(DI))
890 return &PropInfo->ObjCPropDeclInfo;
891
892 return nullptr;
893 }
894
895 const CXIdxIBOutletCollectionAttrInfo *
clang_index_getIBOutletCollectionAttrInfo(const CXIdxAttrInfo * AInfo)896 clang_index_getIBOutletCollectionAttrInfo(const CXIdxAttrInfo *AInfo) {
897 if (!AInfo)
898 return nullptr;
899
900 const AttrInfo *DI = static_cast<const AttrInfo *>(AInfo);
901 if (const IBOutletCollectionInfo *
902 IBInfo = dyn_cast<IBOutletCollectionInfo>(DI))
903 return &IBInfo->IBCollInfo;
904
905 return nullptr;
906 }
907
908 const CXIdxCXXClassDeclInfo *
clang_index_getCXXClassDeclInfo(const CXIdxDeclInfo * DInfo)909 clang_index_getCXXClassDeclInfo(const CXIdxDeclInfo *DInfo) {
910 if (!DInfo)
911 return nullptr;
912
913 const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
914 if (const CXXClassDeclInfo *ClassInfo = dyn_cast<CXXClassDeclInfo>(DI))
915 return &ClassInfo->CXXClassInfo;
916
917 return nullptr;
918 }
919
920 CXIdxClientContainer
clang_index_getClientContainer(const CXIdxContainerInfo * info)921 clang_index_getClientContainer(const CXIdxContainerInfo *info) {
922 if (!info)
923 return nullptr;
924 const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
925 return Container->IndexCtx->getClientContainerForDC(Container->DC);
926 }
927
clang_index_setClientContainer(const CXIdxContainerInfo * info,CXIdxClientContainer client)928 void clang_index_setClientContainer(const CXIdxContainerInfo *info,
929 CXIdxClientContainer client) {
930 if (!info)
931 return;
932 const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
933 Container->IndexCtx->addContainerInMap(Container->DC, client);
934 }
935
clang_index_getClientEntity(const CXIdxEntityInfo * info)936 CXIdxClientEntity clang_index_getClientEntity(const CXIdxEntityInfo *info) {
937 if (!info)
938 return nullptr;
939 const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
940 return Entity->IndexCtx->getClientEntity(Entity->Dcl);
941 }
942
clang_index_setClientEntity(const CXIdxEntityInfo * info,CXIdxClientEntity client)943 void clang_index_setClientEntity(const CXIdxEntityInfo *info,
944 CXIdxClientEntity client) {
945 if (!info)
946 return;
947 const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
948 Entity->IndexCtx->setClientEntity(Entity->Dcl, client);
949 }
950
clang_IndexAction_create(CXIndex CIdx)951 CXIndexAction clang_IndexAction_create(CXIndex CIdx) {
952 return new IndexSessionData(CIdx);
953 }
954
clang_IndexAction_dispose(CXIndexAction idxAction)955 void clang_IndexAction_dispose(CXIndexAction idxAction) {
956 if (idxAction)
957 delete static_cast<IndexSessionData *>(idxAction);
958 }
959
clang_indexSourceFile(CXIndexAction idxAction,CXClientData client_data,IndexerCallbacks * index_callbacks,unsigned index_callbacks_size,unsigned index_options,const char * source_filename,const char * const * command_line_args,int num_command_line_args,struct CXUnsavedFile * unsaved_files,unsigned num_unsaved_files,CXTranslationUnit * out_TU,unsigned TU_options)960 int clang_indexSourceFile(CXIndexAction idxAction,
961 CXClientData client_data,
962 IndexerCallbacks *index_callbacks,
963 unsigned index_callbacks_size,
964 unsigned index_options,
965 const char *source_filename,
966 const char * const *command_line_args,
967 int num_command_line_args,
968 struct CXUnsavedFile *unsaved_files,
969 unsigned num_unsaved_files,
970 CXTranslationUnit *out_TU,
971 unsigned TU_options) {
972 LOG_FUNC_SECTION {
973 *Log << source_filename << ": ";
974 for (int i = 0; i != num_command_line_args; ++i)
975 *Log << command_line_args[i] << " ";
976 }
977
978 if (num_unsaved_files && !unsaved_files)
979 return CXError_InvalidArguments;
980
981 CXErrorCode result = CXError_Failure;
982 IndexSourceFileInfo ITUI = {
983 idxAction,
984 client_data,
985 index_callbacks,
986 index_callbacks_size,
987 index_options,
988 source_filename,
989 command_line_args,
990 num_command_line_args,
991 llvm::makeArrayRef(unsaved_files, num_unsaved_files),
992 out_TU,
993 TU_options,
994 result};
995
996 if (getenv("LIBCLANG_NOTHREADS")) {
997 clang_indexSourceFile_Impl(&ITUI);
998 return result;
999 }
1000
1001 llvm::CrashRecoveryContext CRC;
1002
1003 if (!RunSafely(CRC, clang_indexSourceFile_Impl, &ITUI)) {
1004 fprintf(stderr, "libclang: crash detected during indexing source file: {\n");
1005 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename);
1006 fprintf(stderr, " 'command_line_args' : [");
1007 for (int i = 0; i != num_command_line_args; ++i) {
1008 if (i)
1009 fprintf(stderr, ", ");
1010 fprintf(stderr, "'%s'", command_line_args[i]);
1011 }
1012 fprintf(stderr, "],\n");
1013 fprintf(stderr, " 'unsaved_files' : [");
1014 for (unsigned i = 0; i != num_unsaved_files; ++i) {
1015 if (i)
1016 fprintf(stderr, ", ");
1017 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
1018 unsaved_files[i].Length);
1019 }
1020 fprintf(stderr, "],\n");
1021 fprintf(stderr, " 'options' : %d,\n", TU_options);
1022 fprintf(stderr, "}\n");
1023
1024 return 1;
1025 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
1026 if (out_TU)
1027 PrintLibclangResourceUsage(*out_TU);
1028 }
1029
1030 return result;
1031 }
1032
clang_indexTranslationUnit(CXIndexAction idxAction,CXClientData client_data,IndexerCallbacks * index_callbacks,unsigned index_callbacks_size,unsigned index_options,CXTranslationUnit TU)1033 int clang_indexTranslationUnit(CXIndexAction idxAction,
1034 CXClientData client_data,
1035 IndexerCallbacks *index_callbacks,
1036 unsigned index_callbacks_size,
1037 unsigned index_options,
1038 CXTranslationUnit TU) {
1039 LOG_FUNC_SECTION {
1040 *Log << TU;
1041 }
1042
1043 IndexTranslationUnitInfo ITUI = { idxAction, client_data, index_callbacks,
1044 index_callbacks_size, index_options, TU,
1045 0 };
1046
1047 if (getenv("LIBCLANG_NOTHREADS")) {
1048 clang_indexTranslationUnit_Impl(&ITUI);
1049 return ITUI.result;
1050 }
1051
1052 llvm::CrashRecoveryContext CRC;
1053
1054 if (!RunSafely(CRC, clang_indexTranslationUnit_Impl, &ITUI)) {
1055 fprintf(stderr, "libclang: crash detected during indexing TU\n");
1056
1057 return 1;
1058 }
1059
1060 return ITUI.result;
1061 }
1062
clang_indexLoc_getFileLocation(CXIdxLoc location,CXIdxClientFile * indexFile,CXFile * file,unsigned * line,unsigned * column,unsigned * offset)1063 void clang_indexLoc_getFileLocation(CXIdxLoc location,
1064 CXIdxClientFile *indexFile,
1065 CXFile *file,
1066 unsigned *line,
1067 unsigned *column,
1068 unsigned *offset) {
1069 if (indexFile) *indexFile = nullptr;
1070 if (file) *file = nullptr;
1071 if (line) *line = 0;
1072 if (column) *column = 0;
1073 if (offset) *offset = 0;
1074
1075 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
1076 if (!location.ptr_data[0] || Loc.isInvalid())
1077 return;
1078
1079 IndexingContext &IndexCtx =
1080 *static_cast<IndexingContext*>(location.ptr_data[0]);
1081 IndexCtx.translateLoc(Loc, indexFile, file, line, column, offset);
1082 }
1083
clang_indexLoc_getCXSourceLocation(CXIdxLoc location)1084 CXSourceLocation clang_indexLoc_getCXSourceLocation(CXIdxLoc location) {
1085 SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
1086 if (!location.ptr_data[0] || Loc.isInvalid())
1087 return clang_getNullLocation();
1088
1089 IndexingContext &IndexCtx =
1090 *static_cast<IndexingContext*>(location.ptr_data[0]);
1091 return cxloc::translateSourceLocation(IndexCtx.getASTContext(), Loc);
1092 }
1093
1094 } // end: extern "C"
1095
1096