[WIP][clang] initial commit for module build daemon

[cpsughrue]

Summary

Goal: A source file that doesn't depend on any modules can connect to daemon, get scanned, find that there are no modules, then resumes building. If there are module haves it llvm fatal error not implemented.

clang/include/clang/Driver/Options.td

 // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
 // been rewritten in terms of something more generic, remove the Opts.CUDA
 // term here.
 defm declspec : BoolOption<"f", "declspec",
   LangOpts<"DeclSpecKeyword">, DefaultFalse,
   PosFlag<SetTrue, [], "Allow", [fms_extensions.KeyPath, fborland_extensions.KeyPath, cuda.KeyPath]>,
   NegFlag<SetFalse, [], "Disallow">,
   BothFlags<[CC1Option], " __declspec as a keyword">>, Group<f_clang_Group>;
+
+def fmodule_build_daemon : Flag<["-"], "fmodule-build-daemon">, Group<f_Group>,
+  Flags<[NoXarchOption, CC1Option]>,
+  HelpText<"Enables module build daemon functionality">,
+  MarshallingInfoFlag<FrontendOpts<"ModuleBuildDaemon">>;
+
 def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
   Flags<[NoXarchOption, CC1Option]>, MetaVarName<"<directory>">,
   HelpText<"Specify the module cache path">;
 def fmodules_user_build_path : Separate<["-"], "fmodules-user-build-path">, Group<i_Group>,
   Flags<[NoXarchOption, CC1Option]>, MetaVarName<"<directory>">,
   HelpText<"Specify the module user build path">,
   MarshallingInfoString<HeaderSearchOpts<"ModuleUserBuildPath">>;
 def fprebuilt_module_path : Joined<["-"], "fprebuilt-module-path=">, Group<i_Group>,

clang/include/clang/Frontend/FrontendOptions.h

public:
   unsigned IsSystemModule : 1;
 
   /// Output (and read) PCM files regardless of compiler errors.
   unsigned AllowPCMWithCompilerErrors : 1;
 
   /// 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.
   ASTDumpOutputFormat ASTDumpFormat = ADOF_Default;
 
   enum {
     ARCMT_None,
     ARCMT_Check,

clang/include/clang/Tooling/ModuleBuildDaemon/Protocall.h

+//===---------------------------- Protocall.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_PROTOCAL_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_PROTOCAL_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"
+
+#define MAX_BUFFER 2048
+
+using namespace clang;
+using namespace llvm;
+
+namespace cc1modbuildd {
+
+enum Action { SCAN };
+
+struct Command {
+  Action CMD;
+  std::string WorkingDirectory;
+  std::vector<std::string> FullCommandLine;
+};
+
+Expected<int> CreateSocket();
+
+Expected<int> ConnectToSocket(StringRef SocketPath, int FD);
+
+bool ModuleBuildDaemonExists(StringRef BasePath);
+
+Expected<bool> SpawnModuleBuildDaemon(StringRef BasePath, const char *Argv0);
+
+SmallString<128> GetBasePath();
+
+llvm::Error ReadMsg(int fd, std::function<int(char*)> func);
+
+int SendMessage(CompilerInstance &Clang, StringRef Argv0,
+                ArrayRef<const char *> Argv, std::string WD,
+                StringRef BasePath);
+
+} // namespace cc1modbuildd
+
+template <> struct llvm::yaml::ScalarEnumerationTraits<cc1modbuildd::Action> {
+  static void enumeration(IO &io, cc1modbuildd::Action &value) {
+    io.enumCase(value, "SCAN", cc1modbuildd::SCAN);
+  }
+};
+
+template <> struct llvm::yaml::MappingTraits<cc1modbuildd::Command> {
+  static void mapping(IO &io, cc1modbuildd::Command &info) {
+    io.mapRequired("CMD", info.CMD);
+    io.mapRequired("WorkingDirectory", info.WorkingDirectory);
+    io.mapRequired("FullCommandLine", info.FullCommandLine);
+  }
+};
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_PROTOCAL_H

clang/lib/Driver/ToolChains/Clang.cpp

 //===-- Clang.cpp - Clang+LLVM ToolChain Implementations --------*- C++ -*-===//
 //
 // 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.h"
 #include "AMDGPU.h"
 #include "Arch/AArch64.h"
 #include "Arch/ARM.h"
 #include "Arch/CSKY.h"
 #include "Arch/LoongArch.h"
 #include "Arch/M68k.h"
 #include "Arch/Mips.h"
bool HaveStdCXXModules =
        Std->containsValue("c++20") || Std->containsValue("gnu++20") ||
        Std->containsValue("c++2b") || Std->containsValue("gnu++2b") ||
        Std->containsValue("c++23") || Std->containsValue("gnu++23") ||
        Std->containsValue("c++2c") || Std->containsValue("gnu++2c") ||
        Std->containsValue("c++26") || Std->containsValue("gnu++26") ||
        Std->containsValue("c++latest") || Std->containsValue("gnu++latest"));
   bool HaveModules = HaveStdCXXModules;
 
+  // -fmodule-build-daemon enables the module build daemon functionality
+  if (Args.hasArg(options::OPT_fmodule_build_daemon))
+    Args.AddLastArg(CmdArgs, options::OPT_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.
   bool HaveClangModules = false;
   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
                                      options::OPT_fno_cxx_modules, true);
     if (AllowedInCXX || !IsCXX) {

clang/lib/Tooling/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Option
   FrontendOpenMP
   Support
   TargetParser
   )
 
 add_subdirectory(Core)
 add_subdirectory(Inclusions)
 add_subdirectory(Refactoring)
 add_subdirectory(ASTDiff)
 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)
 if(PATH_LIB_START EQUAL -1)
   message(FATAL_ERROR "Couldn't find lib component in binary directory")
 endif()
 math(EXPR PATH_LIB_END "${PATH_LIB_START}+5")
 string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD)

clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Support
+  )
+
+add_clang_library(clangModuleBuildDaemon
+  Protocall.cpp
+  )
 No newline at end of file

clang/lib/Tooling/ModuleBuildDaemon/Protocall.cpp

+//===--------------------------- Protocall.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/Protocall.h"
+#include "clang/Basic/Version.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/BLAKE3.h"
+
+// TODO: Make portable
+#if LLVM_ON_UNIX
+
+#include <cerrno>
+#include <fstream>
+#include <iostream>
+#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;
+
+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, int FD) {
+
+  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;
+}
+
+bool cc1modbuildd::ModuleBuildDaemonExists(StringRef BasePath) {
+  SmallString<128> SocketPath = BasePath;
+  SocketPath.append(".sock");
+
+  Expected<int> TestFD = cc1modbuildd::CreateSocket();
+  if (!TestFD) {
+    consumeError(TestFD.takeError());
+    return false;
+  }
+
+  Expected<int> ConnectedFD = ConnectToSocket(SocketPath, std::move(*TestFD));
+  if (llvm::sys::fs::exists(SocketPath) && ConnectedFD) {
+    close(std::move(*ConnectedFD));
+    return true;
+  }
+
+  consumeError(ConnectedFD.takeError());
+  return false;
+}
+
+Expected<bool> 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 true;
+}
+
+SmallString<128> 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, "mbd");
+  return BasePath;
+}
+
+llvm::Error cc1modbuildd::ReadMsg(int fd, std::function<int(char*)> func)
+{
+  char buf[MAX_BUFFER];
+  memset(buf, 0, MAX_BUFFER);
+  int n = read(fd, buf, MAX_BUFFER);
+
+  if (n < 0) {
+    std::string msg = "socket read error: " + std::string(strerror(errno));
+    return llvm::make_error<StringError>(msg, inconvertibleErrorCode());
+  } else if (n == 0) {
+    return llvm::make_error<StringError>("EOF", inconvertibleErrorCode());
+  } else {
+    func(buf);
+  }
+  return llvm::Error::success();
+}
+
+// Temporary test component used to send messages to cc1modbuildd
+int cc1modbuildd::SendMessage(CompilerInstance &Clang, StringRef Argv0,
+                              ArrayRef<const char *> Argv, std::string WD,
+                              StringRef BasePath) {
+
+  std::vector<std::string> CC1Cmd = Clang.getInvocation().getCC1CommandLine();
+  CC1Cmd.insert(CC1Cmd.begin(), Argv0.str());
+  cc1modbuildd::Command Command{SCAN, WD, CC1Cmd};
+
+  std::string buffer;
+  llvm::raw_string_ostream OS(buffer);
+  llvm::yaml::Output yout(OS);
+
+  yout << Command;
+
+  // FIXME: Should not need to append again here
+  SmallString<128> SocketPath = BasePath;
+  SocketPath.append(".sock");
+
+  Expected<int> MaybeFD = cc1modbuildd::CreateSocket();
+  if (!MaybeFD) {
+    std::cout << toString(MaybeFD.takeError()) << std::endl;
+    return -1;
+  }
+  consumeError(MaybeFD.takeError());
+  int RealFD = std::move(*MaybeFD);
+
+  Expected<int> MaybeWriteFD = cc1modbuildd::ConnectToSocket(SocketPath, RealFD);
+  if (!MaybeWriteFD) {
+    std::cout << toString(MaybeWriteFD.takeError()) << std::endl;
+    return -1;
+  }
+  int WriteFD = std::move(*MaybeWriteFD);
+
+  // write
+  ssize_t message_size = static_cast<ssize_t>(buffer.size());
+  if (write(WriteFD, buffer.c_str(), buffer.size()) != message_size) {
+    std::perror("write error");
+    close(WriteFD);
+    return -1;
+  }
+
+  char buf[2048];
+  memset(buf, 0, 2048);
+
+  // read MAX_BUFFER bytes from client to buf
+  int n = read(WriteFD, buf, 2048);
+
+  if (n < 0) {
+    perror("read error");
+    return -1;
+  } else if (n == 0) {
+    std::cerr << "EOF" << std::endl;
+    return -1;
+  } else {
+    std::cout << "message: " << buf << std::endl;
+  }
+
+  close(WriteFD);
+  return 0;
+}
+#endif // LLVM_ON_UNIX
 No newline at end of file

clang/tools/driver/CMakeLists.txt

if(CLANG_PLUGIN_SUPPORT)
   set(support_plugins SUPPORT_PLUGINS)
 endif()
 
 add_clang_tool(clang
   driver.cpp
   cc1_main.cpp
   cc1as_main.cpp
   cc1gen_reproducer_main.cpp
+  cc1modbuildd_main.cpp
 
   DEPENDS
   intrinsics_gen
   ${support_plugins}
   GENERATE_DRIVER
   )
 
 clang_target_link_libraries(clang
   PRIVATE
   clangBasic
   clangCodeGen
+  clangDependencyScanning
   clangDriver
   clangFrontend
   clangFrontendTool
+  clangModuleBuildDaemon
   clangSerialization
   )
 
 if(WIN32 AND NOT CYGWIN)
   # Prevent versioning if the buildhost is targeting for Win32.
 else()
   set_target_properties(clang PROPERTIES VERSION ${CLANG_EXECUTABLE_VERSION})
 endif()

clang/tools/driver/cc1_main.cpp

 #include "clang/Driver/Options.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/FrontendTool/Utils.h"
+#include "clang/Tooling/ModuleBuildDaemon/Protocall.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/LinkAllPasses.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include <cstdio>
+#include <filesystem>
+#include <iostream>
+
+// to communicate with module build daemon
+#include <string>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
 
 #ifdef CLANG_HAVE_RLIMITS
 #include <sys/resource.h>
 #endif
 
 using namespace clang;
 using namespace llvm::opt;
 
llvm::install_fatal_error_handler(LLVMErrorHandler,
                                   static_cast<void*>(&Clang->getDiagnostics()));
 
   DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
   if (!Success) {
     Clang->getDiagnosticClient().finish();
     return 1;
   }
 
+#if LLVM_ON_UNIX
+  // handle module build daemon functionality if enabled
+  if (Clang->getInvocation().getFrontendOpts().ModuleBuildDaemon) {
+
+    SmallString<128> BasePath = cc1modbuildd::GetBasePath();
+
+    // start module build daemon if not already running
+    if (!cc1modbuildd::ModuleBuildDaemonExists(BasePath)) {
+      Expected<bool> SpawnedDaemon =
+          cc1modbuildd::SpawnModuleBuildDaemon(BasePath, Argv0);
+      std::cout << toString(std::move(SpawnedDaemon.takeError())) << std::endl;
+      sleep(10);
+    }
+    std::string CWD = std::filesystem::current_path().string();
+    cc1modbuildd::SendMessage(*Clang, Argv0, Argv, CWD, BasePath);
+  }
+#endif
+
   // Execute the frontend actions.
   {
     llvm::TimeTraceScope TimeScope("ExecuteCompiler");
     Success = ExecuteCompilerInvocation(Clang.get());
   }
 
   // If any timers were active but haven't been destroyed yet, print their
   // results now.  This happens in -disable-free mode.

clang/tools/driver/cc1modbuildd_main.cpp

+//===------- 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/Tooling/DependencyScanning/DependencyScanningService.h"
+#include "clang/Tooling/DependencyScanning/DependencyScanningTool.h"
+#include "clang/Tooling/DependencyScanning/ModuleDepCollector.h"
+#include "clang/Tooling/ModuleBuildDaemon/Protocall.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.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 <fstream>
+#include <iostream>
+#include <signal.h>
+#include <sstream>
+#include <stdbool.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#define MAX_BUFFER 2048
+#define BASE_FILE "clang-mbd"
+
+static constexpr const char *SocketExtension = ".sock";
+static constexpr const char *PidExtension = ".pid";
+
+using namespace llvm;
+using namespace clang;
+
+static void Scan(cc1modbuildd::Command Command) {
+
+  tooling::dependencies::DependencyScanningService Service(
+      tooling::dependencies::ScanningMode::DependencyDirectivesScan,
+      tooling::dependencies::ScanningOutputFormat::Full,
+      /*OptimizeArgs*/ false,
+      /*EagerLoadModules*/ false);
+
+  tooling::dependencies::DependencyScanningTool Tool(Service);
+
+  llvm::DenseSet<clang::tooling::dependencies::ModuleID> AlreadySeenModules;
+  auto LookupOutput = [&](const tooling::dependencies::ModuleID &MID,
+                          tooling::dependencies::ModuleOutputKind MOK) {
+    return MID.ContextHash;
+  };
+
+  auto MaybeFile = Tool.getTranslationUnitDependencies(
+      Command.FullCommandLine, Command.WorkingDirectory, AlreadySeenModules,
+      LookupOutput);
+
+  std::cout << toString(MaybeFile.takeError()) << std::endl;
+
+  clang::tooling::dependencies::TranslationUnitDeps TUDeps =
+      std::move(*MaybeFile);
+
+  for (auto const &Dep : TUDeps.FileDeps) {
+    std::cout << Dep << std::endl;
+  }
+}
+
+namespace {
+class ModuleBuildDaemonServer {
+public:
+  SmallString<128> BasePath;
+  SmallString<128> SocketPath;
+  SmallString<128> PidPath;
+
+  ModuleBuildDaemonServer(SmallString<128> Path)
+      : BasePath(Path), SocketPath(Path), PidPath(Path) {
+    SocketPath.append(SocketExtension);
+    PidPath.append(PidExtension);
+  }
+
+  ~ModuleBuildDaemonServer() { Shutdown(SIGTERM); }
+
+  int Fork();
+  int Launch();
+  int Listen();
+
+  // FIXME: Shutdown is not called when computer is powered off
+  void Shutdown(int signal) {
+    ::unlink(SocketPath.c_str());
+    ::shutdown(ListenSocketFD, SHUT_RD);
+    ::close(ListenSocketFD);
+    exit(EXIT_SUCCESS);
+  }
+
+private:
+  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->Shutdown(signal);
+  }
+}
+} // namespace
+
+// Forks and detaches process, creating module build daemon
+int ModuleBuildDaemonServer::Fork() {
+
+  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);
+
+  freopen("daemon.out", "a", stdout);
+  freopen("daemon.err", "a", stderr);
+
+  if (::signal(SIGTERM, HandleSignal) == SIG_ERR)
+    // FIXME: should be replaced by error handler (reportError)
+    std::cout << "failed to handle SIGTERM" << std::endl;
+  if (::signal(SIGHUP, SIG_IGN) == SIG_ERR)
+    // FIXME: should be replaced by error handler (reportError)
+    std::cout << "failed to ignore SIGHUP" << std::endl;
+  if (::setsid() == -1)
+    // FIXME: should be replaced by error handler (reportError)
+    std::cout << "setsid failed" << std::endl;
+
+  std::cout << "daemon initialization complete!" << std::endl;
+  return EXIT_SUCCESS;
+}
+
+// Creates unix socket for IPC with module build daemon
+int ModuleBuildDaemonServer::Launch() {
+
+  struct sockaddr_un addr;
+
+  // new socket
+  if ((ListenSocketFD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+    std::perror("socket error");
+    return -1;
+  }
+
+  // set addr to all 0s
+  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) {
+    std::perror("bind error");
+    return -1;
+  }
+
+  // set socket to accept incoming connection request
+  unsigned MaxBacklog = llvm::hardware_concurrency().compute_thread_count();
+  if (::listen(ListenSocketFD, MaxBacklog) == -1) {
+    std::perror("listen error");
+    return -1;
+  }
+
+  return 0;
+}
+
+int ModuleBuildDaemonServer::Listen() {
+
+  auto Service = [](int client) {
+
+    auto HandleMsg = [](char* buf) {
+      cc1modbuildd::Command Command;
+      llvm::yaml::Input yin(buf);
+
+      yin >> Command;
+      if (yin.error())
+        return -1;
+
+      Scan(Command);
+      return 0;
+    };
+
+    llvm::Error Err = cc1modbuildd::ReadMsg(client, HandleMsg);
+    
+    // When a cc1 invokation checks wheather a daemon exists the act of 
+    // attempting to make a socket connection on SocketPath triggers the
+    // daemon to accept a client connection. Only send response if ReadMsg
+    // reads a command sent from the cc1 invocation
+    if(Err)
+      return std::move(Err);
+
+    std::string msg = "command complete";
+    ssize_t message_size = static_cast<ssize_t>(msg.size());
+    if (write(client, msg.c_str(), msg.size()) != message_size) {
+      close(client);
+      std::string msg = "socket write error: " + std::string(strerror(errno));
+      return llvm::make_error<StringError>(msg, inconvertibleErrorCode());
+    }
+
+    close(client);
+  };
+
+  llvm::ThreadPool Pool;
+  int client;
+
+  while (true) {
+
+    if ((client = accept(ListenSocketFD, NULL, NULL)) == -1) {
+      std::perror("accept error");
+      continue;
+    }
+
+    std::shared_future<llvm::Error> result = Pool.async(Service, client);
+  }
+  return 0;
+}
+
+int cc1modbuildd_main(ArrayRef<const char *> Argv) {
+
+  SmallString<128> BasePath(Argv[0]);
+
+  StringRef BaseDir = llvm::sys::path::parent_path(BasePath);
+  llvm::sys::fs::create_directories(BaseDir);
+
+  ModuleBuildDaemonServer Daemon(BasePath);
+  std::cout << Daemon.SocketPath.c_str() << std::endl;
+
+  // Used to handle signals
+  DaemonPtr = &Daemon;
+
+  Daemon.Fork();
+  Daemon.Launch();
+  Daemon.Listen();
+
+  return 0;
+}
+
+#endif // LLVM_ON_UNIX
 No newline at end of file

clang/tools/driver/driver.cpp

 
 extern int cc1_main(ArrayRef<const char *> Argv, const char *Argv0,
                     void *MainAddr);
 extern int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0,
                       void *MainAddr);
 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,
                                     std::set<std::string> &SavedStrings) {
   // Put target and mode arguments at the start of argument list so that
   // arguments specified in command line could override them. Avoid putting
   // them at index 0, as an option like '-cc1' must remain the first.
   int InsertionPoint = 0;
static int ExecuteCC1Tool(SmallVectorImpl<const char *> &ArgV,
   void *GetExecutablePathVP = (void *)(intptr_t)GetExecutablePath;
   if (Tool == "-cc1")
     return cc1_main(ArrayRef(ArgV).slice(1), ArgV[0], GetExecutablePathVP);
   if (Tool == "-cc1as")
     return cc1as_main(ArrayRef(ArgV).slice(2), ArgV[0], GetExecutablePathVP);
   if (Tool == "-cc1gen-reproducer")
     return cc1gen_reproducer_main(ArrayRef(ArgV).slice(2), ArgV[0],
                                   GetExecutablePathVP, ToolContext);
-  // Reject unknown tools.
+#if LLVM_ON_UNIX
+  if (Tool == "-cc1modbuildd")
+    return cc1modbuildd_main(ArrayRef(ArgV).slice(2));
+
+  // FIXME: Once cc1modbuildd becomes portable unify llvm::errs messages
   llvm::errs() << "error: unknown integrated tool '" << Tool << "'. "
-               << "Valid tools include '-cc1' and '-cc1as'.\n";
+               << "Valid tools include '-cc1', '-cc1as', '-cc1gen-reproducer', "
+               << "and '-cc1modbuildd'.\n";
+#else
+  // Reject unknown tools
+  llvm::errs()
+      << "error: unknown integrated tool '" << Tool << "'. "
+      << "Valid tools include '-cc1', '-cc1as', and '-cc1gen-reproducer'.\n";
+#endif
   return 1;
 }
 
 int clang_main(int Argc, char **Argv, const llvm::ToolContext &ToolContext) {
   noteBottomOfStack();
   llvm::InitLLVM X(Argc, Argv);
   llvm::setBugReportMsg("PLEASE submit a bug report to " BUG_REPORT_URL
                         " and include the crash backtrace, preprocessed "