[v0.0.3] Compiler environment cache support

DronCode · Mar 21, 2024 · f1da3b6 · f1da3b6
1 parent a35a482
commit f1da3b6
Show file tree

Hide file tree

Showing 3 changed files with 55 additions and 10 deletions.
diff --git a/LLVM/include/RG3/LLVM/CodeAnalyzer.h b/LLVM/include/RG3/LLVM/CodeAnalyzer.h
@@ -1,10 +1,12 @@
 #pragma once
 
+#include <RG3/LLVM/CompilerConfigDetector.h>
 #include <RG3/LLVM/CompilerConfig.h>
 #include <RG3/Cpp/TypeBase.h>
 #include <filesystem>
 #include <variant>
 #include <cstdint>
+#include <optional>
 #include <span>
 
 
@@ -40,12 +42,14 @@ namespace rg3::llvm
 
 		void setSourceCode(const std::string& sourceCode);
 		void setSourceFile(const std::filesystem::path& sourceFile);
+		void setCompilerEnvironment(const CompilerEnvironment& env);
 		CompilerConfig& getCompilerConfig();
 
 		AnalyzerResult analyze();
 
 	 private:
 		std::variant<std::filesystem::path, std::string> m_source;
+		std::optional<CompilerEnvironment> m_env;
 		CompilerConfig m_compilerConfig;
 	};
 }
diff --git a/LLVM/source/CodeAnalyzer.cpp b/LLVM/source/CodeAnalyzer.cpp
@@ -111,6 +111,11 @@ namespace rg3::llvm
 		m_source.emplace<std::filesystem::path>(sourceFile);
 	}
 
+	void CodeAnalyzer::setCompilerEnvironment(const CompilerEnvironment& env)
+	{
+		m_env = env;
+	}
+
 	CompilerConfig& CodeAnalyzer::getCompilerConfig()
 	{
 		return m_compilerConfig;
@@ -140,18 +145,24 @@ namespace rg3::llvm
 	AnalyzerResult CodeAnalyzer::analyze()
 	{
 		AnalyzerResult result;
-
+		const CompilerEnvironment* pCompilerEnv = nullptr;
 		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 		// Run platform env detector
-		const auto compilerEnvironment = CompilerConfigDetector::detectSystemCompilerEnvironment();
-		if (auto pEnvFailure = std::get_if<CompilerEnvError>(&compilerEnvironment))
+		if (!m_env.has_value())
 		{
-			// Fatal error
-			result.vIssues.emplace_back(AnalyzerResult::CompilerIssue { AnalyzerResult::CompilerIssue::IssueKind::IK_ERROR, sourceToString(m_source), 0, 0, pEnvFailure->message });
-			return result;
+			const auto compilerEnvironment = CompilerConfigDetector::detectSystemCompilerEnvironment();
+			if (auto pEnvFailure = std::get_if<CompilerEnvError>(&compilerEnvironment))
+			{
+				// Fatal error
+				result.vIssues.emplace_back(AnalyzerResult::CompilerIssue { AnalyzerResult::CompilerIssue::IssueKind::IK_ERROR, sourceToString(m_source), 0, 0, pEnvFailure->message });
+				return result;
+			}
+
+			// Override env
+			m_env = *std::get_if<CompilerEnvironment>(&compilerEnvironment);
 		}
 
-		const auto* pCompilerEnv = std::get_if<CompilerEnvironment>(&compilerEnvironment);
+		pCompilerEnv = &m_env.value();
 
 		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

diff --git a/PyBind/source/PyAnalyzerContext.cpp b/PyBind/source/PyAnalyzerContext.cpp
@@ -4,6 +4,7 @@
 #include <RG3/PyBind/PyTypeEnum.h>
 #include <RG3/PyBind/PyTypeAlias.h>
 #include <RG3/LLVM/CodeAnalyzer.h>
+#include <RG3/LLVM/CompilerConfigDetector.h>
 #include <RG3/Cpp/TransactionGuard.h>
 #include <RG3/Cpp/TypeClass.h>
 #include <RG3/Cpp/TypeEnum.h>
@@ -91,6 +92,7 @@ namespace rg3::pybind
 		std::mutex lockMtx;
 		Storage tasks;
 		std::vector<std::thread> workers;
+		std::optional<rg3::llvm::CompilerEnvironment> m_compilerEnv {};
 
 		PyFoundSubjects* pAnalyzerStorage{ nullptr };
 
@@ -161,6 +163,11 @@ namespace rg3::pybind
 			return Transaction(lockMtx, tasks);
 		}
 
+		void setCompilerEnvironment(const rg3::llvm::CompilerEnvironment& compilerEnv)
+		{
+			m_compilerEnv = compilerEnv;
+		}
+
 		bool runWorkers(int workersAmount)
 		{
 			if (workersAmount <= 1)
@@ -173,7 +180,7 @@ namespace rg3::pybind
 			{
 				std::thread worker {
 					[this, iWorkerIndex = static_cast<size_t>(i)]() {
-						workerEntryPoint(iWorkerIndex);
+						workerEntryPoint(iWorkerIndex, m_compilerEnv);
 					}
 				};
 
@@ -193,12 +200,13 @@ namespace rg3::pybind
 		}
 
 	 private:
-		void workerEntryPoint(size_t iWorkerId)
+		void workerEntryPoint(size_t iWorkerId, const std::optional<rg3::llvm::CompilerEnvironment>& sCompilerEnvironment)
 		{
 			struct Visitor
 			{
 				bool* stopFlag;
 				PyFoundSubjects* pAnalyzerStorage { nullptr };
+				std::optional<rg3::llvm::CompilerEnvironment> sCompilerEnv { std::nullopt };
 
 				void operator()(NullTask)
 				{
@@ -218,6 +226,12 @@ namespace rg3::pybind
 				{
 					// Do analyze stub
 					rg3::llvm::CodeAnalyzer codeAnalyzer { analyzeHeader.headerPath, analyzeHeader.compilerConfig };
+					if (sCompilerEnv.has_value())
+					{
+						// set environment from cache
+						codeAnalyzer.setCompilerEnvironment(sCompilerEnv.value());
+					}
+
 					rg3::llvm::AnalyzerResult analyzeResult = codeAnalyzer.analyze();
 
 					{
@@ -292,7 +306,7 @@ namespace rg3::pybind
 
 
 			bool bShouldStop = false;
-			Visitor v { &bShouldStop, pAnalyzerStorage };
+			Visitor v { &bShouldStop, pAnalyzerStorage, sCompilerEnvironment };
 
 			while (!bShouldStop)
 			{
@@ -515,6 +529,22 @@ namespace rg3::pybind
 		m_pySubjects.vFoundTypeInstances.clear();
 		bool bResult = false;
 
+		// Collect compiler environment
+		auto environmentExtractResult = rg3::llvm::CompilerConfigDetector::detectSystemCompilerEnvironment();
+		if (rg3::llvm::CompilerEnvError* pError = std::get_if<rg3::llvm::CompilerEnvError>(&environmentExtractResult))
+		{
+			rg3::llvm::AnalyzerResult::CompilerIssue issue;
+			issue.kind = rg3::llvm::AnalyzerResult::CompilerIssue::IssueKind::IK_ERROR;
+			issue.sSourceFile = "RG3_GLOBAL_SCOPE";
+			issue.sMessage = fmt::format("RG3|Detect compiler environment failed: {}", pError->message);
+
+			m_pySubjects.pyFoundIssues.append(issue);
+			return false;
+		}
+
+		// Set environment to minimize future clang invocations
+		m_pContext->setCompilerEnvironment(*std::get_if<rg3::llvm::CompilerEnvironment>(&environmentExtractResult));
+
 		// Create tasks
 		{
 			PyGuard pyGuard {};