[mlir][PDLL] Add support for generating PDL patterns from PDLL at build time

[rriddle]

Summary

This essentially sets up mlir-pdll to function in a similar manner to mlir-tblgen. Aside
from the boilerplate of configuring CMake and setting up a basic initial test, two new
options are added to mlir-pdll to mirror options provided by tblgen:

• -d This option generates a dependency file (i.e. a set of build time dependencies) while processing the input file.
  • --write-if-changed This option only writes to the output file if the data would have changed, which for the build system prevents unnecesarry rebuilds if the file was touched but not actually changed.

[jpienaar]

Could we add simple smoke test for -d output? (Not golden of course)

mlir/test/lib/Tools/PDLL/CMakeLists.txt

2

Rm empty newine?

mlir/test/lib/Tools/PDLL/TestPDLL.cpp

31

Move to pass initialization to encourage good behavior

mlir/tools/mlir-pdll/CMakeLists.txt

7

Interesting reuse 🙂

mlir/tools/mlir-pdll/mlir-pdll.cpp

41

Why not StringSet?

[rriddle]

In D124075#3470575, @jpienaar wrote:

Could we add simple smoke test for -d output? (Not golden of course)

Thanks for catching that! Meant to add one, but forgot.

mlir/tools/mlir-pdll/CMakeLists.txt

7

I went back and forth on how to expose it, but figured that matching the tablegen interface was likely the least intrusive, and easiest for downstream users to interact with. We may want to reconsider this at some point though.

mlir/tools/mlir-pdll/mlir-pdll.cpp

41

Given that this is used for generating build dependency files, I wanted to keep a stable sorted order when building the include set. We could use SetVector, but given that the amount of includes we realistically expect are quite small, it shouldn't matter much here.

[stella.stamenova]

This change introduced a race condition in the mlir build. We're now occasionally seeing:

##[error]llvm-project\mlir\include\mlir\IR\BuiltinAttributeInterfaces.h(279,10): Error C1083: Cannot open include file: 'mlir/IR/BuiltinAttributeInterfaces.h.inc': No such file or directory
   697>D:\a\_work\1\s\llvm-project\mlir\include\mlir\IR\BuiltinAttributeInterfaces.h(279,10): fatal error C1083: Cannot open include file: 'mlir/IR/BuiltinAttributeInterfaces.h.inc': No such file or directory [D:\a\_work\1\b\llvm\tools\mlir\tools\mlir-pdll\obj.mlir-pdll.vcxproj]
   697>Done Building Project "D:\a\_work\1\b\llvm\tools\mlir\tools\mlir-pdll\obj.mlir-pdll.vcxproj" (default targets) -- FAILED.
   684>Done Building Project "D:\a\_work\1\b\llvm\tools\mlir\tools\mlir-pdll\mlir-pdll.vcxproj" (default targets) -- FAILED.

I looked at the sources and it should, in theory, work correctly, so I'm not sure why it fails. As far as I can tell, the mlir-pdll executable added via add_tablegen has a dependency on the MLIRPDLLCodeGen library which in turn depends on MLIRParser which depends on MLIRIR which depends on MLIRBuiltinAttributeInterfacesIncGen. I would expect cmake to resolve all these dependencies correctly, but perhaps the order matters and the fact that the mlir-pdll is added bfore the tools directory is not populating the dependencies in the right order?

mlir/CMakeLists.txt

 include_directories( "include")
 include_directories( ${MLIR_INCLUDE_DIR})
 
 # Adding tools/mlir-tblgen here as calling add_tablegen sets some variables like
 # MLIR_TABLEGEN_EXE in PARENT_SCOPE which gets lost if that folder is included
 # from another directory like tools
 add_subdirectory(tools/mlir-tblgen)
 add_subdirectory(tools/mlir-linalg-ods-gen)
+add_subdirectory(tools/mlir-pdll)
 
 add_subdirectory(include/mlir)
 add_subdirectory(lib)
 # C API needs all dialects for registration, but should be built before tests.
 add_subdirectory(lib/CAPI)
 
 if (MLIR_INCLUDE_TESTS)
   add_definitions(-DMLIR_INCLUDE_TESTS)

mlir/cmake/modules/AddMLIR.cmake

 include(GNUInstallDirs)
 include(LLVMDistributionSupport)
 
 function(mlir_tablegen ofn)
   tablegen(MLIR ${ARGV})
   set(TABLEGEN_OUTPUT ${TABLEGEN_OUTPUT} ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
       PARENT_SCOPE)
 endfunction()
 
+# Declare a PDLL library in the current directory.
+function(add_mlir_pdll_library target inputFile ofn)
+  set(LLVM_TARGET_DEFINITIONS ${inputFile})
+
+  tablegen(MLIR_PDLL ${ofn} -x=cpp ${ARGN})
+  set(TABLEGEN_OUTPUT ${TABLEGEN_OUTPUT} ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
+      PARENT_SCOPE)
+
+  add_public_tablegen_target(${target})
+endfunction()
+
 # Declare a dialect in the include directory
 function(add_mlir_dialect dialect dialect_namespace)
   set(LLVM_TARGET_DEFINITIONS ${dialect}.td)
   mlir_tablegen(${dialect}.h.inc -gen-op-decls)
   mlir_tablegen(${dialect}.cpp.inc -gen-op-defs)
   mlir_tablegen(${dialect}Types.h.inc -gen-typedef-decls -typedefs-dialect=${dialect_namespace})
   mlir_tablegen(${dialect}Types.cpp.inc -gen-typedef-defs -typedefs-dialect=${dialect_namespace})
   mlir_tablegen(${dialect}Dialect.h.inc -gen-dialect-decls -dialect=${dialect_namespace})

mlir/cmake/modules/CMakeLists.txt

 set(MLIR_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
 set(MLIR_CONFIG_INCLUDE_EXPORTS "include(\"\${MLIR_CMAKE_DIR}/MLIRTargets.cmake\")")
 set(MLIR_CONFIG_INCLUDE_DIRS
   "${MLIR_SOURCE_DIR}/include"
   "${MLIR_BINARY_DIR}/include"
   )
 # Refer to the best host mlir-tbgen, which might be a host-optimized version
 set(MLIR_CONFIG_TABLEGEN_EXE "${MLIR_TABLEGEN_EXE}")
+set(MLIR_CONFIG_PDLL_TABLEGEN_EXE "${MLIR_PDLL_TABLEGEN_EXE}")
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/MLIRConfig.cmake.in
   ${mlir_cmake_builddir}/MLIRConfig.cmake
   @ONLY)
 set(MLIR_CONFIG_CMAKE_DIR)
 set(MLIR_CONFIG_LLVM_CMAKE_DIR)
 set(MLIR_CONFIG_INCLUDE_DIRS)

 get_config_exports_includes(MLIR MLIR_CONFIG_INCLUDE_EXPORTS)
 extend_path(base_includedir "\${MLIR_INSTALL_PREFIX}" "${CMAKE_INSTALL_INCLUDEDIR}")
 set(MLIR_CONFIG_INCLUDE_DIRS
   "${base_includedir}"
   )
 # Ensure that we are using the installed mlir-tblgen. This might not be MLIR_TABLEGEN_EXE
 # if we're building with a host-optimized mlir-tblgen (with LLVM_OPTIMIZED_TABLEGEN).
 set(MLIR_CONFIG_TABLEGEN_EXE mlir-tblgen)
+set(MLIR_CONFIG_PDLL_TABLEGEN_EXE mlir-pdll)
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/MLIRConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/MLIRConfig.cmake
   @ONLY)
 set(MLIR_CONFIG_CODE)
 set(MLIR_CONFIG_CMAKE_DIR)
 set(MLIR_CONFIG_LLVM_CMAKE_DIR)

mlir/cmake/modules/MLIRConfig.cmake.in

 # This file allows users to call find_package(MLIR) and pick up our targets.
 
 @MLIR_CONFIG_CODE@
 
 find_package(LLVM REQUIRED CONFIG
              HINTS "@MLIR_CONFIG_LLVM_CMAKE_DIR@")
 
 set(MLIR_EXPORTED_TARGETS "@MLIR_EXPORTS@")
 set(MLIR_CMAKE_DIR "@MLIR_CONFIG_CMAKE_DIR@")
 set(MLIR_INCLUDE_DIRS "@MLIR_CONFIG_INCLUDE_DIRS@")
 set(MLIR_TABLEGEN_EXE "@MLIR_CONFIG_TABLEGEN_EXE@")
+set(MLIR_PDLL_TABLEGEN_EXE "@MLIR_CONFIG_PDLL_TABLEGEN_EXE@")
 set(MLIR_INSTALL_AGGREGATE_OBJECTS "@MLIR_INSTALL_AGGREGATE_OBJECTS@")
 set(MLIR_ENABLE_BINDINGS_PYTHON "@MLIR_ENABLE_BINDINGS_PYTHON@")
 
 # For mlir_tablegen()
 set(MLIR_INCLUDE_DIR "@MLIR_INCLUDE_DIR@")
 set(MLIR_MAIN_SRC_DIR "@MLIR_MAIN_SRC_DIR@")
 
 set_property(GLOBAL PROPERTY MLIR_ALL_LIBS "@MLIR_ALL_LIBS@")

mlir/test/lib/CMakeLists.txt

 add_subdirectory(Analysis)
 add_subdirectory(Conversion)
 add_subdirectory(Dialect)
 add_subdirectory(IR)
 add_subdirectory(Pass)
 add_subdirectory(Reducer)
 add_subdirectory(Rewrite)
+add_subdirectory(Tools)
 add_subdirectory(Transforms)

mlir/test/lib/Tools/CMakeLists.txt

+add_subdirectory(PDLL)

mlir/test/lib/Tools/PDLL/CMakeLists.txt

+add_mlir_pdll_library(MLIRTestPDLLPatternsIncGen
+  TestPDLL.pdll
+  TestPDLLPatterns.h.inc
+
+  EXTRA_INCLUDES
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../Dialect/Test
+  ${CMAKE_CURRENT_BINARY_DIR}/../../Dialect/Test
+  )
+
+# Exclude tests from libMLIR.so
+add_mlir_library(MLIRTestPDLL
+  TestPDLL.cpp
+
+  EXCLUDE_FROM_LIBMLIR
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Tools/PDLL
+
+  DEPENDS
+  MLIRTestPDLLPatternsIncGen
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRPass
+  MLIRSupport
+  MLIRTestDialect
+  MLIRTransformUtils
+  )
+
+target_include_directories(MLIRTestPDLL
+  PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../Dialect/Test
+  ${CMAKE_CURRENT_BINARY_DIR}/../../Dialect/Test
+  )

mlir/test/lib/Tools/PDLL/TestPDLL.cpp

+//===- TestPDLByteCode.cpp - Test PDLL functionality ----------------------===//
+//
+// 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 "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
+#include "mlir/Parser/Parser.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+
+using namespace mlir;
+
+#include "TestPDLLPatterns.h.inc"
+
+namespace {
+struct TestPDLLPass : public PassWrapper<TestPDLLPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPDLLPass)
+
+  StringRef getArgument() const final { return "test-pdll-pass"; }
+  StringRef getDescription() const final { return "Test PDLL functionality"; }
+  void getDependentDialects(DialectRegistry &registry) const override {
+    registry.insert<pdl::PDLDialect, pdl_interp::PDLInterpDialect>();
+  }
+  LogicalResult initialize(MLIRContext *ctx) override {
+    // Build the pattern set within the `initialize` to avoid recompiling PDL
+    // patterns during each `runOnOperation` invocation.
+    RewritePatternSet patternList(&getContext());
+    populateGeneratedPDLLPatterns(patternList);
+    patterns = std::move(patternList);
+    return success();
+  }
+
+  void runOnOperation() final {
+    // Invoke the pattern driver with the provided patterns.
+    (void)applyPatternsAndFoldGreedily(getOperation(), patterns);
+  }
+
+  FrozenRewritePatternSet patterns;
+};
+} // namespace
+
+namespace mlir {
+namespace test {
+void registerTestPDLLPasses() { PassRegistration<TestPDLLPass>(); }
+} // namespace test
+} // namespace mlir

mlir/test/lib/Tools/PDLL/TestPDLL.pdll

+//===- TestPDLL.pdll - Test PDLL functionality ----------------------------===//
+//
+// 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 "TestOps.td"
+
+/// A simple pattern that matches and replaces an operation.
+Pattern TestSimplePattern => replace op<test.simple> with op<test.success>;

mlir/test/lib/Tools/PDLL/lit.local.cfg

+config.suffixes.remove('.pdll')

mlir/test/mlir-pdll/Integration/test-pdll.mlir

+// RUN: mlir-opt %s -test-pdll-pass | FileCheck %s
+
+// CHECK-LABEL: func @simpleTest
+func @simpleTest() {
+  // CHECK: test.success
+  "test.simple"() : () -> ()
+  return
+}

mlir/test/mlir-pdll/Parser/dependency-file.pdll

+// RUN: mlir-pdll %s -I %S -I %S/../../../include -d=%t -o %t.cpp.inc
+// RUN: FileCheck %s < %t
+
+// Test support for generating dependency files.
+
+#include "include/ops.td"
+#include "include/included.pdll"
+
+// Check that we depend on the included files. We don't check for all transitive includes
+// here to avoid the need to update this test every time we add a new transitive include.
+// This test is mostly aimed to ensure we are generating the dependency file correctly.
+
+// CHECK: {{.*}}.cpp.inc:
+// CHECK-SAME: include/included.pdll
+// CHECK-SAME: include/ops.td

mlir/tools/CMakeLists.txt

 add_subdirectory(mlir-lsp-server)
 add_subdirectory(mlir-opt)
 add_subdirectory(mlir-parser-fuzzer)
-add_subdirectory(mlir-pdll)
 add_subdirectory(mlir-pdll-lsp-server)
 add_subdirectory(mlir-reduce)
 add_subdirectory(mlir-shlib)
 add_subdirectory(mlir-spirv-cpu-runner)
 add_subdirectory(mlir-translate)
 add_subdirectory(mlir-vulkan-runner)
 
 # mlir-cpu-runner requires ExecutionEngine which is only built
 # when the native target is configured in.
 if(TARGET ${LLVM_NATIVE_ARCH})
   add_subdirectory(mlir-cpu-runner)
 endif()

mlir/tools/mlir-opt/CMakeLists.txt

set(test_libs
     MLIRSCFTestPasses
     MLIRShapeTestPasses
     MLIRSPIRVTestPasses
     MLIRTensorTestPasses
     MLIRTestAnalysis
     MLIRTestDialect
     MLIRTestIR
     MLIRTestPass
+    MLIRTestPDLL
     MLIRTestReducer
     MLIRTestRewrite
     MLIRTestTransformDialect
     MLIRTestTransforms
     MLIRVectorTestPasses
     )
 endif()
 

mlir/tools/mlir-opt/mlir-opt.cpp

 void registerTestMatchReductionPass();
 void registerTestMathAlgebraicSimplificationPass();
 void registerTestMathPolynomialApproximationPass();
 void registerTestMemRefDependenceCheck();
 void registerTestMemRefStrideCalculation();
 void registerTestOpaqueLoc();
 void registerTestPadFusion();
 void registerTestPDLByteCodePass();
+void registerTestPDLLPasses();
 void registerTestPreparationPassWithAllowedMemrefResults();
 void registerTestRecursiveTypesPass();
 void registerTestSCFUtilsPass();
 void registerTestSliceAnalysisPass();
 void registerTestTensorTransforms();
 void registerTestTransformDialectInterpreterPass();
 void registerTestVectorLowerings();
 } // namespace test
#endif
   mlir::test::registerTestMatchReductionPass();
   mlir::test::registerTestMathAlgebraicSimplificationPass();
   mlir::test::registerTestMathPolynomialApproximationPass();
   mlir::test::registerTestMemRefDependenceCheck();
   mlir::test::registerTestMemRefStrideCalculation();
   mlir::test::registerTestOpaqueLoc();
   mlir::test::registerTestPadFusion();
   mlir::test::registerTestPDLByteCodePass();
+  mlir::test::registerTestPDLLPasses();
   mlir::test::registerTestRecursiveTypesPass();
   mlir::test::registerTestSCFUtilsPass();
   mlir::test::registerTestSliceAnalysisPass();
   mlir::test::registerTestTensorTransforms();
   mlir::test::registerTestTransformDialectInterpreterPass();
   mlir::test::registerTestVectorLowerings();
 }
 #endif

mlir/tools/mlir-pdll/CMakeLists.txt

-set(LIBS
-  MLIRPDLLAST
-  MLIRPDLLCodeGen
-  MLIRPDLLParser
-  )
+set(LLVM_LINK_COMPONENTS
+  Demangle
+  Support
+  TableGen
 
-add_llvm_tool(mlir-pdll
+add_tablegen(mlir-pdll MLIR_PDLL
   mlir-pdll.cpp
-
-  DEPENDS
-  ${LIBS}
   )
 
-target_link_libraries(mlir-pdll PRIVATE ${LIBS})
-llvm_update_compile_flags(mlir-pdll)
+set_target_properties(mlir-pdll PROPERTIES FOLDER "Tablegenning")
+target_link_libraries(mlir-pdll
+  PRIVATE
+  MLIRPDLLAST
+  MLIRPDLLCodeGen
+  MLIRPDLLParser
+  )
 
 mlir_check_all_link_libraries(mlir-pdll)

mlir/tools/mlir-pdll/mlir-pdll.cpp

 #include "mlir/Tools/PDLL/CodeGen/CPPGen.h"
 #include "mlir/Tools/PDLL/CodeGen/MLIRGen.h"
 #include "mlir/Tools/PDLL/ODS/Context.h"
 #include "mlir/Tools/PDLL/Parser/Parser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include <set>
 
 using namespace mlir;
 using namespace mlir::pdll;
 
 //===----------------------------------------------------------------------===//
 // main
 //===----------------------------------------------------------------------===//
 
 /// The desired output type.
 enum class OutputType {
   AST,
   MLIR,
   CPP,
 };
 
 static LogicalResult
 processBuffer(raw_ostream &os, std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
               OutputType outputType, std::vector<std::string> &includeDirs,
-              bool dumpODS) {
+              bool dumpODS, std::set<std::string> *includedFiles) {
   llvm::SourceMgr sourceMgr;
   sourceMgr.setIncludeDirs(includeDirs);
   sourceMgr.AddNewSourceBuffer(std::move(chunkBuffer), SMLoc());
 
   ods::Context odsContext;
   ast::Context astContext(odsContext);
   FailureOr<ast::Module *> module = parsePDLAST(astContext, sourceMgr);
   if (failed(module))
     return failure();
 
+  // Add the files that were included to the set.
+  if (includedFiles) {
+    for (unsigned i = 1, e = sourceMgr.getNumBuffers(); i < e; ++i) {
+      includedFiles->insert(
+          sourceMgr.getMemoryBuffer(i + 1)->getBufferIdentifier().str());
+    }
+  }
+
   // Print out the ODS information if requested.
   if (dumpODS)
     odsContext.print(llvm::errs());
 
   // Generate the output.
   if (outputType == OutputType::AST) {
     (*module)->print(os);
     return success();
   }
 
   MLIRContext mlirContext;
   OwningOpRef<ModuleOp> pdlModule =
       codegenPDLLToMLIR(&mlirContext, astContext, sourceMgr, **module);
   if (!pdlModule)
     return failure();
 
   if (outputType == OutputType::MLIR) {
     pdlModule->print(os, OpPrintingFlags().enableDebugInfo());
     return success();
   }
-
   codegenPDLLToCPP(**module, *pdlModule, os);
   return success();
 }
 
+/// Create a dependency file for `-d` option.
+///
+/// This functionality is generally only for the benefit of the build system,
+/// and is modeled after the same option in TableGen.
+static LogicalResult
+createDependencyFile(StringRef outputFilename, StringRef dependencyFile,
+                     std::set<std::string> &includedFiles) {
+  if (outputFilename == "-") {
+    llvm::errs() << "error: the option -d must be used together with -o\n";
+    return failure();
+  }
+
+  std::string errorMessage;
+  std::unique_ptr<llvm::ToolOutputFile> outputFile =
+      openOutputFile(dependencyFile, &errorMessage);
+  if (!outputFile) {
+    llvm::errs() << errorMessage << "\n";
+    return failure();
+  }
+
+  outputFile->os() << outputFilename << ":";
+  for (const auto &includeFile : includedFiles)
+    outputFile->os() << ' ' << includeFile;
+  outputFile->os() << "\n";
+  outputFile->keep();
+  return success();
+}
+
 int main(int argc, char **argv) {
   // FIXME: This is necessary because we link in TableGen, which defines its
   // options as static variables.. some of which overlap with our options.
   llvm::cl::ResetCommandLineParser();
 
   llvm::cl::opt<std::string> inputFilename(
       llvm::cl::Positional, llvm::cl::desc("<input file>"), llvm::cl::init("-"),
       llvm::cl::value_desc("filename"));
llvm::cl::opt<enum OutputType> outputType(
       llvm::cl::desc("The type of output desired"),
       llvm::cl::values(clEnumValN(OutputType::AST, "ast",
                                   "generate the AST for the input file"),
                        clEnumValN(OutputType::MLIR, "mlir",
                                   "generate the PDL MLIR for the input file"),
                        clEnumValN(OutputType::CPP, "cpp",
                                   "generate a C++ source file containing the "
                                   "patterns for the input file")));
+  llvm::cl::opt<std::string> dependencyFilename(
+      "d", llvm::cl::desc("Dependency filename"),
+      llvm::cl::value_desc("filename"), llvm::cl::init(""));
+  llvm::cl::opt<bool> writeIfChanged(
+      "write-if-changed",
+      llvm::cl::desc("Only write to the output file if it changed"));
 
   llvm::InitLLVM y(argc, argv);
   llvm::cl::ParseCommandLineOptions(argc, argv, "PDLL Frontend");
 
   // Set up the input file.
   std::string errorMessage;
   std::unique_ptr<llvm::MemoryBuffer> inputFile =
       openInputFile(inputFilename, &errorMessage);
   if (!inputFile) {
     llvm::errs() << errorMessage << "\n";
     return 1;
   }
 
-  // Set up the output file.
-  std::unique_ptr<llvm::ToolOutputFile> outputFile =
-      openOutputFile(outputFilename, &errorMessage);
-  if (!outputFile) {
-    llvm::errs() << errorMessage << "\n";
-    return 1;
-  }
+  // If we are creating a dependency file, we'll also need to track what files
+  // get included during processing.
+  std::set<std::string> includedFilesStorage;
+  std::set<std::string> *includedFiles = nullptr;
+  if (!dependencyFilename.empty())
+    includedFiles = &includedFilesStorage;
 
   // The split-input-file mode is a very specific mode that slices the file
   // up into small pieces and checks each independently.
+  std::string outputStr;
+  llvm::raw_string_ostream outputStrOS(outputStr);
   auto processFn = [&](std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
                        raw_ostream &os) {
     return processBuffer(os, std::move(chunkBuffer), outputType, includeDirs,
-                         dumpODS);
+                         dumpODS, includedFiles);
   };
   if (splitInputFile) {
     if (failed(splitAndProcessBuffer(std::move(inputFile), processFn,
-                                     outputFile->os())))
+                                     outputStrOS)))
       return 1;
-  } else if (failed(processFn(std::move(inputFile), outputFile->os()))) {
+  } else if (failed(processFn(std::move(inputFile), outputStrOS))) {
     return 1;
   }
+
+  // Write the output.
+  bool shouldWriteOutput = true;
+  if (writeIfChanged) {
+    // Only update the real output file if there are any differences. This
+    // prevents recompilation of all the files depending on it if there aren't
+    // any.
+    if (auto existingOrErr =
+            llvm::MemoryBuffer::getFile(outputFilename, /*IsText=*/true))
+      if (std::move(existingOrErr.get())->getBuffer() == outputStrOS.str())
+        shouldWriteOutput = false;
+  }
+
+  // Populate the output file if necessary.
+  if (shouldWriteOutput) {
+    std::unique_ptr<llvm::ToolOutputFile> outputFile =
+        openOutputFile(outputFilename, &errorMessage);
+    if (!outputFile) {
+      llvm::errs() << errorMessage << "\n";
+      return 1;
+    }
+    outputFile->os() << outputStrOS.str();
     outputFile->keep();
+  }
+
+  // Always write the depfile, even if the main output hasn't changed. If it's
+  // missing, Ninja considers the output dirty.
+  if (!dependencyFilename.empty()) {
+    if (failed(createDependencyFile(outputFilename, dependencyFilename,
+                                    includedFilesStorage)))
+      return 1;
+  }
+
   return 0;
 }