37#include "llvm/ADT/PostOrderIterator.h"
38#include "llvm/ADT/ScopeExit.h"
39#include "llvm/Support/TimeProfiler.h"
40#include "llvm/Support/Timer.h"
41#include "llvm/Support/raw_ostream.h"
49#define DEBUG_TYPE "AnalysisConsumer"
51STAT_COUNTER(NumFunctionTopLevel,
"The # of functions at top level.");
53 "The # of functions and blocks analyzed (as top level "
54 "with inlining turned on).");
56 NumFunctionsAnalyzedSyntaxOnly,
57 "The # of functions analyzed by syntax checkers only.");
59 "The # of basic blocks in the analyzed functions.");
61 NumVisitedBlocksInAnalyzedFunctions,
62 "The # of visited basic blocks in the analyzed functions.");
64 "The % of reachable basic blocks.");
65STAT_MAX(MaxCFGSize,
"The maximum number of basic blocks in a function.");
76 : Input.
getBuffer().getBufferIdentifier();
88 typedef unsigned AnalysisMode;
91 AnalysisMode RecVisitorMode;
93 BugReporter *RecVisitorBR;
95 std::vector<
std::function<void(CheckerRegistry &)>> CheckerRegistrationFns;
100 const std::string OutDir;
101 AnalyzerOptions &Opts;
102 ArrayRef<std::string> Plugins;
103 std::unique_ptr<CodeInjector> Injector;
104 cross_tu::CrossTranslationUnitContext CTU;
113 MacroExpansionContext MacroExpansions;
121 std::unique_ptr<CheckerManager> checkerMgr;
122 std::unique_ptr<AnalysisManager> Mgr;
125 std::unique_ptr<llvm::TimerGroup> AnalyzerTimers;
126 std::unique_ptr<llvm::Timer> SyntaxCheckTimer;
127 std::unique_ptr<llvm::Timer> ExprEngineTimer;
128 std::unique_ptr<llvm::Timer> BugReporterTimer;
129 bool ShouldClearTimersToPreventDisplayingThem;
133 FunctionSummariesTy FunctionSummaries;
135 AnalysisConsumer(CompilerInstance &CI,
const std::string &outdir,
136 AnalyzerOptions &opts, ArrayRef<std::string> plugins,
137 std::unique_ptr<CodeInjector> injector)
139 PP(CI.getPreprocessor()), OutDir(outdir), Opts(opts), Plugins(plugins),
140 Injector(std::move(injector)), CTU(CI),
141 MacroExpansions(CI.getLangOpts()) {
145 DigestAnalyzerOptions();
147 if (Opts.AnalyzerDisplayProgress || Opts.PrintStats ||
148 Opts.ShouldSerializeStats || !Opts.DumpEntryPointStatsToCSV.empty()) {
149 AnalyzerTimers = std::make_unique<llvm::TimerGroup>(
150 "analyzer",
"Analyzer timers");
151 SyntaxCheckTimer = std::make_unique<llvm::Timer>(
152 "syntaxchecks",
"Syntax-based analysis time", *AnalyzerTimers);
153 ExprEngineTimer = std::make_unique<llvm::Timer>(
154 "exprengine",
"Path exploration time", *AnalyzerTimers);
155 BugReporterTimer = std::make_unique<llvm::Timer>(
156 "bugreporter",
"Path-sensitive report post-processing time",
162 ShouldClearTimersToPreventDisplayingThem = !Opts.AnalyzerDisplayProgress &&
164 !Opts.ShouldSerializeStats;
166 if (Opts.PrintStats || Opts.ShouldSerializeStats) {
167 llvm::EnableStatistics(
false);
170 if (Opts.ShouldDisplayMacroExpansions)
171 MacroExpansions.registerForPreprocessor(PP);
174 ShouldWalkTypesOfTypeLocs =
false;
177 ~AnalysisConsumer()
override {
178 if (Opts.PrintStats) {
179 llvm::PrintStatistics();
183 void DigestAnalyzerOptions() {
184 switch (Opts.AnalysisDiagOpt) {
187#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN) \
189 CREATEFN(Opts.getDiagOpts(), PathConsumers, OutDir, PP, CTU, \
192#include "clang/StaticAnalyzer/Core/Analyses.def"
194 llvm_unreachable(
"Unknown analyzer output type!");
200 switch (Opts.AnalysisConstraintsOpt) {
202 llvm_unreachable(
"Unknown constraint manager.");
203#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATEFN) \
204 case NAME##Model: CreateConstraintMgr = CREATEFN; break;
205#include "clang/StaticAnalyzer/Core/Analyses.def"
209 void DisplayTime(llvm::TimeRecord &Time) {
210 if (!Opts.AnalyzerDisplayProgress) {
213 llvm::errs() <<
" : " << llvm::format(
"%1.1f", Time.getWallTime() * 1000)
217 void DisplayFunction(
const Decl *D, AnalysisMode Mode,
219 if (!Opts.AnalyzerDisplayProgress)
222 SourceManager &
SM = Mgr->getASTContext().getSourceManager();
225 llvm::errs() <<
"ANALYZE";
227 if (Mode == AM_Syntax)
228 llvm::errs() <<
" (Syntax)";
229 else if (Mode == AM_Path) {
230 llvm::errs() <<
" (Path, ";
233 llvm::errs() <<
" Inline_Minimal";
236 llvm::errs() <<
" Inline_Regular";
241 assert(Mode == (AM_Syntax | AM_Path) &&
"Unexpected mode!");
250 bool HandleTopLevelDecl(DeclGroupRef D)
override;
251 void HandleTopLevelDeclInObjCContainer(DeclGroupRef D)
override;
253 void HandleTranslationUnit(ASTContext &
C)
override;
259 getInliningModeForFunction(
const Decl *D,
const SetOfConstDecls &Visited);
263 void HandleDeclsCallGraph(
const unsigned LocalTUDeclsSize);
271 void HandleCode(Decl *D, AnalysisMode Mode,
275 void RunPathSensitiveChecks(Decl *D,
280 bool VisitDecl(Decl *D)
override {
281 AnalysisMode Mode = getModeForDecl(D, RecVisitorMode);
282 if (Mode & AM_Syntax) {
283 if (SyntaxCheckTimer)
284 SyntaxCheckTimer->startTimer();
285 checkerMgr->runCheckersOnASTDecl(D, *Mgr, *RecVisitorBR);
286 if (SyntaxCheckTimer)
287 SyntaxCheckTimer->stopTimer();
288 if (AnalyzerTimers && ShouldClearTimersToPreventDisplayingThem) {
289 AnalyzerTimers->clear();
295 bool VisitVarDecl(VarDecl *VD)
override {
296 if (!Opts.IsNaiveCTUEnabled)
310 llvm::Expected<const VarDecl *> CTUDeclOrError =
311 CTU.getCrossTUDefinition(VD, Opts.CTUDir, Opts.CTUIndexName,
312 Opts.DisplayCTUProgress);
314 if (!CTUDeclOrError) {
315 handleAllErrors(CTUDeclOrError.takeError(),
316 [&](
const cross_tu::IndexError &IE) {
317 CTU.emitCrossTUDiagnostics(IE);
324 bool VisitFunctionDecl(FunctionDecl *FD)
override {
326 if (II && II->
getName().starts_with(
"__inline"))
333 assert(RecVisitorMode == AM_Syntax || Mgr->shouldInlineCall() ==
false);
334 HandleCode(FD, RecVisitorMode);
339 bool VisitObjCMethodDecl(ObjCMethodDecl *MD)
override {
341 assert(RecVisitorMode == AM_Syntax || Mgr->shouldInlineCall() ==
false);
342 HandleCode(MD, RecVisitorMode);
347 bool VisitBlockDecl(BlockDecl *BD)
override {
349 assert(RecVisitorMode == AM_Syntax || Mgr->shouldInlineCall() ==
false);
353 HandleCode(BD, RecVisitorMode);
359 void AddDiagnosticConsumer(
360 std::unique_ptr<PathDiagnosticConsumer> Consumer)
override {
361 PathConsumers.push_back(std::move(Consumer));
364 void AddCheckerRegistrationFn(
std::function<
void(CheckerRegistry&)> Fn)
override {
365 CheckerRegistrationFns.push_back(std::move(Fn));
369 void storeTopLevelDecls(DeclGroupRef DG);
372 AnalysisMode getModeForDecl(Decl *D, AnalysisMode Mode);
373 void runAnalysisOnTranslationUnit(ASTContext &
C);
376 void reportAnalyzerProgress(StringRef S);
379std::string timeTraceScopeDeclName(StringRef FunName,
const Decl *D) {
380 if (llvm::timeTraceProfilerEnabled()) {
381 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(D))
382 return (FunName +
" " + ND->getQualifiedNameAsString()).str();
383 return (FunName +
" <anonymous> ").str();
388llvm::TimeTraceMetadata timeTraceScopeDeclMetadata(
const Decl *D) {
390 assert(llvm::timeTraceProfilerEnabled());
394 return llvm::TimeTraceMetadata{
395 std::move(DeclName),
SM.getFilename(
Loc).str(),
396 static_cast<int>(
SM.getExpansionLineNumber(
Loc))};
398 return llvm::TimeTraceMetadata{
"",
""};
401void flushReports(llvm::Timer *BugReporterTimer,
BugReporter &BR) {
402 llvm::TimeTraceScope TCS{
"Flushing reports"};
404 if (BugReporterTimer)
405 BugReporterTimer->startTimer();
407 if (BugReporterTimer)
408 BugReporterTimer->stopTimer();
415bool AnalysisConsumer::HandleTopLevelDecl(
DeclGroupRef DG) {
416 storeTopLevelDecls(DG);
420void AnalysisConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) {
421 storeTopLevelDecls(DG);
424void AnalysisConsumer::storeTopLevelDecls(DeclGroupRef DG) {
432 LocalTUDecls.push_back(I);
439 if (VisitedAsTopLevel.count(D))
445 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(D))
446 if (CD->isInheritingConstructor())
461 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
462 if (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())
467 return Visited.count(D);
471AnalysisConsumer::getInliningModeForFunction(
const Decl *D,
485void AnalysisConsumer::HandleDeclsCallGraph(
const unsigned LocalTUDeclsSize) {
491 for (
unsigned i = 0 ; i < LocalTUDeclsSize ; ++i) {
503 llvm::ReversePostOrderTraversal<clang::CallGraph*> RPOT(&CG);
504 for (
auto &N : RPOT) {
505 NumFunctionTopLevel++;
507 Decl *D = N->getDecl();
522 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
533 HandleCode(D, AM_Path, getInliningModeForFunction(D, Visited),
534 (Mgr->options.InliningMode ==
All ?
nullptr : &VisitedCallees));
537 for (
const Decl *Callee : VisitedCallees)
541 :
Callee->getCanonicalDecl());
542 VisitedAsTopLevel.insert(D);
549 StringRef Buffer =
SM.getBufferOrFake(FID).getBuffer();
550 return Buffer.contains(Substring);
555 llvm::errs() <<
"Every top-level function was skipped.\n";
558 llvm::errs() <<
"Pass the -analyzer-display-progress for tracking which "
559 "functions are analyzed.\n";
566 <<
"For analyzing C++ code you need to pass the function parameter "
567 "list: -analyze-function=\"foobar(int, _Bool)\"\n";
568 }
else if (!Ctx.
getLangOpts().CPlusPlus && HasBrackets) {
569 llvm::errs() <<
"For analyzing C code you shouldn't pass the function "
570 "parameter list, only the name of the function: "
571 "-analyze-function=foobar\n";
575void AnalysisConsumer::runAnalysisOnTranslationUnit(ASTContext &
C) {
576 BugReporter BR(*Mgr);
577 const TranslationUnitDecl *TU =
C.getTranslationUnitDecl();
579 if (SyntaxCheckTimer)
580 SyntaxCheckTimer->startTimer();
581 checkerMgr->runCheckersOnASTDecl(TU, *Mgr, BR);
582 if (SyntaxCheckTimer)
583 SyntaxCheckTimer->stopTimer();
584 if (AnalyzerTimers && ShouldClearTimersToPreventDisplayingThem) {
585 AnalyzerTimers->clear();
591 RecVisitorMode = AM_Syntax;
592 if (!Mgr->shouldInlineCall())
593 RecVisitorMode |= AM_Path;
602 const unsigned LocalTUDeclsSize = LocalTUDecls.size();
603 for (
unsigned i = 0 ; i < LocalTUDeclsSize ; ++i) {
604 TraverseDecl(LocalTUDecls[i]);
607 if (Mgr->shouldInlineCall())
608 HandleDeclsCallGraph(LocalTUDeclsSize);
611 checkerMgr->runCheckersOnEndOfTranslationUnit(TU, *Mgr, BR);
614 RecVisitorBR =
nullptr;
620 NumFunctionsAnalyzedSyntaxOnly == 0) {
625void AnalysisConsumer::reportAnalyzerProgress(StringRef S) {
630void AnalysisConsumer::HandleTranslationUnit(ASTContext &
C) {
637 checkerMgr = std::make_unique<CheckerManager>(*Ctx, Opts, PP, Plugins,
638 CheckerRegistrationFns);
640 Mgr = std::make_unique<AnalysisManager>(
641 *Ctx, PP, std::move(PathConsumers), CreateStoreMgr, CreateConstraintMgr,
642 checkerMgr.get(), Opts, std::move(Injector));
648 const auto DiagFlusherScopeExit =
649 llvm::make_scope_exit([
this] { Mgr.reset(); });
651 if (Opts.ShouldIgnoreBisonGeneratedFiles &&
653 reportAnalyzerProgress(
"Skipping bison-generated file\n");
657 if (Opts.ShouldIgnoreFlexGeneratedFiles &&
659 reportAnalyzerProgress(
"Skipping flex-generated file\n");
666 reportAnalyzerProgress(
"All checks are disabled using a supplied option\n");
671 runAnalysisOnTranslationUnit(
C);
675 NumVisitedBlocksInAnalyzedFunctions =
677 if (NumBlocksInAnalyzedFunctions > 0)
678 PercentReachableBlocks =
680 NumBlocksInAnalyzedFunctions;
682 if (!Opts.DumpEntryPointStatsToCSV.empty()) {
687AnalysisConsumer::AnalysisMode
688AnalysisConsumer::getModeForDecl(Decl *D, AnalysisMode Mode) {
706 const SourceLocation Loc = [&
SM](
Decl *D) -> SourceLocation {
707 const Stmt *Body = D->
getBody();
709 return SM.getExpansionLoc(SL);
717 if (!Mgr->isInCodeFile(Loc))
718 return Mode & ~AM_Path;
725void AnalysisConsumer::HandleCode(
Decl *D, AnalysisMode Mode,
728 llvm::TimeTraceScope TCS(timeTraceScopeDeclName(
"HandleCode", D),
729 [D]() {
return timeTraceScopeDeclMetadata(D); });
732 Mode = getModeForDecl(D, Mode);
737 Mgr->ClearContexts();
739 if (Mgr->getAnalysisDeclContext(D)->isBodyAutosynthesized())
742 CFG *DeclCFG = Mgr->getCFG(D);
744 MaxCFGSize.updateMax(DeclCFG->
size());
746 DisplayFunction(D, Mode, IMode);
747 BugReporter BR(*Mgr);
750 if (Mode & AM_Syntax) {
751 llvm::TimeRecord CheckerStartTime;
752 if (SyntaxCheckTimer) {
753 CheckerStartTime = SyntaxCheckTimer->getTotalTime();
754 SyntaxCheckTimer->startTimer();
756 checkerMgr->runCheckersOnASTBody(D, *Mgr, BR);
757 ++NumFunctionsAnalyzedSyntaxOnly;
758 if (SyntaxCheckTimer) {
759 SyntaxCheckTimer->stopTimer();
760 llvm::TimeRecord CheckerEndTime = SyntaxCheckTimer->getTotalTime();
761 CheckerEndTime -= CheckerStartTime;
762 DisplayTime(CheckerEndTime);
763 if (AnalyzerTimers && ShouldClearTimersToPreventDisplayingThem) {
764 AnalyzerTimers->clear();
771 if ((Mode & AM_Path) && checkerMgr->hasPathSensitiveCheckers()) {
772 RunPathSensitiveChecks(D, IMode, VisitedCallees);
775 NumFunctionsAnalyzed++;
783void AnalysisConsumer::RunPathSensitiveChecks(Decl *D,
792 if (!Mgr->getAnalysisDeclContext(D)->getAnalysis<RelaxedLiveVariables>())
795 ExprEngine Eng(CTU, *Mgr, VisitedCallees, &FunctionSummaries, IMode);
798 llvm::TimeRecord ExprEngineStartTime;
799 if (ExprEngineTimer) {
800 ExprEngineStartTime = ExprEngineTimer->getTotalTime();
801 ExprEngineTimer->startTimer();
803 Eng.ExecuteWorkList(Mgr->getAnalysisDeclContextManager().getStackFrame(D),
804 Mgr->options.MaxNodesPerTopLevelFunction);
805 if (ExprEngineTimer) {
806 ExprEngineTimer->stopTimer();
807 llvm::TimeRecord ExprEngineEndTime = ExprEngineTimer->getTotalTime();
808 ExprEngineEndTime -= ExprEngineStartTime;
810 std::lround(ExprEngineEndTime.getWallTime() * 1000)));
811 DisplayTime(ExprEngineEndTime);
812 if (AnalyzerTimers && ShouldClearTimersToPreventDisplayingThem) {
813 AnalyzerTimers->clear();
817 if (!Mgr->options.DumpExplodedGraphTo.empty())
818 Eng.DumpGraph(Mgr->options.TrimGraph, Mgr->options.DumpExplodedGraphTo);
821 if (Mgr->options.visualizeExplodedGraphWithGraphViz)
822 Eng.ViewGraph(Mgr->options.TrimGraph);
824 flushReports(BugReporterTimer.get(), Eng.getBugReporter());
825 if (AnalyzerTimers && ShouldClearTimersToPreventDisplayingThem) {
826 AnalyzerTimers->clear();
834std::unique_ptr<AnalysisASTConsumer>
840 bool hasModelPath = analyzerOpts.
Config.count(
"model-path") > 0;
842 return std::make_unique<AnalysisConsumer>(
845 hasModelPath ? std::make_unique<ModelInjector>(CI) :
nullptr);
static UnsignedEPStat PathRunningTime("PathRunningTime")
ALWAYS_ENABLED_STATISTIC(NumFunctionsAnalyzed, "The # of functions and blocks analyzed (as top level " "with inlining turned on).")
static bool shouldSkipFunction(const Decl *D, const SetOfConstDecls &Visited, const SetOfConstDecls &VisitedAsTopLevel)
static bool fileContainsString(StringRef Substring, ASTContext &C)
static void reportAnalyzerFunctionMisuse(const AnalyzerOptions &Opts, const ASTContext &Ctx)
Defines the clang::CodeInjector interface which is responsible for injecting AST of function definiti...
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
#define STAT_COUNTER(VARNAME, DESC)
#define STAT_MAX(VARNAME, DESC)
This file defines the clang::ento::ModelInjector class which implements the clang::CodeInjector inter...
Defines the clang::Preprocessor interface.
Defines the SourceManager interface.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
const LangOptions & getLangOpts() const
static std::string getFunctionName(const Decl *D)
Stores options for the analyzer from the command line.
unsigned DisableAllCheckers
Disable all analyzer checkers.
ConfigTable Config
A key-value table of use-specified configuration values.
std::string AnalyzeSpecificFunction
unsigned AnalyzerDisplayProgress
unsigned size() const
Return the total number of CFGBlocks within the CFG This is simply a renaming of the getNumBlockIDs()...
void addToCallGraph(Decl *D)
Populate the call graph with the functions in the given declaration.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
AnalyzerOptions & getAnalyzerOpts()
Preprocessor & getPreprocessor() const
Return the current preprocessor.
ASTContext & getASTContext() const
FrontendOptions & getFrontendOpts()
CompilerInvocation & getInvocation()
Helper class for holding the data necessary to invoke the compiler.
FrontendOptions & getFrontendOpts()
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
virtual bool hasBody() const
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool hasErrorOccurred() const
void setWarningsAsErrors(bool Val)
When set to true, any warnings reported are issued as errors.
bool hasFatalErrorOccurred() const
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
std::string OutputFile
The output file, if any.
std::vector< std::string > Plugins
The list of plugins to load.
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
StringRef getName() const
Return the actual identifier string.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
bool isThisDeclarationADefinition() const
Returns whether this specific method is a definition.
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
DiagnosticsEngine & getDiagnostics() const
const char * getFilename() const
Return the presumed filename of this location.
This class handles loading and caching of source files into memory.
SourceLocation getBeginLoc() const LLVM_READONLY
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
static std::optional< std::string > getLookupName(const Decl *D)
Get a name to identify a decl.
bool isImportedAsNew(const Decl *ToDecl) const
Returns true if the given Decl is newly created during the import.
BugReporter is a utility class for generating PathDiagnostics for analysis.
void FlushReports()
Generate and flush diagnostics for all bug reports.
void setAnalysisEntryPoint(const Decl *EntryPoint)
bool isValid() const =delete
static void dumpStatsAsCSV(llvm::raw_ostream &OS)
static void lockRegistry(llvm::StringRef CPPFileName, ASTContext &Ctx)
static void takeSnapshot(const Decl *EntryPoint)
InliningModes
The modes of inlining, which override the default analysis-wide settings.
@ Inline_Minimal
Do minimal inlining of callees.
@ Inline_Regular
Follow the default settings for inlining callees.
unsigned getTotalNumBasicBlocks()
unsigned getTotalNumVisitedBasicBlocks()
bool shouldImport(const VarDecl *VD, const ASTContext &ACtx)
Returns true if it makes sense to import a foreign variable definition.
std::deque< Decl * > SetOfDecls
std::unique_ptr< AnalysisASTConsumer > CreateAnalysisConsumer(CompilerInstance &CI)
CreateAnalysisConsumer - Creates an ASTConsumer to run various code analysis passes.
llvm::DenseSet< const Decl * > SetOfConstDecls
std::unique_ptr< ConstraintManager >(* ConstraintManagerCreator)(ProgramStateManager &, ExprEngine *)
std::unique_ptr< StoreManager >(* StoreManagerCreator)(ProgramStateManager &)
std::vector< std::unique_ptr< PathDiagnosticConsumer > > PathDiagnosticConsumers
std::unique_ptr< StoreManager > CreateRegionStoreManager(ProgramStateManager &StMgr)
std::variant< struct RequiresDecl, struct HeaderDecl, struct UmbrellaDirDecl, struct ModuleDecl, struct ExcludeDecl, struct ExportDecl, struct ExportAsDecl, struct ExternModuleDecl, struct UseDecl, struct LinkDecl, struct ConfigMacrosDecl, struct ConflictDecl > Decl
All declarations that can appear in a module declaration.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
DynamicRecursiveASTVisitorBase< false > DynamicRecursiveASTVisitor
U cast(CodeGen::Address addr)
int const char * function