[mlir] use intptr_t in C API

[ftynse]

Summary

Using intptr_t is a consensus for MLIR C API, but the change was missing
from 75f239e9756b (that was using unsigned initially) due to a
misrebase.

mlir/docs/CAPI.md

 An object has an _indexed component_ if it has fields accessible using a
 zero-based contiguous integer index, typically arrays. For example, an
 `MlirBlock` has its arguments as a indexed component. An object may have several
 such components. For example, an `MlirOperation` has attributes, operands,
 regions, results and successors.
 
 For indexed components, the following pair of functions is provided.
 
--   `unsigned mlirXGetNum<Y>s(MlirX)` returns the upper bound on the index.
--   `MlirY mlirXGet<Y>(MlirX, unsigned pos)` returns 'pos'-th subobject.
+-   `intptr_t mlirXGetNum<Y>s(MlirX)` returns the upper bound on the index.
+-   `MlirY mlirXGet<Y>(MlirX, intptr_t pos)` returns 'pos'-th subobject.
+
+The sizes are accepted and returned as signed pointer-sized integers, i.e.
+`intptr_t`. This typedef is avalable in C99.
 
 Note that the name of subobject in the function does not necessarily match the
 type of the subobject. For example, `mlirOperationGetOperand` returns a
 `MlirValue`.
 
 #### Iterable Components
 
 An object has an _iterable component_ if it has iterators accessing its fields

mlir/include/mlir-c/IR.h

 |* with C++ due to name mangling. So in addition to C, this interface enables *|
 |* tools written in such languages.                                           *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #ifndef MLIR_C_IR_H
 #define MLIR_C_IR_H
 
+#include <stdint.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /*============================================================================*/
 /** Opaque type declarations.
  *
  * Types are exposed to C bindings as structs containing opaque pointers. They

  * being also used to access the context, and has no other components. These
  * components can be added progressively until the operation is constructed.
  * Users are not expected to rely on the internals of this class and should use
  * mlirOperationState* functions instead.
  */
 struct MlirOperationState {
   const char *name;
   MlirLocation location;
-  unsigned nResults;
+  intptr_t nResults;
   MlirType *results;
-  unsigned nOperands;
+  intptr_t nOperands;
   MlirValue *operands;
-  unsigned nRegions;
+  intptr_t nRegions;
   MlirRegion *regions;
-  unsigned nSuccessors;
+  intptr_t nSuccessors;
   MlirBlock *successors;
-  unsigned nAttributes;
+  intptr_t nAttributes;
   MlirNamedAttribute *attributes;
 };
 typedef struct MlirOperationState MlirOperationState;
 
 /** Constructs an operation state from a name and a location. */
 MlirOperationState mlirOperationStateGet(const char *name, MlirLocation loc);
 
 /** Adds a list of components to the operation state. */
-void mlirOperationStateAddResults(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n,
                                   MlirType *results);
-void mlirOperationStateAddOperands(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
                                    MlirValue *operands);
-void mlirOperationStateAddOwnedRegions(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
                                        MlirRegion *regions);
-void mlirOperationStateAddSuccessors(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
                                      MlirBlock *successors);
-void mlirOperationStateAddAttributes(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
                                      MlirNamedAttribute *attributes);
 
 /*============================================================================*/
 /* Operation API.                                                             */
 /*============================================================================*/
 
 /** Creates an operation and transfers ownership to the caller. */
 MlirOperation mlirOperationCreate(const MlirOperationState *state);
 
 /** Takes an operation owned by the caller and destroys it. */
 void mlirOperationDestroy(MlirOperation op);
 
 /** Checks whether the underlying operation is null. */
 int mlirOperationIsNull(MlirOperation op);
 
 /** Returns the number of regions attached to the given operation. */
-unsigned mlirOperationGetNumRegions(MlirOperation op);
+intptr_t mlirOperationGetNumRegions(MlirOperation op);
 
 /** Returns `pos`-th region attached to the operation. */
-MlirRegion mlirOperationGetRegion(MlirOperation op, unsigned pos);
+MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos);
 
 /** Returns an operation immediately following the given operation it its
  * enclosing block. */
 MlirOperation mlirOperationGetNextInBlock(MlirOperation op);
 
 /** Returns the number of operands of the operation. */
-unsigned mlirOperationGetNumOperands(MlirOperation op);
+intptr_t mlirOperationGetNumOperands(MlirOperation op);
 
 /** Returns `pos`-th operand of the operation. */
-MlirValue mlirOperationGetOperand(MlirOperation op, unsigned pos);
+MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos);
 
 /** Returns the number of results of the operation. */
-unsigned mlirOperationGetNumResults(MlirOperation op);
+intptr_t mlirOperationGetNumResults(MlirOperation op);
 
 /** Returns `pos`-th result of the operation. */
-MlirValue mlirOperationGetResult(MlirOperation op, unsigned pos);
+MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos);
 
 /** Returns the number of successor blocks of the operation. */
-unsigned mlirOperationGetNumSuccessors(MlirOperation op);
+intptr_t mlirOperationGetNumSuccessors(MlirOperation op);
 
 /** Returns `pos`-th successor of the operation. */
-MlirBlock mlirOperationGetSuccessor(MlirOperation op, unsigned pos);
+MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos);
 
 /** Returns the number of attributes attached to the operation. */
-unsigned mlirOperationGetNumAttributes(MlirOperation op);
+intptr_t mlirOperationGetNumAttributes(MlirOperation op);
 
 /** Return `pos`-th attribute of the operation. */
-MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, unsigned pos);
+MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos);
 
 /** Returns an attrbute attached to the operation given its name. */
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               const char *name);
 void mlirOperationDump(MlirOperation op);
 
 /*============================================================================*/
 /* Region API.                                                                */

 /** Gets the first block in the region. */
 MlirBlock mlirRegionGetFirstBlock(MlirRegion region);
 
 /** Takes a block owned by the caller and appends it to the given region. */
 void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block);
 
 /** Takes a block owned by the caller and inserts it at `pos` to the given
  * region. */
-void mlirRegionInsertOwnedBlock(MlirRegion region, unsigned pos,
+void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos,
                                 MlirBlock block);
 
 /*============================================================================*/
 /* Block API.                                                                 */
 /*============================================================================*/
 
 /** Creates a new empty block with the given argument types and transfers
  * ownership to the caller. */
-MlirBlock mlirBlockCreate(unsigned nArgs, MlirType *args);
+MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType *args);
 
 /** Takes a block owned by the caller and destroys it. */
 void mlirBlockDestroy(MlirBlock block);
 
 /** Checks whether a block is null. */
 int mlirBlockIsNull(MlirBlock block);
 
 /** Returns the block immediately following the given block in its parent
  * region. */
 MlirBlock mlirBlockGetNextInRegion(MlirBlock block);
 
 /** Returns the first operation in the block. */
 MlirOperation mlirBlockGetFirstOperation(MlirBlock block);
 
 /** Takes an operation owned by the caller and appends it to the block. */
 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation);
 
 /** Takes an operation owned by the caller and inserts it as `pos` to the block.
  */
-void mlirBlockInsertOwnedOperation(MlirBlock block, unsigned pos,
+void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos,
                                    MlirOperation operation);
 
 /** Returns the number of arguments of the block. */
-unsigned mlirBlockGetNumArguments(MlirBlock block);
+intptr_t mlirBlockGetNumArguments(MlirBlock block);
 
 /** Returns `pos`-th argument of the block. */
-MlirValue mlirBlockGetArgument(MlirBlock block, unsigned pos);
+MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos);
 
 /*============================================================================*/
 /* Value API.                                                                 */
 /*============================================================================*/
 
 /** Returns the type of the value. */
 MlirType mlirValueGetType(MlirValue value);
 

mlir/lib/CAPI/IR/IR.cpp

 
 DEFINE_C_API_METHODS(MlirAttribute, Attribute)
 DEFINE_C_API_METHODS(MlirLocation, Location);
 DEFINE_C_API_METHODS(MlirType, Type)
 DEFINE_C_API_METHODS(MlirValue, Value)
 DEFINE_C_API_METHODS(MlirModule, ModuleOp)
 
 template <typename CppTy, typename CTy>
-static ArrayRef<CppTy> unwrapList(unsigned size, CTy *first,
+static ArrayRef<CppTy> unwrapList(intptr_t size, CTy *first,
                                   SmallVectorImpl<CppTy> &storage) {
   static_assert(
       std::is_same<decltype(unwrap(std::declval<CTy>())), CppTy>::value,
       "incompatible C and C++ types");
 
   if (size == 0)
     return llvm::None;
 
   assert(storage.empty() && "expected to populate storage");
   storage.reserve(size);
-  for (unsigned i = 0; i < size; ++i)
+  for (intptr_t i = 0; i < size; ++i)
     storage.push_back(unwrap(*(first + i)));
   return storage;
 }
 
 /* ========================================================================== */
 /* Context API.                                                               */
 /* ========================================================================== */
 

 }
 
 #define APPEND_ELEMS(type, sizeName, elemName)                                 \
   state->elemName =                                                            \
       (type *)realloc(state->elemName, (state->sizeName + n) * sizeof(type));  \
   memcpy(state->elemName + state->sizeName, elemName, n * sizeof(type));       \
   state->sizeName += n;
 
-void mlirOperationStateAddResults(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n,
                                   MlirType *results) {
   APPEND_ELEMS(MlirType, nResults, results);
 }
 
-void mlirOperationStateAddOperands(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
                                    MlirValue *operands) {
   APPEND_ELEMS(MlirValue, nOperands, operands);
 }
-void mlirOperationStateAddOwnedRegions(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
                                        MlirRegion *regions) {
   APPEND_ELEMS(MlirRegion, nRegions, regions);
 }
-void mlirOperationStateAddSuccessors(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
                                      MlirBlock *successors) {
   APPEND_ELEMS(MlirBlock, nSuccessors, successors);
 }
-void mlirOperationStateAddAttributes(MlirOperationState *state, unsigned n,
+void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
                                      MlirNamedAttribute *attributes) {
   APPEND_ELEMS(MlirNamedAttribute, nAttributes, attributes);
 }
 
 /* ========================================================================== */
 /* Operation API.                                                             */
 /* ========================================================================== */
 
 MlirOperation mlirOperationCreate(const MlirOperationState *state) {
   assert(state);
   OperationState cppState(unwrap(state->location), state->name);
   SmallVector<Type, 4> resultStorage;
   SmallVector<Value, 8> operandStorage;
   SmallVector<Block *, 2> successorStorage;
   cppState.addTypes(unwrapList(state->nResults, state->results, resultStorage));
   cppState.addOperands(
       unwrapList(state->nOperands, state->operands, operandStorage));
   cppState.addSuccessors(
       unwrapList(state->nSuccessors, state->successors, successorStorage));
 
   cppState.attributes.reserve(state->nAttributes);
-  for (unsigned i = 0; i < state->nAttributes; ++i)
+  for (intptr_t i = 0; i < state->nAttributes; ++i)
     cppState.addAttribute(state->attributes[i].name,
                           unwrap(state->attributes[i].attribute));
 
-  for (unsigned i = 0; i < state->nRegions; ++i)
+  for (intptr_t i = 0; i < state->nRegions; ++i)
     cppState.addRegion(std::unique_ptr<Region>(unwrap(state->regions[i])));
 
+  MlirOperation result = wrap(Operation::create(cppState));
   free(state->results);
   free(state->operands);
-  free(state->regions);
   free(state->successors);
+  free(state->regions);
   free(state->attributes);
-
-  return wrap(Operation::create(cppState));
+  return result;
 }
 
 void mlirOperationDestroy(MlirOperation op) { unwrap(op)->erase(); }
 
 int mlirOperationIsNull(MlirOperation op) { return unwrap(op) == nullptr; }
 
-unsigned mlirOperationGetNumRegions(MlirOperation op) {
-  return unwrap(op)->getNumRegions();
+intptr_t mlirOperationGetNumRegions(MlirOperation op) {
+  return static_cast<intptr_t>(unwrap(op)->getNumRegions());
 }
 
-MlirRegion mlirOperationGetRegion(MlirOperation op, unsigned pos) {
-  return wrap(&unwrap(op)->getRegion(pos));
+MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos) {
+  return wrap(&unwrap(op)->getRegion(static_cast<unsigned>(pos)));
 }
 
 MlirOperation mlirOperationGetNextInBlock(MlirOperation op) {
   return wrap(unwrap(op)->getNextNode());
 }
 
-unsigned mlirOperationGetNumOperands(MlirOperation op) {
-  return unwrap(op)->getNumOperands();
+intptr_t mlirOperationGetNumOperands(MlirOperation op) {
+  return static_cast<intptr_t>(unwrap(op)->getNumOperands());
 }
 
-MlirValue mlirOperationGetOperand(MlirOperation op, unsigned pos) {
-  return wrap(unwrap(op)->getOperand(pos));
+MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos) {
+  return wrap(unwrap(op)->getOperand(static_cast<unsigned>(pos)));
 }
 
-unsigned mlirOperationGetNumResults(MlirOperation op) {
-  return unwrap(op)->getNumResults();
+intptr_t mlirOperationGetNumResults(MlirOperation op) {
+  return static_cast<intptr_t>(unwrap(op)->getNumResults());
 }
 
-MlirValue mlirOperationGetResult(MlirOperation op, unsigned pos) {
-  return wrap(unwrap(op)->getResult(pos));
+MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos) {
+  return wrap(unwrap(op)->getResult(static_cast<unsigned>(pos)));
 }
 
-unsigned mlirOperationGetNumSuccessors(MlirOperation op) {
-  return unwrap(op)->getNumSuccessors();
+intptr_t mlirOperationGetNumSuccessors(MlirOperation op) {
+  return static_cast<intptr_t>(unwrap(op)->getNumSuccessors());
 }
 
-MlirBlock mlirOperationGetSuccessor(MlirOperation op, unsigned pos) {
-  return wrap(unwrap(op)->getSuccessor(pos));
+MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos) {
+  return wrap(unwrap(op)->getSuccessor(static_cast<unsigned>(pos)));
 }
 
-unsigned mlirOperationGetNumAttributes(MlirOperation op) {
-  return unwrap(op)->getAttrs().size();
+intptr_t mlirOperationGetNumAttributes(MlirOperation op) {
+  return static_cast<intptr_t>(unwrap(op)->getAttrs().size());
 }
 
-MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, unsigned pos) {
+MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos) {
   NamedAttribute attr = unwrap(op)->getAttrs()[pos];
   return MlirNamedAttribute{attr.first.c_str(), wrap(attr.second)};
 }
 
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               const char *name) {
   return wrap(unwrap(op)->getAttr(name));
 }
if (cppRegion->empty())
     return wrap(static_cast<Block *>(nullptr));
   return wrap(&cppRegion->front());
 }
 
 void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block) {
   unwrap(region)->push_back(unwrap(block));
 }
 
-void mlirRegionInsertOwnedBlock(MlirRegion region, unsigned pos,
+void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos,
                                 MlirBlock block) {
   auto &blockList = unwrap(region)->getBlocks();
   blockList.insert(std::next(blockList.begin(), pos), unwrap(block));
 }
 
 void mlirRegionDestroy(MlirRegion region) {
   delete static_cast<Region *>(region.ptr);
 }
 
 int mlirRegionIsNull(MlirRegion region) { return unwrap(region) == nullptr; }
 
 /* ========================================================================== */
 /* Block API.                                                                 */
 /* ========================================================================== */
 
-MlirBlock mlirBlockCreate(unsigned nArgs, MlirType *args) {
+MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType *args) {
   Block *b = new Block;
-  for (unsigned i = 0; i < nArgs; ++i)
+  for (intptr_t i = 0; i < nArgs; ++i)
     b->addArgument(unwrap(args[i]));
   return wrap(b);
 }
 
 MlirBlock mlirBlockGetNextInRegion(MlirBlock block) {
   return wrap(unwrap(block)->getNextNode());
 }
 
 MlirOperation mlirBlockGetFirstOperation(MlirBlock block) {
   Block *cppBlock = unwrap(block);
   if (cppBlock->empty())
     return wrap(static_cast<Operation *>(nullptr));
   return wrap(&cppBlock->front());
 }
 
 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation) {
   unwrap(block)->push_back(unwrap(operation));
 }
 
-void mlirBlockInsertOwnedOperation(MlirBlock block, unsigned pos,
+void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos,
                                    MlirOperation operation) {
   auto &opList = unwrap(block)->getOperations();
   opList.insert(std::next(opList.begin(), pos), unwrap(operation));
 }
 
 void mlirBlockDestroy(MlirBlock block) { delete unwrap(block); }
 
 int mlirBlockIsNull(MlirBlock block) { return unwrap(block) == nullptr; }
 
-unsigned mlirBlockGetNumArguments(MlirBlock block) {
-  return unwrap(block)->getNumArguments();
+intptr_t mlirBlockGetNumArguments(MlirBlock block) {
+  return static_cast<intptr_t>(unwrap(block)->getNumArguments());
 }
 
-MlirValue mlirBlockGetArgument(MlirBlock block, unsigned pos) {
-  return wrap(unwrap(block)->getArgument(pos));
+MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
+  return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
 }
 
 /* ========================================================================== */
 /* Value API.                                                                 */
 /* ========================================================================== */
 
 MlirType mlirValueGetType(MlirValue value) {
   return wrap(unwrap(value).getType());