[Driver] Add callback to Command execution

[sepavloff]

Summary

Object of type Compilation now can keep a callback that is called
after each execution of Command. This must simplify adaptation of
clang in custom distributions and allow facilities like collection of
execution statistics.

[sepavloff]

Rebased patch

[sepavloff]

Ping.

[sepavloff]

Rebased patch

[sepavloff]

Rebased patch

[sepavloff]

Ping.

[sepavloff]

Rebased patch

[sepavloff]

Ping.
This is the only remaining prerequisite for D78903.

[aganea]

LGTM, thanks!

[MaskRay]

clang/include/clang/Driver/Compilation.h

118

Can you comment what int means?

[sepavloff]

Added documentation

clang/include/clang/Driver/Compilation.h

class Compilation {
 
   /// Result files which are generated correctly on failure, and which should
   /// only be removed if we crash.
   ArgStringMap FailureResultFiles;
 
   /// Optional redirection for stdin, stdout, stderr.
   std::vector<Optional<StringRef>> Redirects;
 
+  /// Callback called after the command has been executed.
+  std::function<void(const Command &, int)> PostCallback;
+
   /// Whether we're compiling for diagnostic purposes.
   bool ForDiagnostics = false;
 
   /// Whether an error during the parsing of the input args.
   bool ContainsError;
 
   /// Whether to keep temporary files regardless of -save-temps.
   bool ForceKeepTempFiles = false;
public:
   const llvm::opt::ArgStringList &getTempFiles() const { return TempFiles; }
 
   const ArgStringMap &getResultFiles() const { return ResultFiles; }
 
   const ArgStringMap &getFailureResultFiles() const {
     return FailureResultFiles;
   }
 
+  void setPostCallback(const std::function<void(const Command &, int)> &CB) {
+    PostCallback = CB;
+  }
+
   /// Returns the sysroot path.
   StringRef getSysRoot() const;
 
   /// getArgsForToolChain - Return the derived argument list for the
   /// tool chain \p TC (or the default tool chain, if TC is not specified).
   /// If a device offloading kind is specified, a translation specific for that
   /// kind is performed, if any.
   ///

clang/lib/Driver/Compilation.cpp

if (getDriver().CCPrintOptions)
       *OS << "[Logging clang options]\n";
 
     C.Print(*OS, "\n", /*Quote=*/getDriver().CCPrintOptions);
   }
 
   std::string Error;
   bool ExecutionFailed;
   int Res = C.Execute(Redirects, &Error, &ExecutionFailed);
+  if (PostCallback)
+    PostCallback(C, Res);
   if (!Error.empty()) {
     assert(Res && "Error string set with 0 result code!");
     getDriver().Diag(diag::err_drv_command_failure) << Error;
   }
 
   if (Res)
     FailingCommand = &C;
 

clang/unittests/Driver/ToolChainTest.cpp

 //===- unittests/Driver/ToolChainTest.cpp --- ToolChain tests -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Unit tests for ToolChains.
TEST(ToolChainTest, GetTargetAndMode) {
   EXPECT_FALSE(Res.TargetIsValid);
 
   Res = ToolChain::getTargetAndModeFromProgramName("qqq-clang-cl");
   EXPECT_TRUE(Res.TargetPrefix == "qqq");
   EXPECT_TRUE(Res.ModeSuffix == "clang-cl");
   EXPECT_STREQ(Res.DriverMode, "--driver-mode=cl");
   EXPECT_FALSE(Res.TargetIsValid);
 }
+
+TEST(ToolChainTest, PostCallback) {
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  struct TestDiagnosticConsumer : public DiagnosticConsumer {};
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
+  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
+      new llvm::vfs::InMemoryFileSystem);
+
+  // The executable path must not exist.
+  Driver CCDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
+                  InMemoryFileSystem);
+  CCDriver.setCheckInputsExist(false);
+  std::unique_ptr<Compilation> CC(
+      CCDriver.BuildCompilation({"/home/test/bin/clang", "foo.cpp"}));
+  bool CallbackHasCalled = false;
+  CC->setPostCallback([&](const Command &C, int Ret) {
+    CallbackHasCalled = true;
+  });
+  const JobList &Jobs = CC->getJobs();
+  auto &CmdCompile = Jobs.getJobs().front();
+  const Command *FailingCmd = nullptr;
+  CC->ExecuteCommand(*CmdCompile, FailingCmd);
+  EXPECT_TRUE(CallbackHasCalled);
+}
+
 } // end anonymous namespace.