[MLIR] Add a number of methods to the C API

[apaszke]

Summary

Those include:

• mlirFuncSetArgAttr
• mlirOperationSetOperands
• mlirRegionTakeBody
• mlirBlockInsertArgument

[ftynse]

mlir/include/mlir-c/Dialect/Func.h

32

Please add some documentation.

mlir/lib/CAPI/Dialect/Func.cpp

14

Normally we shouldn't need this (there's no IWYU rule in LLVM) and we are do have this transitively from virtually any MLIR C++ header.

mlir/lib/CAPI/IR/IR.cpp

502

Nit: don't hardcode the number of stack elements in small vectors.

[apaszke]

Addressed review comments

[apaszke]

All requested changes have been applied.

mlir/include/mlir-c/Dialect/Func.h

 // before using any of its attributes, operations or types. Parser and pass
 // manager can load registered dialects automatically.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_DIALECT_FUNC_H
 #define MLIR_C_DIALECT_FUNC_H
 
+#include <stdint.h>
+
 #include "mlir-c/IR.h"
+#include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(Func, func);
 
+/// Sets the argument attribute 'name' of an argument at index 'pos'.
+/// Asserts that the operation is a FuncOp.
+MLIR_CAPI_EXPORTED void mlirFuncSetArgAttr(MlirOperation op, intptr_t pos,
+                                           MlirStringRef name,
+                                           MlirAttribute attr);
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_DIALECT_FUNC_H

mlir/include/mlir-c/IR.h

 /// Returns `pos`-th operand of the operation.
 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op,
                                                      intptr_t pos);
 
 /// Sets the `pos`-th operand of the operation.
 MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
                                                 MlirValue newValue);
 
+/// Replaces the operands of the operation.
+MLIR_CAPI_EXPORTED void mlirOperationSetOperands(MlirOperation op,
+                                                 intptr_t nOperands,
+                                                 MlirValue const *operands);
+
 /// Returns the number of results of the operation.
 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op);
 
 /// Returns `pos`-th result of the operation.
 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op,
                                                     intptr_t pos);
 
 /// Returns the number of successor blocks of the operation.

 
 /// Returns first region attached to the operation.
 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op);
 
 /// Returns the region immediately following the given region in its parent
 /// operation.
 MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region);
 
+/// Moves the entire content of the source region to the target region.
+MLIR_CAPI_EXPORTED void mlirRegionTakeBody(MlirRegion target,
+                                           MlirRegion source);
+
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a new empty block with the given argument types and transfers
 /// ownership to the caller.
 MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs,
                                              MlirType const *args,

 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block);
 
 /// Appends an argument of the specified type to the block. Returns the newly
 /// added argument.
 MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block,
                                                   MlirType type,
                                                   MlirLocation loc);
 
+/// Inserts an argument of the specified type at a specified index to the block.
+/// Returns the newly added argument.
+MLIR_CAPI_EXPORTED MlirValue mlirBlockInsertArgument(MlirBlock block,
+                                                     intptr_t pos,
+                                                     MlirType type,
+                                                     MlirLocation loc);
+
 /// Returns `pos`-th argument of the block.
 MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block,
                                                   intptr_t pos);
 
 /// Prints a block by sending chunks of the string representation and
 /// forwarding `userData to `callback`. Note that the callback may be called
 /// several times with consecutive chunks of the string.
 MLIR_CAPI_EXPORTED void

mlir/lib/CAPI/Dialect/Func.cpp

 //===- Func.cpp - C Interface for Func dialect ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/Dialect/Func.h"
+#include "mlir-c/IR.h"
+#include "mlir-c/Support.h"
 #include "mlir/CAPI/Registration.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 
 MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(Func, func, mlir::func::FuncDialect)
+
+void mlirFuncSetArgAttr(MlirOperation op, intptr_t pos, MlirStringRef name,
+                        MlirAttribute attr) {
+  llvm::cast<mlir::func::FuncOp>(unwrap(op))
+      .setArgAttr(pos, unwrap(name), unwrap(attr));
+}

mlir/lib/CAPI/IR/IR.cpp

MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos) {
   return wrap(unwrap(op)->getOperand(static_cast<unsigned>(pos)));
 }
 
 void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
                              MlirValue newValue) {
   unwrap(op)->setOperand(static_cast<unsigned>(pos), unwrap(newValue));
 }
 
+void mlirOperationSetOperands(MlirOperation op, intptr_t nOperands,
+                              MlirValue const *operands) {
+  SmallVector<Value> ops;
+  unwrap(op)->setOperands(unwrapList(nOperands, operands, ops));
+}
+
 intptr_t mlirOperationGetNumResults(MlirOperation op) {
   return static_cast<intptr_t>(unwrap(op)->getNumResults());
 }
 
 MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos) {
   return wrap(unwrap(op)->getResult(static_cast<unsigned>(pos)));
 }
 
void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference,
   unwrap(region)->getBlocks().insert(Region::iterator(unwrap(reference)),
                                      unwrap(block));
 }
 
 void mlirRegionDestroy(MlirRegion region) {
   delete static_cast<Region *>(region.ptr);
 }
 
+void mlirRegionTakeBody(MlirRegion target, MlirRegion source) {
+  unwrap(target)->takeBody(*unwrap(source));
+}
+
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
 MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args,
                           MlirLocation const *locs) {
   Block *b = new Block;
   for (intptr_t i = 0; i < nArgs; ++i)
intptr_t mlirBlockGetNumArguments(MlirBlock block) {
   return static_cast<intptr_t>(unwrap(block)->getNumArguments());
 }
 
 MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type,
                                MlirLocation loc) {
   return wrap(unwrap(block)->addArgument(unwrap(type), unwrap(loc)));
 }
 
+MlirValue mlirBlockInsertArgument(MlirBlock block, intptr_t pos, MlirType type,
+                                  MlirLocation loc) {
+  return wrap(unwrap(block)->insertArgument(pos, unwrap(type), unwrap(loc)));
+}
+
 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
   return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
 }
 
 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
                     void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(block)->print(stream);