Add ArrayToPointerOp and its conversion pattern

Signed-off-by: Roberto Raggi <[email protected]>

Author: robertoraggi

src/mlir/cxx/mlir/CxxOps.td

@@ -202,6 +202,12 @@ def Cxx_IntegralCastOp : Cxx_Op<"integral_cast"> {
   let results = (outs Cxx_IntegerType:$result);
 }
 
+def Cxx_ArrayToPointerOp : Cxx_Op<"array_to_pointer"> {
+  let arguments = (ins Cxx_PointerType:$value);
+
+  let results = (outs Cxx_PointerType:$result);
+}
+
 def Cxx_NotOp : Cxx_Op<"not"> {
   let arguments = (ins AnyType:$value);
 

src/mlir/cxx/mlir/codegen_expressions.cc

@@ -1013,6 +1013,17 @@ auto Codegen::ExpressionVisitor::operator()(ImplicitCastExpressionAST* ast)
       break;
     }
 
+    case ImplicitCastKind::kArrayToPointerConversion: {
+      // generate an array to pointer conversion
+      auto expressionResult = gen.expression(ast->expression);
+      auto resultType = gen.convertType(ast->type);
+
+      auto op = gen.builder_.create<mlir::cxx::ArrayToPointerOp>(
+          loc, resultType, expressionResult.value);
+
+      return {op};
+    }
+
     default:
       break;
 

src/mlir/cxx/mlir/cxx_dialect_conversions.cc

@@ -256,14 +256,14 @@ class SubscriptOpLowering : public OpConversionPattern<cxx::SubscriptOp> {
     auto typeConverter = getTypeConverter();
     auto context = getContext();
 
-    auto ptrType = dyn_cast_or_null<cxx::PointerType>(op.getBase().getType());
+    auto ptrType = dyn_cast<cxx::PointerType>(op.getBase().getType());
 
     if (!ptrType) {
       return rewriter.notifyMatchFailure(
           op, "failed to convert subscript operation type");
     }
 
-    auto arrayType = dyn_cast_or_null<cxx::ArrayType>(ptrType.getElementType());
+    auto arrayType = dyn_cast<cxx::ArrayType>(ptrType.getElementType());
     if (!arrayType) {
       return rewriter.notifyMatchFailure(
           op, "expected base type of subscript to be an array type");
@@ -435,6 +435,45 @@ class IntToBoolOpLowering : public OpConversionPattern<cxx::IntToBoolOp> {
   }
 };
 
+class ArrayToPointerOpLowering
+    : public OpConversionPattern<cxx::ArrayToPointerOp> {
+ public:
+  using OpConversionPattern::OpConversionPattern;
+
+  auto matchAndRewrite(cxx::ArrayToPointerOp op, OpAdaptor adaptor,
+                       ConversionPatternRewriter &rewriter) const
+      -> LogicalResult override {
+    auto typeConverter = getTypeConverter();
+    auto context = getContext();
+
+    auto ptrType = dyn_cast<cxx::PointerType>(op.getValue().getType());
+
+    if (!ptrType) {
+      return rewriter.notifyMatchFailure(
+          op, "failed to convert subscript operation type");
+    }
+
+    auto arrayType = dyn_cast<cxx::ArrayType>(ptrType.getElementType());
+    if (!arrayType) {
+      return rewriter.notifyMatchFailure(
+          op, "expected base type of subscript to be an array type");
+    }
+
+    SmallVector<LLVM::GEPArg> indices;
+
+    indices.push_back(0);
+    indices.push_back(0);
+
+    auto resultType = LLVM::LLVMPointerType::get(context);
+    auto elementType = typeConverter->convertType(ptrType.getElementType());
+
+    rewriter.replaceOpWithNewOp<LLVM::GEPOp>(op, resultType, elementType,
+                                             adaptor.getValue(), indices);
+
+    return success();
+  }
+};
+
 class BoolToIntOpLowering : public OpConversionPattern<cxx::BoolToIntOp> {
  public:
   using OpConversionPattern::OpConversionPattern;
@@ -1225,9 +1264,9 @@ void CxxToLLVMLoweringPass::runOnOperation() {
                   SubscriptOpLowering>(typeConverter, dataLayout, context);
 
   // cast operations
-  patterns
-      .insert<IntToBoolOpLowering, BoolToIntOpLowering, IntegralCastOpLowering>(
-          typeConverter, context);
+  patterns.insert<IntToBoolOpLowering, BoolToIntOpLowering,
+                  IntegralCastOpLowering, ArrayToPointerOpLowering>(
+      typeConverter, context);
 
   // constant operations
   patterns.insert<BoolConstantOpLowering, IntConstantOpLowering,