mlir/include/mlir-c/IR.h

   1 //===-- mlir-c/IR.h - C API to Core MLIR IR classes ---------------*- C -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
   4 // Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This header declares the C interface to MLIR core IR classes.
  11 //
  12 // Many exotic languages can interoperate with C code but have a harder time
  13 // with C++ due to name mangling. So in addition to C, this interface enables
  14 // tools written in such languages.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #ifndef MLIR_C_IR_H
  19 #define MLIR_C_IR_H
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23
  24 #include "mlir-c/Support.h"
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif
  29
  30 //===----------------------------------------------------------------------===//
  31 /// Opaque type declarations.
  32 ///
  33 /// Types are exposed to C bindings as structs containing opaque pointers. They
  34 /// are not supposed to be inspected from C. This allows the underlying
  35 /// representation to change without affecting the API users. The use of structs
  36 /// instead of typedefs enables some type safety as structs are not implicitly
  37 /// convertible to each other.
  38 ///
  39 /// Instances of these types may or may not own the underlying object (most
  40 /// often only point to an IR fragment without owning it). The ownership
  41 /// semantics is defined by how an instance of the type was obtained.
  42
  43 //===----------------------------------------------------------------------===//
  44
  45 #define DEFINE_C_API_STRUCT(name, storage)                                     \
  46   struct name {                                                                \
  47     storage *ptr;                                                              \
  48   };                                                                           \
  49   typedef struct name name
  50
  51 DEFINE_C_API_STRUCT(MlirAsmState, void);
  52 DEFINE_C_API_STRUCT(MlirBytecodeWriterConfig, void);
  53 DEFINE_C_API_STRUCT(MlirContext, void);
  54 DEFINE_C_API_STRUCT(MlirDialect, void);
  55 DEFINE_C_API_STRUCT(MlirDialectRegistry, void);
  56 DEFINE_C_API_STRUCT(MlirOperation, void);
  57 DEFINE_C_API_STRUCT(MlirOpOperand, void);
  58 DEFINE_C_API_STRUCT(MlirOpPrintingFlags, void);
  59 DEFINE_C_API_STRUCT(MlirBlock, void);
  60 DEFINE_C_API_STRUCT(MlirRegion, void);
  61 DEFINE_C_API_STRUCT(MlirSymbolTable, void);
  62
  63 DEFINE_C_API_STRUCT(MlirAttribute, const void);
  64 DEFINE_C_API_STRUCT(MlirIdentifier, const void);
  65 DEFINE_C_API_STRUCT(MlirLocation, const void);
  66 DEFINE_C_API_STRUCT(MlirModule, const void);
  67 DEFINE_C_API_STRUCT(MlirType, const void);
  68 DEFINE_C_API_STRUCT(MlirValue, const void);
  69
  70 #undef DEFINE_C_API_STRUCT
  71
  72 /// Named MLIR attribute.
  73 ///
  74 /// A named attribute is essentially a (name, attribute) pair where the name is
  75 /// a string.
  76 struct MlirNamedAttribute {
  77   MlirIdentifier name;
  78   MlirAttribute attribute;
  79 };
  80 typedef struct MlirNamedAttribute MlirNamedAttribute;
  81
  82 //===----------------------------------------------------------------------===//
  83 // Context API.
  84 //===----------------------------------------------------------------------===//
  85
  86 /// Creates an MLIR context and transfers its ownership to the caller.
  87 /// This sets the default multithreading option (enabled).
  88 MLIR_CAPI_EXPORTED MlirContext mlirContextCreate(void);
  89
  90 /// Creates an MLIR context with an explicit setting of the multithreading
  91 /// setting and transfers its ownership to the caller.
  92 MLIR_CAPI_EXPORTED MlirContext
  93 mlirContextCreateWithThreading(bool threadingEnabled);
  94
  95 /// Creates an MLIR context, setting the multithreading setting explicitly and
  96 /// pre-loading the dialects from the provided DialectRegistry.
  97 MLIR_CAPI_EXPORTED MlirContext mlirContextCreateWithRegistry(
  98     MlirDialectRegistry registry, bool threadingEnabled);
  99
 100 /// Checks if two contexts are equal.
 101 MLIR_CAPI_EXPORTED bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2);
 102
 103 /// Checks whether a context is null.
 104 static inline bool mlirContextIsNull(MlirContext context) {
 105   return !context.ptr;
 106 }
 107
 108 /// Takes an MLIR context owned by the caller and destroys it.
 109 MLIR_CAPI_EXPORTED void mlirContextDestroy(MlirContext context);
 110
 111 /// Sets whether unregistered dialects are allowed in this context.
 112 MLIR_CAPI_EXPORTED void
 113 mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow);
 114
 115 /// Returns whether the context allows unregistered dialects.
 116 MLIR_CAPI_EXPORTED bool
 117 mlirContextGetAllowUnregisteredDialects(MlirContext context);
 118
 119 /// Returns the number of dialects registered with the given context. A
 120 /// registered dialect will be loaded if needed by the parser.
 121 MLIR_CAPI_EXPORTED intptr_t
 122 mlirContextGetNumRegisteredDialects(MlirContext context);
 123
 124 /// Append the contents of the given dialect registry to the registry associated
 125 /// with the context.
 126 MLIR_CAPI_EXPORTED void
 127 mlirContextAppendDialectRegistry(MlirContext ctx, MlirDialectRegistry registry);
 128
 129 /// Returns the number of dialects loaded by the context.
 130
 131 MLIR_CAPI_EXPORTED intptr_t
 132 mlirContextGetNumLoadedDialects(MlirContext context);
 133
 134 /// Gets the dialect instance owned by the given context using the dialect
 135 /// namespace to identify it, loads (i.e., constructs the instance of) the
 136 /// dialect if necessary. If the dialect is not registered with the context,
 137 /// returns null. Use mlirContextLoad<Name>Dialect to load an unregistered
 138 /// dialect.
 139 MLIR_CAPI_EXPORTED MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
 140                                                            MlirStringRef name);
 141
 142 /// Set threading mode (must be set to false to mlir-print-ir-after-all).
 143 MLIR_CAPI_EXPORTED void mlirContextEnableMultithreading(MlirContext context,
 144                                                         bool enable);
 145
 146 /// Eagerly loads all available dialects registered with a context, making
 147 /// them available for use for IR construction.
 148 MLIR_CAPI_EXPORTED void
 149 mlirContextLoadAllAvailableDialects(MlirContext context);
 150
 151 /// Returns whether the given fully-qualified operation (i.e.
 152 /// 'dialect.operation') is registered with the context. This will return true
 153 /// if the dialect is loaded and the operation is registered within the
 154 /// dialect.
 155 MLIR_CAPI_EXPORTED bool mlirContextIsRegisteredOperation(MlirContext context,
 156                                                          MlirStringRef name);
 157
 158 /// Sets the thread pool of the context explicitly, enabling multithreading in
 159 /// the process. This API should be used to avoid re-creating thread pools in
 160 /// long-running applications that perform multiple compilations, see
 161 /// the C++ documentation for MLIRContext for details.
 162 MLIR_CAPI_EXPORTED void mlirContextSetThreadPool(MlirContext context,
 163                                                  MlirLlvmThreadPool threadPool);
 164
 165 //===----------------------------------------------------------------------===//
 166 // Dialect API.
 167 //===----------------------------------------------------------------------===//
 168
 169 /// Returns the context that owns the dialect.
 170 MLIR_CAPI_EXPORTED MlirContext mlirDialectGetContext(MlirDialect dialect);
 171
 172 /// Checks if the dialect is null.
 173 static inline bool mlirDialectIsNull(MlirDialect dialect) {
 174   return !dialect.ptr;
 175 }
 176
 177 /// Checks if two dialects that belong to the same context are equal. Dialects
 178 /// from different contexts will not compare equal.
 179 MLIR_CAPI_EXPORTED bool mlirDialectEqual(MlirDialect dialect1,
 180                                          MlirDialect dialect2);
 181
 182 /// Returns the namespace of the given dialect.
 183 MLIR_CAPI_EXPORTED MlirStringRef mlirDialectGetNamespace(MlirDialect dialect);
 184
 185 //===----------------------------------------------------------------------===//
 186 // DialectHandle API.
 187 // Registration entry-points for each dialect are declared using the common
 188 // MLIR_DECLARE_DIALECT_REGISTRATION_CAPI macro, which takes the dialect
 189 // API name (i.e. "Func", "Tensor", "Linalg") and namespace (i.e. "func",
 190 // "tensor", "linalg"). The following declarations are produced:
 191 //
 192 //   /// Gets the above hook methods in struct form for a dialect by namespace.
 193 //   /// This is intended to facilitate dynamic lookup and registration of
 194 //   /// dialects via a plugin facility based on shared library symbol lookup.
 195 //   const MlirDialectHandle *mlirGetDialectHandle__{NAMESPACE}__();
 196 //
 197 // This is done via a common macro to facilitate future expansion to
 198 // registration schemes.
 199 //===----------------------------------------------------------------------===//
 200
 201 struct MlirDialectHandle {
 202   const void *ptr;
 203 };
 204 typedef struct MlirDialectHandle MlirDialectHandle;
 205
 206 #define MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(Name, Namespace)                \
 207   MLIR_CAPI_EXPORTED MlirDialectHandle mlirGetDialectHandle__##Namespace##__(  \
 208       void)
 209
 210 /// Returns the namespace associated with the provided dialect handle.
 211 MLIR_CAPI_EXPORTED
 212 MlirStringRef mlirDialectHandleGetNamespace(MlirDialectHandle);
 213
 214 /// Inserts the dialect associated with the provided dialect handle into the
 215 /// provided dialect registry
 216 MLIR_CAPI_EXPORTED void mlirDialectHandleInsertDialect(MlirDialectHandle,
 217                                                        MlirDialectRegistry);
 218
 219 /// Registers the dialect associated with the provided dialect handle.
 220 MLIR_CAPI_EXPORTED void mlirDialectHandleRegisterDialect(MlirDialectHandle,
 221                                                          MlirContext);
 222
 223 /// Loads the dialect associated with the provided dialect handle.
 224 MLIR_CAPI_EXPORTED MlirDialect mlirDialectHandleLoadDialect(MlirDialectHandle,
 225                                                             MlirContext);
 226
 227 //===----------------------------------------------------------------------===//
 228 // DialectRegistry API.
 229 //===----------------------------------------------------------------------===//
 230
 231 /// Creates a dialect registry and transfers its ownership to the caller.
 232 MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate(void);
 233
 234 /// Checks if the dialect registry is null.
 235 static inline bool mlirDialectRegistryIsNull(MlirDialectRegistry registry) {
 236   return !registry.ptr;
 237 }
 238
 239 /// Takes a dialect registry owned by the caller and destroys it.
 240 MLIR_CAPI_EXPORTED void
 241 mlirDialectRegistryDestroy(MlirDialectRegistry registry);
 242
 243 //===----------------------------------------------------------------------===//
 244 // Location API.
 245 //===----------------------------------------------------------------------===//
 246
 247 /// Returns the underlying location attribute of this location.
 248 MLIR_CAPI_EXPORTED MlirAttribute
 249 mlirLocationGetAttribute(MlirLocation location);
 250
 251 /// Creates a location from a location attribute.
 252 MLIR_CAPI_EXPORTED MlirLocation
 253 mlirLocationFromAttribute(MlirAttribute attribute);
 254
 255 /// Creates an File/Line/Column location owned by the given context.
 256 MLIR_CAPI_EXPORTED MlirLocation mlirLocationFileLineColGet(
 257     MlirContext context, MlirStringRef filename, unsigned line, unsigned col);
 258
 259 /// Creates a call site location with a callee and a caller.
 260 MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee,
 261                                                         MlirLocation caller);
 262
 263 /// Creates a fused location with an array of locations and metadata.
 264 MLIR_CAPI_EXPORTED MlirLocation
 265 mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations,
 266                      MlirLocation const *locations, MlirAttribute metadata);
 267
 268 /// Creates a name location owned by the given context. Providing null location
 269 /// for childLoc is allowed and if childLoc is null location, then the behavior
 270 /// is the same as having unknown child location.
 271 MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context,
 272                                                     MlirStringRef name,
 273                                                     MlirLocation childLoc);
 274
 275 /// Creates a location with unknown position owned by the given context.
 276 MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context);
 277
 278 /// Gets the context that a location was created with.
 279 MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location);
 280
 281 /// Checks if the location is null.
 282 static inline bool mlirLocationIsNull(MlirLocation location) {
 283   return !location.ptr;
 284 }
 285
 286 /// Checks if two locations are equal.
 287 MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2);
 288
 289 /// Prints a location by sending chunks of the string representation and
 290 /// forwarding `userData to `callback`. Note that the callback may be called
 291 /// several times with consecutive chunks of the string.
 292 MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location,
 293                                           MlirStringCallback callback,
 294                                           void *userData);
 295
 296 //===----------------------------------------------------------------------===//
 297 // Module API.
 298 //===----------------------------------------------------------------------===//
 299
 300 /// Creates a new, empty module and transfers ownership to the caller.
 301 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location);
 302
 303 /// Parses a module from the string and transfers ownership to the caller.
 304 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context,
 305                                                     MlirStringRef module);
 306
 307 /// Gets the context that a module was created with.
 308 MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module);
 309
 310 /// Gets the body of the module, i.e. the only block it contains.
 311 MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module);
 312
 313 /// Checks whether a module is null.
 314 static inline bool mlirModuleIsNull(MlirModule module) { return !module.ptr; }
 315
 316 /// Takes a module owned by the caller and deletes it.
 317 MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module);
 318
 319 /// Views the module as a generic operation.
 320 MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module);
 321
 322 /// Views the generic operation as a module.
 323 /// The returned module is null when the input operation was not a ModuleOp.
 324 MLIR_CAPI_EXPORTED MlirModule mlirModuleFromOperation(MlirOperation op);
 325
 326 //===----------------------------------------------------------------------===//
 327 // Operation state.
 328 //===----------------------------------------------------------------------===//
 329
 330 /// An auxiliary class for constructing operations.
 331 ///
 332 /// This class contains all the information necessary to construct the
 333 /// operation. It owns the MlirRegions it has pointers to and does not own
 334 /// anything else. By default, the state can be constructed from a name and
 335 /// location, the latter being also used to access the context, and has no other
 336 /// components. These components can be added progressively until the operation
 337 /// is constructed. Users are not expected to rely on the internals of this
 338 /// class and should use mlirOperationState* functions instead.
 339
 340 struct MlirOperationState {
 341   MlirStringRef name;
 342   MlirLocation location;
 343   intptr_t nResults;
 344   MlirType *results;
 345   intptr_t nOperands;
 346   MlirValue *operands;
 347   intptr_t nRegions;
 348   MlirRegion *regions;
 349   intptr_t nSuccessors;
 350   MlirBlock *successors;
 351   intptr_t nAttributes;
 352   MlirNamedAttribute *attributes;
 353   bool enableResultTypeInference;
 354 };
 355 typedef struct MlirOperationState MlirOperationState;
 356
 357 /// Constructs an operation state from a name and a location.
 358 MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(MlirStringRef name,
 359                                                             MlirLocation loc);
 360
 361 /// Adds a list of components to the operation state.
 362 MLIR_CAPI_EXPORTED void mlirOperationStateAddResults(MlirOperationState *state,
 363                                                      intptr_t n,
 364                                                      MlirType const *results);
 365 MLIR_CAPI_EXPORTED void
 366 mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
 367                               MlirValue const *operands);
 368 MLIR_CAPI_EXPORTED void
 369 mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
 370                                   MlirRegion const *regions);
 371 MLIR_CAPI_EXPORTED void
 372 mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
 373                                 MlirBlock const *successors);
 374 MLIR_CAPI_EXPORTED void
 375 mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
 376                                 MlirNamedAttribute const *attributes);
 377
 378 /// Enables result type inference for the operation under construction. If
 379 /// enabled, then the caller must not have called
 380 /// mlirOperationStateAddResults(). Note that if enabled, the
 381 /// mlirOperationCreate() call is failable: it will return a null operation
 382 /// on inference failure and will emit diagnostics.
 383 MLIR_CAPI_EXPORTED void
 384 mlirOperationStateEnableResultTypeInference(MlirOperationState *state);
 385
 386 //===----------------------------------------------------------------------===//
 387 // AsmState API.
 388 // While many of these are simple settings that could be represented in a
 389 // struct, they are wrapped in a heap allocated object and accessed via
 390 // functions to maximize the possibility of compatibility over time.
 391 //===----------------------------------------------------------------------===//
 392
 393 /// Creates new AsmState, as with AsmState the IR should not be mutated
 394 /// in-between using this state.
 395 /// Must be freed with a call to mlirAsmStateDestroy().
 396 // TODO: This should be expanded to handle location & resouce map.
 397 MLIR_CAPI_EXPORTED MlirAsmState
 398 mlirAsmStateCreateForOperation(MlirOperation op, MlirOpPrintingFlags flags);
 399
 400 /// Creates new AsmState from value.
 401 /// Must be freed with a call to mlirAsmStateDestroy().
 402 // TODO: This should be expanded to handle location & resouce map.
 403 MLIR_CAPI_EXPORTED MlirAsmState
 404 mlirAsmStateCreateForValue(MlirValue value, MlirOpPrintingFlags flags);
 405
 406 /// Destroys printing flags created with mlirAsmStateCreate.
 407 MLIR_CAPI_EXPORTED void mlirAsmStateDestroy(MlirAsmState state);
 408
 409 //===----------------------------------------------------------------------===//
 410 // Op Printing flags API.
 411 // While many of these are simple settings that could be represented in a
 412 // struct, they are wrapped in a heap allocated object and accessed via
 413 // functions to maximize the possibility of compatibility over time.
 414 //===----------------------------------------------------------------------===//
 415
 416 /// Creates new printing flags with defaults, intended for customization.
 417 /// Must be freed with a call to mlirOpPrintingFlagsDestroy().
 418 MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void);
 419
 420 /// Destroys printing flags created with mlirOpPrintingFlagsCreate.
 421 MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags);
 422
 423 /// Enables the elision of large elements attributes by printing a lexically
 424 /// valid but otherwise meaningless form instead of the element data. The
 425 /// `largeElementLimit` is used to configure what is considered to be a "large"
 426 /// ElementsAttr by providing an upper limit to the number of elements.
 427 MLIR_CAPI_EXPORTED void
 428 mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
 429                                            intptr_t largeElementLimit);
 430
 431 /// Enable or disable printing of debug information (based on `enable`). If
 432 /// 'prettyForm' is set to true, debug information is printed in a more readable
 433 /// 'pretty' form. Note: The IR generated with 'prettyForm' is not parsable.
 434 MLIR_CAPI_EXPORTED void
 435 mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable,
 436                                    bool prettyForm);
 437
 438 /// Always print operations in the generic form.
 439 MLIR_CAPI_EXPORTED void
 440 mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags);
 441
 442 /// Use local scope when printing the operation. This allows for using the
 443 /// printer in a more localized and thread-safe setting, but may not
 444 /// necessarily be identical to what the IR will look like when dumping
 445 /// the full module.
 446 MLIR_CAPI_EXPORTED void
 447 mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags);
 448
 449 /// Do not verify the operation when using custom operation printers.
 450 MLIR_CAPI_EXPORTED void
 451 mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags);
 452
 453 //===----------------------------------------------------------------------===//
 454 // Bytecode printing flags API.
 455 //===----------------------------------------------------------------------===//
 456
 457 /// Creates new printing flags with defaults, intended for customization.
 458 /// Must be freed with a call to mlirBytecodeWriterConfigDestroy().
 459 MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig
 460 mlirBytecodeWriterConfigCreate(void);
 461
 462 /// Destroys printing flags created with mlirBytecodeWriterConfigCreate.
 463 MLIR_CAPI_EXPORTED void
 464 mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config);
 465
 466 /// Sets the version to emit in the writer config.
 467 MLIR_CAPI_EXPORTED void
 468 mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags,
 469                                            int64_t version);
 470
 471 //===----------------------------------------------------------------------===//
 472 // Operation API.
 473 //===----------------------------------------------------------------------===//
 474
 475 /// Creates an operation and transfers ownership to the caller.
 476 /// Note that caller owned child objects are transferred in this call and must
 477 /// not be further used. Particularly, this applies to any regions added to
 478 /// the state (the implementation may invalidate any such pointers).
 479 ///
 480 /// This call can fail under the following conditions, in which case, it will
 481 /// return a null operation and emit diagnostics:
 482 ///   - Result type inference is enabled and cannot be performed.
 483 MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreate(MlirOperationState *state);
 484
 485 /// Parses an operation, giving ownership to the caller. If parsing fails a null
 486 /// operation will be returned, and an error diagnostic emitted.
 487 ///
 488 /// `sourceStr` may be either the text assembly format, or binary bytecode
 489 /// format. `sourceName` is used as the file name of the source; any IR without
 490 /// locations will get a `FileLineColLoc` location with `sourceName` as the file
 491 /// name.
 492 MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreateParse(
 493     MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName);
 494
 495 /// Creates a deep copy of an operation. The operation is not inserted and
 496 /// ownership is transferred to the caller.
 497 MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op);
 498
 499 /// Takes an operation owned by the caller and destroys it.
 500 MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op);
 501
 502 /// Removes the given operation from its parent block. The operation is not
 503 /// destroyed. The ownership of the operation is transferred to the caller.
 504 MLIR_CAPI_EXPORTED void mlirOperationRemoveFromParent(MlirOperation op);
 505
 506 /// Checks whether the underlying operation is null.
 507 static inline bool mlirOperationIsNull(MlirOperation op) { return !op.ptr; }
 508
 509 /// Checks whether two operation handles point to the same operation. This does
 510 /// not perform deep comparison.
 511 MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op,
 512                                            MlirOperation other);
 513
 514 /// Gets the context this operation is associated with
 515 MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op);
 516
 517 /// Gets the location of the operation.
 518 MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op);
 519
 520 /// Gets the type id of the operation.
 521 /// Returns null if the operation does not have a registered operation
 522 /// description.
 523 MLIR_CAPI_EXPORTED MlirTypeID mlirOperationGetTypeID(MlirOperation op);
 524
 525 /// Gets the name of the operation as an identifier.
 526 MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op);
 527
 528 /// Gets the block that owns this operation, returning null if the operation is
 529 /// not owned.
 530 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op);
 531
 532 /// Gets the operation that owns this operation, returning null if the operation
 533 /// is not owned.
 534 MLIR_CAPI_EXPORTED MlirOperation
 535 mlirOperationGetParentOperation(MlirOperation op);
 536
 537 /// Returns the number of regions attached to the given operation.
 538 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op);
 539
 540 /// Returns `pos`-th region attached to the operation.
 541 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op,
 542                                                      intptr_t pos);
 543
 544 /// Returns an operation immediately following the given operation it its
 545 /// enclosing block.
 546 MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op);
 547
 548 /// Returns the number of operands of the operation.
 549 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op);
 550
 551 /// Returns `pos`-th operand of the operation.
 552 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op,
 553                                                      intptr_t pos);
 554
 555 /// Sets the `pos`-th operand of the operation.
 556 MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
 557                                                 MlirValue newValue);
 558
 559 /// Replaces the operands of the operation.
 560 MLIR_CAPI_EXPORTED void mlirOperationSetOperands(MlirOperation op,
 561                                                  intptr_t nOperands,
 562                                                  MlirValue const *operands);
 563
 564 /// Returns the number of results of the operation.
 565 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op);
 566
 567 /// Returns `pos`-th result of the operation.
 568 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op,
 569                                                     intptr_t pos);
 570
 571 /// Returns the number of successor blocks of the operation.
 572 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op);
 573
 574 /// Returns `pos`-th successor of the operation.
 575 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op,
 576                                                        intptr_t pos);
 577
 578 /// Set `pos`-th successor of the operation.
 579 MLIR_CAPI_EXPORTED void
 580 mlirOperationSetSuccessor(MlirOperation op, intptr_t pos, MlirBlock block);
 581
 582 /// Returns true if this operation defines an inherent attribute with this name.
 583 /// Note: the attribute can be optional, so
 584 /// `mlirOperationGetInherentAttributeByName` can still return a null attribute.
 585 MLIR_CAPI_EXPORTED bool
 586 mlirOperationHasInherentAttributeByName(MlirOperation op, MlirStringRef name);
 587
 588 /// Returns an inherent attribute attached to the operation given its name.
 589 MLIR_CAPI_EXPORTED MlirAttribute
 590 mlirOperationGetInherentAttributeByName(MlirOperation op, MlirStringRef name);
 591
 592 /// Sets an inherent attribute by name, replacing the existing if it exists.
 593 /// This has no effect if "name" does not match an inherent attribute.
 594 MLIR_CAPI_EXPORTED void
 595 mlirOperationSetInherentAttributeByName(MlirOperation op, MlirStringRef name,
 596                                         MlirAttribute attr);
 597
 598 /// Returns the number of discardable attributes attached to the operation.
 599 MLIR_CAPI_EXPORTED intptr_t
 600 mlirOperationGetNumDiscardableAttributes(MlirOperation op);
 601
 602 /// Return `pos`-th discardable attribute of the operation.
 603 MLIR_CAPI_EXPORTED MlirNamedAttribute
 604 mlirOperationGetDiscardableAttribute(MlirOperation op, intptr_t pos);
 605
 606 /// Returns a discardable attribute attached to the operation given its name.
 607 MLIR_CAPI_EXPORTED MlirAttribute mlirOperationGetDiscardableAttributeByName(
 608     MlirOperation op, MlirStringRef name);
 609
 610 /// Sets a discardable attribute by name, replacing the existing if it exists or
 611 /// adding a new one otherwise. The new `attr` Attribute is not allowed to be
 612 /// null, use `mlirOperationRemoveDiscardableAttributeByName` to remove an
 613 /// Attribute instead.
 614 MLIR_CAPI_EXPORTED void
 615 mlirOperationSetDiscardableAttributeByName(MlirOperation op, MlirStringRef name,
 616                                            MlirAttribute attr);
 617
 618 /// Removes a discardable attribute by name. Returns false if the attribute was
 619 /// not found and true if removed.
 620 MLIR_CAPI_EXPORTED bool
 621 mlirOperationRemoveDiscardableAttributeByName(MlirOperation op,
 622                                               MlirStringRef name);
 623
 624 /// Returns the number of attributes attached to the operation.
 625 /// Deprecated, please use `mlirOperationGetNumInherentAttributes` or
 626 /// `mlirOperationGetNumDiscardableAttributes`.
 627 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op);
 628
 629 /// Return `pos`-th attribute of the operation.
 630 /// Deprecated, please use `mlirOperationGetInherentAttribute` or
 631 /// `mlirOperationGetDiscardableAttribute`.
 632 MLIR_CAPI_EXPORTED MlirNamedAttribute
 633 mlirOperationGetAttribute(MlirOperation op, intptr_t pos);
 634
 635 /// Returns an attribute attached to the operation given its name.
 636 /// Deprecated, please use `mlirOperationGetInherentAttributeByName` or
 637 /// `mlirOperationGetDiscardableAttributeByName`.
 638 MLIR_CAPI_EXPORTED MlirAttribute
 639 mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name);
 640
 641 /// Sets an attribute by name, replacing the existing if it exists or
 642 /// adding a new one otherwise.
 643 /// Deprecated, please use `mlirOperationSetInherentAttributeByName` or
 644 /// `mlirOperationSetDiscardableAttributeByName`.
 645 MLIR_CAPI_EXPORTED void mlirOperationSetAttributeByName(MlirOperation op,
 646                                                         MlirStringRef name,
 647                                                         MlirAttribute attr);
 648
 649 /// Removes an attribute by name. Returns false if the attribute was not found
 650 /// and true if removed.
 651 /// Deprecated, please use `mlirOperationRemoveInherentAttributeByName` or
 652 /// `mlirOperationRemoveDiscardableAttributeByName`.
 653 MLIR_CAPI_EXPORTED bool mlirOperationRemoveAttributeByName(MlirOperation op,
 654                                                            MlirStringRef name);
 655
 656 /// Prints an operation by sending chunks of the string representation and
 657 /// forwarding `userData to `callback`. Note that the callback may be called
 658 /// several times with consecutive chunks of the string.
 659 MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op,
 660                                            MlirStringCallback callback,
 661                                            void *userData);
 662
 663 /// Same as mlirOperationPrint but accepts flags controlling the printing
 664 /// behavior.
 665 MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op,
 666                                                     MlirOpPrintingFlags flags,
 667                                                     MlirStringCallback callback,
 668                                                     void *userData);
 669
 670 /// Same as mlirOperationPrint but accepts AsmState controlling the printing
 671 /// behavior as well as caching computed names.
 672 MLIR_CAPI_EXPORTED void mlirOperationPrintWithState(MlirOperation op,
 673                                                     MlirAsmState state,
 674                                                     MlirStringCallback callback,
 675                                                     void *userData);
 676
 677 /// Same as mlirOperationPrint but writing the bytecode format.
 678 MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op,
 679                                                    MlirStringCallback callback,
 680                                                    void *userData);
 681
 682 /// Same as mlirOperationWriteBytecode but with writer config and returns
 683 /// failure only if desired bytecode could not be honored.
 684 MLIR_CAPI_EXPORTED MlirLogicalResult mlirOperationWriteBytecodeWithConfig(
 685     MlirOperation op, MlirBytecodeWriterConfig config,
 686     MlirStringCallback callback, void *userData);
 687
 688 /// Prints an operation to stderr.
 689 MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op);
 690
 691 /// Verify the operation and return true if it passes, false if it fails.
 692 MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op);
 693
 694 /// Moves the given operation immediately after the other operation in its
 695 /// parent block. The given operation may be owned by the caller or by its
 696 /// current block. The other operation must belong to a block. In any case, the
 697 /// ownership is transferred to the block of the other operation.
 698 MLIR_CAPI_EXPORTED void mlirOperationMoveAfter(MlirOperation op,
 699                                                MlirOperation other);
 700
 701 /// Moves the given operation immediately before the other operation in its
 702 /// parent block. The given operation may be owner by the caller or by its
 703 /// current block. The other operation must belong to a block. In any case, the
 704 /// ownership is transferred to the block of the other operation.
 705 MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op,
 706                                                 MlirOperation other);
 707
 708 /// Operation walk result.
 709 typedef enum MlirWalkResult {
 710   MlirWalkResultAdvance,
 711   MlirWalkResultInterrupt,
 712   MlirWalkResultSkip
 713 } MlirWalkResult;
 714
 715 /// Traversal order for operation walk.
 716 typedef enum MlirWalkOrder {
 717   MlirWalkPreOrder,
 718   MlirWalkPostOrder
 719 } MlirWalkOrder;
 720
 721 /// Operation walker type. The handler is passed an (opaque) reference to an
 722 /// operation and a pointer to a `userData`.
 723 typedef MlirWalkResult (*MlirOperationWalkCallback)(MlirOperation,
 724                                                     void *userData);
 725
 726 /// Walks operation `op` in `walkOrder` and calls `callback` on that operation.
 727 /// `*userData` is passed to the callback as well and can be used to tunnel some
 728 /// context or other data into the callback.
 729 MLIR_CAPI_EXPORTED
 730 void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback,
 731                        void *userData, MlirWalkOrder walkOrder);
 732
 733 //===----------------------------------------------------------------------===//
 734 // Region API.
 735 //===----------------------------------------------------------------------===//
 736
 737 /// Creates a new empty region and transfers ownership to the caller.
 738 MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void);
 739
 740 /// Takes a region owned by the caller and destroys it.
 741 MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region);
 742
 743 /// Checks whether a region is null.
 744 static inline bool mlirRegionIsNull(MlirRegion region) { return !region.ptr; }
 745
 746 /// Checks whether two region handles point to the same region. This does not
 747 /// perform deep comparison.
 748 MLIR_CAPI_EXPORTED bool mlirRegionEqual(MlirRegion region, MlirRegion other);
 749
 750 /// Gets the first block in the region.
 751 MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region);
 752
 753 /// Takes a block owned by the caller and appends it to the given region.
 754 MLIR_CAPI_EXPORTED void mlirRegionAppendOwnedBlock(MlirRegion region,
 755                                                    MlirBlock block);
 756
 757 /// Takes a block owned by the caller and inserts it at `pos` to the given
 758 /// region. This is an expensive operation that linearly scans the region,
 759 /// prefer insertAfter/Before instead.
 760 MLIR_CAPI_EXPORTED void
 761 mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block);
 762
 763 /// Takes a block owned by the caller and inserts it after the (non-owned)
 764 /// reference block in the given region. The reference block must belong to the
 765 /// region. If the reference block is null, prepends the block to the region.
 766 MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockAfter(MlirRegion region,
 767                                                         MlirBlock reference,
 768                                                         MlirBlock block);
 769
 770 /// Takes a block owned by the caller and inserts it before the (non-owned)
 771 /// reference block in the given region. The reference block must belong to the
 772 /// region. If the reference block is null, appends the block to the region.
 773 MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockBefore(MlirRegion region,
 774                                                          MlirBlock reference,
 775                                                          MlirBlock block);
 776
 777 /// Returns first region attached to the operation.
 778 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op);
 779
 780 /// Returns the region immediately following the given region in its parent
 781 /// operation.
 782 MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region);
 783
 784 /// Moves the entire content of the source region to the target region.
 785 MLIR_CAPI_EXPORTED void mlirRegionTakeBody(MlirRegion target,
 786                                            MlirRegion source);
 787
 788 //===----------------------------------------------------------------------===//
 789 // Block API.
 790 //===----------------------------------------------------------------------===//
 791
 792 /// Creates a new empty block with the given argument types and transfers
 793 /// ownership to the caller.
 794 MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs,
 795                                              MlirType const *args,
 796                                              MlirLocation const *locs);
 797
 798 /// Takes a block owned by the caller and destroys it.
 799 MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block);
 800
 801 /// Detach a block from the owning region and assume ownership.
 802 MLIR_CAPI_EXPORTED void mlirBlockDetach(MlirBlock block);
 803
 804 /// Checks whether a block is null.
 805 static inline bool mlirBlockIsNull(MlirBlock block) { return !block.ptr; }
 806
 807 /// Checks whether two blocks handles point to the same block. This does not
 808 /// perform deep comparison.
 809 MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other);
 810
 811 /// Returns the closest surrounding operation that contains this block.
 812 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock);
 813
 814 /// Returns the region that contains this block.
 815 MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block);
 816
 817 /// Returns the block immediately following the given block in its parent
 818 /// region.
 819 MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block);
 820
 821 /// Returns the first operation in the block.
 822 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block);
 823
 824 /// Returns the terminator operation in the block or null if no terminator.
 825 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block);
 826
 827 /// Takes an operation owned by the caller and appends it to the block.
 828 MLIR_CAPI_EXPORTED void mlirBlockAppendOwnedOperation(MlirBlock block,
 829                                                       MlirOperation operation);
 830
 831 /// Takes an operation owned by the caller and inserts it as `pos` to the block.
 832 /// This is an expensive operation that scans the block linearly, prefer
 833 /// insertBefore/After instead.
 834 MLIR_CAPI_EXPORTED void mlirBlockInsertOwnedOperation(MlirBlock block,
 835                                                       intptr_t pos,
 836                                                       MlirOperation operation);
 837
 838 /// Takes an operation owned by the caller and inserts it after the (non-owned)
 839 /// reference operation in the given block. If the reference is null, prepends
 840 /// the operation. Otherwise, the reference must belong to the block.
 841 MLIR_CAPI_EXPORTED void
 842 mlirBlockInsertOwnedOperationAfter(MlirBlock block, MlirOperation reference,
 843                                    MlirOperation operation);
 844
 845 /// Takes an operation owned by the caller and inserts it before the (non-owned)
 846 /// reference operation in the given block. If the reference is null, appends
 847 /// the operation. Otherwise, the reference must belong to the block.
 848 MLIR_CAPI_EXPORTED void
 849 mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference,
 850                                     MlirOperation operation);
 851
 852 /// Returns the number of arguments of the block.
 853 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block);
 854
 855 /// Appends an argument of the specified type to the block. Returns the newly
 856 /// added argument.
 857 MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block,
 858                                                   MlirType type,
 859                                                   MlirLocation loc);
 860
 861 /// Inserts an argument of the specified type at a specified index to the block.
 862 /// Returns the newly added argument.
 863 MLIR_CAPI_EXPORTED MlirValue mlirBlockInsertArgument(MlirBlock block,
 864                                                      intptr_t pos,
 865                                                      MlirType type,
 866                                                      MlirLocation loc);
 867
 868 /// Returns `pos`-th argument of the block.
 869 MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block,
 870                                                   intptr_t pos);
 871
 872 /// Prints a block by sending chunks of the string representation and
 873 /// forwarding `userData to `callback`. Note that the callback may be called
 874 /// several times with consecutive chunks of the string.
 875 MLIR_CAPI_EXPORTED void
 876 mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData);
 877
 878 //===----------------------------------------------------------------------===//
 879 // Value API.
 880 //===----------------------------------------------------------------------===//
 881
 882 /// Returns whether the value is null.
 883 static inline bool mlirValueIsNull(MlirValue value) { return !value.ptr; }
 884
 885 /// Returns 1 if two values are equal, 0 otherwise.
 886 MLIR_CAPI_EXPORTED bool mlirValueEqual(MlirValue value1, MlirValue value2);
 887
 888 /// Returns 1 if the value is a block argument, 0 otherwise.
 889 MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value);
 890
 891 /// Returns 1 if the value is an operation result, 0 otherwise.
 892 MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value);
 893
 894 /// Returns the block in which this value is defined as an argument. Asserts if
 895 /// the value is not a block argument.
 896 MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value);
 897
 898 /// Returns the position of the value in the argument list of its block.
 899 MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value);
 900
 901 /// Sets the type of the block argument to the given type.
 902 MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value,
 903                                                  MlirType type);
 904
 905 /// Returns an operation that produced this value as its result. Asserts if the
 906 /// value is not an op result.
 907 MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value);
 908
 909 /// Returns the position of the value in the list of results of the operation
 910 /// that produced it.
 911 MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value);
 912
 913 /// Returns the type of the value.
 914 MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value);
 915
 916 /// Set the type of the value.
 917 MLIR_CAPI_EXPORTED void mlirValueSetType(MlirValue value, MlirType type);
 918
 919 /// Prints the value to the standard error stream.
 920 MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value);
 921
 922 /// Prints a value by sending chunks of the string representation and
 923 /// forwarding `userData to `callback`. Note that the callback may be called
 924 /// several times with consecutive chunks of the string.
 925 MLIR_CAPI_EXPORTED void
 926 mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData);
 927
 928 /// Prints a value as an operand (i.e., the ValueID).
 929 MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value,
 930                                                 MlirAsmState state,
 931                                                 MlirStringCallback callback,
 932                                                 void *userData);
 933
 934 /// Returns an op operand representing the first use of the value, or a null op
 935 /// operand if there are no uses.
 936 MLIR_CAPI_EXPORTED MlirOpOperand mlirValueGetFirstUse(MlirValue value);
 937
 938 /// Replace all uses of 'of' value with the 'with' value, updating anything in
 939 /// the IR that uses 'of' to use the other value instead.  When this returns
 940 /// there are zero uses of 'of'.
 941 MLIR_CAPI_EXPORTED void mlirValueReplaceAllUsesOfWith(MlirValue of,
 942                                                       MlirValue with);
 943
 944 //===----------------------------------------------------------------------===//
 945 // OpOperand API.
 946 //===----------------------------------------------------------------------===//
 947
 948 /// Returns whether the op operand is null.
 949 MLIR_CAPI_EXPORTED bool mlirOpOperandIsNull(MlirOpOperand opOperand);
 950
 951 /// Returns the value of an op operand.
 952 MLIR_CAPI_EXPORTED MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand);
 953
 954 /// Returns the owner operation of an op operand.
 955 MLIR_CAPI_EXPORTED MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand);
 956
 957 /// Returns the operand number of an op operand.
 958 MLIR_CAPI_EXPORTED unsigned
 959 mlirOpOperandGetOperandNumber(MlirOpOperand opOperand);
 960
 961 /// Returns an op operand representing the next use of the value, or a null op
 962 /// operand if there is no next use.
 963 MLIR_CAPI_EXPORTED MlirOpOperand
 964 mlirOpOperandGetNextUse(MlirOpOperand opOperand);
 965
 966 //===----------------------------------------------------------------------===//
 967 // Type API.
 968 //===----------------------------------------------------------------------===//
 969
 970 /// Parses a type. The type is owned by the context.
 971 MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context,
 972                                              MlirStringRef type);
 973
 974 /// Gets the context that a type was created with.
 975 MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type);
 976
 977 /// Gets the type ID of the type.
 978 MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(MlirType type);
 979
 980 /// Gets the dialect a type belongs to.
 981 MLIR_CAPI_EXPORTED MlirDialect mlirTypeGetDialect(MlirType type);
 982
 983 /// Checks whether a type is null.
 984 static inline bool mlirTypeIsNull(MlirType type) { return !type.ptr; }
 985
 986 /// Checks if two types are equal.
 987 MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2);
 988
 989 /// Prints a location by sending chunks of the string representation and
 990 /// forwarding `userData to `callback`. Note that the callback may be called
 991 /// several times with consecutive chunks of the string.
 992 MLIR_CAPI_EXPORTED void
 993 mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData);
 994
 995 /// Prints the type to the standard error stream.
 996 MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type);
 997
 998 //===----------------------------------------------------------------------===//
 999 // Attribute API.
1000 //===----------------------------------------------------------------------===//
1001
1002 /// Parses an attribute. The attribute is owned by the context.
1003 MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context,
1004                                                        MlirStringRef attr);
1005
1006 /// Gets the context that an attribute was created with.
1007 MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute);
1008
1009 /// Gets the type of this attribute.
1010 MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute);
1011
1012 /// Gets the type id of the attribute.
1013 MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(MlirAttribute attribute);
1014
1015 /// Gets the dialect of the attribute.
1016 MLIR_CAPI_EXPORTED MlirDialect mlirAttributeGetDialect(MlirAttribute attribute);
1017
1018 /// Checks whether an attribute is null.
1019 static inline bool mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; }
1020
1021 /// Checks if two attributes are equal.
1022 MLIR_CAPI_EXPORTED bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
1023
1024 /// Prints an attribute by sending chunks of the string representation and
1025 /// forwarding `userData to `callback`. Note that the callback may be called
1026 /// several times with consecutive chunks of the string.
1027 MLIR_CAPI_EXPORTED void mlirAttributePrint(MlirAttribute attr,
1028                                            MlirStringCallback callback,
1029                                            void *userData);
1030
1031 /// Prints the attribute to the standard error stream.
1032 MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr);
1033
1034 /// Associates an attribute with the name. Takes ownership of neither.
1035 MLIR_CAPI_EXPORTED MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name,
1036                                                             MlirAttribute attr);
1037
1038 //===----------------------------------------------------------------------===//
1039 // Identifier API.
1040 //===----------------------------------------------------------------------===//
1041
1042 /// Gets an identifier with the given string value.
1043 MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context,
1044                                                     MlirStringRef str);
1045
1046 /// Returns the context associated with this identifier
1047 MLIR_CAPI_EXPORTED MlirContext mlirIdentifierGetContext(MlirIdentifier);
1048
1049 /// Checks whether two identifiers are the same.
1050 MLIR_CAPI_EXPORTED bool mlirIdentifierEqual(MlirIdentifier ident,
1051                                             MlirIdentifier other);
1052
1053 /// Gets the string value of the identifier.
1054 MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident);
1055
1056 //===----------------------------------------------------------------------===//
1057 // Symbol and SymbolTable API.
1058 //===----------------------------------------------------------------------===//
1059
1060 /// Returns the name of the attribute used to store symbol names compatible with
1061 /// symbol tables.
1062 MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName(void);
1063
1064 /// Returns the name of the attribute used to store symbol visibility.
1065 MLIR_CAPI_EXPORTED MlirStringRef
1066 mlirSymbolTableGetVisibilityAttributeName(void);
1067
1068 /// Creates a symbol table for the given operation. If the operation does not
1069 /// have the SymbolTable trait, returns a null symbol table.
1070 MLIR_CAPI_EXPORTED MlirSymbolTable
1071 mlirSymbolTableCreate(MlirOperation operation);
1072
1073 /// Returns true if the symbol table is null.
1074 static inline bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable) {
1075   return !symbolTable.ptr;
1076 }
1077
1078 /// Destroys the symbol table created with mlirSymbolTableCreate. This does not
1079 /// affect the operations in the table.
1080 MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable);
1081
1082 /// Looks up a symbol with the given name in the given symbol table and returns
1083 /// the operation that corresponds to the symbol. If the symbol cannot be found,
1084 /// returns a null operation.
1085 MLIR_CAPI_EXPORTED MlirOperation
1086 mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name);
1087
1088 /// Inserts the given operation into the given symbol table. The operation must
1089 /// have the symbol trait. If the symbol table already has a symbol with the
1090 /// same name, renames the symbol being inserted to ensure name uniqueness. Note
1091 /// that this does not move the operation itself into the block of the symbol
1092 /// table operation, this should be done separately. Returns the name of the
1093 /// symbol after insertion.
1094 MLIR_CAPI_EXPORTED MlirAttribute
1095 mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation);
1096
1097 /// Removes the given operation from the symbol table and erases it.
1098 MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable,
1099                                              MlirOperation operation);
1100
1101 /// Attempt to replace all uses that are nested within the given operation
1102 /// of the given symbol 'oldSymbol' with the provided 'newSymbol'. This does
1103 /// not traverse into nested symbol tables. Will fail atomically if there are
1104 /// any unknown operations that may be potential symbol tables.
1105 MLIR_CAPI_EXPORTED MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses(
1106     MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from);
1107
1108 /// Walks all symbol table operations nested within, and including, `op`. For
1109 /// each symbol table operation, the provided callback is invoked with the op
1110 /// and a boolean signifying if the symbols within that symbol table can be
1111 /// treated as if all uses within the IR are visible to the caller.
1112 /// `allSymUsesVisible` identifies whether all of the symbol uses of symbols
1113 /// within `op` are visible.
1114 MLIR_CAPI_EXPORTED void mlirSymbolTableWalkSymbolTables(
1115     MlirOperation from, bool allSymUsesVisible,
1116     void (*callback)(MlirOperation, bool, void *userData), void *userData);
1117
1118 #ifdef __cplusplus
1119 }
1120 #endif
1121
1122 #endif // MLIR_C_IR_H