Surface clone APIs in CAPI

[GeorgeLyon]

Fix comment

[GeorgeLyon]

Test

[GeorgeLyon]

Test

[mehdi_amini]

mlir/include/mlir-c/IR.h

199

Since we can turn a Module into an Operation, should we avoid duplicating every single method on operation to take directly a module as well?

329

330

mlir/test/CAPI/ir.c

1656

[GeorgeLyon]

• Address feedback

[GeorgeLyon]

mlir/include/mlir-c/IR.h

199

Generally I would agree, but in this case the issue is we cannot create a module from an operation.

[mehdi_amini]

mlir/include/mlir-c/IR.h

199

mlirModuleFromOperation line 217?

[GeorgeLyon]

• Remove mlirModuleClone

mlir/include/mlir-c/IR.h

199

Whoops, missed this API. Thanks!

[GeorgeLyon]

• Remove suprious function

mlir/include/mlir-c/IR.h

 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location);
 
 /// Parses a module from the string and transfers ownership to the caller.
 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context,
                                                     MlirStringRef module);
 
 /// Gets the context that a module was created with.
 MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module);
 
 /// Gets the body of the module, i.e. the only block it contains.
 MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module);
 
 /// Checks whether a module is null.
 static inline bool mlirModuleIsNull(MlirModule module) { return !module.ptr; }
 
 /// Takes a module owned by the caller and deletes it.
 MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module);

 /// not be further used. Particularly, this applies to any regions added to
 /// the state (the implementation may invalidate any such pointers).
 ///
 /// This call can fail under the following conditions, in which case, it will
 /// return a null operation and emit diagnostics:
 ///   - Result type inference is enabled and cannot be performed.
 MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreate(MlirOperationState *state);
 
+/// Creates a deep copy of an operation. The operation is not inserted and
+/// ownership is transferred to the caller.
+MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op);
+
 /// Takes an operation owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op);
 
 /// Checks whether the underlying operation is null.
 static inline bool mlirOperationIsNull(MlirOperation op) { return !op.ptr; }
 
 /// Checks whether two operation handles point to the same operation. This does
 /// not perform deep comparison.

mlir/lib/CAPI/IR/IR.cpp

if (state->enableResultTypeInference) {
     if (failed(inferOperationTypes(cppState)))
       return {nullptr};
   }
 
   MlirOperation result = wrap(Operation::create(cppState));
   return result;
 }
 
+MlirOperation mlirOperationClone(MlirOperation op) {
+  return wrap(unwrap(op)->clone());
+}
+
 void mlirOperationDestroy(MlirOperation op) { unwrap(op)->erase(); }
 
 bool mlirOperationEqual(MlirOperation op, MlirOperation other) {
   return unwrap(op) == unwrap(other);
 }
 
 MlirContext mlirOperationGetContext(MlirOperation op) {
   return wrap(unwrap(op)->getContext());

mlir/test/CAPI/ir.c

int testOperands() {
   mlirOperationDestroy(op);
   mlirOperationDestroy(constZero);
   mlirOperationDestroy(constOne);
   mlirContextDestroy(ctx);
 
   return 0;
 }
 
+/// Tests clone APIs.
+int testClone() {
+  fprintf(stderr, "@testClone\n");
+  // CHECK-LABEL: @testClone
+
+  MlirContext ctx = mlirContextCreate();
+  MlirLocation loc = mlirLocationUnknownGet(ctx);
+  MlirType indexType = mlirIndexTypeGet(ctx);
+  MlirStringRef valueStringRef =  mlirStringRefCreateFromCString("value");
+
+  MlirAttribute indexZeroLiteral =
+      mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("0 : index"));
+  MlirNamedAttribute indexZeroValueAttr = mlirNamedAttributeGet(mlirIdentifierGet(ctx, valueStringRef), indexZeroLiteral);
+  MlirOperationState constZeroState = mlirOperationStateGet(
+      mlirStringRefCreateFromCString("std.constant"), loc);
+  mlirOperationStateAddResults(&constZeroState, 1, &indexType);
+  mlirOperationStateAddAttributes(&constZeroState, 1, &indexZeroValueAttr);
+  MlirOperation constZero = mlirOperationCreate(&constZeroState);
+
+  MlirAttribute indexOneLiteral =
+      mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("1 : index"));
+  MlirOperation constOne = mlirOperationClone(constZero);
+  mlirOperationSetAttributeByName(constOne, valueStringRef, indexOneLiteral);
+
+  mlirOperationPrint(constZero, printToStderr, NULL);
+  mlirOperationPrint(constOne, printToStderr, NULL);
+  // CHECK: %0 = "std.constant"() {value = 0 : index} : () -> index
+  // CHECK: %0 = "std.constant"() {value = 1 : index} : () -> index
+
+  return 0;
+}
+
 // Wraps a diagnostic into additional text we can match against.
 MlirLogicalResult errorHandler(MlirDiagnostic diagnostic, void *userData) {
   fprintf(stderr, "processing diagnostic (userData: %ld) <<\n", (long)userData);
   mlirDiagnosticPrint(diagnostic, printToStderr, NULL);
   fprintf(stderr, "\n");
   MlirLocation loc = mlirDiagnosticGetLocation(diagnostic);
   mlirLocationPrint(loc, printToStderr, NULL);
   assert(mlirDiagnosticGetNumNotes(diagnostic) == 0);
   fprintf(stderr, "\n>> end of diagnostic (userData: %ld)\n", (long)userData);
   return mlirLogicalResultSuccess();
 }
int main() {
   if (printIntegerSet(ctx))
     return 8;
   if (registerOnlyStd())
     return 9;
   if (testBackreferences())
     return 10;
   if (testOperands())
     return 11;
+  if (testClone())
+    return 12;
 
   mlirContextDestroy(ctx);
 
   testDiagnostics();
   return 0;
 }