Make sure uccsd compiles for quantum devices

include/cudaq/Optimizer/Dialect/CC/CCOps.td

@@ -393,6 +393,7 @@ def cc_IfOp : CCOp<"if",
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
+  let hasCanonicalizer = 1;
 
   let extraClassDeclaration = [{
     using RegionBuilderFn = llvm::function_ref<void(mlir::OpBuilder &,

include/cudaq/Optimizer/Transforms/Passes.td

@@ -167,6 +167,29 @@ def CombineMeasurements :
 }
 
 
+def CollapseStores : Pass<"collapse-stores", "mlir::func::FuncOp"> {
+  let summary = "Remove stores that are overriden by other stores.";
+  let description = [{
+
+    Example:
+    ```mlir
+    %1 = cc.alloca !cc.array<i64 x 1>
+    %2 = cc.cast %1 : (!cc.ptr<!cc.array<i64 x 1>>) -> !cc.ptr<i64>
+    cc.store %c0_i64, %2 : !cc.ptr<i64>
+    // nothing using %2 until the next instruction
+    cc.store %c1_i64, %2 : !cc.ptr<i64>
+    ```
+
+    would be converted to
+
+    ```mlir
+    %1 = cc.alloca !cc.array<i64 x 1>
+    %2 = cc.cast %1 : (!cc.ptr<!cc.array<i64 x 1>>) -> !cc.ptr<i64>
+    cc.store %c1_i64, %2 : !cc.ptr<i64>
+    ```
+  }];
+}
+
 def CombineQuantumAllocations :
     Pass<"combine-quantum-alloc", "mlir::func::FuncOp"> {
   let summary = "Combines quake alloca operations.";
@@ -623,6 +646,8 @@ def LoopUnroll : Pass<"cc-loop-unroll"> {
     Option<"signalFailure",
       "signal-failure-if-any-loop-cannot-be-completely-unrolled", "bool",
       /*default=*/"false", "Signal failure if pass can't unroll all loops.">,
+    Option<"allowClosedInterval", "allow-closed-interval", "bool",
+      /*default=*/"true", "Allow loop iterations on a closed interval.">,
     Option<"allowBreak", "allow-early-exit", "bool", /*default=*/"false",
       "Allow unrolling of loop with early exit (i.e. break statement).">
   ];

lib/Optimizer/Dialect/CC/CCOps.cpp

@@ -2038,6 +2038,63 @@ MutableOperandRange cudaq::cc::ConditionOp::getMutableSuccessorOperands(
   return getResultsMutable();
 }
 
+//===----------------------------------------------------------------------===//
+// IfOp
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// const prop `cc.if($true)` and `cc.if($false)`
+struct EraseConstIf : public OpRewritePattern<cudaq::cc::IfOp> {
+  using OpRewritePattern::OpRewritePattern;
+
+  static bool hasQuantumAllocations(Block &block) {
+    for (auto &op : block) {
+      for (auto &region : op.getRegions())
+        for (auto &b : region)
+          if (hasQuantumAllocations(b))
+            return true;
+
+      if (auto alloc = dyn_cast<quake::AllocaOp>(&op))
+        return true;
+    }
+    return false;
+  }
+
+  LogicalResult matchAndRewrite(cudaq::cc::IfOp ifOp,
+                                PatternRewriter &rewriter) const override {
+    auto cond = ifOp.getCondition();
+    if (auto constCond = cond.getDefiningOp<arith::ConstantOp>()) {
+      if (auto attr = dyn_cast<BoolAttr>(constCond.getValue())) {
+        auto value = attr.getValue();
+        auto block =
+            value ? ifOp.getThenEntryBlock() : ifOp.getElseEntryBlock();
+
+        // Prevent quantum allocations from moving to an outer scope.
+        if (block && hasQuantumAllocations(*block))
+          return failure();
+
+        if (block) {
+          if (auto cont = dyn_cast<cudaq::cc::ContinueOp>(block->back())) {
+            for (std::size_t i = 0; auto opnd : ifOp.getResults())
+              rewriter.replaceAllUsesWith(opnd, cont.getOperand(i++));
+            rewriter.eraseOp(cont);
+          }
+          rewriter.mergeBlockBefore(block, ifOp);
+        }
+        rewriter.eraseOp(ifOp);
+        return success();
+      }
+    }
+    return failure();
+  }
+};
+} // namespace
+
+void cudaq::cc::IfOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
+                                                  MLIRContext *context) {
+  patterns.add<EraseConstIf>(context);
+}
+
 //===----------------------------------------------------------------------===//
 // OffsetOfOp
 //===----------------------------------------------------------------------===//

lib/Optimizer/Transforms/CMakeLists.txt

@@ -17,6 +17,8 @@ add_cudaq_library(OptTransforms
   ApplyOpSpecialization.cpp
   ArgumentSynthesis.cpp
   BasisConversion.cpp
+  CollapseStores.cpp
+  CollapseStoresPatterns.cpp
   CombineMeasurements.cpp
   CombineQuantumAlloc.cpp
   ConstPropComplex.cpp
@@ -34,9 +36,11 @@ add_cudaq_library(OptTransforms
   GlobalizeArrayValues.cpp
   LambdaLifting.cpp
   LiftArrayAlloc.cpp
+  LiftArrayAllocPatterns.cpp
   LinearCtrlRelations.cpp
   LoopAnalysis.cpp
   LoopNormalize.cpp
+  LoopNormalizePatterns.cpp
   LoopPeeling.cpp
   LoopUnroll.cpp
   LowerToCFG.cpp

lib/Optimizer/Transforms/CollapseStores.cpp

@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                  *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+#include "CollapseStoresPatterns.h"
+#include "PassDetails.h"
+#include "cudaq/Optimizer/Builder/Intrinsics.h"
+#include "cudaq/Optimizer/Dialect/CC/CCOps.h"
+#include "cudaq/Optimizer/Dialect/Quake/QuakeOps.h"
+#include "cudaq/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Complex/IR/Complex.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Dominance.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "mlir/Transforms/Passes.h"
+
+namespace cudaq::opt {
+#define GEN_PASS_DEF_COLLAPSESTORES
+#include "cudaq/Optimizer/Transforms/Passes.h.inc"
+} // namespace cudaq::opt
+
+#define DEBUG_TYPE "collapse-stores"
+
+using namespace mlir;
+
+namespace {
+class CollapseStoresPass
+    : public cudaq::opt::impl::CollapseStoresBase<CollapseStoresPass> {
+public:
+  using CollapseStoresBase::CollapseStoresBase;
+
+  void runOnOperation() override {
+    auto *ctx = &getContext();
+    auto func = getOperation();
+
+    RewritePatternSet patterns(ctx);
+    patterns.insert<RemoveUselessStorePattern>(ctx);
+
+    LLVM_DEBUG(llvm::dbgs() << "Before collapsing stores: " << func << '\n');
+
+    if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns))))
+      signalPassFailure();
+
+    LLVM_DEBUG(llvm::dbgs() << "After collapsing stores: " << func << '\n');
+  }
+};
+} // namespace

lib/Optimizer/Transforms/CollapseStoresPatterns.cpp

@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                  *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+#include "CollapseStoresPatterns.h"
+#include "PassDetails.h"
+#include "cudaq/Optimizer/Builder/Intrinsics.h"
+#include "cudaq/Optimizer/Dialect/CC/CCOps.h"
+#include "cudaq/Optimizer/Dialect/Quake/QuakeOps.h"
+#include "cudaq/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Complex/IR/Complex.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Dominance.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "mlir/Transforms/Passes.h"
+
+#define DEBUG_TYPE "collapse-stores"
+
+using namespace mlir;
+
+/// Remove stores followed by a store to the same pointer
+/// if the pointer is not used in between.
+/// ```
+/// cc.store %c0_i64, %5 : !cc.ptr<i64>
+///  // no use of %5 until next line
+/// cc.store %3, %5 : !cc.ptr<i64>
+/// ───────────────────────────────────────────
+/// cc.store %3, %5 : !cc.ptr<i64>
+/// ```
+LogicalResult
+RemoveUselessStorePattern::matchAndRewrite(cudaq::cc::StoreOp store,
+                                           PatternRewriter &rewriter) const {
+  if (isUselessStore(store)) {
+    rewriter.eraseOp(store);
+    return success();
+  }
+  return failure();
+}
+
+/// Detect if the current store can be removed.
+bool RemoveUselessStorePattern::isUselessStore(cudaq::cc::StoreOp store) {
+  Value currentPtr;
+
+  if (!isStoreToStack(store))
+    return false;
+
+  auto block = store.getOperation()->getBlock();
+  for (auto &op : *block) {
+    if (auto s = dyn_cast<cudaq::cc::StoreOp>(&op)) {
+      auto nextPtr = s.getPtrvalue();
+      if (store == s) {
+        // Start searching from the current store
+        currentPtr = nextPtr;
+      } else {
+        // Found an overriding store, the current store is useless
+        if (currentPtr == nextPtr)
+          return true;
+
+        // Found a use for a current ptr before the overriding store
+        if (currentPtr && isUsed(currentPtr, &op))
+          return false;
+      }
+    } else {
+      // Found a use for a current ptr before the overriding store
+      if (currentPtr && isUsed(currentPtr, &op))
+        return false;
+    }
+  }
+  // No multiple stores to the same location found
+  return false;
+}
+
+/// Detect stores to stack locations
+/// ```
+/// %1 = cc.alloca !cc.array<i64 x 2>
+///
+/// %2 = cc.cast %1 : (!cc.ptr<!cc.array<i64 x 2>>) -> !cc.ptr<i64>
+/// cc.store %c0_i64, %2 : !cc.ptr<i64>
+///
+/// %3 = cc.compute_ptr %1[1] : (!cc.ptr<!cc.array<i64 x 2>>) -> !cc.ptr<i64>
+/// cc.store %c0_i64, %3 : !cc.ptr<i64>
+/// ```
+bool RemoveUselessStorePattern::isStoreToStack(cudaq::cc::StoreOp store) {
+  auto ptrOp = store.getPtrvalue();
+  if (auto cast = ptrOp.getDefiningOp<cudaq::cc::CastOp>())
+    ptrOp = cast.getOperand();
+
+  if (auto computePtr = ptrOp.getDefiningOp<cudaq::cc::ComputePtrOp>())
+    ptrOp = computePtr.getBase();
+
+  if (auto alloca = ptrOp.getDefiningOp<cudaq::cc::AllocaOp>())
+    return true;
+
+  return false;
+}
+
+/// Detect if value is used in the op or its nested blocks.
+bool RemoveUselessStorePattern::isUsed(Value v, Operation *op) {
+  for (auto opnd : op->getOperands())
+    if (opnd == v)
+      return true;
+
+  for (auto &region : op->getRegions())
+    for (auto &b : region)
+      for (auto &innerOp : b)
+        if (isUsed(v, &innerOp))
+          return true;
+
+  return false;
+}

lib/Optimizer/Transforms/CollapseStoresPatterns.h

@@ -0,0 +1,60 @@
+/****************************************************************-*- C++ -*-****
+ * Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                  *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+#include "PassDetails.h"
+#include "cudaq/Optimizer/Builder/Intrinsics.h"
+#include "cudaq/Optimizer/Dialect/CC/CCOps.h"
+#include "cudaq/Optimizer/Dialect/Quake/QuakeOps.h"
+#include "cudaq/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Complex/IR/Complex.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Dominance.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "mlir/Transforms/Passes.h"
+
+/// Remove stores followed by a store to the same pointer
+/// if the pointer is not used in between.
+/// ```
+/// cc.store %c0_i64, %5 : !cc.ptr<i64>
+///  // no use of %5 until next line
+/// cc.store %3, %5 : !cc.ptr<i64>
+/// ───────────────────────────────────────────
+/// cc.store %3, %5 : !cc.ptr<i64>
+/// ```
+class RemoveUselessStorePattern
+    : public mlir::OpRewritePattern<cudaq::cc::StoreOp> {
+public:
+  using OpRewritePattern::OpRewritePattern;
+
+  explicit RemoveUselessStorePattern(mlir::MLIRContext *ctx)
+      : OpRewritePattern(ctx) {}
+
+  mlir::LogicalResult
+  matchAndRewrite(cudaq::cc::StoreOp store,
+                  mlir::PatternRewriter &rewriter) const override;
+
+private:
+  /// Detect if the current store can be removed.
+  static bool isUselessStore(cudaq::cc::StoreOp store);
+
+  /// Detect stores to stack locations
+  /// ```
+  /// %1 = cc.alloca !cc.array<i64 x 2>
+  ///
+  /// %2 = cc.cast %1 : (!cc.ptr<!cc.array<i64 x 2>>) -> !cc.ptr<i64>
+  /// cc.store %c0_i64, %2 : !cc.ptr<i64>
+  ///
+  /// %3 = cc.compute_ptr %1[1] : (!cc.ptr<!cc.array<i64 x 2>>) -> !cc.ptr<i64>
+  /// cc.store %c0_i64, %3 : !cc.ptr<i64>
+  /// ```
+  static bool isStoreToStack(cudaq::cc::StoreOp store);
+
+  /// Detect if value is used in the op or its nested blocks.
+  static bool isUsed(mlir::Value v, mlir::Operation *op);
+};