[clang] [WIP][clang][MBD] Initial implementation of module build daemon (PR #68498)
Connor Sughrue via cfe-commits
cfe-commits at lists.llvm.org
Sat Oct 7 14:00:42 PDT 2023
https://github.com/cpsughrue created https://github.com/llvm/llvm-project/pull/68498
Work in progress implementation of the module build daemon proposed in https://discourse.llvm.org/t/rfc-modules-build-daemon-build-system-agnostic-support-for-explicitly-built-modules/71524.
>From 9fe97509277fbce0333c454bb4e2619fed04b189 Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Sun, 9 Jul 2023 23:19:58 -0400
Subject: [PATCH 1/2] [WIP][clang][MBD] module build daemon
---
clang/include/clang/Driver/Options.td | 12 +
.../include/clang/Frontend/FrontendOptions.h | 7 +
.../clang/Tooling/ModuleBuildDaemon/Client.h | 56 ++
.../ModuleBuildDaemon/SocketMsgSupport.h | 166 ++++++
.../Tooling/ModuleBuildDaemon/SocketSupport.h | 31 +
.../clang/Tooling/ModuleBuildDaemon/Utils.h | 28 +
clang/lib/Driver/ToolChains/Clang.cpp | 14 +-
clang/lib/Tooling/CMakeLists.txt | 1 +
.../Tooling/ModuleBuildDaemon/CMakeLists.txt | 9 +
.../lib/Tooling/ModuleBuildDaemon/Client.cpp | 224 +++++++
.../ModuleBuildDaemon/SocketSupport.cpp | 128 ++++
clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp | 32 +
clang/test/Driver/unknown-arg.c | 2 +-
clang/test/ModuleBuildDaemon/launch.c | 10 +
clang/test/ModuleBuildDaemon/parallel-scan.c | 31 +
clang/test/ModuleBuildDaemon/scan.c | 20 +
clang/tools/driver/CMakeLists.txt | 3 +
clang/tools/driver/cc1_main.cpp | 74 ++-
clang/tools/driver/cc1modbuildd_main.cpp | 553 ++++++++++++++++++
clang/tools/driver/driver.cpp | 17 +-
20 files changed, 1408 insertions(+), 10 deletions(-)
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
create mode 100644 clang/test/ModuleBuildDaemon/launch.c
create mode 100644 clang/test/ModuleBuildDaemon/parallel-scan.c
create mode 100644 clang/test/ModuleBuildDaemon/scan.c
create mode 100644 clang/tools/driver/cc1modbuildd_main.cpp
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 5415b18d3f406df..33c24e182fccca2 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -2883,6 +2883,18 @@ defm declspec : BoolOption<"f", "declspec",
NegFlag<SetFalse, [], [ClangOption], "Disallow">,
BothFlags<[], [ClangOption, CC1Option],
" __declspec as a keyword">>, Group<f_clang_Group>;
+
+def fmodule_build_daemon : Flag<["-"], "fmodule-build-daemon">, Group<f_Group>,
+ Flags<[NoXarchOption]>,
+ Visibility<[ClangOption, CC1Option]>,
+ HelpText<"Enables module build daemon functionality">,
+ MarshallingInfoFlag<FrontendOpts<"ModuleBuildDaemon">>;
+def fmodule_build_daemon_EQ : Joined<["-"], "fmodule-build-daemon=">, Group<f_Group>,
+ Flags<[NoXarchOption]>,
+ Visibility<[ClangOption, CC1Option]>,
+ HelpText<"Enables module build daemon functionality and defines location of output files">,
+ MarshallingInfoString<FrontendOpts<"ModuleBuildDaemonPath">>;
+
def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
Flags<[NoXarchOption]>, Visibility<[ClangOption, CC1Option]>,
MetaVarName<"<directory>">,
diff --git a/clang/include/clang/Frontend/FrontendOptions.h b/clang/include/clang/Frontend/FrontendOptions.h
index 117e35de6f76c4c..8ce97a57d413c0b 100644
--- a/clang/include/clang/Frontend/FrontendOptions.h
+++ b/clang/include/clang/Frontend/FrontendOptions.h
@@ -350,6 +350,9 @@ class FrontendOptions {
/// Whether to share the FileManager when building modules.
unsigned ModulesShareFileManager : 1;
+ /// Connect to module build daemon
+ unsigned ModuleBuildDaemon : 1;
+
CodeCompleteOptions CodeCompleteOpts;
/// Specifies the output format of the AST.
@@ -435,6 +438,10 @@ class FrontendOptions {
/// The output file, if any.
std::string OutputFile;
+ /// If given, the path to the module build daemon's output files and socket
+ /// address
+ std::string ModuleBuildDaemonPath;
+
/// If given, the new suffix for fix-it rewritten files.
std::string FixItSuffix;
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
new file mode 100644
index 000000000000000..5d5df74743a6a68
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
@@ -0,0 +1,56 @@
+//===----------------------------- Protocol.h -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_CLIENT_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_CLIENT_H
+
+#include "clang/Frontend/CompilerInstance.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+
+#define MAX_BUFFER 4096
+#define SOCKET_FILE_NAME "mbd.sock"
+#define STDOUT_FILE_NAME "mbd.out"
+#define STDERR_FILE_NAME "mbd.err"
+
+using namespace clang;
+using namespace llvm;
+
+namespace cc1modbuildd {
+
+// Returns where to store log files and socket address. Of the format
+// /tmp/clang-<BLAKE3HashOfClagnFullVersion>/
+std::string getBasePath();
+
+llvm::Error attemptHandshake(int SocketFD);
+
+llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0);
+
+Expected<int> getModuleBuildDaemon(const char *Argv0, StringRef BasePath);
+
+// Sends request to module build daemon
+llvm::Error registerTranslationUnit(ArrayRef<const char *> CC1Cmd,
+ StringRef Argv0, StringRef CWD,
+ int ServerFD);
+
+// Processes response from module build daemon
+Expected<std::vector<std::string>> getUpdatedCC1(int ServerFD);
+
+// Work in progress. Eventually function will modify CC1 command line to include
+// path to modules already built by the daemon
+Expected<std::vector<std::string>>
+updateCC1WithModuleBuildDaemon(const CompilerInvocation &Clang,
+ ArrayRef<const char *> CC1Cmd, const char *Argv0,
+ StringRef CWD);
+
+} // namespace cc1modbuildd
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_PROTOCAL_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
new file mode 100644
index 000000000000000..c02a426054f1170
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
@@ -0,0 +1,166 @@
+//===------------------------- SocketMsgSupport.h -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETMSGSUPPORT_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETMSGSUPPORT_H
+
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+
+using namespace clang;
+using namespace llvm;
+
+namespace cc1modbuildd {
+
+enum class ActionType { REGISTER, HANDSHAKE };
+enum class StatusType { REQUEST, SUCCESS, FAILURE };
+
+struct BaseMsg {
+ ActionType MsgAction;
+ StatusType MsgStatus;
+
+ BaseMsg() = default;
+ BaseMsg(ActionType Action, StatusType Status)
+ : MsgAction(Action), MsgStatus(Status) {}
+};
+
+struct RegisterMsg : public BaseMsg {
+ std::optional<std::string> WorkingDirectory;
+ // The scanner requires the path to the clang executable
+ std::optional<std::string> ExecutablePath;
+ // Does not include executable
+ std::optional<std::vector<std::string>> CC1CommandLine;
+
+ RegisterMsg() = default;
+
+ RegisterMsg(ActionType Action, StatusType Status,
+ const std::optional<std::string> &CurrentWD,
+ const std::optional<std::string> &Argv0,
+ const std::optional<std::vector<std::string>> &Argv)
+ : BaseMsg(Action, Status), WorkingDirectory(CurrentWD),
+ ExecutablePath(Argv0), CC1CommandLine(Argv) {}
+
+ RegisterMsg(ActionType Action, StatusType Status)
+ : BaseMsg(Action, Status), WorkingDirectory(std::nullopt),
+ ExecutablePath(std::nullopt), CC1CommandLine(std::nullopt) {}
+};
+
+struct HandshakeMsg : public BaseMsg {
+ HandshakeMsg() = default;
+ HandshakeMsg(ActionType Action, StatusType Status)
+ : BaseMsg(Action, Status) {}
+};
+
+template <typename T> std::string getBufferFromSocketMsg(T Msg) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ std::string Buffer;
+ llvm::raw_string_ostream OS(Buffer);
+ llvm::yaml::Output YamlOut(OS);
+
+ YamlOut << Msg;
+ return Buffer;
+}
+
+template <typename T> Expected<T> getSocketMsgFromBuffer(const char *Buffer) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ T ClientRequest;
+ llvm::yaml::Input YamlIn(Buffer);
+ YamlIn >> ClientRequest;
+
+ if (YamlIn.error()) {
+ std::string Msg = "Syntax or semantic error during YAML parsing";
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
+ }
+
+ return ClientRequest;
+}
+
+template <typename T> Expected<T> readSocketMsgFromSocket(int FD) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ Expected<std::string> MaybeResponseBuffer = readFromSocket(FD);
+ if (!MaybeResponseBuffer)
+ return std::move(MaybeResponseBuffer.takeError());
+
+ // Wait for response from module build daemon
+ Expected<T> MaybeResponse =
+ getSocketMsgFromBuffer<T>(std::move(*MaybeResponseBuffer).c_str());
+ if (!MaybeResponse)
+ return std::move(MaybeResponse.takeError());
+ return std::move(*MaybeResponse);
+}
+
+template <typename T> llvm::Error writeSocketMsgToSocket(T Msg, int FD) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ std::string Buffer = getBufferFromSocketMsg(Msg);
+ if (llvm::Error Err = writeToSocket(Buffer, FD))
+ return std::move(Err);
+
+ return llvm::Error::success();
+}
+
+template <typename T>
+Expected<int> connectAndWriteSocketMsgToSocket(T Msg, StringRef SocketPath) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ Expected<int> MaybeFD = connectToSocket(SocketPath);
+ if (!MaybeFD)
+ return std::move(MaybeFD.takeError());
+ int FD = std::move(*MaybeFD);
+
+ if (llvm::Error Err = writeSocketMsgToSocket(Msg, FD))
+ return std::move(Err);
+
+ return FD;
+}
+
+} // namespace cc1modbuildd
+
+template <>
+struct llvm::yaml::ScalarEnumerationTraits<cc1modbuildd::StatusType> {
+ static void enumeration(IO &Io, cc1modbuildd::StatusType &Value) {
+ Io.enumCase(Value, "REQUEST", cc1modbuildd::StatusType::REQUEST);
+ Io.enumCase(Value, "SUCCESS", cc1modbuildd::StatusType::SUCCESS);
+ Io.enumCase(Value, "FAILURE", cc1modbuildd::StatusType::FAILURE);
+ }
+};
+
+template <>
+struct llvm::yaml::ScalarEnumerationTraits<cc1modbuildd::ActionType> {
+ static void enumeration(IO &Io, cc1modbuildd::ActionType &Value) {
+ Io.enumCase(Value, "REGISTER", cc1modbuildd::ActionType::REGISTER);
+ Io.enumCase(Value, "HANDSHAKE", cc1modbuildd::ActionType::HANDSHAKE);
+ }
+};
+
+template <> struct llvm::yaml::MappingTraits<cc1modbuildd::RegisterMsg> {
+ static void mapping(IO &Io, cc1modbuildd::RegisterMsg &Info) {
+ Io.mapRequired("Action", Info.MsgAction);
+ Io.mapRequired("Status", Info.MsgStatus);
+ Io.mapOptional("WorkingDirectory", Info.WorkingDirectory);
+ Io.mapOptional("ExecutablePath", Info.ExecutablePath);
+ Io.mapOptional("CC1CommandLine", Info.CC1CommandLine);
+ }
+};
+
+template <> struct llvm::yaml::MappingTraits<cc1modbuildd::HandshakeMsg> {
+ static void mapping(IO &Io, cc1modbuildd::HandshakeMsg &Info) {
+ Io.mapRequired("Action", Info.MsgAction);
+ Io.mapRequired("Status", Info.MsgStatus);
+ }
+};
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETMSGSUPPORT_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
new file mode 100644
index 000000000000000..bc21084faab3966
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
@@ -0,0 +1,31 @@
+//===-------------------------- SocketSupport.h ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETSUPPORT_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETSUPPORT_H
+
+#include "clang/Frontend/CompilerInstance.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace clang;
+using namespace llvm;
+
+namespace cc1modbuildd {
+
+Expected<int> createSocket();
+Expected<int> connectToSocket(StringRef SocketPath);
+Expected<int> connectAndWriteToSocket(std::string Buffer, StringRef SocketPath);
+Expected<std::string> readFromSocket(int FD);
+llvm::Error writeToSocket(std::string Buffer, int WriteFD);
+
+} // namespace cc1modbuildd
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETSUPPORT_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
new file mode 100644
index 000000000000000..79a2ffc3c1804d8
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
@@ -0,0 +1,28 @@
+//===------------------------------ Utils.h -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Functions required by both the module build daemon (server) and clang
+// invocation (client)
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_UTILS_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_UTILS_H
+
+#include "llvm/Support/Error.h"
+#include <string>
+
+namespace cc1modbuildd {
+
+void writeError(llvm::Error Err, std::string Msg);
+std::string getFullErrorMsg(llvm::Error Err, std::string Msg);
+llvm::Error makeStringError(llvm::Error Err, std::string Msg);
+
+} // namespace cc1modbuildd
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_UTILS_H
\ No newline at end of file
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index bfd6c5c2864abf7..62fbcae0f87cf45 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -5,7 +5,6 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
-
#include "Clang.h"
#include "AMDGPU.h"
#include "Arch/AArch64.h"
@@ -3740,6 +3739,19 @@ static bool RenderModulesOptions(Compilation &C, const Driver &D,
Std->containsValue("c++latest") || Std->containsValue("gnu++latest"));
bool HaveModules = HaveStdCXXModules;
+ // -fmodule-build-daemon enables module build daemon functionality
+ if (Args.hasArg(options::OPT_fmodule_build_daemon))
+ Args.AddLastArg(CmdArgs, options::OPT_fmodule_build_daemon);
+
+ // by default module build daemon socket address and output files are saved
+ // under /tmp/ but that can be overridden by providing the
+ // -fmodule-build-daemon=<path> flag
+ if (Arg *A = Args.getLastArg(options::OPT_fmodule_build_daemon_EQ)) {
+ CmdArgs.push_back(
+ Args.MakeArgString(Twine("-fmodule-build-daemon=") + A->getValue()));
+ CmdArgs.push_back("-fmodule-build-daemon");
+ }
+
// -fmodules enables the use of precompiled modules (off by default).
// Users can pass -fno-cxx-modules to turn off modules support for
// C++/Objective-C++ programs.
diff --git a/clang/lib/Tooling/CMakeLists.txt b/clang/lib/Tooling/CMakeLists.txt
index aff39e4de13c0b2..85752e577332650 100644
--- a/clang/lib/Tooling/CMakeLists.txt
+++ b/clang/lib/Tooling/CMakeLists.txt
@@ -13,6 +13,7 @@ add_subdirectory(DumpTool)
add_subdirectory(Syntax)
add_subdirectory(DependencyScanning)
add_subdirectory(Transformer)
+add_subdirectory(ModuleBuildDaemon)
# Replace the last lib component of the current binary directory with include
string(FIND ${CMAKE_CURRENT_BINARY_DIR} "/lib/" PATH_LIB_START REVERSE)
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt b/clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt
new file mode 100644
index 000000000000000..9c1f5dc1aa2c0c0
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(LLVM_LINK_COMPONENTS
+ Support
+ )
+
+add_clang_library(clangModuleBuildDaemon
+ Client.cpp
+ SocketSupport.cpp
+ Utils.cpp
+ )
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
new file mode 100644
index 000000000000000..08fe14476c901b0
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
@@ -0,0 +1,224 @@
+//===----------------------------- Client.cpp -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
+#include "clang/Basic/Version.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/Utils.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/BLAKE3.h"
+
+// TODO: Make portable
+#if LLVM_ON_UNIX
+
+#include <cerrno>
+#include <filesystem>
+#include <fstream>
+#include <signal.h>
+#include <spawn.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+using namespace clang;
+using namespace llvm;
+using namespace cc1modbuildd;
+
+std::string cc1modbuildd::getBasePath() {
+ llvm::BLAKE3 Hash;
+ Hash.update(getClangFullVersion());
+ auto HashResult = Hash.final<sizeof(uint64_t)>();
+ uint64_t HashValue =
+ llvm::support::endian::read<uint64_t, llvm::support::native>(
+ HashResult.data());
+ std::string Key = toString(llvm::APInt(64, HashValue), 36, /*Signed*/ false);
+
+ // set paths
+ SmallString<128> BasePath;
+ llvm::sys::path::system_temp_directory(/*erasedOnReboot*/ true, BasePath);
+ llvm::sys::path::append(BasePath, "clang-" + Key);
+ return BasePath.c_str();
+}
+
+llvm::Error cc1modbuildd::attemptHandshake(int SocketFD) {
+
+ cc1modbuildd::HandshakeMsg Request{ActionType::HANDSHAKE,
+ StatusType::REQUEST};
+ std::string Buffer = cc1modbuildd::getBufferFromSocketMsg(Request);
+
+ if (llvm::Error Err = writeToSocket(Buffer, SocketFD))
+ return std::move(Err);
+
+ Expected<RegisterMsg> MaybeServerResponse =
+ readSocketMsgFromSocket<RegisterMsg>(SocketFD);
+ if (!MaybeServerResponse)
+ return std::move(MaybeServerResponse.takeError());
+ RegisterMsg ServerResponse = std::move(*MaybeServerResponse);
+
+ assert(ServerResponse.MsgAction == ActionType::HANDSHAKE &&
+ "At this point response ActionType should only ever be HANDSHAKE");
+
+ if (ServerResponse.MsgStatus == StatusType::SUCCESS)
+ return llvm::Error::success();
+
+ return llvm::make_error<StringError>("Handshake failed",
+ inconvertibleErrorCode());
+}
+
+llvm::Error cc1modbuildd::spawnModuleBuildDaemon(StringRef BasePath,
+ const char *Argv0) {
+ std::string BasePathStr = BasePath.str();
+ const char *Args[] = {Argv0, "-cc1modbuildd", BasePathStr.c_str(), nullptr};
+ pid_t pid;
+ int EC = posix_spawn(&pid, Args[0],
+ /*file_actions*/ nullptr,
+ /*spawnattr*/ nullptr, const_cast<char **>(Args),
+ /*envp*/ nullptr);
+ if (EC)
+ return createStringError(std::error_code(EC, std::generic_category()),
+ "failed to spawn module build daemon process");
+
+ return llvm::Error::success();
+}
+
+Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
+ StringRef BasePath) {
+
+ SmallString<128> SocketPath = BasePath;
+ llvm::sys::path::append(SocketPath, SOCKET_FILE_NAME);
+
+ if (llvm::sys::fs::exists(SocketPath)) {
+ Expected<int> MaybeFD = connectToSocket(SocketPath);
+ if (MaybeFD)
+ return std::move(*MaybeFD);
+ consumeError(MaybeFD.takeError());
+ }
+
+ if (llvm::Error Err = cc1modbuildd::spawnModuleBuildDaemon(BasePath, Argv0))
+ return std::move(Err);
+
+ const unsigned int MICROSEC_IN_SEC = 1000000;
+ constexpr unsigned int MAX_TIME = 30 * MICROSEC_IN_SEC;
+ const unsigned short INTERVAL = 100;
+
+ unsigned int CumulativeTime = 0;
+ unsigned int WaitTime = 0;
+
+ while (CumulativeTime <= MAX_TIME) {
+ // Wait a bit then check to see if the module build daemon has initialized
+ usleep(WaitTime);
+
+ if (llvm::sys::fs::exists(SocketPath)) {
+ Expected<int> MaybeFD = connectToSocket(SocketPath);
+ if (MaybeFD)
+ return std::move(*MaybeFD);
+ consumeError(MaybeFD.takeError());
+ }
+
+ CumulativeTime += INTERVAL;
+ }
+
+ // After waiting 30 seconds give up
+ return llvm::make_error<StringError>(
+ "Module build daemon did not exist after spawn attempt",
+ inconvertibleErrorCode());
+}
+
+llvm::Error
+cc1modbuildd::registerTranslationUnit(ArrayRef<const char *> CC1Command,
+ StringRef Argv0, StringRef CWD,
+ int ServerFD) {
+
+ std::vector<std::string> StrCC1Command;
+ for (const char *Arg : CC1Command)
+ StrCC1Command.emplace_back(Arg);
+
+ cc1modbuildd::RegisterMsg Request{ActionType::REGISTER, StatusType::REQUEST,
+ CWD.str(), Argv0.str(), StrCC1Command};
+
+ llvm::Error WriteErr = writeSocketMsgToSocket(Request, ServerFD);
+ if (WriteErr)
+ return std::move(WriteErr);
+
+ return llvm::Error::success();
+}
+
+Expected<std::vector<std::string>> cc1modbuildd::getUpdatedCC1(int ServerFD) {
+
+ // Blocks cc1 invocation until module build daemon is done processing
+ // translation unit. Currently receives a SUCCESS message and returns
+ // llvm::Error::success() but will eventually recive updated cc1 command line
+ Expected<RegisterMsg> MaybeServerResponse =
+ readSocketMsgFromSocket<RegisterMsg>(ServerFD);
+ if (!MaybeServerResponse)
+ return std::move(MaybeServerResponse.takeError());
+ RegisterMsg ServerResponse = std::move(*MaybeServerResponse);
+
+ // Confirm response is REGISTER and MsgStatus is SUCCESS
+ assert(ServerResponse.MsgAction == ActionType::REGISTER &&
+ "At this point response ActionType should only ever be REGISTER");
+
+ if (ServerResponse.MsgStatus == StatusType::SUCCESS)
+ return ServerResponse.CC1CommandLine.value();
+
+ return llvm::make_error<StringError>(
+ "Daemon failed to processes registered translation unit",
+ inconvertibleErrorCode());
+}
+
+Expected<std::vector<std::string>>
+cc1modbuildd::updateCC1WithModuleBuildDaemon(const CompilerInvocation &Clang,
+ ArrayRef<const char *> CC1Cmd,
+ const char *Argv0, StringRef CWD) {
+
+ // The module build daemon stores all output files and its socket address
+ // under BasePath. Either set BasePath to a user provided option or create an
+ // appropriate BasePath based on the hash of the clang version
+ std::string BasePath;
+ if (!Clang.getFrontendOpts().ModuleBuildDaemonPath.empty())
+ BasePath = Clang.getFrontendOpts().ModuleBuildDaemonPath;
+ else
+ BasePath = cc1modbuildd::getBasePath();
+
+ // If module build daemon does not exist spawn module build daemon
+ Expected<int> MaybeDaemonFD =
+ cc1modbuildd::getModuleBuildDaemon(Argv0, BasePath);
+ if (!MaybeDaemonFD)
+ return makeStringError(MaybeDaemonFD.takeError(),
+ "Connect to daemon failed: ");
+ int DaemonFD = std::move(*MaybeDaemonFD);
+
+ if (llvm::Error HandshakeErr = attemptHandshake(DaemonFD))
+ return makeStringError(std::move(HandshakeErr),
+ "Failed to hadshake with daemon: ");
+
+ // Send translation unit information to module build daemon for processing
+ if (llvm::Error RegisterErr =
+ registerTranslationUnit(CC1Cmd, Argv0, CWD, DaemonFD))
+ return makeStringError(std::move(RegisterErr),
+ "Register translation unti failed: ");
+
+ // Wait for response from module build daemon. Response will hopefully be an
+ // updated cc1 command line with additional -fmodule-file=<file> flags and
+ // implicit module flags removed
+ Expected<std::vector<std::string>> MaybeUpdatedCC1 = getUpdatedCC1(DaemonFD);
+ if (!MaybeUpdatedCC1)
+ return makeStringError(MaybeUpdatedCC1.takeError(),
+ "Failed to get updated CC1: ");
+ return std::move(*MaybeUpdatedCC1);
+}
+
+#endif // LLVM_ON_UNIX
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
new file mode 100644
index 000000000000000..58526e4422f457b
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
@@ -0,0 +1,128 @@
+//===------------------------- SocketSupport.cpp --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+#include "clang/Basic/Version.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/BLAKE3.h"
+
+// TODO: Make portable
+#if LLVM_ON_UNIX
+
+#include <cerrno>
+#include <filesystem>
+#include <fstream>
+#include <signal.h>
+#include <spawn.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+Expected<int> cc1modbuildd::createSocket() {
+ int FD;
+ if ((FD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ std::string Msg = "socket create error: " + std::string(strerror(errno));
+ return createStringError(inconvertibleErrorCode(), Msg);
+ }
+ return FD;
+}
+
+Expected<int> cc1modbuildd::connectToSocket(StringRef SocketPath) {
+
+ Expected<int> MaybeFD = cc1modbuildd::createSocket();
+ if (!MaybeFD)
+ return std::move(MaybeFD.takeError());
+
+ int FD = std::move(*MaybeFD);
+
+ struct sockaddr_un Addr;
+ memset(&Addr, 0, sizeof(Addr));
+ Addr.sun_family = AF_UNIX;
+ strncpy(Addr.sun_path, SocketPath.str().c_str(), sizeof(Addr.sun_path) - 1);
+
+ if (connect(FD, (struct sockaddr *)&Addr, sizeof(Addr)) == -1) {
+ close(FD);
+ std::string msg = "socket connect error: " + std::string(strerror(errno));
+ return createStringError(inconvertibleErrorCode(), msg);
+ }
+ return FD;
+}
+
+Expected<int> cc1modbuildd::connectAndWriteToSocket(std::string Buffer,
+ StringRef SocketPath) {
+
+ Expected<int> MaybeConnectedFD = connectToSocket(SocketPath);
+ if (!MaybeConnectedFD)
+ return std::move(MaybeConnectedFD.takeError());
+
+ int ConnectedFD = std::move(*MaybeConnectedFD);
+ llvm::Error Err = writeToSocket(Buffer, ConnectedFD);
+ if (Err)
+ return std::move(Err);
+
+ return ConnectedFD;
+}
+
+Expected<std::string> cc1modbuildd::readFromSocket(int FD) {
+
+ const size_t BUFFER_SIZE = 4096;
+ std::vector<char> Buffer(BUFFER_SIZE);
+ size_t TotalBytesRead = 0;
+
+ ssize_t n;
+ while ((n = read(FD, Buffer.data() + TotalBytesRead,
+ Buffer.size() - TotalBytesRead)) > 0) {
+
+ TotalBytesRead += n;
+ // Read until ...\n encountered (last line of YAML document)
+ if (std::string(&Buffer[TotalBytesRead - 4], 4) == "...\n")
+ break;
+ if (Buffer.size() - TotalBytesRead < BUFFER_SIZE)
+ Buffer.resize(Buffer.size() + BUFFER_SIZE);
+ }
+
+ if (n < 0) {
+ std::string Msg = "socket read error: " + std::string(strerror(errno));
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
+ }
+ if (n == 0)
+ return llvm::make_error<StringError>("EOF", inconvertibleErrorCode());
+ return std::string(Buffer.begin(), Buffer.end());
+}
+
+llvm::Error cc1modbuildd::writeToSocket(std::string Buffer, int WriteFD) {
+
+ ssize_t BytesToWrite = static_cast<ssize_t>(Buffer.size());
+ const char *Bytes = Buffer.c_str();
+
+ while (BytesToWrite) {
+ ssize_t BytesWritten = write(WriteFD, Bytes, BytesToWrite);
+ if (BytesWritten == -1) {
+ std::string Msg = "socket write error: " + std::string(strerror(errno));
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
+ }
+
+ if (!BytesWritten || BytesWritten > BytesToWrite)
+ return llvm::errorCodeToError(
+ std::error_code(EIO, std::generic_category()));
+
+ BytesToWrite -= BytesWritten;
+ Bytes += BytesWritten;
+ }
+ return llvm::Error::success();
+}
+
+#endif // LLVM_ON_UNIX
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
new file mode 100644
index 000000000000000..c03e8e3762114f6
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
@@ -0,0 +1,32 @@
+//===------------------------------ Utils.cpp -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <clang/Tooling/ModuleBuildDaemon/Utils.h>
+#include <llvm/Support/Error.h>
+#include <string>
+
+using namespace llvm;
+
+void cc1modbuildd::writeError(llvm::Error Err, std::string Msg) {
+ handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
+ errs() << Msg << EIB.message() << '\n';
+ });
+}
+
+std::string cc1modbuildd::getFullErrorMsg(llvm::Error Err, std::string Msg) {
+ std::string ErrMessage;
+ handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
+ ErrMessage = Msg + EIB.message();
+ });
+ return ErrMessage;
+}
+
+llvm::Error cc1modbuildd::makeStringError(llvm::Error Err, std::string Msg) {
+ std::string ErrMsg = getFullErrorMsg(std::move(Err), Msg);
+ return llvm::make_error<StringError>(ErrMsg, inconvertibleErrorCode());
+}
\ No newline at end of file
diff --git a/clang/test/Driver/unknown-arg.c b/clang/test/Driver/unknown-arg.c
index 52ea0f5ff3220fc..3a22b824adc5c74 100644
--- a/clang/test/Driver/unknown-arg.c
+++ b/clang/test/Driver/unknown-arg.c
@@ -59,7 +59,7 @@
// SILENT-NOT: warning:
// CC1AS-DID-YOU-MEAN: error: unknown argument '-hell'; did you mean '-help'?
// CC1AS-DID-YOU-MEAN: error: unknown argument '--version'; did you mean '-version'?
-// UNKNOWN-INTEGRATED: error: unknown integrated tool '-cc1asphalt'. Valid tools include '-cc1' and '-cc1as'.
+// UNKNOWN-INTEGRATED: error: unknown integrated tool '-cc1asphalt'. Valid tools include '-cc1', '-cc1as', '-cc1gen-reproducer', and '-cc1modbuildd'.
// RUN: %clang -S %s -o %t.s -Wunknown-to-clang-option 2>&1 | FileCheck --check-prefix=IGNORED %s
diff --git a/clang/test/ModuleBuildDaemon/launch.c b/clang/test/ModuleBuildDaemon/launch.c
new file mode 100644
index 000000000000000..575aba0ac3ce603
--- /dev/null
+++ b/clang/test/ModuleBuildDaemon/launch.c
@@ -0,0 +1,10 @@
+// REQUIRES: !system-windows
+
+// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
+
+// RUN: %clang -cc1modbuildd mbd-launch -v
+// RUN: cat mbd-launch/mbd.out | FileCheck %s -DPREFIX=%t
+
+// CHECK: mbd created and binded to socket address at: mbd-launch/mbd.sock
+
+// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
\ No newline at end of file
diff --git a/clang/test/ModuleBuildDaemon/parallel-scan.c b/clang/test/ModuleBuildDaemon/parallel-scan.c
new file mode 100644
index 000000000000000..0dddaa0f161457e
--- /dev/null
+++ b/clang/test/ModuleBuildDaemon/parallel-scan.c
@@ -0,0 +1,31 @@
+// Confirm module build daemon can handle two translation units simultaneously
+
+// REQUIRES: !system-windows
+
+// RUN: if pgrep -f "cc1modbuildd parallel-scan"; then pkill -f "cc1modbuildd parallel-scan"; fi
+// : rm -rf parallel-scan
+// RUN: split-file %s %t
+
+//--- main.c
+#include "app.h"
+int main() {return 0;}
+
+//--- app.c
+#include "util.h"
+
+//--- app.h
+
+//--- util.h
+
+// RUN: %clang -fmodule-build-daemon=parallel-scan %t/main.c %t/app.c
+// RUN: pwd && ls
+// RUN: cat parallel-scan/mbd.out
+// RUN: cat parallel-scan/mbd.out | FileCheck %s -DPREFIX=%t
+
+// CHECK: main.c
+// CHECK: app.h
+// CHECK: app.c
+// CHECK: util.h
+
+// RUN: if pgrep -f "cc1modbuildd parallel-scan"; then pkill -f "cc1modbuildd parallel-scan"; fi
+// : rm -rf parallel-scan
diff --git a/clang/test/ModuleBuildDaemon/scan.c b/clang/test/ModuleBuildDaemon/scan.c
new file mode 100644
index 000000000000000..f70210362ab6443
--- /dev/null
+++ b/clang/test/ModuleBuildDaemon/scan.c
@@ -0,0 +1,20 @@
+// REQUIRES: !system-windows
+
+// RUN: if pgrep -f "cc1modbuildd scan"; then pkill -f "cc1modbuildd scan"; fi
+// RUN: rm -rf scan
+// RUN: split-file %s %t
+
+//--- main.c
+#include "header.h"
+int main() {return 0;}
+
+//--- header.h
+
+// RUN: %clang -fmodule-build-daemon=scan %t/main.c
+// RUN: cat scan/mbd.out | FileCheck %s -DPREFIX=%t
+
+// CHECK: main.c
+// CHECK: header.h
+
+// RUN: if pgrep -f "cc1modbuildd scan"; then pkill -f "cc1modbuildd scan"; fi
+// RUN: rm -rf scan
diff --git a/clang/tools/driver/CMakeLists.txt b/clang/tools/driver/CMakeLists.txt
index 2182486f93a5553..9f4c7a01f848938 100644
--- a/clang/tools/driver/CMakeLists.txt
+++ b/clang/tools/driver/CMakeLists.txt
@@ -28,6 +28,7 @@ add_clang_tool(clang
cc1_main.cpp
cc1as_main.cpp
cc1gen_reproducer_main.cpp
+ cc1modbuildd_main.cpp
DEPENDS
intrinsics_gen
@@ -39,9 +40,11 @@ clang_target_link_libraries(clang
PRIVATE
clangBasic
clangCodeGen
+ clangDependencyScanning
clangDriver
clangFrontend
clangFrontendTool
+ clangModuleBuildDaemon
clangSerialization
)
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
index e9d2c6aad371dbb..b4b19c7e778226c 100644
--- a/clang/tools/driver/cc1_main.cpp
+++ b/clang/tools/driver/cc1_main.cpp
@@ -25,6 +25,7 @@
#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "clang/Frontend/Utils.h"
#include "clang/FrontendTool/Utils.h"
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/LinkAllPasses.h"
@@ -63,7 +64,7 @@ using namespace llvm::opt;
static void LLVMErrorHandler(void *UserData, const char *Message,
bool GenCrashDiag) {
- DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);
+ DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine *>(UserData);
Diags.Report(diag::err_fe_error_backend) << Message;
@@ -251,8 +252,69 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
Diags.setSeverity(diag::remark_cc1_round_trip_generated,
diag::Severity::Remark, {});
- bool Success = CompilerInvocation::CreateFromArgs(Clang->getInvocation(),
- Argv, Diags, Argv0);
+ std::shared_ptr<CompilerInvocation> Invocation =
+ std::make_shared<CompilerInvocation>();
+ bool Success =
+ CompilerInvocation::CreateFromArgs(*Invocation, Argv, Diags, Argv0);
+
+ // FIXME: does not actually flush any diagnostics
+ DiagsBuffer->FlushDiagnostics(Diags);
+ if (!Success) {
+ DiagsBuffer->finish();
+ return 1;
+ }
+
+ // The module build daemon may update the cc1 args and needs someplace to
+ // store a modified command line for the lifetime of the compilation
+ std::vector<std::string> UpdatedArgv;
+ std::vector<const char *> CharUpdatedArgv;
+
+#if LLVM_ON_UNIX
+ // Handle module build daemon functionality if enabled
+ if (Invocation->getFrontendOpts().ModuleBuildDaemon) {
+
+ // Scanner needs cc1 invocations working directory
+ IntrusiveRefCntPtr<vfs::FileSystem> System =
+ createVFSFromCompilerInvocation(*Invocation, Diags);
+ ErrorOr<std::string> MaybeCWD = System->getCurrentWorkingDirectory();
+
+ if (MaybeCWD.getError()) {
+ errs() << "Could not get working directory: "
+ << MaybeCWD.getError().message() << "\n";
+ return 1;
+ }
+
+ Expected<std::vector<std::string>> MaybeUpdatedArgv =
+ cc1modbuildd::updateCC1WithModuleBuildDaemon(*Invocation, Argv, Argv0,
+ *MaybeCWD);
+ if (!MaybeUpdatedArgv) {
+ errs() << toString(std::move(MaybeUpdatedArgv.takeError())) << '\n';
+ return 1;
+ }
+
+ // CompilerInvocation::CreateFromArgs expects an ArrayRef<const char *>
+ UpdatedArgv = std::move(*MaybeUpdatedArgv);
+ CharUpdatedArgv.reserve(UpdatedArgv.size());
+ for (const auto &Arg : UpdatedArgv) {
+ CharUpdatedArgv.push_back(Arg.c_str());
+ }
+ }
+#endif
+
+ outs() << "translation unit command line" << '\n';
+ for (const auto &Arg : Argv)
+ outs() << Arg << " ";
+ outs() << "\n";
+
+ // If Argv was modified by the module build daemon create new Invocation
+ if (!Argv.equals(ArrayRef<const char *>(CharUpdatedArgv)) &&
+ !CharUpdatedArgv.empty()) {
+ Argv = ArrayRef<const char *>(CharUpdatedArgv);
+ Success = CompilerInvocation::CreateFromArgs(Clang->getInvocation(), Argv,
+ Diags, Argv0);
+ } else {
+ Clang->setInvocation(Invocation);
+ }
if (!Clang->getFrontendOpts().TimeTracePath.empty()) {
llvm::timeTraceProfilerInitialize(
@@ -270,7 +332,7 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
Clang->getHeaderSearchOpts().ResourceDir.empty())
Clang->getHeaderSearchOpts().ResourceDir =
- CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
+ CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
// Create the actual diagnostics engine.
Clang->createDiagnostics();
@@ -279,8 +341,8 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
// Set an error handler, so that any LLVM backend diagnostics go through our
// error handler.
- llvm::install_fatal_error_handler(LLVMErrorHandler,
- static_cast<void*>(&Clang->getDiagnostics()));
+ llvm::install_fatal_error_handler(
+ LLVMErrorHandler, static_cast<void *>(&Clang->getDiagnostics()));
DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
if (!Success) {
diff --git a/clang/tools/driver/cc1modbuildd_main.cpp b/clang/tools/driver/cc1modbuildd_main.cpp
new file mode 100644
index 000000000000000..96b95c1c8509bf1
--- /dev/null
+++ b/clang/tools/driver/cc1modbuildd_main.cpp
@@ -0,0 +1,553 @@
+//===------- cc1modbuildd_main.cpp - Clang CC1 Module Build Daemon --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/DiagnosticCategories.h"
+#include "clang/Basic/DiagnosticFrontend.h"
+#include "clang/Frontend/TextDiagnosticBuffer.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
+#include "clang/Tooling/DependencyScanning/DependencyScanningTool.h"
+#include "clang/Tooling/DependencyScanning/ModuleDepCollector.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/Utils.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Program.h"
+#include "llvm/Support/ThreadPool.h"
+#include "llvm/Support/Threading.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+
+// TODO: Make portable
+#if LLVM_ON_UNIX
+
+#include <errno.h>
+#include <fstream>
+#include <mutex>
+#include <optional>
+#include <signal.h>
+#include <sstream>
+#include <stdbool.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <type_traits>
+#include <unistd.h>
+#include <unordered_map>
+
+using namespace llvm;
+using namespace clang;
+using namespace tooling::dependencies;
+using namespace cc1modbuildd;
+
+// Create unbuffered STDOUT stream so that any logging done by module build
+// daemon can be viewed without having to terminate the process
+static raw_fd_ostream &unbuff_outs() {
+ static raw_fd_ostream S(STDOUT_FILENO, false, true);
+ return S;
+}
+
+namespace {
+
+enum class BuildStatus { WAITING, BUILDING, BUILT };
+
+struct ModuleIDHash {
+ std::size_t
+ operator()(const clang::tooling::dependencies::ModuleID &ID) const {
+ return llvm::hash_value(ID);
+ }
+};
+
+struct ModuleBuildInfo {
+ const ModuleDeps Info;
+ BuildStatus ModuleBuildStatus;
+};
+
+// Thread safe hash map that stores dependency and build information
+class DependencyBuildData {
+public:
+ void insert(ModuleID Key, ModuleBuildInfo Value) {
+ std::lock_guard<std::mutex> lock(Mutex);
+ HashMap.insert({Key, Value});
+ }
+
+ std::optional<std::reference_wrapper<ModuleBuildInfo>> get(ModuleID Key) {
+ std::lock_guard<std::mutex> lock(Mutex);
+ if (auto search = HashMap.find(Key); search != HashMap.end())
+ return std::ref(search->second);
+ return std::nullopt;
+ }
+
+ bool updateBuildStatus(ModuleID Key, BuildStatus newStatus) {
+ std::lock_guard<std::mutex> lock(Mutex);
+ if (auto search = HashMap.find(Key); search != HashMap.end()) {
+ search->second.ModuleBuildStatus = newStatus;
+ return true;
+ }
+ return false;
+ }
+
+ void print() {
+ unbuff_outs() << "printing hash table keys" << '\n';
+ for (const auto &i : HashMap) {
+ unbuff_outs() << "Module: " << i.first.ModuleName << '\n';
+ unbuff_outs() << "Dependencies: ";
+ for (const auto &Dep : i.second.Info.ClangModuleDeps)
+ unbuff_outs() << Dep.ModuleName << ", ";
+ unbuff_outs() << '\n';
+ }
+ }
+
+private:
+ std::unordered_map<ModuleID, ModuleBuildInfo, ModuleIDHash> HashMap;
+ std::mutex Mutex;
+};
+
+class ModuleBuildDaemonServer {
+public:
+ SmallString<128> BasePath;
+ SmallString<128> SocketPath;
+ SmallString<128> PidPath;
+
+ ModuleBuildDaemonServer(SmallString<128> Path, ArrayRef<const char *> Argv)
+ : BasePath(Path), SocketPath(Path) {
+ llvm::sys::path::append(SocketPath, SOCKET_FILE_NAME);
+ }
+
+ ~ModuleBuildDaemonServer() { shutdownDaemon(SIGTERM); }
+
+ int forkDaemon();
+ int launchDaemon();
+ int listenForClients();
+
+ static void handleClient(int Client);
+ static void handleRegister(int Client, RegisterMsg ClientRequest);
+
+ void shutdownDaemon(int signal) {
+ unlink(SocketPath.c_str());
+ shutdown(ListenSocketFD, SHUT_RD);
+ close(ListenSocketFD);
+ exit(EXIT_SUCCESS);
+ }
+
+private:
+ // Initializes and returns DiagnosticsEngine
+ pid_t Pid = -1;
+ int ListenSocketFD = -1;
+};
+
+// Required to handle SIGTERM by calling Shutdown
+ModuleBuildDaemonServer *DaemonPtr = nullptr;
+void handleSignal(int Signal) {
+ if (DaemonPtr != nullptr) {
+ DaemonPtr->shutdownDaemon(Signal);
+ }
+}
+} // namespace
+
+static bool verbose = false;
+static void verbose_print(const llvm::Twine &message) {
+ if (verbose) {
+ unbuff_outs() << message << '\n';
+ }
+}
+
+static DependencyBuildData DaemonBuildData;
+
+static Expected<TranslationUnitDeps>
+scanTranslationUnit(cc1modbuildd::RegisterMsg Request) {
+
+ DependencyScanningService Service(ScanningMode::DependencyDirectivesScan,
+ ScanningOutputFormat::Full,
+ /*OptimizeArgs*/ false,
+ /*EagerLoadModules*/ false);
+
+ DependencyScanningTool Tool(Service);
+ llvm::DenseSet<ModuleID> AlreadySeenModules;
+ auto LookupOutput = [&](const ModuleID &MID, ModuleOutputKind MOK) {
+ return "/tmp/" + MID.ContextHash;
+ };
+
+ // Add executable path to cc1 command line for dependency scanner
+ std::vector<std::string> ScannerCommandLine;
+ ScannerCommandLine.push_back(Request.ExecutablePath.value());
+ ScannerCommandLine.insert(ScannerCommandLine.end(),
+ Request.CC1CommandLine.value().begin(),
+ Request.CC1CommandLine.value().end());
+
+ Expected<TranslationUnitDeps> MaybeTUDeps =
+ Tool.getTranslationUnitDependencies(ScannerCommandLine,
+ Request.WorkingDirectory.value(),
+ AlreadySeenModules, LookupOutput);
+
+ if (!MaybeTUDeps)
+ return std::move(MaybeTUDeps.takeError());
+
+ return std::move(*MaybeTUDeps);
+}
+
+static void storeScanResults(const TranslationUnitDeps &Results) {
+
+ if (Results.ModuleGraph.empty())
+ return;
+
+ // Insert children
+ for (const ModuleDeps &MD : Results.ModuleGraph)
+ DaemonBuildData.insert(MD.ID, {MD, BuildStatus::WAITING});
+}
+
+// Remove -fmodule-build-daemon and add -fno-implicit-modules to command line.
+// Return value can either be a std::vector of std::string or StringRef
+template <typename T>
+static std::vector<T> modifyCC1(const std::vector<std::string> &CommandLine) {
+ static_assert(std::is_same_v<T, std::string> || std::is_same_v<T, StringRef>);
+
+ std::vector<T> ReturnArgs;
+ ReturnArgs.reserve(CommandLine.size());
+
+ for (const auto &Arg : CommandLine) {
+ if (Arg != "-fmodule-build-daemon")
+ ReturnArgs.emplace_back(Arg);
+ }
+ ReturnArgs.emplace_back("-fno-implicit-modules");
+ return ReturnArgs;
+}
+
+// TODO: Return llvm::Error
+static void precompileModuleID(const StringRef Executable, const ModuleID ID) {
+ unbuff_outs() << "module " << ID.ModuleName << " will be built" << '\n';
+
+ std::optional<std::reference_wrapper<ModuleBuildInfo>> MaybeDeps =
+ DaemonBuildData.get(ID);
+ if (!MaybeDeps)
+ return;
+ ModuleBuildInfo &Deps = MaybeDeps->get();
+
+ // TODO: look into making getBuildArguments a const method
+ ModuleDeps &NonConstDepsInfo = const_cast<ModuleDeps &>(Deps.Info);
+ const std::vector<std::string> &Args = NonConstDepsInfo.getBuildArguments();
+ std::vector<std::string> NonConstArgs =
+ const_cast<std::vector<std::string> &>(Args);
+
+ unbuff_outs() << "original command line" << '\n';
+ for (const auto &Arg : Args)
+ unbuff_outs() << Arg << " ";
+ unbuff_outs() << "\n\n";
+
+ const std::vector<StringRef> ProcessedArgs =
+ modifyCC1<StringRef>(NonConstArgs);
+
+ std::vector<StringRef> ExecuteCommandLine;
+ ExecuteCommandLine.push_back(Executable);
+ ExecuteCommandLine.insert(ExecuteCommandLine.end(), ProcessedArgs.begin(),
+ ProcessedArgs.end());
+
+ unbuff_outs() << "new command line" << '\n';
+ for (const auto &Arg : NonConstArgs)
+ unbuff_outs() << Arg << " ";
+ unbuff_outs() << "\n";
+
+ // TODO: Handle error code returned from ExecuteAndWait
+ llvm::sys::ExecuteAndWait(Executable,
+ ArrayRef<StringRef>(ExecuteCommandLine));
+ DaemonBuildData.updateBuildStatus(ID, BuildStatus::BUILT);
+
+ unbuff_outs() << "module " << ID.ModuleName << " finished building" << '\n';
+ unbuff_outs() << "\n\n";
+
+ return;
+}
+
+// TODO: implement concurrent approach
+// can only handle one translation unit at a time
+static void buildModuleID(const StringRef Executable, const ModuleID ID) {
+
+ std::optional<std::reference_wrapper<ModuleBuildInfo>> MaybeDeps =
+ DaemonBuildData.get(ID);
+ if (!MaybeDeps)
+ return;
+ ModuleBuildInfo &Deps = MaybeDeps->get();
+
+ if (Deps.ModuleBuildStatus == BuildStatus::BUILT)
+ return;
+
+ for (const ModuleID &Dep : Deps.Info.ClangModuleDeps)
+ buildModuleID(Executable, Dep);
+
+ // Do not build the root ID aka the registered translation unit
+ if (ID.ModuleName.empty())
+ return;
+
+ precompileModuleID(Executable, ID);
+ return;
+}
+
+// Takes a client request in the form of a cc1modbuildd::SocketMsg and
+// returns an updated cc1 command line for the registered cc1 invocation
+// after building all modular dependencies
+static Expected<std::vector<std::string>>
+processRegisterRequest(cc1modbuildd::RegisterMsg Request) {
+
+ Expected<TranslationUnitDeps> MaybeTUDeps = scanTranslationUnit(Request);
+ if (!MaybeTUDeps)
+ return std::move(MaybeTUDeps.takeError());
+ const TranslationUnitDeps TUDeps = std::move(*MaybeTUDeps);
+
+ // For now write dependencies to log file
+ for (const auto &Dep : TUDeps.FileDeps)
+ unbuff_outs() << Dep << '\n';
+
+ // If TU does not depend on modules then return command line as is
+ if (TUDeps.ModuleGraph.empty())
+ return Request.CC1CommandLine.value();
+
+ unbuff_outs() << "modules detected" << '\n';
+ storeScanResults(TUDeps);
+ DaemonBuildData.print();
+
+ // Build all direct and transitive dependencies by iterating over direct
+ // dependencies
+ for (const ModuleID &Dep : TUDeps.ClangModuleDeps)
+ buildModuleID(Request.ExecutablePath.value(), Dep);
+
+ return modifyCC1<std::string>(TUDeps.Commands[0].Arguments);
+}
+
+// Forks and detaches process, creating module build daemon
+int ModuleBuildDaemonServer::forkDaemon() {
+
+ pid_t pid = fork();
+
+ if (pid < 0) {
+ exit(EXIT_FAILURE);
+ }
+ if (pid > 0) {
+ exit(EXIT_SUCCESS);
+ }
+
+ Pid = getpid();
+
+ // close(STDIN_FILENO);
+ // close(STDOUT_FILENO);
+ // close(STDERR_FILENO);
+
+ // SmallString<128> STDOUT = BasePath;
+ // llvm::sys::path::append(STDOUT, STDOUT_FILE_NAME);
+ // freopen(STDOUT.c_str(), "a", stdout);
+
+ // SmallString<128> STDERR = BasePath;
+ // llvm::sys::path::append(STDERR, STDERR_FILE_NAME);
+ // freopen(STDERR.c_str(), "a", stderr);
+
+ if (signal(SIGTERM, handleSignal) == SIG_ERR) {
+ errs() << "failed to handle SIGTERM" << '\n';
+ exit(EXIT_FAILURE);
+ }
+ if (signal(SIGHUP, SIG_IGN) == SIG_ERR) {
+ errs() << "failed to ignore SIGHUP" << '\n';
+ exit(EXIT_FAILURE);
+ }
+ if (setsid() == -1) {
+ errs() << "setsid failed" << '\n';
+ exit(EXIT_FAILURE);
+ }
+
+ return EXIT_SUCCESS;
+}
+
+// Creates unix socket for IPC with module build daemon
+int ModuleBuildDaemonServer::launchDaemon() {
+
+ // new socket
+ if ((ListenSocketFD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ std::perror("Socket create error: ");
+ exit(EXIT_FAILURE);
+ }
+
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(struct sockaddr_un));
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, SocketPath.c_str(), sizeof(addr.sun_path) - 1);
+
+ // bind to local address
+ if (bind(ListenSocketFD, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+
+ // If the socket address is already in use, exit because another module
+ // build daemon has successfully launched. When translation units are
+ // compiled in parallel, until the socket file is created, all clang
+ // invocations will spawn a module build daemon.
+ if (errno == EADDRINUSE) {
+ close(ListenSocketFD);
+ exit(EXIT_SUCCESS);
+ }
+ std::perror("Socket bind error: ");
+ exit(EXIT_FAILURE);
+ }
+ verbose_print("mbd created and binded to socket address at: " + SocketPath);
+
+ // set socket to accept incoming connection request
+ unsigned MaxBacklog = llvm::hardware_concurrency().compute_thread_count();
+ if (listen(ListenSocketFD, MaxBacklog) == -1) {
+ std::perror("Socket listen error: ");
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
+}
+
+void ModuleBuildDaemonServer::handleRegister(int Client,
+ RegisterMsg ClientRequest) {
+
+ Expected<std::vector<std::string>> MaybeExplicitCC1 =
+ processRegisterRequest(ClientRequest);
+
+ // if getUpdatedCC1 fails emit error
+ if (!MaybeExplicitCC1) {
+
+ RegisterMsg Msg(ActionType::REGISTER, StatusType::FAILURE);
+ llvm::Error RegisterFailureWriteErr = writeSocketMsgToSocket(Msg, Client);
+
+ if (RegisterFailureWriteErr) {
+ writeError(llvm::joinErrors(std::move(RegisterFailureWriteErr),
+ std::move(MaybeExplicitCC1.takeError())),
+ "Failed to process register request and was unable to notify "
+ "clang infocation: ");
+ return;
+ }
+ writeError(MaybeExplicitCC1.takeError(),
+ "Failed to process register request: ");
+ return;
+ }
+
+ // getUpdateCC1 success
+ std::vector<std::string> ExplicitCC1 = std::move(*MaybeExplicitCC1);
+
+ unbuff_outs() << "modified command line for translation unit" << '\n';
+ for (const auto &Arg : ExplicitCC1)
+ unbuff_outs() << Arg << " ";
+ unbuff_outs() << "\n";
+
+ // Send new CC1 command line to waiting clang invocation
+ RegisterMsg Msg(ActionType::REGISTER, StatusType::SUCCESS,
+ ClientRequest.WorkingDirectory, ClientRequest.ExecutablePath,
+ ExplicitCC1);
+
+ llvm::Error RegisterSuccessWriteErr = writeSocketMsgToSocket(Msg, Client);
+
+ if (RegisterSuccessWriteErr) {
+ writeError(std::move(RegisterSuccessWriteErr),
+ "Failed to notify clang invocation that register request was a "
+ "success: ");
+ return;
+ }
+ return;
+}
+
+// Function submitted to thread pool with each client connection. Not
+// responsible for closing client connections
+void ModuleBuildDaemonServer::handleClient(int Client) {
+
+ // Read handshake from client
+ Expected<HandshakeMsg> MaybeHandshake =
+ readSocketMsgFromSocket<HandshakeMsg>(Client);
+
+ if (!MaybeHandshake) {
+ writeError(MaybeHandshake.takeError(),
+ "Failed to read handshake message from socket: ");
+ return;
+ }
+
+ // Handle HANDSHAKE
+ RegisterMsg Msg(ActionType::HANDSHAKE, StatusType::SUCCESS);
+ llvm::Error WriteErr = writeSocketMsgToSocket(Msg, Client);
+
+ if (WriteErr) {
+ writeError(std::move(WriteErr),
+ "Failed to notify client that handshake was received");
+ return;
+ }
+
+ // Read register request from client
+ Expected<RegisterMsg> MaybeRegister =
+ readSocketMsgFromSocket<RegisterMsg>(Client);
+
+ if (!MaybeRegister) {
+ writeError(MaybeRegister.takeError(),
+ "Failed to read registration message from socket: ");
+ return;
+ }
+
+ RegisterMsg Register = std::move(*MaybeRegister);
+ handleRegister(Client, Register);
+ return;
+}
+
+int ModuleBuildDaemonServer::listenForClients() {
+
+ llvm::ThreadPool Pool;
+ int Client;
+
+ while (true) {
+
+ if ((Client = accept(ListenSocketFD, NULL, NULL)) == -1) {
+ std::perror("Socket accept error: ");
+ continue;
+ }
+
+ Pool.async(handleClient, Client);
+ }
+ return 0;
+}
+
+// Module build daemon is spawned with the following command line:
+//
+// clang -cc1modbuildd <path> -v
+//
+// <path> defines the location of all files created by the module build daemon
+// and should follow the format /path/to/dir. For example, `clang
+// -cc1modbuildd /tmp/` creates a socket file at `/tmp/mbd.sock`. /tmp is also
+// valid.
+//
+// When module build daemons are spawned by cc1 invocations, <path> follows
+// the format /tmp/clang-<BLAKE3HashOfClangFullVersion>
+//
+// -v is optional and provides debug information
+//
+int cc1modbuildd_main(ArrayRef<const char *> Argv) {
+
+ if (Argv.size() < 1) {
+ outs() << "spawning a module build daemon requies a command line format of "
+ "`clang -cc1modbuildd <path>`. <path> defines where the module "
+ "build daemon will create files"
+ << '\n';
+ return 1;
+ }
+
+ // Where to store log files and socket address
+ // TODO: Add check to confirm BasePath is directory
+ SmallString<128> BasePath(Argv[0]);
+ llvm::sys::fs::create_directories(BasePath);
+ ModuleBuildDaemonServer Daemon(BasePath, Argv);
+
+ // Used to handle signals
+ DaemonPtr = &Daemon;
+
+ if (find(Argv, StringRef("-v")) != Argv.end())
+ verbose = true;
+
+ Daemon.forkDaemon();
+ Daemon.launchDaemon();
+ Daemon.listenForClients();
+
+ return 0;
+}
+
+#endif // LLVM_ON_UNIX
diff --git a/clang/tools/driver/driver.cpp b/clang/tools/driver/driver.cpp
index 531b5b4a61c1804..9697bc6d457776d 100644
--- a/clang/tools/driver/driver.cpp
+++ b/clang/tools/driver/driver.cpp
@@ -213,6 +213,9 @@ extern int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0,
extern int cc1gen_reproducer_main(ArrayRef<const char *> Argv,
const char *Argv0, void *MainAddr,
const llvm::ToolContext &);
+#if LLVM_ON_UNIX
+extern int cc1modbuildd_main(ArrayRef<const char *> Argv);
+#endif
static void insertTargetAndModeArgs(const ParsedClangName &NameParts,
SmallVectorImpl<const char *> &ArgVector,
@@ -369,9 +372,19 @@ static int ExecuteCC1Tool(SmallVectorImpl<const char *> &ArgV,
if (Tool == "-cc1gen-reproducer")
return cc1gen_reproducer_main(ArrayRef(ArgV).slice(2), ArgV[0],
GetExecutablePathVP, ToolContext);
- // Reject unknown tools.
+ if (Tool == "-cc1modbuildd") {
+#if LLVM_ON_UNIX
+ return cc1modbuildd_main(ArrayRef(ArgV).slice(2));
+#else
+ llvm::errs() << "-cc1modbuildd not supported by current platform" << '\n';
+ return 1;
+#endif
+ }
+
+ // Reject unknown tools
llvm::errs() << "error: unknown integrated tool '" << Tool << "'. "
- << "Valid tools include '-cc1' and '-cc1as'.\n";
+ << "Valid tools include '-cc1', '-cc1as', '-cc1gen-reproducer', "
+ "and '-cc1modbuildd'.\n";
return 1;
}
>From 749d0489b403686b225dbaa39af5ba4f2626ff50 Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Sat, 7 Oct 2023 16:54:25 -0400
Subject: [PATCH 2/2] temporarily remove tests. if a test fails daemon will
never terminate
---
clang/test/ModuleBuildDaemon/launch.c | 10 -------
clang/test/ModuleBuildDaemon/parallel-scan.c | 31 --------------------
clang/test/ModuleBuildDaemon/scan.c | 20 -------------
3 files changed, 61 deletions(-)
delete mode 100644 clang/test/ModuleBuildDaemon/launch.c
delete mode 100644 clang/test/ModuleBuildDaemon/parallel-scan.c
delete mode 100644 clang/test/ModuleBuildDaemon/scan.c
diff --git a/clang/test/ModuleBuildDaemon/launch.c b/clang/test/ModuleBuildDaemon/launch.c
deleted file mode 100644
index 575aba0ac3ce603..000000000000000
--- a/clang/test/ModuleBuildDaemon/launch.c
+++ /dev/null
@@ -1,10 +0,0 @@
-// REQUIRES: !system-windows
-
-// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
-
-// RUN: %clang -cc1modbuildd mbd-launch -v
-// RUN: cat mbd-launch/mbd.out | FileCheck %s -DPREFIX=%t
-
-// CHECK: mbd created and binded to socket address at: mbd-launch/mbd.sock
-
-// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
\ No newline at end of file
diff --git a/clang/test/ModuleBuildDaemon/parallel-scan.c b/clang/test/ModuleBuildDaemon/parallel-scan.c
deleted file mode 100644
index 0dddaa0f161457e..000000000000000
--- a/clang/test/ModuleBuildDaemon/parallel-scan.c
+++ /dev/null
@@ -1,31 +0,0 @@
-// Confirm module build daemon can handle two translation units simultaneously
-
-// REQUIRES: !system-windows
-
-// RUN: if pgrep -f "cc1modbuildd parallel-scan"; then pkill -f "cc1modbuildd parallel-scan"; fi
-// : rm -rf parallel-scan
-// RUN: split-file %s %t
-
-//--- main.c
-#include "app.h"
-int main() {return 0;}
-
-//--- app.c
-#include "util.h"
-
-//--- app.h
-
-//--- util.h
-
-// RUN: %clang -fmodule-build-daemon=parallel-scan %t/main.c %t/app.c
-// RUN: pwd && ls
-// RUN: cat parallel-scan/mbd.out
-// RUN: cat parallel-scan/mbd.out | FileCheck %s -DPREFIX=%t
-
-// CHECK: main.c
-// CHECK: app.h
-// CHECK: app.c
-// CHECK: util.h
-
-// RUN: if pgrep -f "cc1modbuildd parallel-scan"; then pkill -f "cc1modbuildd parallel-scan"; fi
-// : rm -rf parallel-scan
diff --git a/clang/test/ModuleBuildDaemon/scan.c b/clang/test/ModuleBuildDaemon/scan.c
deleted file mode 100644
index f70210362ab6443..000000000000000
--- a/clang/test/ModuleBuildDaemon/scan.c
+++ /dev/null
@@ -1,20 +0,0 @@
-// REQUIRES: !system-windows
-
-// RUN: if pgrep -f "cc1modbuildd scan"; then pkill -f "cc1modbuildd scan"; fi
-// RUN: rm -rf scan
-// RUN: split-file %s %t
-
-//--- main.c
-#include "header.h"
-int main() {return 0;}
-
-//--- header.h
-
-// RUN: %clang -fmodule-build-daemon=scan %t/main.c
-// RUN: cat scan/mbd.out | FileCheck %s -DPREFIX=%t
-
-// CHECK: main.c
-// CHECK: header.h
-
-// RUN: if pgrep -f "cc1modbuildd scan"; then pkill -f "cc1modbuildd scan"; fi
-// RUN: rm -rf scan
More information about the cfe-commits
mailing list