huge refactor for high RewritePatterns usage and less ad-hoc cpp code

remove Spatial many ops in favor of tensor ops like in pim

src/PIM/Pass/PimCodegen/HostConstantFolding/Common.cpp

@@ -1,9 +1,9 @@
-#include "Common.hpp"
-#include "src/Accelerators/PIM/Common/PimCommon.hpp"
-
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
 
+#include "Common.hpp"
+#include "src/Accelerators/PIM/Common/PimCommon.hpp"
+
 using namespace mlir;
 
 namespace onnx_mlir {
@@ -31,7 +31,8 @@ struct DenseSubviewKeyInfo {
 
   static unsigned getHashValue(const DenseSubviewKey& key) {
     return static_cast<unsigned>(
-      llvm::hash_combine(key.source, llvm::hash_combine_range(key.offsets.begin(), key.offsets.end()),
+      llvm::hash_combine(key.source,
+                         llvm::hash_combine_range(key.offsets.begin(), key.offsets.end()),
                          llvm::hash_combine_range(key.resultShape.begin(), key.resultShape.end())));
   }
 
@@ -98,16 +99,16 @@ memref::GlobalOp createFoldedGlobal(ModuleOp moduleOp,
                                   alignment);
 }
 
-FailureOr<DenseElementsAttr> foldDenseSubview(DenseElementsAttr denseAttr,
-                                              ArrayRef<int64_t> staticOffsets,
-                                              ArrayRef<int64_t> resultShape) {
+FailureOr<DenseElementsAttr>
+foldDenseSubview(DenseElementsAttr denseAttr, ArrayRef<int64_t> staticOffsets, ArrayRef<int64_t> resultShape) {
   auto sourceType = dyn_cast<RankedTensorType>(denseAttr.getType());
   if (!sourceType || !sourceType.hasStaticShape() || sourceType.getRank() != static_cast<int64_t>(staticOffsets.size())
       || sourceType.getRank() != static_cast<int64_t>(resultShape.size()))
     return failure();
 
   static DenseMap<DenseSubviewKey, DenseElementsAttr, DenseSubviewKeyInfo> cache;
-  DenseSubviewKey key {denseAttr, SmallVector<int64_t>(staticOffsets.begin(), staticOffsets.end()),
+  DenseSubviewKey key {denseAttr,
+                       SmallVector<int64_t>(staticOffsets.begin(), staticOffsets.end()),
                        SmallVector<int64_t>(resultShape.begin(), resultShape.end())};
   if (auto cached = cache.find(key); cached != cache.end())
     return cached->second;
@@ -152,6 +153,30 @@ FailureOr<DenseElementsAttr> getDenseGlobalValue(ModuleOp moduleOp, Value value)
   return denseAttr;
 }
 
+FailureOr<DenseElementsAttr> foldDenseSourceToType(ModuleOp moduleOp, Value source, MemRefType resultType) {
+  auto srcSubview = getStaticSubviewInfo(source);
+  Value globalSource = succeeded(srcSubview) ? srcSubview->source : stripMemRefCasts(source);
+
+  auto denseAttr = getDenseGlobalValue(moduleOp, globalSource);
+  if (failed(denseAttr))
+    return failure();
+
+  if (succeeded(srcSubview)) {
+    if (llvm::any_of(srcSubview->strides, [](int64_t stride) { return stride != 1; }))
+      return failure();
+    auto staticOffsets = getStaticSubviewOffsets(*srcSubview);
+    if (failed(staticOffsets))
+      return failure();
+
+    return foldDenseSubview(*denseAttr, *staticOffsets, resultType.getShape());
+  }
+
+  auto resultTensorType = RankedTensorType::get(resultType.getShape(), resultType.getElementType());
+  if (resultTensorType != denseAttr->getType())
+    return failure();
+  return *denseAttr;
+}
+
 FailureOr<StaticSubviewInfo> getStaticSubviewInfo(Value value) {
   value = stripMemRefViewOps(value);
   auto subviewOp = value.getDefiningOp<memref::SubViewOp>();

src/PIM/Pass/PimCodegen/HostConstantFolding/Common.hpp

@@ -36,6 +36,9 @@ llvm::FailureOr<mlir::DenseElementsAttr> foldDenseSubview(mlir::DenseElementsAtt
 
 llvm::FailureOr<mlir::DenseElementsAttr> getDenseGlobalValue(mlir::ModuleOp moduleOp, mlir::Value value);
 
+llvm::FailureOr<mlir::DenseElementsAttr>
+foldDenseSourceToType(mlir::ModuleOp moduleOp, mlir::Value source, mlir::MemRefType resultType);
+
 llvm::FailureOr<StaticSubviewInfo> getStaticSubviewInfo(mlir::Value value);
 
 /// Returns the offsets in `info` as int64_t, failing if any offset is dynamic.

src/PIM/Pass/PimCodegen/HostConstantFolding/Patterns/Constant.cpp

@@ -90,6 +90,7 @@ static FailureOr<Attribute> getConstantMapYield(linalg::MapOp mapOp) {
   return attr;
 }
 
+// Folds constant linalg fills inside cores into private globals plus device copies.
 struct FoldConstantCoreMapPattern final : OpRewritePattern<linalg::MapOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -249,6 +250,7 @@ static FailureOr<DenseElementsAttr> foldConstantAlloc(memref::AllocOp allocOp, M
   return DenseElementsAttr::get(resultTensorType, resultValues);
 }
 
+// Folds transposes of constant globals so weight-only transposes stay host-side.
 struct FoldConstantTransposePattern final : OpRewritePattern<pim::PimTransposeOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -304,11 +306,9 @@ struct FoldConstantTransposePattern final : OpRewritePattern<pim::PimTransposeOp
     rewriter.setInsertionPoint(transposeOp);
     auto newGetGlobal = memref::GetGlobalOp::create(rewriter, transposeOp.getLoc(), resultType, newGlobal.getName());
 
-    bool isAlwaysWeight =
-      !transposeOp->getUsers().empty()
-      && llvm::all_of(transposeOp->getUsers(), [](Operation* user) {
-           return isa<pim::PimCoreOp, pim::PimCoreBatchOp>(user);
-         });
+    bool isAlwaysWeight = !transposeOp->getUsers().empty()
+                       && llvm::all_of(transposeOp->getUsers(),
+                                       [](Operation* user) { return isa<pim::PimCoreOp, pim::PimCoreBatchOp>(user); });
     if (isAlwaysWeight) {
       markWeightAlways(newGlobal);
       markWeightAlways(newGetGlobal);
@@ -330,6 +330,7 @@ struct FoldConstantTransposePattern final : OpRewritePattern<pim::PimTransposeOp
   }
 };
 
+// Collapses fill-and-copy allocation chains into one folded constant global.
 struct FoldConstantAllocPattern final : OpRewritePattern<memref::AllocOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -367,9 +368,8 @@ struct FoldConstantAllocPattern final : OpRewritePattern<memref::AllocOp> {
     }
 
     if (!llvm::all_of(castsToReplace, [](memref::CastOp castOp) {
-          return llvm::all_of(castOp->getUsers(), [](Operation* user) {
-            return isa<pim::PimCoreOp, pim::PimCoreBatchOp>(user);
-          });
+          return llvm::all_of(castOp->getUsers(),
+                              [](Operation* user) { return isa<pim::PimCoreOp, pim::PimCoreBatchOp>(user); });
         })) {
       allLiveUsersAreCoreOps = false;
     }
@@ -417,6 +417,7 @@ struct FoldConstantAllocPattern final : OpRewritePattern<memref::AllocOp> {
   }
 };
 
+// Converts host copies from dense globals into direct folded globals.
 struct FoldConstantHostCopyPattern final : OpRewritePattern<memref::CopyOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -431,37 +432,14 @@ struct FoldConstantHostCopyPattern final : OpRewritePattern<memref::CopyOp> {
     if (!allocType || !allocType.hasStaticShape())
       return failure();
 
-    auto srcSubview = getStaticSubviewInfo(copyOp.getSource());
-    Value globalSource = succeeded(srcSubview) ? srcSubview->source : stripMemRefCasts(copyOp.getSource());
-
     auto moduleOp = copyOp->getParentOfType<ModuleOp>();
     if (!moduleOp)
       return failure();
 
-    auto denseAttr = getDenseGlobalValue(moduleOp, globalSource);
-    if (failed(denseAttr))
+    auto foldedAttr = foldDenseSourceToType(moduleOp, copyOp.getSource(), allocType);
+    if (failed(foldedAttr))
       return failure();
 
-    DenseElementsAttr foldedAttr;
-    if (succeeded(srcSubview)) {
-      if (llvm::any_of(srcSubview->strides, [](int64_t stride) { return stride != 1; }))
-        return failure();
-      auto staticOffsets = getStaticSubviewOffsets(*srcSubview);
-      if (failed(staticOffsets))
-        return failure();
-
-      auto maybeFoldedAttr = foldDenseSubview(*denseAttr, *staticOffsets, allocType.getShape());
-      if (failed(maybeFoldedAttr))
-        return failure();
-      foldedAttr = *maybeFoldedAttr;
-    }
-    else {
-      auto resultTensorType = RankedTensorType::get(allocType.getShape(), allocType.getElementType());
-      if (resultTensorType != denseAttr->getType())
-        return failure();
-      foldedAttr = *denseAttr;
-    }
-
     bool allLiveUsersAreCores = true;
     for (Operation* user : allocOp->getUsers()) {
       if (user == copyOp)
@@ -477,7 +455,7 @@ struct FoldConstantHostCopyPattern final : OpRewritePattern<memref::CopyOp> {
       return failure();
     }
 
-    auto newGlobal = createFoldedGlobal(moduleOp, allocOp.getLoc(), allocType, foldedAttr, "pim_folded_host_copy");
+    auto newGlobal = createFoldedGlobal(moduleOp, allocOp.getLoc(), allocType, *foldedAttr, "pim_folded_host_copy");
     if (allLiveUsersAreCores)
       markWeightAlways(newGlobal);
 
@@ -494,6 +472,7 @@ struct FoldConstantHostCopyPattern final : OpRewritePattern<memref::CopyOp> {
   }
 };
 
+// Converts PIM copies from dense globals into direct folded globals before codegen.
 struct FoldConstantMemCpPattern final : OpRewritePattern<pim::PimMemCopyOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -511,37 +490,14 @@ struct FoldConstantMemCpPattern final : OpRewritePattern<pim::PimMemCopyOp> {
     if (copyOp.getTargetOffset() != 0 || copyOp.getSourceOffset() != 0)
       return failure();
 
-    auto srcSubview = getStaticSubviewInfo(copyOp.getSource());
-    Value globalSource = succeeded(srcSubview) ? srcSubview->source : stripMemRefCasts(copyOp.getSource());
-
     auto moduleOp = copyOp->getParentOfType<ModuleOp>();
     if (!moduleOp)
       return failure();
 
-    auto denseAttr = getDenseGlobalValue(moduleOp, globalSource);
-    if (failed(denseAttr))
+    auto foldedAttr = foldDenseSourceToType(moduleOp, copyOp.getSource(), allocType);
+    if (failed(foldedAttr))
       return failure();
 
-    DenseElementsAttr foldedAttr;
-    if (succeeded(srcSubview)) {
-      if (llvm::any_of(srcSubview->strides, [](int64_t stride) { return stride != 1; }))
-        return failure();
-      auto staticOffsets = getStaticSubviewOffsets(*srcSubview);
-      if (failed(staticOffsets))
-        return failure();
-
-      auto maybeFoldedAttr = foldDenseSubview(*denseAttr, *staticOffsets, allocType.getShape());
-      if (failed(maybeFoldedAttr))
-        return failure();
-      foldedAttr = *maybeFoldedAttr;
-    }
-    else {
-      auto resultTensorType = RankedTensorType::get(allocType.getShape(), allocType.getElementType());
-      if (resultTensorType != denseAttr->getType())
-        return failure();
-      foldedAttr = *denseAttr;
-    }
-
     bool allLiveUsersAreCores = true;
     for (Operation* user : allocOp->getUsers()) {
       if (user == copyOp)
@@ -557,7 +513,7 @@ struct FoldConstantMemCpPattern final : OpRewritePattern<pim::PimMemCopyOp> {
       return failure();
     }
 
-    auto newGlobal = createFoldedGlobal(moduleOp, allocOp.getLoc(), allocType, foldedAttr, "pim_folded_memcp");
+    auto newGlobal = createFoldedGlobal(moduleOp, allocOp.getLoc(), allocType, *foldedAttr, "pim_folded_memcp");
     if (allLiveUsersAreCores)
       markWeightAlways(newGlobal);
 
@@ -577,13 +533,11 @@ struct FoldConstantMemCpPattern final : OpRewritePattern<pim::PimMemCopyOp> {
 } // namespace
 
 void populateConstantFoldingConstantPatterns(RewritePatternSet& patterns) {
-  patterns
-    .add<FoldConstantTransposePattern,
-         FoldConstantAllocPattern,
-         FoldConstantCoreMapPattern,
-         FoldConstantHostCopyPattern,
-         FoldConstantMemCpPattern>(
-      patterns.getContext());
+  patterns.add<FoldConstantTransposePattern,
+               FoldConstantAllocPattern,
+               FoldConstantCoreMapPattern,
+               FoldConstantHostCopyPattern,
+               FoldConstantMemCpPattern>(patterns.getContext());
 }
 
 } // namespace onnx_mlir

src/PIM/Pass/PimCodegen/HostConstantFolding/Patterns/Subview.cpp

@@ -128,6 +128,7 @@ static LogicalResult rewriteSubviewCopyLikeOp(CopyOp copyOp,
   return success();
 }
 
+// Splits core copies through subviews into contiguous copy chunks for codegen.
 struct RewriteCoreSubviewCopyPattern final : OpRewritePattern<pim::PimMemCopyOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -162,6 +163,7 @@ struct RewriteCoreSubviewCopyPattern final : OpRewritePattern<pim::PimMemCopyOp>
   }
 };
 
+// Splits host-to-device subview loads into contiguous copy chunks.
 struct RewriteHostSubviewLoadPattern final : OpRewritePattern<pim::PimMemCopyHostToDevOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -193,6 +195,7 @@ struct RewriteHostSubviewLoadPattern final : OpRewritePattern<pim::PimMemCopyHos
   }
 };
 
+// Splits device-to-host subview stores into contiguous copy chunks.
 struct RewriteHostSubviewStorePattern final : OpRewritePattern<pim::PimMemCopyDevToHostOp> {
   using OpRewritePattern::OpRewritePattern;
 
@@ -224,6 +227,7 @@ struct RewriteHostSubviewStorePattern final : OpRewritePattern<pim::PimMemCopyDe
   }
 };
 
+// Folds constant subviews used as core weights into standalone globals.
 struct FoldConstantCoreSubviewPattern final : OpRewritePattern<memref::SubViewOp> {
   using OpRewritePattern::OpRewritePattern;
 

src/PIM/Pass/PimCodegen/MaterializeHostConstantsPass.cpp

@@ -1,5 +1,6 @@
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
@@ -9,6 +10,8 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/MathExtras.h"
 
+#include <type_traits>
+
 #include "src/Accelerators/PIM/Common/PimCommon.hpp"
 #include "src/Accelerators/PIM/Dialect/Pim/PimOps.hpp"
 
@@ -21,6 +24,8 @@ namespace {
 static bool isExplicitHostOperand(Operation* op, unsigned operandIndex) {
   if (isa<pim::PimMemCopyHostToDevOp>(op))
     return operandIndex == 1;
+  if (isa<pim::PimMemCopyHostToDevBatchOp>(op))
+    return operandIndex == 1;
   if (isa<pim::PimMemCopyDevToHostOp>(op))
     return operandIndex == 0;
   return false;
@@ -33,6 +38,91 @@ static int64_t getValueSizeInBytes(Value value) {
   return type.getNumElements() * type.getElementTypeBitWidth() / 8;
 }
 
+template <typename CoreOpTy>
+static void materializeHostConstantsInCore(CoreOpTy coreOp, IRRewriter& rewriter, bool& hasFailure) {
+  DenseMap<Value, DenseMap<int64_t, DenseMap<Type, Value>>> materializedValues;
+  SmallVector<Operation*> ops;
+  coreOp.getBody().front().walk([&](Operation* op) {
+    if (!isa<pim::PimHaltOp, scf::YieldOp>(op))
+      ops.push_back(op);
+  });
+
+  for (Operation* op : ops) {
+    for (OpOperand& operand : op->getOpOperands()) {
+      Value originalValue = operand.get();
+      if (!isa<BaseMemRefType>(originalValue.getType()) || isExplicitHostOperand(op, operand.getOperandNumber()))
+        continue;
+
+      auto resolvedAddress = resolveContiguousAddress(originalValue);
+      if (failed(resolvedAddress))
+        continue;
+
+      auto getGlobalOp = dyn_cast_or_null<memref::GetGlobalOp>(resolvedAddress->base.getDefiningOp());
+      if (!getGlobalOp)
+        continue;
+
+      auto originalType = dyn_cast<MemRefType>(originalValue.getType());
+      if (!originalType || !originalType.hasStaticShape()) {
+        op->emitOpError("host constant materialization requires a static memref operand");
+        hasFailure = true;
+        continue;
+      }
+
+      auto& cachedByOffset = materializedValues[resolvedAddress->base];
+      auto& cachedByType = cachedByOffset[resolvedAddress->byteOffset];
+      auto cachedValue = cachedByType.find(originalType);
+      if (cachedValue != cachedByType.end()) {
+        operand.set(cachedValue->second);
+        continue;
+      }
+
+      int64_t totalBytes = getValueSizeInBytes(originalValue);
+      if (totalBytes < 0 || !llvm::isInt<32>(totalBytes) || !llvm::isInt<32>(resolvedAddress->byteOffset)) {
+        op->emitOpError("host constant materialization requires 32-bit copy sizes and offsets");
+        hasFailure = true;
+        continue;
+      }
+
+      auto contiguousType = MemRefType::get(originalType.getShape(), originalType.getElementType());
+
+      rewriter.setInsertionPoint(op);
+      Value localAlloc = memref::AllocOp::create(rewriter, op->getLoc(), contiguousType);
+      Value deviceDst = localAlloc;
+      if (contiguousType != originalType)
+        deviceDst = memref::CastOp::create(rewriter, op->getLoc(), originalType, localAlloc);
+
+      Value copiedValue;
+      if constexpr (std::is_same_v<CoreOpTy, pim::PimCoreBatchOp>) {
+        copiedValue = pim::PimMemCopyHostToDevBatchOp::create(
+                        rewriter,
+                        op->getLoc(),
+                        originalType,
+                        deviceDst,
+                        getGlobalOp.getResult(),
+                        rewriter.getI32IntegerAttr(0),
+                        rewriter.getI32IntegerAttr(static_cast<int32_t>(resolvedAddress->byteOffset)),
+                        rewriter.getI32IntegerAttr(static_cast<int32_t>(totalBytes)))
+                        .getOutput();
+      }
+      else {
+        copiedValue = pim::PimMemCopyHostToDevOp::create(
+                        rewriter,
+                        op->getLoc(),
+                        originalType,
+                        deviceDst,
+                        getGlobalOp.getResult(),
+                        rewriter.getI32IntegerAttr(0),
+                        rewriter.getI32IntegerAttr(static_cast<int32_t>(resolvedAddress->byteOffset)),
+                        rewriter.getI32IntegerAttr(static_cast<int32_t>(totalBytes)))
+                        .getOutput();
+      }
+
+      cachedByType[originalType] = copiedValue;
+      operand.set(copiedValue);
+    }
+  }
+}
+
 struct MaterializeHostConstantsPass : PassWrapper<MaterializeHostConstantsPass, OperationPass<ModuleOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MaterializeHostConstantsPass)
 
@@ -50,71 +140,11 @@ struct MaterializeHostConstantsPass : PassWrapper<MaterializeHostConstantsPass,
       if (funcOp.isExternal())
         continue;
 
-      for (pim::PimCoreOp coreOp : funcOp.getOps<pim::PimCoreOp>()) {
-        DenseMap<Value, DenseMap<int64_t, DenseMap<Type, Value>>> materializedValues;
+      for (pim::PimCoreOp coreOp : funcOp.getOps<pim::PimCoreOp>())
+        materializeHostConstantsInCore(coreOp, rewriter, hasFailure);
 
-        for (Operation& op : llvm::make_early_inc_range(coreOp.getBody().front())) {
-          if (isa<pim::PimHaltOp>(op))
-            continue;
-
-          for (OpOperand& operand : op.getOpOperands()) {
-            Value originalValue = operand.get();
-            if (!isa<BaseMemRefType>(originalValue.getType()) || isExplicitHostOperand(&op, operand.getOperandNumber()))
-              continue;
-
-            auto resolvedAddress = resolveContiguousAddress(originalValue);
-            if (failed(resolvedAddress))
-              continue;
-
-            auto getGlobalOp = dyn_cast_or_null<memref::GetGlobalOp>(resolvedAddress->base.getDefiningOp());
-            if (!getGlobalOp)
-              continue;
-
-            auto originalType = dyn_cast<MemRefType>(originalValue.getType());
-            if (!originalType || !originalType.hasStaticShape()) {
-              op.emitOpError("host constant materialization requires a static memref operand");
-              hasFailure = true;
-              continue;
-            }
-
-            auto& cachedByOffset = materializedValues[resolvedAddress->base];
-            auto& cachedByType = cachedByOffset[resolvedAddress->byteOffset];
-            auto cachedValue = cachedByType.find(originalType);
-            if (cachedValue != cachedByType.end()) {
-              operand.set(cachedValue->second);
-              continue;
-            }
-
-            int64_t totalBytes = getValueSizeInBytes(originalValue);
-            if (totalBytes < 0 || !llvm::isInt<32>(totalBytes) || !llvm::isInt<32>(resolvedAddress->byteOffset)) {
-              op.emitOpError("host constant materialization requires 32-bit copy sizes and offsets");
-              hasFailure = true;
-              continue;
-            }
-
-            auto contiguousType = MemRefType::get(originalType.getShape(), originalType.getElementType());
-
-            rewriter.setInsertionPoint(&op);
-            Value localAlloc = memref::AllocOp::create(rewriter, op.getLoc(), contiguousType);
-            Value deviceDst = localAlloc;
-            if (contiguousType != originalType)
-              deviceDst = memref::CastOp::create(rewriter, op.getLoc(), originalType, localAlloc);
-
-            auto hostToDevCopy = pim::PimMemCopyHostToDevOp::create(
-              rewriter,
-              op.getLoc(),
-              originalType,
-              deviceDst,
-              getGlobalOp.getResult(),
-              rewriter.getI32IntegerAttr(0),
-              rewriter.getI32IntegerAttr(static_cast<int32_t>(resolvedAddress->byteOffset)),
-              rewriter.getI32IntegerAttr(static_cast<int32_t>(totalBytes)));
-
-            cachedByType[originalType] = hostToDevCopy.getResult();
-            operand.set(hostToDevCopy.getResult());
-          }
-        }
-      }
+      for (pim::PimCoreBatchOp coreBatchOp : funcOp.getOps<pim::PimCoreBatchOp>())
+        materializeHostConstantsInCore(coreBatchOp, rewriter, hasFailure);
 
       SmallVector<Operation*> hostCompactOps;
       for (Operation& op : funcOp.getBody().front())

src/PIM/Pass/PimCodegen/VerificationPass.cpp

@@ -122,6 +122,14 @@ struct VerificationPass : PassWrapper<VerificationPass, OperationPass<ModuleOp>>
     ModuleOp moduleOp = getOperation();
     bool hasFailure = false;
 
+    moduleOp.walk([&](Operation* op) {
+      if (op->getDialect()->getNamespace() != "spat")
+        return;
+
+      op->emitError("illegal Spatial operation reached PIM codegen verification");
+      hasFailure = true;
+    });
+
     for (func::FuncOp funcOp : moduleOp.getOps<func::FuncOp>()) {
       if (funcOp.isExternal())
         continue;