✨ Integrate registers

CHANGELOG.md

@@ -15,7 +15,7 @@ This project adheres to [Semantic Versioning], with the exception that minor rel
 - ✨ Add conversions between Jeff and QCO ([#1479], [#1548], [#1565]) ([**@denialhaag**])
 - ✨ Add a `place-and-route` pass for mapping circuits to architectures with restricted topologies ([#1537], [#1547], [#1568], [#1581], [#1583], [#1588]) ([**@MatthiasReumann**])
 - ✨ Add initial infrastructure for new QC and QCO MLIR dialects
-  ([#1264], [#1330], [#1402], [#1428], [#1430], [#1436], [#1443], [#1446], [#1464], [#1465], [#1470], [#1471], [#1472], [#1474], [#1475], [#1506], [#1510], [#1513], [#1521], [#1542], [#1548], [#1550], [#1554], [#1567], [#1569], [#1570], [#1572], [#1573], [#1602])
+  ([#1264], [#1330], [#1402], [#1428], [#1430], [#1436], [#1443], [#1446], [#1464], [#1465], [#1470], [#1471], [#1472], [#1474], [#1475], [#1506], [#1510], [#1513], [#1521], [#1542], [#1548], [#1550], [#1554], [#1567], [#1569], [#1570], [#1572], [#1573], [#1580], [#1602])
   ([**@burgholzer**], [**@denialhaag**], [**@taminob**], [**@DRovara**], [**@li-mingbao**], [**@Ectras**], [**@MatthiasReumann**], [**@simon1hofmann**])
 
 ### Changed
@@ -341,6 +341,7 @@ _📚 Refer to the [GitHub Release Notes](https://github.com/munich-quantum-tool
 [#1588]: https://github.com/munich-quantum-toolkit/core/pull/1588
 [#1583]: https://github.com/munich-quantum-toolkit/core/pull/1583
 [#1581]: https://github.com/munich-quantum-toolkit/core/pull/1581
+[#1580]: https://github.com/munich-quantum-toolkit/core/pull/1580
 [#1573]: https://github.com/munich-quantum-toolkit/core/pull/1573
 [#1572]: https://github.com/munich-quantum-toolkit/core/pull/1572
 [#1571]: https://github.com/munich-quantum-toolkit/core/pull/1571

mlir/include/mlir/Compiler/CompilerPipeline.h

@@ -72,18 +72,18 @@ struct CompilationRecord {
  *
  * 1. QC dialect (reference semantics) - imported from
  * qc::QuantumComputation
- * 2. Canonicalization + cleanup
+ * 2. QC cleanup pipeline
  * 3. QCO dialect (value semantics) - enables SSA-based optimizations
- * 4. Canonicalization + cleanup
+ * 4. QCO cleanup pipeline
  * 5. Quantum optimization passes
- * 6. Canonicalization + cleanup
+ * 6. QCO cleanup pipeline
  * 7. QC dialect - converted back for backend lowering
- * 8. Canonicalization + cleanup
+ * 8. QC cleanup pipeline
  * 9. QIR (Quantum Intermediate Representation) - optional final lowering
- * 10. Canonicalization + cleanup
+ * 10. QIR cleanup pipeline
  *
- * Following MLIR best practices, canonicalization and dead value removal
- * are always run after each major transformation stage.
+ * Following MLIR best practices, simplification and dead-value cleanup are
+ * run after each major transformation stage.
  */
 class QuantumCompilerPipeline {
 public:
@@ -111,15 +111,6 @@ class QuantumCompilerPipeline {
                             CompilationRecord* record = nullptr) const;
 
 private:
-  /**
-   * @brief Add canonicalization and cleanup passes
-   *
-   * @details
-   * Always adds the standard MLIR canonicalization pass followed by common
-   * sub-expression elimination and dead value removal.
-   */
-  static void addCleanupPasses(PassManager& pm);
-
   /**
    * @brief Configure PassManager with diagnostic options
    *

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

@@ -16,5 +16,6 @@ def QCOToQC : Pass<"qco-to-qc"> {
     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.
   }];
 
-  let dependentDialects = ["mlir::qc::QCDialect"];
+  let dependentDialects = ["mlir::memref::MemRefDialect",
+                           "mlir::qc::QCDialect"];
 }

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

@@ -16,5 +16,6 @@ def QCToQCO : Pass<"qc-to-qco"> {
     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.
   }];
 
-  let dependentDialects = ["mlir::qco::QCODialect"];
+  let dependentDialects = ["mlir::arith::ArithDialect", "mlir::qco::QCODialect",
+                           "mlir::qtensor::QTensorDialect"];
 }

mlir/include/mlir/Dialect/CMakeLists.txt

@@ -8,4 +8,5 @@
 
 add_subdirectory(QC)
 add_subdirectory(QCO)
+add_subdirectory(QIR)
 add_subdirectory(QTensor)

mlir/include/mlir/Dialect/QC/Builder/QCProgramBuilder.h

@@ -126,21 +126,20 @@ class QCProgramBuilder final : public ImplicitLocOpBuilder {
   /**
    * @brief Allocate a qubit register
    * @param size Number of qubits (must be positive)
-   * @param name Register name (default: "q")
    * @return Vector of qubit references
    *
    * @par Example:
    * ```c++
-   * auto q = builder.allocQubitRegister(3, "q");
+   * auto q = builder.allocQubitRegister(3);
    * ```
    * ```mlir
-   * %q0 = qc.alloc("q", 3, 0) : !qc.qubit
-   * %q1 = qc.alloc("q", 3, 1) : !qc.qubit
-   * %q2 = qc.alloc("q", 3, 2) : !qc.qubit
+   * %memref = memref.alloc() : memref<3x!qc.qubit>
+   * %q0 = memref.load %memref[%c0] : memref<3x!qc.qubit>
+   * %q1 = memref.load %memref[%c1] : memref<3x!qc.qubit>
+   * %q2 = memref.load %memref[%c2] : memref<3x!qc.qubit>
    * ```
    */
-  llvm::SmallVector<Value> allocQubitRegister(int64_t size,
-                                              const std::string& name = "q");
+  llvm::SmallVector<Value> allocQubitRegister(int64_t size);
 
   /**
    * @brief A small structure representing a single classical bit within a
@@ -942,6 +941,9 @@ class QCProgramBuilder final : public ImplicitLocOpBuilder {
   /// Track allocated qubits for automatic deallocation
   llvm::DenseSet<Value> allocatedQubits;
 
+  /// Track allocated MemRefs for automatic deallocation
+  llvm::DenseSet<Value> allocatedMemrefs;
+
   /// Check if the builder has been finalized
   void checkFinalized() const;
 };

mlir/include/mlir/Dialect/QC/CMakeLists.txt

@@ -7,3 +7,4 @@
 # Licensed under the MIT License
 
 add_subdirectory(IR)
+add_subdirectory(Transforms)

mlir/include/mlir/Dialect/QC/Transforms/CMakeLists.txt

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

mlir/include/mlir/Dialect/QC/Transforms/Passes.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 - 2026 Chair for Design Automation, TUM
+ * Copyright (c) 2025 - 2026 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "mlir/Dialect/QC/IR/QCDialect.h"
+
+#include <mlir/Pass/Pass.h>
+#include <mlir/Pass/PassRegistry.h>
+
+namespace mlir::qc {
+
+#define GEN_PASS_DECL
+#include "mlir/Dialect/QC/Transforms/Passes.h.inc" // IWYU pragma: export
+
+//===----------------------------------------------------------------------===//
+// Registration
+//===----------------------------------------------------------------------===//
+
+/// Generate the code for registering passes.
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/QC/Transforms/Passes.h.inc" // IWYU pragma: export
+
+} // namespace mlir::qc

mlir/include/mlir/Dialect/QC/Transforms/Passes.td

@@ -0,0 +1,27 @@
+// Copyright (c) 2023 - 2026 Chair for Design Automation, TUM
+// Copyright (c) 2025 - 2026 Munich Quantum Software Company GmbH
+// All rights reserved.
+//
+// SPDX-License-Identifier: MIT
+//
+// Licensed under the MIT License
+
+#ifndef MLIR_DIALECT_QC_TRANSFORMS_PASSES_TD
+#define MLIR_DIALECT_QC_TRANSFORMS_PASSES_TD
+
+include "mlir/Pass/PassBase.td"
+
+def ShrinkQubitRegistersPass
+    : Pass<"qc-shrink-qubit-registers", "mlir::ModuleOp"> {
+  let dependentDialects = ["mlir::qc::QCDialect", "mlir::arith::ArithDialect",
+                           "mlir::memref::MemRefDialect"];
+  let summary =
+      "Shrink static qc::QubitType memref registers to accessed indices.";
+  let description = [{
+    Shrinks one-dimensional static memref registers with element type
+    `!qc.qubit` by removing never-read indices and remapping `memref.load`
+    users accordingly.
+  }];
+}
+
+#endif // MLIR_DIALECT_QC_TRANSFORMS_PASSES_TD

mlir/include/mlir/Dialect/QCO/Builder/QCOProgramBuilder.h

@@ -10,6 +10,7 @@
 
 #pragma once
 
+#include <llvm/ADT/DenseMap.h>
 #include <llvm/ADT/DenseSet.h>
 #include <llvm/ADT/STLFunctionalExtras.h>
 #include <llvm/ADT/SmallVector.h>
@@ -134,21 +135,20 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
   /**
    * @brief Allocate a qubit register
    * @param size Number of qubits (must be positive)
-   * @param name Register name (default: "q")
    * @return Vector of tracked, valid qubit SSA values
    *
    * @par Example:
    * ```c++
-   * auto q = builder.allocQubitRegister(3, "q");
+   * auto q = builder.allocQubitRegister(3);
    * ```
    * ```mlir
-   * %q0 = qco.alloc("q", 3, 0) : !qco.qubit
-   * %q1 = qco.alloc("q", 3, 1) : !qco.qubit
-   * %q2 = qco.alloc("q", 3, 2) : !qco.qubit
+   * %t0 = qtensor.alloc(%c3) : tensor<3x!qco.qubit>
+   * %t1, %q0 = qtensor.extract %t0[%c0]: tensor<3x!qco.qubit>
+   * %t2, %q1 = qtensor.extract %t1[%c1]: tensor<3x!qco.qubit>
+   * %t3, %q2 = qtensor.extract %t2[%c2]: tensor<3x!qco.qubit>
    * ```
    */
-  llvm::SmallVector<Value> allocQubitRegister(int64_t size,
-                                              const std::string& name = "q");
+  llvm::SmallVector<Value> allocQubitRegister(int64_t size);
 
   /**
    * @brief A small structure representing a single classical bit within a
@@ -272,36 +272,7 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    * %outTensor, %q0 = qtensor.extract %tensor[%c0]: tensor<3x!qco.qubit>
    * ```
    */
-  std::pair<Value, Value>
-  qtensorExtract(Value tensor, const std::variant<int64_t, Value>& index);
-
-  /**
-   * @brief Extract a qubit slice from a tensor
-   *
-   * @details
-   * Extracts a slice from a one-dimensional tensor of qubits at the given
-   * offset and size and returns the updated input tensor and the extracted
-   * tensor. The extracted tensor is added to the qubit tensor tracking and the
-   * tracking for the input tensor is updated.
-   *
-   * @param tensor Source tensor (must be valid/unconsumed)
-   * @param offset The offset from where the slice is extracted
-   * @param size The size of the extracted slice
-   * @return Pair of (outTensor, extractedSlice)
-   *
-   * @par Example:
-   * ```c++
-   * auto [outTensor, extractedSlice] = builder.qtensorExtractSlice(tensor, 0,
-   * 2);
-   * ```
-   * ```mlir
-   * %outTensor, %extractedSlice = qtensor.extract_slice %tensor[%c0][%c2]
-   * : tensor<3x!qco.qubit> to tensor<2x!qco.qubit>
-   * ```
-   */
-  std::pair<Value, Value>
-  qtensorExtractSlice(Value tensor, const std::variant<int64_t, Value>& offset,
-                      const std::variant<int64_t, Value>& size);
+  std::pair<Value, Value> qtensorExtract(Value tensor, const int64_t index);
 
   /**
    * @brief Insert a qubit into a tensor
@@ -328,35 +299,6 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
   Value qtensorInsert(Value scalar, Value tensor,
                       const std::variant<int64_t, Value>& index);
 
-  /**
-   * @brief Insert a qubit slice into a tensor
-   *
-   * @details
-   * Inserts a one-dimensional tensor of qubits into another one-dimensional
-   * tensor of qubits at the given offset and size. The inserted tensor slice is
-   * consumed and removed from the tracking, while the tracking for the
-   * destination tensor is updated.
-   *
-   * @param sourceTensor The slice that is inserted (must be valid/unconsumed)
-   * @param destTensor The tensor where the slice is inserted (must be
-   * valid/unconsumed)
-   * @param offset The offset into where the slice is inserted
-   * @param size The size of the inserted slice
-   * @return The output tensor
-   *
-   * @par Example:
-   * ```c++
-   * auto outTensor = builder.qtensorInsertSlice(slicedTensor, tensor, 0, 2);
-   * ```
-   * ```mlir
-   * %outTensor = qtensor.insert_slice %slicedTensor into %tensor[%c0][%c2]
-   * : tensor<2x!qco.qubit> into tensor<3x!qco.qubit>
-   * ```
-   */
-  Value qtensorInsertSlice(Value sourceTensor, Value destTensor,
-                           const std::variant<int64_t, Value>& offset,
-                           const std::variant<int64_t, Value>& size);
-
   /**
    * @brief Explicitly deallocate a tensor
    *
@@ -1347,11 +1289,24 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    */
   void updateQubitTracking(Value inputQubit, Value outputQubit);
 
+  /// Count unique tensors
+  int64_t tensorCounter = 0;
+
+  /**
+   * @brief Information about a qubit
+   */
+  struct QubitInfo {
+    /// ID of the register the qubit belongs to
+    int64_t regId = -1;
+    /// Index of the qubit within its register
+    int64_t regIndex = -1;
+  };
+
   /// Track valid (unconsumed) qubit SSA values for linear type enforcement.
-  /// Only values present in this set are valid for use in operations.
+  /// Only values present in this map are valid for use in operations.
   /// When an operation consumes a qubit and produces a new one, the old value
   /// is removed and the new output is added.
-  llvm::DenseSet<Value> validQubits;
+  llvm::DenseMap<Value, QubitInfo> validQubits;
 
   /**
    * @brief Validate that a tensor value is valid and unconsumed. This also
@@ -1369,10 +1324,18 @@ class QCOProgramBuilder final : public ImplicitLocOpBuilder {
    */
   void updateTensorTracking(Value inputTensor, Value outputTensor);
 
+  /**
+   * @brief Information about a tensor
+   */
+  struct TensorInfo {
+    /// ID of the register the tensor corresponds to
+    int64_t regId = -1;
+  };
+
   /// Track valid (unconsumed) tensor SSA values for linear type enforcement.
-  /// Only values present in this set are valid for use in operations.
+  /// Only values present in this map are valid for use in operations.
   /// When an operation consumes a tensor and produces a new one, the old value
   /// is removed and the new output is added.
-  llvm::DenseSet<Value> validTensors;
+  llvm::DenseMap<Value, TensorInfo> validTensors;
 };
 } // namespace mlir::qco