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?

332

333

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-c/IR.h - C API to Core MLIR IR classes ---------------*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
 // Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 
 /// Creates a new, empty module and transfers ownership to the caller.
 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);
 
+/// Creates a deep copy of a module
+MLIR_CAPI_EXPORTED MlirModule mlirModuleClone(MlirModule 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; }

 /// 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 operatioon
+MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation module);
+
 /// 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

 //===- IR.cpp - C Interface for Core MLIR APIs ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 
 MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module) {
   OwningModuleRef owning = parseSourceString(unwrap(module), unwrap(context));
   if (!owning)
     return MlirModule{nullptr};
   return MlirModule{owning.release().getOperation()};
 }
 
+MlirModule mlirModuleClone(MlirModule module) {
+  return wrap(unwrap(module).clone());
+}
+
 MlirContext mlirModuleGetContext(MlirModule module) {
   return wrap(unwrap(module).getContext());
 }
 
 MlirBlock mlirModuleGetBody(MlirModule module) {
   return wrap(unwrap(module).getBody());
 }
 
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;
 }
 
+intptr_t countOperations(MlirBlock block) {
+  intptr_t count = 0;
+  MlirOperation op = mlirBlockGetFirstOperation(block);
+  while (!mlirOperationIsNull(op)) {
+    op = mlirOperationGetNextInBlock(op);
+    count++;
+  }
+  return count;
+}
+
+/// Tests operand APIs.
+int testClone() {
+  fprintf(stderr, "@testClone\n");
+  // CHECK-LABEL: @testClone
+
+  MlirContext ctx = mlirContextCreate();
+  MlirLocation loc = mlirLocationUnknownGet(ctx);
+  MlirModule module = mlirModuleCreateEmpty(loc);
+  MlirBlock body = mlirModuleGetBody(module);
+  MlirType indexType = mlirIndexTypeGet(ctx);
+
+  // Create a constant
+  MlirAttribute indexOneLiteral =
+      mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("1 : index"));
+  MlirNamedAttribute indexOneValueAttr = mlirNamedAttributeGet(
+      mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("value")),
+      indexOneLiteral);
+  MlirOperationState constOneState = mlirOperationStateGet(
+      mlirStringRefCreateFromCString("std.constant"), loc);
+  mlirOperationStateAddResults(&constOneState, 1, &indexType);
+  mlirOperationStateAddAttributes(&constOneState, 1, &indexOneValueAttr);
+  MlirOperation constOne = mlirOperationCreate(&constOneState);
+  
+  // Replace the original const one with a clone and destroy the original
+  MlirOperation evilConstOne = mlirOperationClone(constOne);
+  mlirOperationDestroy(constOne);
+  constOne = evilConstOne;
+
+  // Check that modifying a module does not modify its clone
+  MlirModule moduleClone = mlirModuleClone(module);
+  MlirBlock cloneBody = mlirModuleGetBody(moduleClone);
+  mlirBlockAppendOwnedOperation(body, constOne);
+
+  fprintf(stderr, "Module operation count: %ld\n", countOperations(body));
+  fprintf(stderr, "Clone operation count: %ld\n", countOperations(cloneBody));
+  // CHECK: Module operation count: 1
+  // CHECK: Clone operation count: 0
+
+  mlirModuleDestroy(moduleClone);
+  mlirOperationDestroy(constOne);
+  mlirContextDestroy(ctx);
+
+  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);
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;
 }