WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h

Rev	Author	Line No.	Line
14	pmbaty	1	//== AnalysisManager.h - Path sensitive analysis data manager ------- C++ --//
		2	//
		3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
		4	// See https://llvm.org/LICENSE.txt for license information.
		5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
		6	//
		7	//===----------------------------------------------------------------------===//
		8	//
		9	// This file defines the AnalysisManager class that manages the data and policy
		10	// for path sensitive analysis.
		11	//
		12	//===----------------------------------------------------------------------===//
		13
		14	#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
		15	#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
		16
		17	#include "clang/Analysis/AnalysisDeclContext.h"
		18	#include "clang/Analysis/PathDiagnostic.h"
		19	#include "clang/Lex/Preprocessor.h"
		20	#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
		21	#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
		22	#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
		23
		24	namespace clang {
		25
		26	class CodeInjector;
		27
		28	namespace ento {
		29	class CheckerManager;
		30
		31	class AnalysisManager : public BugReporterData {
		32	virtual void anchor();
		33	AnalysisDeclContextManager AnaCtxMgr;
		34
		35	ASTContext &Ctx;
		36	Preprocessor &PP;
		37	const LangOptions &LangOpts;
		38	PathDiagnosticConsumers PathConsumers;
		39
		40	// Configurable components creators.
		41	StoreManagerCreator CreateStoreMgr;
		42	ConstraintManagerCreator CreateConstraintMgr;
		43
		44	CheckerManager *CheckerMgr;
		45
		46	public:
		47	AnalyzerOptions &options;
		48
		49	AnalysisManager(ASTContext &ctx, Preprocessor &PP,
		50	const PathDiagnosticConsumers &Consumers,
		51	StoreManagerCreator storemgr,
		52	ConstraintManagerCreator constraintmgr,
		53	CheckerManager *checkerMgr, AnalyzerOptions &Options,
		54	CodeInjector *injector = nullptr);
		55
		56	~AnalysisManager() override;
		57
		58	void ClearContexts() {
		59	AnaCtxMgr.clear();
		60	}
		61
		62	AnalysisDeclContextManager& getAnalysisDeclContextManager() {
		63	return AnaCtxMgr;
		64	}
		65
		66	Preprocessor &getPreprocessor() override { return PP; }
		67
		68	StoreManagerCreator getStoreManagerCreator() {
		69	return CreateStoreMgr;
		70	}
		71
		72	AnalyzerOptions& getAnalyzerOptions() override {
		73	return options;
		74	}
		75
		76	ConstraintManagerCreator getConstraintManagerCreator() {
		77	return CreateConstraintMgr;
		78	}
		79
		80	CheckerManager *getCheckerManager() const { return CheckerMgr; }
		81
		82	ASTContext &getASTContext() override {
		83	return Ctx;
		84	}
		85
		86	SourceManager &getSourceManager() override {
		87	return getASTContext().getSourceManager();
		88	}
		89
		90	const LangOptions &getLangOpts() const {
		91	return LangOpts;
		92	}
		93
		94	ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() override {
		95	return PathConsumers;
		96	}
		97
		98	void FlushDiagnostics();
		99
		100	bool shouldVisualize() const {
		101	return options.visualizeExplodedGraphWithGraphViz;
		102	}
		103
		104	bool shouldInlineCall() const {
		105	return options.getIPAMode() != IPAK_None;
		106	}
		107
		108	CFG getCFG(Decl const D) {
		109	return AnaCtxMgr.getContext(D)->getCFG();
		110	}
		111
		112	template <typename T>
		113	T getAnalysis(Decl const D) {
		114	return AnaCtxMgr.getContext(D)->getAnalysis<T>();
		115	}
		116
		117	ParentMap &getParentMap(Decl const *D) {
		118	return AnaCtxMgr.getContext(D)->getParentMap();
		119	}
		120
		121	AnalysisDeclContext getAnalysisDeclContext(const Decl D) {
		122	return AnaCtxMgr.getContext(D);
		123	}
		124
		125	static bool isInCodeFile(SourceLocation SL, const SourceManager &SM) {
		126	if (SM.isInMainFile(SL))
		127	return true;
		128
		129	// Support the "unified sources" compilation method (eg. WebKit) that
		130	// involves producing non-header files that include other non-header files.
		131	// We should be included directly from a UnifiedSource* file
		132	// and we shouldn't be a header - which is a very safe defensive check.
		133	SourceLocation IL = SM.getIncludeLoc(SM.getFileID(SL));
		134	if (!IL.isValid() \|\| !SM.isInMainFile(IL))
		135	return false;
		136	// Should rather be "file name starts with", but the current .getFilename
		137	// includes the full path.
		138	if (SM.getFilename(IL).contains("UnifiedSource")) {
		139	// It might be great to reuse FrontendOptions::getInputKindForExtension()
		140	// but for now it doesn't discriminate between code and header files.
		141	return llvm::StringSwitch<bool>(SM.getFilename(SL).rsplit('.').second)
		142	.Cases("c", "m", "mm", "C", "cc", "cp", true)
		143	.Cases("cpp", "CPP", "c++", "cxx", "cppm", true)
		144	.Default(false);
		145	}
		146
		147	return false;
		148	}
		149
		150	bool isInCodeFile(SourceLocation SL) {
		151	const SourceManager &SM = getASTContext().getSourceManager();
		152	return isInCodeFile(SL, SM);
		153	}
		154	};
		155
		156	} // enAnaCtxMgrspace
		157
		158	} // end clang namespace
		159
		160	#endif

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h – Rev 14