[mlir][emitc] Add a pointer type

[marbre]

Summary

Adds a pointer type to EmitC. The emission of pointers is so far only
possible by using the emitc.opaque type

Co-authored-by: Simon Camphausen <[e-mail]>

[jpienaar]

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

57

Could you add comments for these with what will be emitted?

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

224

Is the declarative syntax unable to handle it?

[marbre]

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

57

Good point! Will add comment with the next revision.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

224

Do you suggest to set useDefaultTypePrinterParser to 0? As far as I see, this is not possible as the opaque type requires a custom parser/printer.

[marbre]

Updating D119337: [mlir][emitc] Add a pointer type

Add comments to show what will be emitted.
Use the declarative syntax.

[marbre]

@jpienaar I adressed your comments with the latest revision.

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

224

The assembly format is now declared in tblgen.

[marbre]

Updating D119337: [mlir][emitc] Add a pointer type

[nfc] Harmonize naming of variables used in type builders.

[jpienaar]

Thanks!

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

def EmitC_OpaqueType : EmitC_Type<"Opaque", "opaque"> {
 
   let description = [{
     An opaque data type of which the value gets emitted as is.
 
     Example:
 
     ```mlir
     !emitc.opaque<"int">
-    !emitc.opaque<"float *">
+    !emitc.opaque<"mytype">
     !emitc.opaque<"std::vector<std::string>">
     ```
   }];
 
   let parameters = (ins StringRefParameter<"the opaque value">:$value);
 }
 
+def EmitC_PointerType : EmitC_Type<"Pointer", "ptr"> {
+  let summary = "EmitC pointer type";
+
+  let description = [{
+    A pointer data type.
+
+    Example:
+
+    ```mlir
+    !emitc.ptr<i32>
+    !emitc.ptr<f32>
+    !emitc.ptr<!emitc.opaque<"int">>
+    ```
+  }];
+
+  let parameters = (ins "Type":$pointee);
+  let builders = [
+    TypeBuilderWithInferredContext<(ins "Type":$elementType), [{
+      return $_get(elementType.getContext(), elementType);
+    }]>
+  ];
+  let skipDefaultBuilders = 1;
+}
+
 #endif // MLIR_DIALECT_EMITC_IR_EMITCTYPES

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

 
 //===----------------------------------------------------------------------===//
 // EmitC Types
 //===----------------------------------------------------------------------===//
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
 
+//===----------------------------------------------------------------------===//
+// OpaqueType
+//===----------------------------------------------------------------------===//
+
 Type emitc::OpaqueType::parse(AsmParser &parser) {
   if (parser.parseLess())
     return Type();
   std::string value;
   SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value) || value.empty()) {
     parser.emitError(loc) << "expected non empty string";
     return Type();
   }
   if (parser.parseGreater())
     return Type();
   return get(parser.getContext(), value);
 }
 
 void emitc::OpaqueType::print(AsmPrinter &printer) const {
   printer << "<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }
+
+//===----------------------------------------------------------------------===//
+// PointerType
+//===----------------------------------------------------------------------===//
+
+Type emitc::PointerType::parse(AsmParser &parser) {
+  if (parser.parseLess())
+    return Type();
+  Type type;
+  SMLoc loc = parser.getCurrentLocation();
+  if (parser.parseType(type)) {
+    parser.emitError(loc) << "unable parse pointee type";
+    return Type();
+  }
+  if (parser.parseGreater())
+    return Type();
+  return get(type);
+}
+
+void emitc::PointerType::print(AsmPrinter &printer) const {
+  printer << "<";
+  printer.printType(getPointee());
+  printer << ">";
+}

mlir/lib/Target/Cpp/TranslateToCpp.cpp

if (auto tType = type.dyn_cast<TensorType>()) {
     return success();
   }
   if (auto tType = type.dyn_cast<TupleType>())
     return emitTupleType(loc, tType.getTypes());
   if (auto oType = type.dyn_cast<emitc::OpaqueType>()) {
     os << oType.getValue();
     return success();
   }
+  if (auto pType = type.dyn_cast<emitc::PointerType>()) {
+    if (failed(emitType(loc, pType.getPointee())))
+      return failure();
+    os << "*";
+    return success();
+  }
   return emitError(loc, "cannot emit type ") << type;
 }
 
 LogicalResult CppEmitter::emitTypes(Location loc, ArrayRef<Type> types) {
   switch (types.size()) {
   case 0:
     os << "void";
     return success();

mlir/test/Dialect/EmitC/types.mlir

func @opaque_types() {
   emitc.call "f"() {template_args = [!emitc<"opaque<\"unsigned\">">]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"status_t">
   emitc.call "f"() {template_args = [!emitc<"opaque<\"status_t\">">]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"std::vector<std::string>">
   emitc.call "f"() {template_args = [!emitc.opaque<"std::vector<std::string>">]} : () -> ()
 
   return
 }
+
+// CHECK-LABEL: func @pointer_types() {
+func @pointer_types() {
+  // CHECK-NEXT: !emitc.ptr<i32>
+  emitc.call "f"() {template_args = [!emitc<"ptr<i32>">]} : () -> ()
+  // CHECK-NEXT: !emitc.ptr<i64>
+  emitc.call "f"() {template_args = [!emitc.ptr<i64>]} : () -> ()
+  // CHECK-NEXT: !emitc.ptr<f32>
+  emitc.call "f"() {template_args = [!emitc<"ptr<f32>">]} : () -> ()
+  // CHECK-NEXT: !emitc.ptr<f64>
+  emitc.call "f"() {template_args = [!emitc.ptr<f64>]} : () -> ()
+  // CHECK-NEXT: !emitc.ptr<i32>
+  %0 = emitc.call "f"() : () -> (!emitc.ptr<i32>)
+  // CHECK-NEXT: (!emitc.ptr<i32>) -> !emitc.ptr<!emitc.ptr<i32>>
+  %1 = emitc.call "f"(%0) : (!emitc.ptr<i32>) -> (!emitc.ptr<!emitc.ptr<i32>>)
+  // CHECK-NEXT: !emitc.ptr<!emitc.opaque<"int">>
+  emitc.call "f"() {template_args = [!emitc.ptr<!emitc.opaque<"int">>]} : () -> ()
+
+  return
+}

mlir/test/Target/Cpp/types.mlir

 // RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s
 
-// CHECK-LABEL: void opaque_template_args() {
-func @opaque_template_args() {
+// CHECK-LABEL: void opaque_types() {
+func @opaque_types() {
   // CHECK-NEXT: f<int>();
   emitc.call "f"() {template_args = [!emitc<"opaque<\"int\">">]} : () -> ()
   // CHECK-NEXT: f<byte>();
   emitc.call "f"() {template_args = [!emitc<"opaque<\"byte\">">]} : () -> ()
   // CHECK-NEXT: f<unsigned>();
   emitc.call "f"() {template_args = [!emitc<"opaque<\"unsigned\">">]} : () -> ()
   // CHECK-NEXT: f<status_t>();
   emitc.call "f"() {template_args = [!emitc<"opaque<\"status_t\">">]} : () -> ()
   // CHECK-NEXT: f<std::vector<std::string>>();
   emitc.call "f"() {template_args = [!emitc.opaque<"std::vector<std::string>">]} : () -> ()
 
   return
 }
+
+// CHECK-LABEL: void ptr_types() {
+func @ptr_types() {
+  // CHECK-NEXT: f<int32_t*>();
+  emitc.call "f"() {template_args = [!emitc<"ptr<i32>">]} : () -> ()
+  // CHECK-NEXT: f<int64_t*>();
+  emitc.call "f"() {template_args = [!emitc.ptr<i64>]} : () -> ()
+  // CHECK-NEXT: f<float*>();
+  emitc.call "f"() {template_args = [!emitc<"ptr<f32>">]} : () -> ()
+  // CHECK-NEXT: f<double*>();
+  emitc.call "f"() {template_args = [!emitc.ptr<f64>]} : () -> ()
+  // CHECK-NEXT: int32_t* [[V0:[^ ]*]] = f();
+  %0 = emitc.call "f"() : () -> (!emitc.ptr<i32>)
+  // CHECK-NEXT: int32_t** [[V1:[^ ]*]] = f([[V0:[^ ]*]]);
+  %1 = emitc.call "f"(%0) : (!emitc.ptr<i32>) -> (!emitc.ptr<!emitc.ptr<i32>>)
+  // CHECK-NEXT: f<int*>();
+  emitc.call "f"() {template_args = [!emitc.ptr<!emitc.opaque<"int">>]} : () -> ()
+
+  return
+}