[mlir][EmitC] Expand the MemRefToEmitC pass - Lowering `CopyOp` #151206

Jaddyen · 2025-07-29T18:20:26Z

This patch lowers memref.copy to emitc.call_opaque "memcpy".
From:

func.func @copying(%arg0 : memref<9x4x5x7xf32>, %arg1 : memref<9x4x5x7xf32>) {
  memref.copy %arg0, %arg1 : memref<9x4x5x7xf32> to memref<9x4x5x7xf32>
  return
}

To:

#include <cstring>
void copying(float v1[9][4][5][7], float v2[9][4][5][7]) {
  size_t v3 = 0;
  float* v4 = &v2[v3][v3][v3][v3];
  float* v5 = &v1[v3][v3][v3][v3];
  size_t v6 = sizeof(float);
  size_t v7 = 1260;
  size_t v8 = v6 * v7;
  memcpy(v5, v4, v8);
  return;
}

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

llvmbot · 2025-07-29T18:24:08Z

@llvm/pr-subscribers-mlir

@llvm/pr-subscribers-mlir-emitc

Author: Jaden Angella (Jaddyen)

Changes

This patch lowers memref.copy to emitc.call_opaque "memcpy".
From:

func.func @<!-- -->copying(%arg0 : memref&lt;9x4xf32&gt;) {
  memref.copy %arg0, %arg0 : memref&lt;9x4xf32&gt; to memref&lt;9x4xf32&gt;
  return
}

To:

void copying(float v1[9][4]) {
  size_t v2 = 0;
  size_t v3 = 0;
  float* v4 = &amp;v1[v2][v3];
  size_t v5 = 0;
  size_t v6 = 0;
  float* v7 = &amp;v1[v5][v6];
  size_t v8 = sizeof(float);
  size_t v9 = 36;
  size_t v10 = v8 * v9;
  memcpy(v7, v4, v10);
  return;
}

Full diff: https://github.com/llvm/llvm-project/pull/151206.diff

5 Files Affected:

(modified) mlir/include/mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h (+2)
(modified) mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp (+75-2)
(modified) mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp (+20-7)
(added) mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-copy.mlir (+24)
(modified) mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-failed.mlir (-8)

diff --git a/mlir/include/mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h b/mlir/include/mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h
index b595b6a308bea..4ea6649d64a92 100644
--- a/mlir/include/mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h
+++ b/mlir/include/mlir/Conversion/MemRefToEmitC/MemRefToEmitC.h
@@ -10,8 +10,10 @@
 
 constexpr const char *alignedAllocFunctionName = "aligned_alloc";
 constexpr const char *mallocFunctionName = "malloc";
+constexpr const char *memcpyFunctionName = "memcpy";
 constexpr const char *cppStandardLibraryHeader = "cstdlib";
 constexpr const char *cStandardLibraryHeader = "stdlib.h";
+constexpr const char *stringLibraryHeader = "string.h";
 
 namespace mlir {
 class DialectRegistry;
diff --git a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp
index 6bd0e2d4d4b08..adb0eb77fdf35 100644
--- a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp
+++ b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp
@@ -97,6 +97,29 @@ Type convertMemRefType(MemRefType opTy, const TypeConverter *typeConverter) {
   return resultTy;
 }
 
+Value calculateMemrefTotalSizeBytes(Location loc, MemRefType memrefType,
+                                    ConversionPatternRewriter &rewriter) {
+  emitc::CallOpaqueOp elementSize = rewriter.create<emitc::CallOpaqueOp>(
+      loc, emitc::SizeTType::get(rewriter.getContext()),
+      rewriter.getStringAttr("sizeof"), ValueRange{},
+      ArrayAttr::get(rewriter.getContext(),
+                     {TypeAttr::get(memrefType.getElementType())}));
+
+  IndexType indexType = rewriter.getIndexType();
+  int64_t numElements = 1;
+  for (int64_t dimSize : memrefType.getShape()) {
+    numElements *= dimSize;
+  }
+  emitc::ConstantOp numElementsValue = rewriter.create<emitc::ConstantOp>(
+      loc, indexType, rewriter.getIndexAttr(numElements));
+
+  Type sizeTType = emitc::SizeTType::get(rewriter.getContext());
+  emitc::MulOp totalSizeBytes = rewriter.create<emitc::MulOp>(
+      loc, sizeTType, elementSize.getResult(0), numElementsValue);
+
+  return totalSizeBytes.getResult();
+}
+
 struct ConvertAlloc final : public OpConversionPattern<memref::AllocOp> {
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
@@ -159,6 +182,55 @@ struct ConvertAlloc final : public OpConversionPattern<memref::AllocOp> {
   }
 };
 
+struct ConvertCopy final : public OpConversionPattern<memref::CopyOp> {
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(memref::CopyOp copyOp, OpAdaptor operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    Location loc = copyOp.getLoc();
+    MemRefType srcMemrefType =
+        dyn_cast<MemRefType>(copyOp.getSource().getType());
+    MemRefType targetMemrefType =
+        dyn_cast<MemRefType>(copyOp.getTarget().getType());
+
+    if (!isMemRefTypeLegalForEmitC(srcMemrefType) ||
+        !isMemRefTypeLegalForEmitC(targetMemrefType)) {
+      return rewriter.notifyMatchFailure(
+          loc, "incompatible memref type for EmitC conversion");
+    }
+
+    emitc::ConstantOp zeroIndex = rewriter.create<emitc::ConstantOp>(
+        loc, rewriter.getIndexType(), rewriter.getIndexAttr(0));
+    auto srcArrayValue =
+        dyn_cast<TypedValue<emitc::ArrayType>>(operands.getSource());
+
+    emitc::SubscriptOp srcSubPtr = rewriter.create<emitc::SubscriptOp>(
+        loc, srcArrayValue, ValueRange{zeroIndex, zeroIndex});
+    emitc::ApplyOp srcPtr = rewriter.create<emitc::ApplyOp>(
+        loc, emitc::PointerType::get(srcMemrefType.getElementType()),
+        rewriter.getStringAttr("&"), srcSubPtr);
+
+    auto arrayValue =
+        dyn_cast<TypedValue<emitc::ArrayType>>(operands.getTarget());
+    emitc::SubscriptOp targetSubPtr = rewriter.create<emitc::SubscriptOp>(
+        loc, arrayValue, ValueRange{zeroIndex, zeroIndex});
+    emitc::ApplyOp targetPtr = rewriter.create<emitc::ApplyOp>(
+        loc, emitc::PointerType::get(targetMemrefType.getElementType()),
+        rewriter.getStringAttr("&"), targetSubPtr);
+
+    emitc::CallOpaqueOp memCpyCall = rewriter.create<emitc::CallOpaqueOp>(
+        loc, TypeRange{}, "memcpy",
+        ValueRange{
+            targetPtr.getResult(), srcPtr.getResult(),
+            calculateMemrefTotalSizeBytes(loc, srcMemrefType, rewriter)});
+
+    rewriter.replaceOp(copyOp, memCpyCall.getResults());
+
+    return success();
+  }
+};
+
 struct ConvertGlobal final : public OpConversionPattern<memref::GlobalOp> {
   using OpConversionPattern::OpConversionPattern;
 
@@ -320,6 +392,7 @@ void mlir::populateMemRefToEmitCTypeConversion(TypeConverter &typeConverter) {
 
 void mlir::populateMemRefToEmitCConversionPatterns(
     RewritePatternSet &patterns, const TypeConverter &converter) {
-  patterns.add<ConvertAlloca, ConvertAlloc, ConvertGlobal, ConvertGetGlobal,
-               ConvertLoad, ConvertStore>(converter, patterns.getContext());
+  patterns.add<ConvertAlloca, ConvertAlloc, ConvertCopy, ConvertGlobal,
+               ConvertGetGlobal, ConvertLoad, ConvertStore>(
+      converter, patterns.getContext());
 }
diff --git a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp
index e78dd76d6e256..8e965b42f1043 100644
--- a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp
+++ b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp
@@ -18,6 +18,7 @@
 #include "mlir/IR/Attributes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTMEMREFTOEMITC
@@ -27,6 +28,15 @@ namespace mlir {
 using namespace mlir;
 
 namespace {
+
+emitc::IncludeOp addHeader(OpBuilder &builder, ModuleOp module,
+                           StringRef headerName) {
+  StringAttr includeAttr = builder.getStringAttr(headerName);
+  return builder.create<emitc::IncludeOp>(
+      module.getLoc(), includeAttr,
+      /*is_standard_include=*/builder.getUnitAttr());
+}
+
 struct ConvertMemRefToEmitCPass
     : public impl::ConvertMemRefToEmitCBase<ConvertMemRefToEmitCPass> {
   using Base::Base;
@@ -57,7 +67,8 @@ struct ConvertMemRefToEmitCPass
     mlir::ModuleOp module = getOperation();
     module.walk([&](mlir::emitc::CallOpaqueOp callOp) {
       if (callOp.getCallee() != alignedAllocFunctionName &&
-          callOp.getCallee() != mallocFunctionName) {
+          callOp.getCallee() != mallocFunctionName &&
+          callOp.getCallee() != memcpyFunctionName) {
         return mlir::WalkResult::advance();
       }
 
@@ -76,12 +87,14 @@ struct ConvertMemRefToEmitCPass
       }
 
       mlir::OpBuilder builder(module.getBody(), module.getBody()->begin());
-      StringAttr includeAttr =
-          builder.getStringAttr(options.lowerToCpp ? cppStandardLibraryHeader
-                                                   : cStandardLibraryHeader);
-      builder.create<mlir::emitc::IncludeOp>(
-          module.getLoc(), includeAttr,
-          /*is_standard_include=*/builder.getUnitAttr());
+      StringRef headerName;
+      if (callOp.getCallee() == memcpyFunctionName)
+        headerName = stringLibraryHeader;
+      else
+        headerName = options.lowerToCpp ? cppStandardLibraryHeader
+                                        : cStandardLibraryHeader;
+
+      addHeader(builder, module, headerName);
       return mlir::WalkResult::interrupt();
     });
   }
diff --git a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-copy.mlir b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-copy.mlir
new file mode 100644
index 0000000000000..4b6eb50807513
--- /dev/null
+++ b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-copy.mlir
@@ -0,0 +1,24 @@
+// RUN: mlir-opt -convert-memref-to-emitc %s  | FileCheck %s
+
+func.func @copying(%arg0 : memref<2x4xf32>) {
+  memref.copy %arg0, %arg0 : memref<2x4xf32> to memref<2x4xf32>
+  return
+}
+
+// CHECK: module {
+// CHECK-NEXT:  emitc.include <"string.h">
+// CHECK-LABEL:  copying
+// CHECK-NEXT: %0 = builtin.unrealized_conversion_cast %arg0 : memref<2x4xf32> to !emitc.array<2x4xf32>
+// CHECK-NEXT: %1 = "emitc.constant"() <{value = 0 : index}> : () -> index
+// CHECK-NEXT: %2 = emitc.subscript %0[%1, %1] : (!emitc.array<2x4xf32>, index, index) -> !emitc.lvalue<f32>
+// CHECK-NEXT: %3 = emitc.apply "&"(%2) : (!emitc.lvalue<f32>) -> !emitc.ptr<f32>
+// CHECK-NEXT: %4 = emitc.subscript %0[%1, %1] : (!emitc.array<2x4xf32>, index, index) -> !emitc.lvalue<f32>
+// CHECK-NEXT: %5 = emitc.apply "&"(%4) : (!emitc.lvalue<f32>) -> !emitc.ptr<f32>
+// CHECK-NEXT: %6 = emitc.call_opaque "sizeof"() {args = [f32]} : () -> !emitc.size_t
+// CHECK-NEXT: %7 = "emitc.constant"() <{value = 8 : index}> : () -> index
+// CHECK-NEXT: %8 = emitc.mul %6, %7 : (!emitc.size_t, index) -> !emitc.size_t
+// CHECK-NEXT: emitc.call_opaque "memcpy"(%5, %3, %8) : (!emitc.ptr<f32>, !emitc.ptr<f32>, !emitc.size_t) -> ()
+// CHECK-NEXT:    return
+// CHECK-NEXT:  }
+// CHECK-NEXT:}
+
diff --git a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-failed.mlir b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-failed.mlir
index fda01974d3fc8..b6eccfc8f0050 100644
--- a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-failed.mlir
+++ b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-failed.mlir
@@ -1,13 +1,5 @@
 // RUN: mlir-opt -convert-memref-to-emitc %s -split-input-file -verify-diagnostics
 
-func.func @memref_op(%arg0 : memref<2x4xf32>) {
-  // expected-error@+1 {{failed to legalize operation 'memref.copy'}}
-  memref.copy %arg0, %arg0 : memref<2x4xf32> to memref<2x4xf32>
-  return
-}
-
-// -----
-
 func.func @alloca_with_dynamic_shape() {
   %0 = index.constant 1
   // expected-error@+1 {{failed to legalize operation 'memref.alloca'}}

mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-copy.mlir

aniragil · 2025-07-31T13:36:57Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

@@ -97,6 +97,29 @@ Type convertMemRefType(MemRefType opTy, const TypeConverter *typeConverter) {
  return resultTy;
 }

+Value calculateMemrefTotalSizeBytes(Location loc, MemRefType memrefType,
+                                    ConversionPatternRewriter &rewriter) {


Can take the more generic OpBuilder here instead of a Rewriter?

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

aniragil · 2025-07-31T13:46:47Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+    if (!isMemRefTypeLegalForEmitC(srcMemrefType) ||
+        !isMemRefTypeLegalForEmitC(targetMemrefType)) {
+      return rewriter.notifyMatchFailure(
+          loc, "incompatible memref type for EmitC conversion");
+    }


I'd split this to two checks to specify in the message which memref was incompatible.

aniragil · 2025-07-31T13:56:24Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+        dyn_cast<TypedValue<emitc::ArrayType>>(operands.getSource());
+
+    emitc::SubscriptOp srcSubPtr = rewriter.create<emitc::SubscriptOp>(
+        loc, srcArrayValue, ValueRange{zeroIndex, zeroIndex});


This only works for 2D arrays

aniragil · 2025-07-31T13:57:47Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+    emitc::SubscriptOp targetSubPtr = rewriter.create<emitc::SubscriptOp>(
+        loc, arrayValue, ValueRange{zeroIndex, zeroIndex});
+    emitc::ApplyOp targetPtr = rewriter.create<emitc::ApplyOp>(
+        loc, emitc::PointerType::get(targetMemrefType.getElementType()),
+        rewriter.getStringAttr("&"), targetSubPtr);


Duplicates the work for srcArrayValue, can be folded into a lambda.

aniragil · 2025-07-31T14:13:25Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+    MemRefType srcMemrefType =
+        dyn_cast<MemRefType>(copyOp.getSource().getType());
+    MemRefType targetMemrefType =
+        dyn_cast<MemRefType>(copyOp.getTarget().getType());


Use cast (these arguments must be MemRefs by op definition).

aniragil · 2025-07-31T14:16:02Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp

@@ -27,6 +28,15 @@ namespace mlir {
 using namespace mlir;

 namespace {
+
+emitc::IncludeOp addHeader(OpBuilder &builder, ModuleOp module,


This function should be probably be named addStandardHeader as it always sets is_standard_include.

aniragil · 2025-07-31T14:35:02Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp

-          /*is_standard_include=*/builder.getUnitAttr());
+      StringRef headerName;
+      if (callOp.getCallee() == memcpyFunctionName)
+        headerName = stringLibraryHeader;


Why not follow the C/C++ distinction as with stdlib, i.e. cstring vs string.h?

ilovepi · 2025-08-04T18:28:30Z

mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-copy.mlir

+}
+
+// CHECK: module {
+// CHECK-NEXT:  emitc.include <"string.h">


There should probably be a c++ test too.

you only have a test for <string.h>, right? in the c++ mode, you'd have , so you probably need a test for the cpp mode too. Sorry for not being more explicit.

ack, thanks for the feedback!

aniragil · 2025-08-05T06:29:01Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+        [&](mlir::Location loc, mlir::OpBuilder &rewriter,
+            mlir::TypedValue<emitc::ArrayType> arrayValue,
+            mlir::MemRefType memrefType,
+            emitc::ConstantOp zeroIndex) -> emitc::ApplyOp {


You're already capturing rewriter and zeroIndex, no need to pass them as arguments (if you move zeroIndex creation above the lambda).

Usually better to capture exactly lambda uses than capture everything (&).

ack, thanks for the feedback!

aniragil · 2025-08-05T06:37:05Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+      emitc::SubscriptOp subPtr = rewriter.create<emitc::SubscriptOp>(
+          loc, arrayValue, mlir::ValueRange(indices));
+      emitc::ApplyOp ptr = rewriter.create<emitc::ApplyOp>(
+          loc, emitc::PointerType::get(memrefType.getElementType()),


Why not take element type from arrayValue (as done for the rank)? Would save passing memrefType as arg.

ack, thanks for the feedback!

aniragil · 2025-08-05T11:43:42Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+        loc, rewriter.getIndexType(), rewriter.getIndexAttr(0));
+
+    auto srcArrayValue =
+        dyn_cast<TypedValue<emitc::ArrayType>>(operands.getSource());


Use cast rather than dyn_cast when you expect cast to succeed (it will assert on failure).

aniragil · 2025-08-05T11:43:52Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+        loc, rewriter, srcArrayValue, srcMemrefType, zeroIndex);
+
+    auto targetArrayValue =
+        dyn_cast<TypedValue<emitc::ArrayType>>(operands.getTarget());


Same as above.

aniragil · 2025-08-05T11:46:52Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

+    emitc::CallOpaqueOp memCpyCall = rewriter.create<emitc::CallOpaqueOp>(
+        loc, TypeRange{}, "memcpy",
+        ValueRange{targetPtr.getResult(), srcPtr.getResult(),
+                   calculateMemrefTotalSizeBytes(loc, srcMemrefType, builder)});


Rewriter is a builder, you can just pass it as argument (and should, as you're working within a conversion pattern).

aniragil · 2025-08-05T12:06:31Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp


      for (auto &op : *module.getBody()) {
        emitc::IncludeOp includeOp = llvm::dyn_cast<mlir::emitc::IncludeOp>(op);
-        if (!includeOp) {


Change itself is good (removing braces from single-line blocks) but should be done on a separate PR to avoid cluttering this one with unrelated modifications.

ideally, yes.
but im already modifying this portion of code and this would be a single line change.

aniragil · 2025-08-05T12:07:37Z

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitCPass.cpp

        if (includeOp.getIsStandardInclude() &&
            ((options.lowerToCpp &&
              includeOp.getInclude() == cppStandardLibraryHeader) ||
             (!options.lowerToCpp &&
-              includeOp.getInclude() == cStandardLibraryHeader))) {


Same here.
Also, shouldn't the code here also check for c/cppStringLibraryHeader?

yes, i should!
thanks for the pointer!

Jaddyen added 2 commits July 29, 2025 04:20

Adding lowering for copyop

3768def

use subscript and apply ops

bc4dd4f

Jaddyen commented Jul 29, 2025

View reviewed changes

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp Show resolved Hide resolved

Jaddyen marked this pull request as ready for review July 29, 2025 18:23

Jaddyen requested review from aniragil, simon-camp and mgehre-amd July 29, 2025 18:23

llvmbot added mlir mlir:emitc labels Jul 29, 2025

Jaddyen requested review from jpienaar, mtrofin and ilovepi July 29, 2025 18:24

ilovepi reviewed Jul 29, 2025

View reviewed changes

mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-copy.mlir Outdated Show resolved Hide resolved

aniragil requested changes Jul 31, 2025

View reviewed changes

Jaddyen added 2 commits August 4, 2025 18:11

allow for multi dimensional arays

7e7f59c

update test file

7650eaa

ilovepi reviewed Aug 4, 2025

View reviewed changes

Jaddyen requested a review from aniragil August 4, 2025 22:05

aniragil requested changes Aug 5, 2025

View reviewed changes

test cpp output

cc17120

Jaddyen requested review from ilovepi and aniragil August 5, 2025 17:45

[mlir][EmitC] Expand the MemRefToEmitC pass - Lowering CopyOp #151206

Are you sure you want to change the base?

[mlir][EmitC] Expand the MemRefToEmitC pass - Lowering CopyOp #151206

Conversation

Jaddyen commented Jul 29, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

llvmbot commented Jul 29, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

[mlir][EmitC] Expand the MemRefToEmitC pass - Lowering `CopyOp` #151206

[mlir][EmitC] Expand the MemRefToEmitC pass - Lowering `CopyOp` #151206

Jaddyen commented Jul 29, 2025 •

edited

Loading

llvmbot commented Jul 29, 2025 •

edited

Loading