[dyn-seq P1.3] AIEX->EmitC conversion + C++ TXN target

Add the runtime-parameterizable mirror of the compile-time binary TXN
emitter. A straight-line aie.runtime_sequence of npu ops lowers to a
standalone generate_txn_<seq>() C++ function that assembles the TXN
stream from TxnEncoding.h, with scalar operands (constant or runtime)
flowing through as C++ literals/parameters.

- New pass --convert-aiex-to-emitc: converts write32, maskwrite32, sync,
  address_patch, blockwrite (+ feeding memref.get_global) to emitc calls;
  runs upstream ArithToEmitC so constant and derived scalar fields lower
  uniformly; rejects scf control flow with a clean diagnostic.
- New aie-translate target --aie-npu-to-cpp (pass + translateToCpp).
- Per-op / runtime-value / reject / end-to-end FileCheck coverage.

For constant operands the generated C++ produces byte-identical TXN to
aie-npu-to-binary; runtime scalar operands become generate_txn_<seq>()
parameters (foundation for dynamic runtime sequences, milestone #3222).

Co-Authored-By: Claude <noreply@anthropic.com>

Author: hunhoffe

include/aie/Conversion/AIEXToEmitC/AIEXToEmitC.h

@@ -0,0 +1,25 @@
+//===- AIEXToEmitC.h --------------------------------------------*- C++ -*-===//
+//
+// This file is licensed 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
+//
+// Copyright (C) 2026 Advanced Micro Devices, Inc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef AIE_CONVERSION_AIEXTOEMITC_AIEXTOEMITC_H
+#define AIE_CONVERSION_AIEXTOEMITC_AIEXTOEMITC_H
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+#include <memory>
+
+namespace xilinx {
+
+std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
+createConvertAIEXToEmitCPass();
+
+} // namespace xilinx
+
+#endif // AIE_CONVERSION_AIEXTOEMITC_AIEXTOEMITC_H

include/aie/Conversion/Passes.h

@@ -11,6 +11,7 @@
 
 #include "aie/Conversion/AIEToConfiguration/AIEToConfiguration.h"
 #include "aie/Conversion/AIEVecToLLVM/AIEVecToLLVM.h"
+#include "aie/Conversion/AIEXToEmitC/AIEXToEmitC.h"
 #include "aie/Conversion/PassesEnums.h.inc"
 
 namespace xilinx {

include/aie/Conversion/Passes.td

@@ -78,6 +78,31 @@ def ConvertAIEToTransaction : Pass<"convert-aie-to-transaction",
   ];
 }
 
+//===----------------------------------------------------------------------===//
+// AIEXToEmitC
+//===----------------------------------------------------------------------===//
+
+def ConvertAIEXToEmitC : Pass<"convert-aiex-to-emitc", "mlir::ModuleOp"> {
+  let summary = "Convert AIEX runtime sequence ops to EmitC for C++ TXN generation";
+  let description = [{
+    This pass converts the straight-line npu transaction ops in an
+    `aie.runtime_sequence` (`npu.write32`, `npu.maskwrite32`, `npu.sync`,
+    `npu.address_patch`, `npu.blockwrite`) into EmitC dialect calls naming the
+    functions in `aie/Runtime/TxnEncoding.h`. Running MLIR's `translateToCpp()`
+    on the result produces a standalone `generate_txn_<seq>(...)` C++ function
+    that assembles the TXN binary at run time -- the same words the compile-time
+    binary emitter (`AIETargetNPU.cpp`) produces, but from a C++ function so
+    runtime-valued operands can flow through to a single compiled xclbin.
+
+    Control flow (`scf.for`/`scf.if`) inside a runtime sequence is rejected with
+    a diagnostic; it is handled by later passes in the dynamic-sequences work.
+  }];
+  let constructor = "xilinx::createConvertAIEXToEmitCPass()";
+  let dependentDialects = ["mlir::emitc::EmitCDialect",
+                           "xilinx::AIE::AIEDialect",
+                           "xilinx::AIEX::AIEXDialect"];
+}
+
 //===----------------------------------------------------------------------===//
 // AIEToControlPackets
 //===----------------------------------------------------------------------===//

include/aie/Targets/AIETargets.h

@@ -75,6 +75,8 @@ AIETranslateNpuToBinary(mlir::ModuleOp, std::vector<uint32_t> &,
                         llvm::StringRef deviceName = "",
                         llvm::StringRef sequenceName = "",
                         std::vector<TxnLocEntry> *locmap = nullptr);
+mlir::LogicalResult AIETranslateNpuToCpp(mlir::ModuleOp module,
+                                         llvm::raw_ostream &output);
 mlir::LogicalResult AIETranslateToUcDma(mlir::ModuleOp module,
                                         llvm::raw_ostream &output);
 mlir::LogicalResult AIETranslateToUcDma(mlir::ModuleOp, std::string &assembly);