merge main to the branch

Author: lanluo-nvidia

mlir-tensorrt/build_tools/patches/stablehlo/0005-Solve-multiple-pass-bugs.patch

@@ -0,0 +1,73 @@
+From c4d93d8def7a5b77ba3d8ee41e5bb8f4259f7b1c Mon Sep 17 00:00:00 2001
+From: Christopher Bate <cbate@nvidia.com>
+Date: Mon, 5 Jan 2026 23:34:56 +0000
+Subject: [PATCH 1/1] Solve multiple minor bugs in StablehloRefineShapes and
+ StablehloAggressiveFolder
+
+---
+ .../conversions/linalg/transforms/MapStablehloToScalarOp.h   | 5 +++++
+ stablehlo/transforms/StablehloRefineShapes.cpp               | 3 ++-
+ .../transforms/optimization/StablehloAggressiveFolder.cpp    | 3 ++-
+ 3 files changed, 9 insertions(+), 2 deletions(-)
+
+diff --git a/stablehlo/conversions/linalg/transforms/MapStablehloToScalarOp.h b/stablehlo/conversions/linalg/transforms/MapStablehloToScalarOp.h
+index 2cf82769..9634bbda 100644
+--- a/stablehlo/conversions/linalg/transforms/MapStablehloToScalarOp.h
++++ b/stablehlo/conversions/linalg/transforms/MapStablehloToScalarOp.h
+@@ -164,6 +164,7 @@ struct StablehloToScalarOp<stablehlo::TanOp> {
+ template <>
+ struct StablehloToScalarOp<stablehlo::Atan2Op> {
+   using COp = ::mlir::complex::Atan2Op;
++  using FOp = ::mlir::math::Atan2Op;
+ };
+
+ template <>
+@@ -831,6 +832,10 @@ inline Value mapStablehloOpToStdScalarOp<stablehlo::BitcastConvertOp>(
+   Type argType = getElementTypeOrSelf(argTypes.front());
+   Type resultType = getElementTypeOrSelf(resultTypes.front());
+
++  // arith::BitcastOp doesn't support complex types, so bail out if either type
++  // is complex.
++  if (!argType.isIntOrFloat() || !resultType.isIntOrFloat()) return nullptr;
++
+   if (resultType.getIntOrFloatBitWidth() != argType.getIntOrFloatBitWidth())
+     return nullptr;
+
+diff --git a/stablehlo/transforms/StablehloRefineShapes.cpp b/stablehlo/transforms/StablehloRefineShapes.cpp
+index 4b585b46..80fd237b 100644
+--- a/stablehlo/transforms/StablehloRefineShapes.cpp
++++ b/stablehlo/transforms/StablehloRefineShapes.cpp
+@@ -45,6 +45,7 @@ limitations under the License.
+ #include "mlir/IR/Value.h"
+ #include "mlir/IR/ValueRange.h"
+ #include "mlir/Interfaces/InferTypeOpInterface.h"
++#include "mlir/Interfaces/SideEffectInterfaces.h"
+ #include "mlir/Rewrite/FrozenRewritePatternSet.h"
+ #include "mlir/Support/LLVM.h"
+ #include "mlir/Support/LogicalResult.h"
+@@ -565,7 +566,7 @@ struct RefineCallOpPattern : public OpRewritePattern<func::CallOp> {
+     auto callee = refinementKey->getFunc();
+     std::optional<SmallVector<DenseIntElementsAttr>> constantAttrs =
+         isConstantFunction(callee);
+-    if (constantAttrs.has_value()) {
++    if (constantAttrs.has_value() && mlir::isMemoryEffectFree(callee)) {
+       SmallVector<Value> constants;
+       for (auto constAttr : constantAttrs.value()) {
+         constants.push_back(
+diff --git a/stablehlo/transforms/optimization/StablehloAggressiveFolder.cpp b/stablehlo/transforms/optimization/StablehloAggressiveFolder.cpp
+index 8dac8c97..c10f2ae7 100644
+--- a/stablehlo/transforms/optimization/StablehloAggressiveFolder.cpp
++++ b/stablehlo/transforms/optimization/StablehloAggressiveFolder.cpp
+@@ -625,7 +625,8 @@ struct FoldCompareOpPattern : public ShapeOpRewritePattern<CompareOp> {
+   LogicalResult matchAndRewrite(CompareOp op,
+                                 PatternRewriter& rewriter) const override {
+     auto resultType = op.getType();
+-    if (failed(validateShapeFoldDtype(rewriter, op, resultType)))
++    if (failed(validateStaticShapeResult(rewriter, op, resultType)) ||
++        failed(validateShapeFoldDtype(rewriter, op, resultType)))
+       return failure();
+
+     auto res = foldBinaryOpIntOrFloat<FoldCompare, IntegerAttr, IntegerAttr>(
+--
+2.52.0
+

mlir-tensorrt/compiler/cmake/GenerateEmbeddedStandaloneCPP.cmake

@@ -0,0 +1,80 @@
+# GenerateEmbeddedStandaloneCPP.cmake
+#
+# CMake script that generates a C++ source file embedding a list of text files
+# as raw string literals. Intended to embed the StandaloneCPP runtime sources
+# into the compiler so that support files can be emitted without reading the
+# source tree at runtime.
+#
+# Expected variables:
+# - OUTPUT: output .cpp file path
+# - INPUT_FILES: CMake list of absolute input file paths
+# - REL_PATHS: CMake list of relative/basename paths (same length as INPUT_FILES)
+
+if(NOT DEFINED OUTPUT)
+  message(FATAL_ERROR "GenerateEmbeddedStandaloneCPP: OUTPUT is required")
+endif()
+if(NOT DEFINED INPUT_FILES)
+  message(FATAL_ERROR "GenerateEmbeddedStandaloneCPP: INPUT_FILES is required")
+endif()
+if(NOT DEFINED REL_PATHS)
+  message(FATAL_ERROR "GenerateEmbeddedStandaloneCPP: REL_PATHS is required")
+endif()
+
+list(LENGTH INPUT_FILES _n_inputs)
+list(LENGTH REL_PATHS _n_rels)
+if(NOT _n_inputs EQUAL _n_rels)
+  message(FATAL_ERROR "GenerateEmbeddedStandaloneCPP: INPUT_FILES and REL_PATHS must have same length")
+endif()
+
+file(WRITE "${OUTPUT}" "//===- EmbeddedStandaloneCPP.cpp ------------------------------*- C++ -*-===//\n")
+file(APPEND "${OUTPUT}" "//\n")
+file(APPEND "${OUTPUT}" "// This file is generated by compiler/cmake/GenerateEmbeddedStandaloneCPP.cmake.\n")
+file(APPEND "${OUTPUT}" "// Do not edit manually.\n")
+file(APPEND "${OUTPUT}" "//\n")
+file(APPEND "${OUTPUT}" "#include \"mlir-tensorrt/Conversion/HostToEmitC/EmbeddedStandaloneCPP.h\"\n")
+file(APPEND "${OUTPUT}" "#include \"llvm/ADT/StringMap.h\"\n")
+file(APPEND "${OUTPUT}" "\n")
+file(APPEND "${OUTPUT}" "namespace mtrt::compiler::emitc_support {\n\n")
+
+set(_var_names "")
+math(EXPR _last "${_n_inputs} - 1")
+foreach(i RANGE 0 ${_last})
+  list(GET INPUT_FILES ${i} _in)
+  list(GET REL_PATHS ${i} _rel)
+
+  # Sanitize a C++ identifier for the backing char array name.
+  set(_var "${_rel}")
+  string(REPLACE "/" "_" _var "${_var}")
+  string(REPLACE "." "_" _var "${_var}")
+  string(REPLACE "-" "_" _var "${_var}")
+
+  file(READ "${_in}" _contents)
+
+  file(APPEND "${OUTPUT}" "static constexpr char k_${_var}[] = R\"__MTRT_EMBED__(\n")
+  file(APPEND "${OUTPUT}" "${_contents}")
+  file(APPEND "${OUTPUT}" "\n)__MTRT_EMBED__\";\n\n")
+
+  list(APPEND _var_names "${_var}")
+endforeach()
+
+file(APPEND "${OUTPUT}" "static const EmbeddedTextFile kFiles[] = {\n")
+foreach(i RANGE 0 ${_last})
+  list(GET REL_PATHS ${i} _rel)
+  list(GET _var_names ${i} _var)
+  file(APPEND "${OUTPUT}" "  {\"${_rel}\", llvm::StringRef(k_${_var}, sizeof(k_${_var}) - 1)},\n")
+endforeach()
+file(APPEND "${OUTPUT}" "};\n\n")
+
+file(APPEND "${OUTPUT}" "llvm::ArrayRef<EmbeddedTextFile> getEmbeddedStandaloneCPPFiles() {\n")
+file(APPEND "${OUTPUT}" "  return llvm::ArrayRef<EmbeddedTextFile>(kFiles);\n")
+file(APPEND "${OUTPUT}" "}\n\n")
+
+file(APPEND "${OUTPUT}" "llvm::StringRef getEmbeddedStandaloneCPPFileContents(llvm::StringRef path) {\n")
+file(APPEND "${OUTPUT}" "  for (const auto &f : kFiles) {\n")
+file(APPEND "${OUTPUT}" "    if (f.path == path)\n")
+file(APPEND "${OUTPUT}" "      return f.contents;\n")
+file(APPEND "${OUTPUT}" "  }\n")
+file(APPEND "${OUTPUT}" "  return {};\n")
+file(APPEND "${OUTPUT}" "}\n\n")
+
+file(APPEND "${OUTPUT}" "} // namespace mtrt::compiler::emitc_support\n")

mlir-tensorrt/compiler/include/mlir-tensorrt/Compiler/Options.h

@@ -38,6 +38,7 @@
 #include "llvm/ADT/SmallVectorExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
+#include <optional>
 #include <string>
 
 namespace mtrt::compiler {
@@ -199,6 +200,32 @@ struct EmitCOptions : public mlir::OptionsGroup {
 
   static llvm::cl::OptionCategory category;
 
+  Option<bool> emitSupportFiles{
+      this->ctx, "emitc-emit-support-files", llvm::cl::init(false),
+      llvm::cl::desc(
+          "Emit EmitC support files (runtime sources/headers, example CMake, "
+          "and a test driver) into the artifacts directory."),
+      llvm::cl::cat(category)};
+
+  Option<bool> emitRuntimeFiles{
+      this->ctx, "emitc-emit-runtime-files", llvm::cl::init(false),
+      llvm::cl::desc("Emit the required subset of StandaloneCPP runtime source "
+                     "and header files needed by the generated C++ code."),
+      llvm::cl::cat(category)};
+
+  Option<bool> emitCMakeFile{
+      this->ctx, "emitc-emit-cmake-file", llvm::cl::init(false),
+      llvm::cl::desc("Emit an example CMake file for compiling the generated "
+                     "C++ code (and emitted runtime files, if requested)."),
+      llvm::cl::cat(category)};
+
+  Option<bool> emitTestDriver{
+      this->ctx, "emitc-emit-test-driver", llvm::cl::init(false),
+      llvm::cl::desc("Emit a C++ test driver source file for building an "
+                     "executable that includes and runs the generated C++ "
+                     "code."),
+      llvm::cl::cat(category)};
+
   Option<bool> wrapModuleInEmitCClass{
       this->ctx, "emitc-wrap-in-class", llvm::cl::init(false),
       llvm::cl::desc("Wrap the module in an EmitC class"),
@@ -446,6 +473,22 @@ class MainOptions : public mlir::CLOptionScope,
   // Options common to all tasks
   //===----------------------------------------------------------------------===//
 
+  /// Output directory or file name for the translated host-target output.
+  ///
+  /// This option is only registered in the global CLI scope. It is
+  /// intentionally not registered for locally-scoped option parsing (e.g.
+  /// `MainOptions::fromString`) to avoid duplicate option registrations and to
+  /// keep local parsing focused on pipeline behavior rather than tool output.
+  std::optional<Option<std::string>> outputPath;
+
+  /// Returns the output path value. If the option is not registered (local
+  /// scope), returns ".".
+  llvm::StringRef getOutputPath() const {
+    if (outputPath)
+      return outputPath->getValue();
+    return ".";
+  }
+
   Option<HostTarget> hostTarget{
       *this,
       "host-target",
@@ -599,6 +642,13 @@ class MainOptions : public mlir::CLOptionScope,
   MainOptions(mlir::CLOptionScope::GlobalScope, ExtensionList extensions)
       : mlir::CLOptionScope(GlobalScope{}), extensions(std::move(extensions)),
         groups(mlir::make_options_group_tuple<SubGroups>(*this)) {
+    // Register tool output path only in the global scope.
+    if (this->isGlobalScope()) {
+      outputPath.emplace(
+          *this, "o", llvm::cl::desc("<output directory or file name>"),
+          llvm::cl::init("."), llvm::cl::value_desc("directory or file"),
+          llvm::cl::cat(category));
+    }
     this->extensions.loadExtensions(*this);
   }
 

mlir-tensorrt/compiler/include/mlir-tensorrt/Conversion/HostToEmitC/EmbeddedStandaloneCPP.h

@@ -0,0 +1,35 @@
+//===- EmbeddedStandaloneCPP.h ----------------------------------*- C++ -*-===//
+//
+// SPDX-FileCopyrightText: Copyright 2026 NVIDIA CORPORATION & AFFILIATES.
+// All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// Provides access to StandaloneCPP runtime source/header contents embedded in
+/// the compiler binary at build time.
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TENSORRT_CONVERSION_HOSTTOEMITC_EMBEDDEDSTANDALONECPP_H
+#define MLIR_TENSORRT_CONVERSION_HOSTTOEMITC_EMBEDDEDSTANDALONECPP_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace mtrt::compiler::emitc_support {
+
+struct EmbeddedTextFile {
+  llvm::StringRef path;
+  llvm::StringRef contents;
+};
+
+/// Returns the list of embedded StandaloneCPP runtime files.
+llvm::ArrayRef<EmbeddedTextFile> getEmbeddedStandaloneCPPFiles();
+
+/// Returns the embedded contents for the given path, or an empty StringRef if
+/// not found.
+llvm::StringRef getEmbeddedStandaloneCPPFileContents(llvm::StringRef path);
+
+} // namespace mtrt::compiler::emitc_support
+
+#endif // MLIR_TENSORRT_CONVERSION_HOSTTOEMITC_EMBEDDEDSTANDALONECPP_H

mlir-tensorrt/compiler/include/mlir-tensorrt/Conversion/HostToEmitC/HostToEmitC.h

@@ -31,8 +31,18 @@ class OpPassManager;
 }
 
 namespace mtrt::compiler {
+struct EmitCOptions;
+
+/// Populate the pass manager with the EmitC lowering pipeline.
+///
+/// The pipeline is parameterized by the EmitC options, and additionally takes
+/// the tool output path and entrypoint to enable optional emission of C++
+/// support files (StandaloneCPP runtime sources/headers, example CMake, and/or
+/// a test driver) as artifacts.
 void applyEmitCLoweringPipeline(mlir::OpPassManager &pm,
-                                bool wrapModuleInEmitCClass);
+                                const EmitCOptions &opts,
+                                llvm::StringRef outputPath,
+                                llvm::StringRef entrypoint);
 } // namespace mtrt::compiler
 
 #endif // MLIR_TENSORRT_CONVERSION_HOSTTOEMITC_HOSTTOEMITC

mlir-tensorrt/compiler/include/mlir-tensorrt/Conversion/Passes.td

@@ -132,6 +132,41 @@ def WrapModuleInEmitCClassPass : Pass<"wrap-module-in-emitc-class", "::mlir::Mod
   ];
 }
 
+def EmitCppSupportFilesPass : Pass<"emit-cpp-support-files", "::mlir::ModuleOp"> {
+  let summary = "Emit EmitC C++ support files as executor.file_artifact ops";
+  let description = [{
+    This pass emits optional support files required to compile and test the C++
+    produced by the EmitC host target. The files are emitted as
+    `executor.file_artifact` operations, to be materialized by the
+    `executor-serialize-artifacts` pass into the artifacts directory.
+
+    The emitted files can include:
+    - StandaloneCPP runtime source and header files (subset based on runtime usage)
+    - An example CMake file
+    - A simple test driver
+  }];
+
+  let dependentDialects = [
+    "::mlir::emitc::EmitCDialect",
+    "::mlir::executor::ExecutorDialect"
+  ];
+
+  let options = [
+    Option<"emitRuntimeFiles", "emit-runtime-files", "bool", "false",
+      "Emit the required subset of StandaloneCPP runtime source/header files">,
+    Option<"emitCMakeFile", "emit-cmake-file", "bool", "false",
+      "Emit an example CMakeLists.txt file">,
+    Option<"emitTestDriver", "emit-test-driver", "bool", "false",
+      "Emit a simple test driver source file">,
+    Option<"outputFile", "output-file", "std::string", "\"\"",
+      "The path to the generated EmitC translation output file (for driver/CMake generation)">,
+    Option<"entrypoint", "entrypoint", "std::string", "\"main\"",
+      "Entrypoint function name (used by the generated test driver, if present)">,
+    Option<"supportSubdir", "support-subdir", "std::string", "\"emitc_support\"",
+      "Subdirectory under the artifacts directory to place emitted support files">,
+  ];
+}
+
 //===----------------------------------------------------------------------===//
 // TensorRTEmitCBuilderPass
 //===----------------------------------------------------------------------===//

mlir-tensorrt/compiler/lib/Compiler/Pipeline.cpp

@@ -345,8 +345,9 @@ static void addLLVMOrEmitCTail(OpPassManager &pm, const MainOptions &options,
   }
 
   if (hostTarget == HostTarget::EmitC) {
-    mtrt::compiler::applyEmitCLoweringPipeline(
-        pm, options.get<EmitCOptions>().wrapModuleInEmitCClass);
+    mtrt::compiler::applyEmitCLoweringPipeline(pm, options.get<EmitCOptions>(),
+                                               options.getOutputPath(),
+                                               options.entrypoint);
   }
 
   pm.addPass(mlir::executor::createExecutorSerializeArtifactsPass(