🗺️ MLIR Dialect Redesign

.github/workflows/ci.yml

@@ -147,7 +147,7 @@ jobs:
       cmake-args: -DBUILD_MQT_CORE_BENCHMARKS=ON -DBUILD_MQT_CORE_MLIR=ON -DBUILD_MQT_CORE_BINDINGS=ON
       clang-version: 21
       build-project: true
-      files-changed-only: true
+      files-changed-only: false
       setup-python: true
       install-pkgs: "pybind11==3.0.1"
       cpp-linter-extra-args: "-std=c++20"

.github/workflows/reusable-mlir-tests.yml

@@ -83,8 +83,8 @@ jobs:
       - name: Build MLIR lit target
         run: cmake --build build --config ${{ matrix.coverage && 'Debug' || 'Release' }} --target mqt-core-mlir-lit-test-build-only
 
-      - name: Build MLIR translation unittests
-        run: cmake --build build --config ${{ matrix.coverage && 'Debug' || 'Release' }} --target mqt-core-mlir-translation-test --target mqt-core-mlir-wireiterator-test
+      - name: Build MLIR unittests
+        run: cmake --build build --config ${{ matrix.coverage && 'Debug' || 'Release' }} --target mqt-core-mlir-unittests
 
       # Test
       - name: Run lit tests

CHANGELOG.md

@@ -11,6 +11,7 @@ This project adheres to [Semantic Versioning], with the exception that minor rel
 
 ### Added
 
+- ✨ Add initial infrastructure for new QC and QCO MLIR dialects ([#1264]) ([**@burgholzer**], [**@denialhaag**])
 - ✨ Return device handle from `add_dynamic_device_library` for direct backend creation ([#1381]) ([**@marcelwa**])
 - ✨ Add IQM JSON support for job submission in Qiskit-QDMI Backend ([#1375], [#1382]) ([**@marcelwa**], [**@burgholzer**])
 - ✨ Add authentication support for QDMI sessions with token, username/password, auth file, auth URL, and project ID parameters ([#1355]) ([**@marcelwa**])
@@ -307,6 +308,7 @@ _📚 Refer to the [GitHub Release Notes](https://github.com/munich-quantum-tool
 [#1276]: https://github.com/munich-quantum-toolkit/core/pull/1276
 [#1271]: https://github.com/munich-quantum-toolkit/core/pull/1271
 [#1269]: https://github.com/munich-quantum-toolkit/core/pull/1269
+[#1264]: https://github.com/munich-quantum-toolkit/core/pull/1264
 [#1263]: https://github.com/munich-quantum-toolkit/core/pull/1263
 [#1247]: https://github.com/munich-quantum-toolkit/core/pull/1247
 [#1246]: https://github.com/munich-quantum-toolkit/core/pull/1246

cmake/SetupMLIR.cmake

@@ -10,7 +10,7 @@
 set(MQT_MLIR_SOURCE_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/mlir/include")
 set(MQT_MLIR_BUILD_INCLUDE_DIR "${PROJECT_BINARY_DIR}/mlir/include")
 set(MQT_MLIR_MIN_VERSION
-    "21.0"
+    "21.1"
     CACHE STRING "Minimum required MLIR version")
 
 # MLIR must be installed on the system

docs/mlir/index.md

@@ -121,6 +121,6 @@ module {
 
 ## Development
 
-Building the MLIR library requires LLVM version 21.0 or later.
+Building the MLIR library requires LLVM version 21.1 or later.
 Our CI pipeline on GitHub continuously builds and tests the MLIR library on Linux, macOS, and Windows.
 To access the latest build logs, visit the [GitHub Actions page](https://github.com/munich-quantum-toolkit/core/actions/workflows/ci.yml).

mlir/.clang-tidy

@@ -0,0 +1,9 @@
+InheritParentConfig: true
+Checks: |
+  llvm-namespace-comment,
+  llvm-prefer-isa-or-dyn-cast-in-conditionals,
+  llvm-prefer-register-over-unsigned,
+  llvm-prefer-static-over-anonymous-namespace,
+  -misc-use-anonymous-namespace,
+  llvm-twine-local,
+  -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access

mlir/include/mlir/Compiler/CompilerPipeline.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include <mlir/Pass/PassManager.h>
+#include <mlir/Support/LogicalResult.h>
+#include <string>
+
+namespace mlir {
+class ModuleOp;
+
+/**
+ * @brief Configuration for the quantum compiler pipeline
+ *
+ * @details
+ * Controls which stages of the compilation pipeline are executed and
+ * diagnostic options for profiling and debugging.
+ */
+struct QuantumCompilerConfig {
+  /// Convert to QIR at the end of the pipeline
+  bool convertToQIR = false;
+
+  /// Record intermediate IR at each stage for debugging/testing
+  bool recordIntermediates = false;
+
+  /// Enable pass timing statistics (MLIR builtin)
+  bool enableTiming = false;
+
+  /// Enable pass statistics (MLIR builtin)
+  bool enableStatistics = false;
+
+  /// Print IR after each stage
+  bool printIRAfterAllStages = false;
+};
+
+/**
+ * @brief Records the state of IR at various compilation stages
+ *
+ * @details
+ * Stores string representations of the MLIR module at different
+ * points in the compilation pipeline. Useful for testing and debugging.
+ * All stages are recorded when recordIntermediates is enabled.
+ */
+struct CompilationRecord {
+  std::string afterQCImport;
+  std::string afterInitialCanon;
+  std::string afterQCOConversion;
+  std::string afterQCOCanon;
+  std::string afterOptimization;
+  std::string afterOptimizationCanon;
+  std::string afterQCConversion;
+  std::string afterQCCanon;
+  std::string afterQIRConversion;
+  std::string afterQIRCanon;
+};
+
+/**
+ * @brief Main quantum compiler pipeline
+ *
+ * @details
+ * Provides a high-level interface for compiling quantum programs through
+ * the MQT compiler infrastructure. The pipeline stages are:
+ *
+ * 1. QC dialect (reference semantics) - imported from
+ * qc::QuantumComputation
+ * 2. Canonicalization + cleanup
+ * 3. QCO dialect (value semantics) - enables SSA-based optimizations
+ * 4. Canonicalization + cleanup
+ * 5. Quantum optimization passes
+ * 6. Canonicalization + cleanup
+ * 7. QC dialect - converted back for backend lowering
+ * 8. Canonicalization + cleanup
+ * 9. QIR (Quantum Intermediate Representation) - optional final lowering
+ * 10. Canonicalization + cleanup
+ *
+ * Following MLIR best practices, canonicalization and dead value removal
+ * are always run after each major transformation stage.
+ */
+class QuantumCompilerPipeline {
+public:
+  explicit QuantumCompilerPipeline(const QuantumCompilerConfig& config = {})
+      : config_(config) {}
+
+  /**
+   * @brief Run the complete compilation pipeline on a module
+   *
+   * @details
+   * Executes all enabled compilation stages on the provided MLIR module.
+   * If recordIntermediates is enabled in the config, captures IR snapshots
+   * at every stage (10 snapshots total for full pipeline).
+   *
+   * Automatically configures the PassManager with:
+   * - Timing statistics if enableTiming is true
+   * - Pass statistics if enableStatistics is true
+   * - IR printing after each stage if printIRAfterAllStages is true
+   *
+   * @param module The MLIR module to compile
+   * @param record Optional pointer to record intermediate states
+   * @return success() if compilation succeeded, failure() otherwise
+   */
+  LogicalResult runPipeline(ModuleOp module,
+                            CompilationRecord* record = nullptr) const;
+
+private:
+  /**
+   * @brief Add canonicalization and cleanup passes
+   *
+   * @details
+   * Always adds the standard MLIR canonicalization pass followed by dead
+   * value removal.
+   */
+  static void addCleanupPasses(PassManager& pm);
+
+  /**
+   * @brief Configure PassManager with diagnostic options
+   *
+   * @details
+   * Enables timing, statistics, and IR printing based on config flags.
+   * Uses MLIR's builtin PassManager configuration methods.
+   */
+  void configurePassManager(PassManager& pm) const;
+
+  QuantumCompilerConfig config_;
+};
+
+/**
+ * @brief Utility to capture IR as string
+ *
+ * @details
+ * Prints the MLIR module to a string for recording or comparison.
+ *
+ * @param module The module to convert to string
+ * @return String representation of the IR
+ */
+std::string captureIR(ModuleOp module);
+
+} // namespace mlir

mlir/include/mlir/Conversion/CMakeLists.txt

@@ -10,3 +10,6 @@ add_subdirectory(MQTRefToMQTOpt)
 add_subdirectory(MQTOptToMQTRef)
 add_subdirectory(MQTRefToQIR)
 add_subdirectory(QIRToMQTRef)
+add_subdirectory(QCOToQC)
+add_subdirectory(QCToQCO)
+add_subdirectory(QCToQIR)

mlir/include/mlir/Conversion/QCOToQC/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+set(LLVM_TARGET_DEFINITIONS QCOToQC.td)
+mlir_tablegen(QCOToQC.h.inc -gen-pass-decls -name QCOToQC)
+add_public_tablegen_target(QCOToQCIncGen)
+
+add_mlir_doc(QCOToQC MLIRQCOToQC Conversions/ -gen-pass-doc)

mlir/include/mlir/Conversion/QCOToQC/QCOToQC.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include <mlir/Pass/Pass.h> // from @llvm-project
+
+namespace mlir {
+#define GEN_PASS_DECL_QCOTOQC
+#include "mlir/Conversion/QCOToQC/QCOToQC.h.inc"
+
+#define GEN_PASS_REGISTRATION
+#include "mlir/Conversion/QCOToQC/QCOToQC.h.inc"
+} // namespace mlir

mlir/include/mlir/Conversion/QCOToQC/QCOToQC.td

@@ -0,0 +1,26 @@
+// Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+// Copyright (c) 2025 Munich Quantum Software Company GmbH
+// All rights reserved.
+//
+// SPDX-License-Identifier: MIT
+//
+// Licensed under the MIT License
+
+include "mlir/Pass/PassBase.td"
+
+def QCOToQC : Pass<"qco-to-qc"> {
+  let summary = "Convert QCO dialect to QC dialect.";
+
+  let description = [{
+      This pass converts all operations from the QCO dialect to their equivalent
+      operations in the QC dialect. It handles the transformation of qubit
+      values in QCO to qubit references in QC, ensuring that the semantics
+      of quantum operations are preserved during the conversion process.
+   }];
+
+  // Define dependent dialects
+  let dependentDialects = [
+    "mlir::qco::QCODialect",
+    "mlir::qc::QCDialect"
+  ];
+}

mlir/include/mlir/Conversion/QCToQCO/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+set(LLVM_TARGET_DEFINITIONS QCToQCO.td)
+mlir_tablegen(QCToQCO.h.inc -gen-pass-decls -name QCToQCO)
+add_public_tablegen_target(QCToQCOIncGen)
+
+add_mlir_doc(QCToQCO MLIRQCToQCO Conversions/ -gen-pass-doc)

mlir/include/mlir/Conversion/QCToQCO/QCToQCO.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include <mlir/Pass/Pass.h> // from @llvm-project
+
+namespace mlir {
+#define GEN_PASS_DECL_QCTOQCO
+#include "mlir/Conversion/QCToQCO/QCToQCO.h.inc"
+
+#define GEN_PASS_REGISTRATION
+#include "mlir/Conversion/QCToQCO/QCToQCO.h.inc"
+} // namespace mlir

mlir/include/mlir/Conversion/QCToQCO/QCToQCO.td

@@ -0,0 +1,26 @@
+// Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+// Copyright (c) 2025 Munich Quantum Software Company GmbH
+// All rights reserved.
+//
+// SPDX-License-Identifier: MIT
+//
+// Licensed under the MIT License
+
+include "mlir/Pass/PassBase.td"
+
+def QCToQCO : Pass<"qc-to-qco"> {
+  let summary = "Convert QC dialect to QCO dialect.";
+
+  let description = [{
+      This pass converts all operations from the QC dialect to their equivalent
+      operations in the QCO dialect. It handles the transformation of qubit
+      references in QC to qubit values in QCO, ensuring that the semantics
+      of quantum operations are preserved during the conversion process.
+   }];
+
+  // Define dependent dialects
+  let dependentDialects = [
+    "mlir::qc::QCDialect",
+    "mlir::qco::QCODialect"
+  ];
+}

mlir/include/mlir/Conversion/QCToQIR/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+set(LLVM_TARGET_DEFINITIONS QCToQIR.td)
+mlir_tablegen(QCToQIR.h.inc -gen-pass-decls -name QCToQIR)
+add_public_tablegen_target(QCToQIRIncGen)
+
+add_mlir_doc(QCToQIR MLIRQCToQIR Conversions/ -gen-pass-doc)

mlir/include/mlir/Conversion/QCToQIR/QCToQIR.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include <mlir/Pass/Pass.h> // from @llvm-project
+
+namespace mlir {
+#define GEN_PASS_DECL_QCTOQIR
+#include "mlir/Conversion/QCToQIR/QCToQIR.h.inc"
+
+#define GEN_PASS_REGISTRATION
+#include "mlir/Conversion/QCToQIR/QCToQIR.h.inc"
+} // namespace mlir