[mlir] Expose Dialect class and registration/loading to C API

[ftynse]

Summary

• Add a minimalist C API for mlir::Dialect.
• Allow one to query the context about registered and loaded dialects.
• Add API for loading dialects.
• Provide functions to register the Standard dialect.

When used naively, this will require to separately register each dialect. When
we have more than one exposed, we can add variadic macros that expand to
individual calls.

[mehdi_amini]

mlir/include/mlir-c/IR.h

99

Dialects don't need to be registered for pass dependency or to be loaded explicitly.

The *only* purpose of the registry is the MLIR textual parser at this point.

102

(Typo on operations)

106

(Typo on constructs)

122

Clarify if the same dialect in different context would compare equal or not

126

Seems like a useful clang-tidy warning here? (same below)

mlir/lib/CAPI/IR/IR.cpp

47

What is the use for the two APIs above?
(edit: maybe you just need these because of your unit-tests?)

mlir/lib/CAPI/Standard/StandardDialect.cpp

18

Is the plan that someone that would want to create operations in the standard dialect using the C API to first register it and then explicitly load it with its name?
Is this just to reduce the API surface compared to adding a Load entry point as well here?

[ftynse]

review and more questions

[ftynse]

mlir/include/mlir-c/IR.h

99

What's the longer-term plan? Do you see value in exposing the registration/loading dichotomy to the C API or should the registration + auto-loading be restricted to "testing" tools like mlir-opt?

mlir/lib/CAPI/IR/IR.cpp

47

We eventually need a way to obtain lists that are returned as std::vector in C++. Having a cheap way to query the size makes different styles of reallocation- and copy-minimizing APIs possible.

mlir/lib/CAPI/Standard/StandardDialect.cpp

18

I actually don't have a strong preference here, hesitating to even expose registration at all.

[mehdi_amini]

mlir/include/mlir-c/IR.h

99

I don't see a problem with exposing registration to the C API, it should just be documented what is it intended to be used for.

[ftynse]

Expose both registration and loading + clarify docs

mlir/include/mlir-c/IR.h

 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #ifndef MLIR_C_IR_H
 #define MLIR_C_IR_H
 
 #include <stdint.h>
 
+#include "mlir-c/Support.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /*============================================================================*/
 /** Opaque type declarations.
  *
  * Types are exposed to C bindings as structs containing opaque pointers. They

 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirContext, void);
+DEFINE_C_API_STRUCT(MlirDialect, void);
 DEFINE_C_API_STRUCT(MlirOperation, void);
 DEFINE_C_API_STRUCT(MlirBlock, void);
 DEFINE_C_API_STRUCT(MlirRegion, void);
 
 DEFINE_C_API_STRUCT(MlirValue, const void);
 DEFINE_C_API_STRUCT(MlirAttribute, const void);
 DEFINE_C_API_STRUCT(MlirType, const void);
 DEFINE_C_API_STRUCT(MlirLocation, const void);

 /** Checks if two contexts are equal. */
 int mlirContextEqual(MlirContext ctx1, MlirContext ctx2);
 
 /** Takes an MLIR context owned by the caller and destroys it. */
 void mlirContextDestroy(MlirContext context);
 
 /** Sets whether unregistered dialects are allowed in this context. */
 void mlirContextSetAllowUnregisteredDialects(MlirContext context, int allow);
 
 /** Returns whether the context allows unregistered dialects. */
 int mlirContextGetAllowUnregisteredDialects(MlirContext context);
 
+/** Returns the number of dialects registered with the given context. A
+ * registered dialect will be loaded if needed by the parser. */
+intptr_t mlirContextGetNumRegisteredDialects(MlirContext context);
+
+/** Returns the number of dialects loaded by the context.
+ */
+intptr_t mlirContextGetNumLoadedDialects(MlirContext context);
+
+/** Gets the dialect instance owned by the given context using the dialect
+ * namespace to identify it, loads (i.e., constructs the instance of) the
+ * dialect if necessary. If the dialect is not registered with the context,
+ * returns null. Use mlirContextLoad<Name>Dialect to load an unregistered
+ * dialect. */
+MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
+                                        MlirStringRef name);
+
+/*============================================================================*/
+/* Dialect API.                                                               */
+/*============================================================================*/
+
+/** Returns the context that owns the dialect. */
+MlirContext mlirDialectGetContext(MlirDialect dialect);
+
+/** Checks if the dialect is null. */
+int mlirDialectIsNull(MlirDialect dialect);
+
+/** Checks if two dialects that belong to the same context are equal. Dialects
+ * from different contexts will not compare equal. */
+int mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2);
+
+/** Returns the namespace of the given dialect. */
+MlirStringRef mlirDialectGetNamespace(MlirDialect dialect);
+
 /*============================================================================*/
 /* Location API.                                                              */
 /*============================================================================*/
 
 /** Creates an File/Line/Column location owned by the given context. */
 MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         const char *filename, unsigned line,
                                         unsigned col);

mlir/include/mlir-c/StandardDialect.h

+/*===-- mlir-c/StandardDialect.h - C API for Standard dialect -----*- 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                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface for registering and accessing the     *|
+|* Standard dialect. A dialect should be registered with a context to make it *|
+|* available to users of the context. These users must load the dialect       *|
+|* before using any of its attributes, operations or types. Parser and pass   *|
+|* manager can load registered dialects automatically.                        *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef MLIR_C_STANDARDDIALECT_H
+#define MLIR_C_STANDARDDIALECT_H
+
+#include "mlir-c/IR.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Registers the Standard dialect with the given context. This allows the
+ * dialect to be loaded dynamically if needed when parsing. */
+void mlirContextRegisterStandardDialect(MlirContext context);
+
+/** Loads the Standard dialect into the given context. The dialect does _not_
+ * have to be registered in advance. */
+MlirDialect mlirContextLoadStandardDialect(MlirContext context);
+
+/** Returns the namespace of the Standard dialect, suitable for loading it. */
+MlirStringRef mlirStandardDialectGetNamespace();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MLIR_C_STANDARDDIALECT_H

mlir/include/mlir/CAPI/IR.h

 #define MLIR_INCLUDE_MLIR_CAPI_IR_H
 
 #include "mlir/CAPI/Wrap.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 
 DEFINE_C_API_PTR_METHODS(MlirContext, mlir::MLIRContext)
+DEFINE_C_API_PTR_METHODS(MlirDialect, mlir::Dialect)
 DEFINE_C_API_PTR_METHODS(MlirOperation, mlir::Operation)
 DEFINE_C_API_PTR_METHODS(MlirBlock, mlir::Block)
 DEFINE_C_API_PTR_METHODS(MlirRegion, mlir::Region)
 
 DEFINE_C_API_METHODS(MlirAttribute, mlir::Attribute)
 DEFINE_C_API_METHODS(MlirLocation, mlir::Location)
 DEFINE_C_API_METHODS(MlirType, mlir::Type)
 DEFINE_C_API_METHODS(MlirValue, mlir::Value)
 DEFINE_C_API_METHODS(MlirModule, mlir::ModuleOp)
 
 #endif // MLIR_INCLUDE_MLIR_CAPI_IR_H

mlir/lib/CAPI/CMakeLists.txt

 add_subdirectory(IR)
 add_subdirectory(Registration)
+add_subdirectory(Standard)

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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/IR.h"
+#include "mlir-c/Support.h"
 
 #include "mlir/CAPI/IR.h"
+#include "mlir/CAPI/Support.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
 

 
 void mlirContextSetAllowUnregisteredDialects(MlirContext context, int allow) {
   unwrap(context)->allowUnregisteredDialects(allow);
 }
 
 int mlirContextGetAllowUnregisteredDialects(MlirContext context) {
   return unwrap(context)->allowsUnregisteredDialects();
 }
+intptr_t mlirContextGetNumRegisteredDialects(MlirContext context) {
+  return static_cast<intptr_t>(unwrap(context)->getAvailableDialects().size());
+}
+
+// TODO: expose a cheaper way than constructing + sorting a vector only to take
+// its size.
+intptr_t mlirContextGetNumLoadedDialects(MlirContext context) {
+  return static_cast<intptr_t>(unwrap(context)->getLoadedDialects().size());
+}
+
+MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
+                                        MlirStringRef name) {
+  return wrap(unwrap(context)->getOrLoadDialect(unwrap(name)));
+}
+
+/* ========================================================================== */
+/* Dialect API.                                                               */
+/* ========================================================================== */
+
+MlirContext mlirDialectGetContext(MlirDialect dialect) {
+  return wrap(unwrap(dialect)->getContext());
+}
+
+int mlirDialectIsNull(MlirDialect dialect) {
+  return unwrap(dialect) == nullptr;
+}
+
+int mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2) {
+  return unwrap(dialect1) == unwrap(dialect2);
+}
+
+MlirStringRef mlirDialectGetNamespace(MlirDialect dialect) {
+  return wrap(unwrap(dialect)->getNamespace());
+}
 
 /* ========================================================================== */
 /* Location API.                                                              */
 /* ========================================================================== */
 
 MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         const char *filename, unsigned line,
                                         unsigned col) {

mlir/lib/CAPI/Standard/CMakeLists.txt

+add_mlir_library(MLIRCAPIStandard
+
+  StandardDialect.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir-c
+
+  LINK_LIBS PUBLIC
+  MLIRCAPIIR
+  MLIRStandardOps
+  )

mlir/lib/CAPI/Standard/StandardDialect.cpp

+//===- StandardDialect.cpp - C Interface for Standard 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/StandardDialect.h"
+#include "mlir-c/IR.h"
+#include "mlir/CAPI/IR.h"
+#include "mlir/CAPI/Support.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+
+void mlirContextRegisterStandardDialect(MlirContext context) {
+  unwrap(context)->getDialectRegistry().insert<mlir::StandardOpsDialect>();
+}
+
+MlirDialect mlirContextLoadStandardDialect(MlirContext context) {
+  return wrap(unwrap(context)->getOrLoadDialect<mlir::StandardOpsDialect>());
+}
+
+MlirStringRef mlirStandardDialectGetNamespace() {
+  return wrap(mlir::StandardOpsDialect::getDialectNamespace());
+}

mlir/test/CAPI/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
   Support
   )
 
 add_llvm_executable(mlir-capi-ir-test
   ir.c
   )
 llvm_update_compile_flags(mlir-capi-ir-test)
 
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 target_link_libraries(mlir-capi-ir-test
   PRIVATE
   MLIRCAPIIR
   MLIRCAPIRegistration
+  MLIRCAPIStandard
   ${dialect_libs})

mlir/test/CAPI/ir.c

 /*===- ir.c - Simple test of C 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                    *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 /* RUN: mlir-capi-ir-test 2>&1 | FileCheck %s
  */
 
 #include "mlir-c/IR.h"
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/Registration.h"
 #include "mlir-c/StandardAttributes.h"
+#include "mlir-c/StandardDialect.h"
 #include "mlir-c/StandardTypes.h"
 
 #include <assert.h>
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
int printAffineMap(MlirContext ctx) {
 
   mlirAffineMapDump(subMap);
   mlirAffineMapDump(majorSubMap);
   mlirAffineMapDump(minorSubMap);
 
   return 0;
 }
 
+int registerOnlyStd() {
+  MlirContext ctx = mlirContextCreate();
+  // The built-in dialect is always loaded.
+  if (mlirContextGetNumLoadedDialects(ctx) != 1)
+    return 1;
+
+  MlirDialect std =
+      mlirContextGetOrLoadDialect(ctx, mlirStandardDialectGetNamespace());
+  if (!mlirDialectIsNull(std))
+    return 2;
+
+  mlirContextRegisterStandardDialect(ctx);
+  if (mlirContextGetNumRegisteredDialects(ctx) != 1)
+    return 3;
+  if (mlirContextGetNumLoadedDialects(ctx) != 1)
+    return 4;
+
+  std = mlirContextGetOrLoadDialect(ctx, mlirStandardDialectGetNamespace());
+  if (mlirDialectIsNull(std))
+    return 5;
+  if (mlirContextGetNumLoadedDialects(ctx) != 2)
+    return 6;
+
+  MlirDialect alsoStd = mlirContextLoadStandardDialect(ctx);
+  if (!mlirDialectEqual(std, alsoStd))
+    return 7;
+
+  MlirStringRef stdNs = mlirDialectGetNamespace(std);
+  MlirStringRef alsoStdNs = mlirStandardDialectGetNamespace();
+  if (stdNs.length != alsoStdNs.length ||
+      strncmp(stdNs.data, alsoStdNs.data, stdNs.length))
+    return 8;
+
+  return 0;
+}
+
 int main() {
   MlirContext ctx = mlirContextCreate();
   mlirRegisterAllDialects(ctx);
   MlirLocation location = mlirLocationUnknownGet(ctx);
 
   MlirModule moduleOp = makeAdd(ctx, location);
   MlirOperation module = mlirModuleGetOperation(moduleOp);
   mlirOperationDump(module);
int main() {
   // CHECK: (d0, d1, d2) -> (d0)
   // CHECK: (d0, d1, d2) -> (d2)
   // CHECK: 0
   // clang-format on
   fprintf(stderr, "@affineMap\n");
   errcode = printAffineMap(ctx);
   fprintf(stderr, "%d\n", errcode);
 
+  fprintf(stderr, "@registration\n");
+  errcode = registerOnlyStd();
+  fprintf(stderr, "%d\n", errcode);
+  // clang-format off
+  // CHECK-LABEL: @registration
+  // CHECK: 0
+  // clang-format on
+
   mlirContextDestroy(ctx);
 
   return 0;
 }