almost functional option

Author: Jaddyen

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

@@ -20,6 +20,7 @@
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Value.h"
+#include "mlir/IR/ValueRange.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <cstdint>
@@ -316,36 +317,26 @@ struct ConvertReinterpretCastOp final
 
       return ptr;
     };
-    auto [strides, offset] = targetMemRefType.getStridesAndOffset();
-    // Value offsetValue = rewriter.create<emitc::ConstantOp>(
-    //     loc, rewriter.getIndexType(), rewriter.getIndexAttr(offset));
 
     auto srcPtr = createPointerFromEmitcArray(srcArrayValue);
-    // emitc::PointerType targetPointerType =
-    //     emitc::PointerType::get(srcArrayValue.getType().getElementType());
-
-    auto dimensions = targetMemRefType.getShape();
-    std::string reinterpretCastName = llvm::formatv(
-        "reinterpret_cast<{0}(*)", srcArrayValue.getType().getElementType());
-    std::string dimensionsStr;
-    for (auto dim : dimensions) {
-      dimensionsStr += llvm::formatv("[{0}]", dim);
-    }
-    reinterpretCastName += llvm::formatv("{0}>", dimensionsStr);
-    reinterpretCastName += ">";
-
-    reinterpretCastName += llvm::formatv("{0}", srcPtr->getResult(0));
+    // 1. Create a TypeAttr for the target type.
+    TypeAttr targetTypeAttr =
+        TypeAttr::get(emitc::PointerType::get(targetInEmitC));
+    IntegerAttr resty = rewriter.getIndexAttr(0);
 
-    std::string outputStr = llvm::formatv(
-        "{0}(*){1}", srcArrayValue.getType().getElementType(), dimensionsStr);
-    auto outputType = emitc::PointerType::get(
-        emitc::OpaqueType::get(rewriter.getContext(), outputStr));
+    // 2. Create an ArrayAttr with the TypeAttr. This will be the
+    // templateArgsAttr.
+    ArrayAttr templateArgsAttr = rewriter.getArrayAttr({targetTypeAttr});
 
-    emitc::ConstantOp reinterpretOp = rewriter.create<emitc::ConstantOp>(
-        loc, outputType,
-        emitc::OpaqueAttr::get(rewriter.getContext(), reinterpretCastName));
+    auto reinterpretCastCall = rewriter.create<emitc::CallOpaqueOp>(
+        loc,
+        /*result types=*/TypeRange{emitc::PointerType::get(targetInEmitC)},
+        /*callee=*/"reinterpret_cast",
+        /*args*/ rewriter.getArrayAttr({resty}),
+        /*template_args=*/templateArgsAttr,
+        /*operands=*/ValueRange{srcPtr.getResult()});
 
-    rewriter.replaceOp(castOp, reinterpretOp.getResult());
+    rewriter.replaceOp(castOp, reinterpretCastCall.getResults());
     return success();
   }
 };

mlir/lib/Target/Cpp/TranslateToCpp.cpp

@@ -1848,8 +1848,17 @@ LogicalResult CppEmitter::emitType(Location loc, Type type) {
   if (auto lType = dyn_cast<emitc::LValueType>(type))
     return emitType(loc, lType.getValueType());
   if (auto pType = dyn_cast<emitc::PointerType>(type)) {
-    if (isa<ArrayType>(pType.getPointee()))
-      return emitError(loc, "cannot emit pointer to array type ") << type;
+    // Check if the pointee is an array type.
+    if (auto aType = dyn_cast<emitc::ArrayType>(pType.getPointee())) {
+      // Handle pointer to array: `element_type (*)[dim]`.
+      if (failed(emitType(loc, aType.getElementType())))
+        return failure();
+      os << "(*)";
+      for (auto dim : aType.getShape())
+        os << "[" << dim << "]";
+      return success();
+    }
+    // Handle standard pointer: `element_type*`.
     if (failed(emitType(loc, pType.getPointee())))
       return failure();
     os << "*";

mlir/test/Conversion/MemRefToEmitC/memref-to-emitc-reinterpret-cast.mlir

@@ -0,0 +1,16 @@
+// RUN: mlir-opt -convert-memref-to-emitc %s -split-input-file | FileCheck %s
+
+func.func @casting(%arg0: memref<999xi32>) {
+  %reinterpret_cast_5 = memref.reinterpret_cast %arg0 to offset: [0], sizes: [1, 1, 999], strides: [999, 999, 1] : memref<999xi32> to memref<1x1x999xi32>
+  return
+}
+
+//CHECK: module {
+//CHECK-NEXT:   func.func @casting(%arg0: memref<999xi32>) {
+//CHECK-NEXT:     %0 = builtin.unrealized_conversion_cast %arg0 : memref<999xi32> to !emitc.array<999xi32>
+//CHECK-NEXT:     %1 = "emitc.constant"() <{value = 0 : index}> : () -> index
+//CHECK-NEXT:     %2 = emitc.subscript %0[%1] : (!emitc.array<999xi32>, index) -> !emitc.lvalue<i32>
+//CHECK-NEXT:     %3 = emitc.apply "&"(%2) : (!emitc.lvalue<i32>) -> !emitc.ptr<i32>
+//CHECK-NEXT:     %4 = emitc.call_opaque "reinterpret_cast"(%3) {args = [0 : index], template_args = [!emitc.ptr<!emitc.array<1x1x999xi32>>]} : (!emitc.ptr<i32>) -> !emitc.ptr<!emitc.array<1x1x999xi32>>
+//CHECK-NEXT:     return
+