================
@@ -312,58 +316,222 @@ static std::optional<SmallVector<std::string, 0>>
getFirstCC1CommandLine(
return std::nullopt;
}
-bool DependencyScanningTool::initializeWorkerCIWithContextFromCommandline(
- DependencyScanningWorker &Worker, StringRef CWD,
+std::optional<CompilerInstanceWithContext>
+CompilerInstanceWithContext::initializeFromCommandline(
+ DependencyScanningTool &Tool, StringRef CWD,
ArrayRef<std::string> CommandLine, DiagnosticConsumer &DC) {
+ auto [OverlayFS, ModifiedCommandLine] = initVFSForByNameScanning(
+ &Tool.Worker.getVFS(), CommandLine, CWD, "ScanningByName");
+ auto DiagEngineWithCmdAndOpts =
+ std::make_unique<DiagnosticsEngineWithDiagOpts>(ModifiedCommandLine,
+ OverlayFS, DC);
+
if (CommandLine.size() >= 2 && CommandLine[1] == "-cc1") {
// The input command line is already a -cc1 invocation; initialize the
// compiler instance directly from it.
- return Worker.initializeCompilerInstanceWithContext(CWD, CommandLine, DC);
+ CompilerInstanceWithContext CIWithContext(Tool.Worker, CWD, CommandLine);
+ if (!CIWithContext.initialize(std::move(DiagEngineWithCmdAndOpts),
+ OverlayFS))
+ return std::nullopt;
+ return CIWithContext;
}
// The input command line is either a driver-style command line, or
// ill-formed. In this case, we will first call the Driver to build a -cc1
// command line for this compilation or diagnose any ill-formed input.
- auto [OverlayFS, ModifiedCommandLine] = initVFSForByNameScanning(
- &Worker.getVFS(), CommandLine, CWD, "ScanningByName");
- auto DiagEngineWithCmdAndOpts =
- std::make_unique<DiagnosticsEngineWithDiagOpts>(ModifiedCommandLine,
- OverlayFS, DC);
-
const auto MaybeFirstCC1 = getFirstCC1CommandLine(
ModifiedCommandLine, *DiagEngineWithCmdAndOpts->DiagEngine, OverlayFS);
if (!MaybeFirstCC1)
- return false;
+ return std::nullopt;
- return Worker.initializeCompilerInstanceWithContext(
- CWD, *MaybeFirstCC1, std::move(DiagEngineWithCmdAndOpts), OverlayFS);
+ std::vector<std::string> CC1CommandLine(MaybeFirstCC1->begin(),
+ MaybeFirstCC1->end());
+ CompilerInstanceWithContext CIWithContext(Tool.Worker, CWD,
+ std::move(CC1CommandLine));
+ if (!CIWithContext.initialize(std::move(DiagEngineWithCmdAndOpts),
OverlayFS))
+ return std::nullopt;
+ return CIWithContext;
}
-llvm::Error
-DependencyScanningTool::initializeCompilerInstanceWithContextOrError(
- StringRef CWD, ArrayRef<std::string> CommandLine) {
- DiagPrinterWithOS =
+llvm::Expected<CompilerInstanceWithContext>
+CompilerInstanceWithContext::initializeOrError(
+ DependencyScanningTool &Tool, StringRef CWD,
+ ArrayRef<std::string> CommandLine) {
+ auto DiagPrinterWithOS =
std::make_unique<TextDiagnosticsPrinterWithOutput>(CommandLine);
- bool Result = initializeWorkerCIWithContextFromCommandline(
- Worker, CWD, CommandLine, DiagPrinterWithOS->DiagPrinter);
-
- if (Result)
- return llvm::Error::success();
+ auto Result = initializeFromCommandline(Tool, CWD, CommandLine,
+ DiagPrinterWithOS->DiagPrinter);
+ if (Result) {
+ Result->DiagPrinterWithOS = std::move(DiagPrinterWithOS);
+ return std::move(*Result);
+ }
return makeErrorFromDiagnosticsOS(*DiagPrinterWithOS);
}
llvm::Expected<TranslationUnitDeps>
-DependencyScanningTool::computeDependenciesByNameWithContextOrError(
+CompilerInstanceWithContext::computeDependenciesByNameOrError(
StringRef ModuleName, const llvm::DenseSet<ModuleID> &AlreadySeen,
LookupModuleOutputCallback LookupModuleOutput) {
FullDependencyConsumer Consumer(AlreadySeen);
CallbackActionController Controller(LookupModuleOutput);
// We need to clear the DiagnosticOutput so that each by-name lookup
// has a clean diagnostics buffer.
DiagPrinterWithOS->DiagnosticOutput.clear();
- if (Worker.computeDependenciesByNameWithContext(ModuleName, Consumer,
- Controller))
+ if (computeDependencies(ModuleName, Consumer, Controller))
return Consumer.takeTranslationUnitDeps();
return makeErrorFromDiagnosticsOS(*DiagPrinterWithOS);
}
+
+bool CompilerInstanceWithContext::initialize(
+ std::unique_ptr<DiagnosticsEngineWithDiagOpts> DiagEngineWithDiagOpts,
+ IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS) {
+ assert(DiagEngineWithDiagOpts && "Valid diagnostics engine required!");
+ DiagEngineWithCmdAndOpts = std::move(DiagEngineWithDiagOpts);
+ DiagConsumer = DiagEngineWithCmdAndOpts->DiagEngine->getClient();
+
+#ifndef NDEBUG
+ assert(OverlayFS && "OverlayFS required!");
+ bool SawDepFS = false;
+ OverlayFS->visit([&](llvm::vfs::FileSystem &VFS) {
+ SawDepFS |= &VFS == Worker.DepFS.get();
+ });
+ assert(SawDepFS && "OverlayFS not based on DepFS");
+#endif
+
+ OriginalInvocation = createCompilerInvocation(
+ CommandLine, *DiagEngineWithCmdAndOpts->DiagEngine);
+ if (!OriginalInvocation) {
+ DiagEngineWithCmdAndOpts->DiagEngine->Report(
+ diag::err_fe_expected_compiler_job)
+ << llvm::join(CommandLine, " ");
+ return false;
+ }
+
+ if (any(Worker.Service.getOpts().OptimizeArgs &
+ ScanningOptimizations::Macros))
+ canonicalizeDefines(OriginalInvocation->getPreprocessorOpts());
+
+ // Create the CompilerInstance.
+ std::shared_ptr<ModuleCache> ModCache =
+ makeInProcessModuleCache(Worker.Service.getModuleCacheEntries());
+ CIPtr = std::make_unique<CompilerInstance>(
+ createScanCompilerInvocation(*OriginalInvocation, Worker.Service),
+ Worker.PCHContainerOps, std::move(ModCache));
+ auto &CI = *CIPtr;
+
+ initializeScanCompilerInstance(
+ CI, OverlayFS, DiagEngineWithCmdAndOpts->DiagEngine->getClient(),
+ Worker.Service, Worker.DepFS);
+
+ StableDirs = getInitialStableDirs(CI);
+ auto MaybePrebuiltModulesASTMap =
+ computePrebuiltModulesASTMap(CI, StableDirs);
+ if (!MaybePrebuiltModulesASTMap)
+ return false;
+
+ PrebuiltModuleASTMap = std::move(*MaybePrebuiltModulesASTMap);
+ OutputOpts = createDependencyOutputOptions(*OriginalInvocation);
+
+ // We do not create the target in initializeScanCompilerInstance because
+ // setting it here is unique for by-name lookups. We create the target only
+ // once here, and the information is reused for all computeDependencies
calls.
+ // We do not need to call createTarget explicitly if we go through
+ // CompilerInstance::ExecuteAction to perform scanning.
+ CI.createTarget();
+
+ return true;
----------------
shafik wrote:
It looks like this should really be `return CI.createTarget();` unless there is
some non-obvious reason why we believe `CI.createTarget()` can't fail.
https://github.com/llvm/llvm-project/pull/184376
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
