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 an File/Line/Column range location owned by the given context. 260 MLIR_CAPI_EXPORTED MlirLocation mlirLocationFileLineColRangeGet( 261 MlirContext context, MlirStringRef filename, unsigned start_line, 262 unsigned start_col, unsigned end_line, unsigned end_col); 263 264 /// Creates a call site location with a callee and a caller. 265 MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee, 266 MlirLocation caller); 267 268 /// Creates a fused location with an array of locations and metadata. 269 MLIR_CAPI_EXPORTED MlirLocation 270 mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations, 271 MlirLocation const *locations, MlirAttribute metadata); 272 273 /// Creates a name location owned by the given context. Providing null location 274 /// for childLoc is allowed and if childLoc is null location, then the behavior 275 /// is the same as having unknown child location. 276 MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context, 277 MlirStringRef name, 278 MlirLocation childLoc); 279 280 /// Creates a location with unknown position owned by the given context. 281 MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context); 282 283 /// Gets the context that a location was created with. 284 MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location); 285 286 /// Checks if the location is null. 287 static inline bool mlirLocationIsNull(MlirLocation location) { 288 return !location.ptr; 289 } 290 291 /// Checks if two locations are equal. 292 MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2); 293 294 /// Prints a location by sending chunks of the string representation and 295 /// forwarding `userData to `callback`. Note that the callback may be called 296 /// several times with consecutive chunks of the string. 297 MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location, 298 MlirStringCallback callback, 299 void *userData); 300 301 //===----------------------------------------------------------------------===// 302 // Module API. 303 //===----------------------------------------------------------------------===// 304 305 /// Creates a new, empty module and transfers ownership to the caller. 306 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location); 307 308 /// Parses a module from the string and transfers ownership to the caller. 309 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context, 310 MlirStringRef module); 311 312 /// Gets the context that a module was created with. 313 MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module); 314 315 /// Gets the body of the module, i.e. the only block it contains. 316 MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module); 317 318 /// Checks whether a module is null. 319 static inline bool mlirModuleIsNull(MlirModule module) { return !module.ptr; } 320 321 /// Takes a module owned by the caller and deletes it. 322 MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module); 323 324 /// Views the module as a generic operation. 325 MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module); 326 327 /// Views the generic operation as a module. 328 /// The returned module is null when the input operation was not a ModuleOp. 329 MLIR_CAPI_EXPORTED MlirModule mlirModuleFromOperation(MlirOperation op); 330 331 //===----------------------------------------------------------------------===// 332 // Operation state. 333 //===----------------------------------------------------------------------===// 334 335 /// An auxiliary class for constructing operations. 336 /// 337 /// This class contains all the information necessary to construct the 338 /// operation. It owns the MlirRegions it has pointers to and does not own 339 /// anything else. By default, the state can be constructed from a name and 340 /// location, the latter being also used to access the context, and has no other 341 /// components. These components can be added progressively until the operation 342 /// is constructed. Users are not expected to rely on the internals of this 343 /// class and should use mlirOperationState* functions instead. 344 345 struct MlirOperationState { 346 MlirStringRef name; 347 MlirLocation location; 348 intptr_t nResults; 349 MlirType *results; 350 intptr_t nOperands; 351 MlirValue *operands; 352 intptr_t nRegions; 353 MlirRegion *regions; 354 intptr_t nSuccessors; 355 MlirBlock *successors; 356 intptr_t nAttributes; 357 MlirNamedAttribute *attributes; 358 bool enableResultTypeInference; 359 }; 360 typedef struct MlirOperationState MlirOperationState; 361 362 /// Constructs an operation state from a name and a location. 363 MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(MlirStringRef name, 364 MlirLocation loc); 365 366 /// Adds a list of components to the operation state. 367 MLIR_CAPI_EXPORTED void mlirOperationStateAddResults(MlirOperationState *state, 368 intptr_t n, 369 MlirType const *results); 370 MLIR_CAPI_EXPORTED void 371 mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n, 372 MlirValue const *operands); 373 MLIR_CAPI_EXPORTED void 374 mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n, 375 MlirRegion const *regions); 376 MLIR_CAPI_EXPORTED void 377 mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n, 378 MlirBlock const *successors); 379 MLIR_CAPI_EXPORTED void 380 mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n, 381 MlirNamedAttribute const *attributes); 382 383 /// Enables result type inference for the operation under construction. If 384 /// enabled, then the caller must not have called 385 /// mlirOperationStateAddResults(). Note that if enabled, the 386 /// mlirOperationCreate() call is failable: it will return a null operation 387 /// on inference failure and will emit diagnostics. 388 MLIR_CAPI_EXPORTED void 389 mlirOperationStateEnableResultTypeInference(MlirOperationState *state); 390 391 //===----------------------------------------------------------------------===// 392 // AsmState API. 393 // While many of these are simple settings that could be represented in a 394 // struct, they are wrapped in a heap allocated object and accessed via 395 // functions to maximize the possibility of compatibility over time. 396 //===----------------------------------------------------------------------===// 397 398 /// Creates new AsmState, as with AsmState the IR should not be mutated 399 /// in-between using this state. 400 /// Must be freed with a call to mlirAsmStateDestroy(). 401 // TODO: This should be expanded to handle location & resouce map. 402 MLIR_CAPI_EXPORTED MlirAsmState 403 mlirAsmStateCreateForOperation(MlirOperation op, MlirOpPrintingFlags flags); 404 405 /// Creates new AsmState from value. 406 /// Must be freed with a call to mlirAsmStateDestroy(). 407 // TODO: This should be expanded to handle location & resouce map. 408 MLIR_CAPI_EXPORTED MlirAsmState 409 mlirAsmStateCreateForValue(MlirValue value, MlirOpPrintingFlags flags); 410 411 /// Destroys printing flags created with mlirAsmStateCreate. 412 MLIR_CAPI_EXPORTED void mlirAsmStateDestroy(MlirAsmState state); 413 414 //===----------------------------------------------------------------------===// 415 // Op Printing flags API. 416 // While many of these are simple settings that could be represented in a 417 // struct, they are wrapped in a heap allocated object and accessed via 418 // functions to maximize the possibility of compatibility over time. 419 //===----------------------------------------------------------------------===// 420 421 /// Creates new printing flags with defaults, intended for customization. 422 /// Must be freed with a call to mlirOpPrintingFlagsDestroy(). 423 MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void); 424 425 /// Destroys printing flags created with mlirOpPrintingFlagsCreate. 426 MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags); 427 428 /// Enables the elision of large elements attributes by printing a lexically 429 /// valid but otherwise meaningless form instead of the element data. The 430 /// `largeElementLimit` is used to configure what is considered to be a "large" 431 /// ElementsAttr by providing an upper limit to the number of elements. 432 MLIR_CAPI_EXPORTED void 433 mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags, 434 intptr_t largeElementLimit); 435 436 /// Enables the elision of large resources strings by omitting them from the 437 /// `dialect_resources` section. The `largeResourceLimit` is used to configure 438 /// what is considered to be a "large" resource by providing an upper limit to 439 /// the string size. 440 MLIR_CAPI_EXPORTED void 441 mlirOpPrintingFlagsElideLargeResourceString(MlirOpPrintingFlags flags, 442 intptr_t largeResourceLimit); 443 444 /// Enable or disable printing of debug information (based on `enable`). If 445 /// 'prettyForm' is set to true, debug information is printed in a more readable 446 /// 'pretty' form. Note: The IR generated with 'prettyForm' is not parsable. 447 MLIR_CAPI_EXPORTED void 448 mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable, 449 bool prettyForm); 450 451 /// Always print operations in the generic form. 452 MLIR_CAPI_EXPORTED void 453 mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags); 454 455 /// Use local scope when printing the operation. This allows for using the 456 /// printer in a more localized and thread-safe setting, but may not 457 /// necessarily be identical to what the IR will look like when dumping 458 /// the full module. 459 MLIR_CAPI_EXPORTED void 460 mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags); 461 462 /// Do not verify the operation when using custom operation printers. 463 MLIR_CAPI_EXPORTED void 464 mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags); 465 466 /// Skip printing regions. 467 MLIR_CAPI_EXPORTED void 468 mlirOpPrintingFlagsSkipRegions(MlirOpPrintingFlags flags); 469 470 //===----------------------------------------------------------------------===// 471 // Bytecode printing flags API. 472 //===----------------------------------------------------------------------===// 473 474 /// Creates new printing flags with defaults, intended for customization. 475 /// Must be freed with a call to mlirBytecodeWriterConfigDestroy(). 476 MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig 477 mlirBytecodeWriterConfigCreate(void); 478 479 /// Destroys printing flags created with mlirBytecodeWriterConfigCreate. 480 MLIR_CAPI_EXPORTED void 481 mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config); 482 483 /// Sets the version to emit in the writer config. 484 MLIR_CAPI_EXPORTED void 485 mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags, 486 int64_t version); 487 488 //===----------------------------------------------------------------------===// 489 // Operation API. 490 //===----------------------------------------------------------------------===// 491 492 /// Creates an operation and transfers ownership to the caller. 493 /// Note that caller owned child objects are transferred in this call and must 494 /// not be further used. Particularly, this applies to any regions added to 495 /// the state (the implementation may invalidate any such pointers). 496 /// 497 /// This call can fail under the following conditions, in which case, it will 498 /// return a null operation and emit diagnostics: 499 /// - Result type inference is enabled and cannot be performed. 500 MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreate(MlirOperationState *state); 501 502 /// Parses an operation, giving ownership to the caller. If parsing fails a null 503 /// operation will be returned, and an error diagnostic emitted. 504 /// 505 /// `sourceStr` may be either the text assembly format, or binary bytecode 506 /// format. `sourceName` is used as the file name of the source; any IR without 507 /// locations will get a `FileLineColLoc` location with `sourceName` as the file 508 /// name. 509 MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreateParse( 510 MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName); 511 512 /// Creates a deep copy of an operation. The operation is not inserted and 513 /// ownership is transferred to the caller. 514 MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op); 515 516 /// Takes an operation owned by the caller and destroys it. 517 MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op); 518 519 /// Removes the given operation from its parent block. The operation is not 520 /// destroyed. The ownership of the operation is transferred to the caller. 521 MLIR_CAPI_EXPORTED void mlirOperationRemoveFromParent(MlirOperation op); 522 523 /// Checks whether the underlying operation is null. 524 static inline bool mlirOperationIsNull(MlirOperation op) { return !op.ptr; } 525 526 /// Checks whether two operation handles point to the same operation. This does 527 /// not perform deep comparison. 528 MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op, 529 MlirOperation other); 530 531 /// Gets the context this operation is associated with 532 MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op); 533 534 /// Gets the location of the operation. 535 MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op); 536 537 /// Gets the type id of the operation. 538 /// Returns null if the operation does not have a registered operation 539 /// description. 540 MLIR_CAPI_EXPORTED MlirTypeID mlirOperationGetTypeID(MlirOperation op); 541 542 /// Gets the name of the operation as an identifier. 543 MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op); 544 545 /// Gets the block that owns this operation, returning null if the operation is 546 /// not owned. 547 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op); 548 549 /// Gets the operation that owns this operation, returning null if the operation 550 /// is not owned. 551 MLIR_CAPI_EXPORTED MlirOperation 552 mlirOperationGetParentOperation(MlirOperation op); 553 554 /// Returns the number of regions attached to the given operation. 555 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op); 556 557 /// Returns `pos`-th region attached to the operation. 558 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op, 559 intptr_t pos); 560 561 /// Returns an operation immediately following the given operation it its 562 /// enclosing block. 563 MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op); 564 565 /// Returns the number of operands of the operation. 566 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op); 567 568 /// Returns `pos`-th operand of the operation. 569 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op, 570 intptr_t pos); 571 572 /// Sets the `pos`-th operand of the operation. 573 MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos, 574 MlirValue newValue); 575 576 /// Replaces the operands of the operation. 577 MLIR_CAPI_EXPORTED void mlirOperationSetOperands(MlirOperation op, 578 intptr_t nOperands, 579 MlirValue const *operands); 580 581 /// Returns the number of results of the operation. 582 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op); 583 584 /// Returns `pos`-th result of the operation. 585 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op, 586 intptr_t pos); 587 588 /// Returns the number of successor blocks of the operation. 589 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op); 590 591 /// Returns `pos`-th successor of the operation. 592 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op, 593 intptr_t pos); 594 595 /// Set `pos`-th successor of the operation. 596 MLIR_CAPI_EXPORTED void 597 mlirOperationSetSuccessor(MlirOperation op, intptr_t pos, MlirBlock block); 598 599 /// Returns true if this operation defines an inherent attribute with this name. 600 /// Note: the attribute can be optional, so 601 /// `mlirOperationGetInherentAttributeByName` can still return a null attribute. 602 MLIR_CAPI_EXPORTED bool 603 mlirOperationHasInherentAttributeByName(MlirOperation op, MlirStringRef name); 604 605 /// Returns an inherent attribute attached to the operation given its name. 606 MLIR_CAPI_EXPORTED MlirAttribute 607 mlirOperationGetInherentAttributeByName(MlirOperation op, MlirStringRef name); 608 609 /// Sets an inherent attribute by name, replacing the existing if it exists. 610 /// This has no effect if "name" does not match an inherent attribute. 611 MLIR_CAPI_EXPORTED void 612 mlirOperationSetInherentAttributeByName(MlirOperation op, MlirStringRef name, 613 MlirAttribute attr); 614 615 /// Returns the number of discardable attributes attached to the operation. 616 MLIR_CAPI_EXPORTED intptr_t 617 mlirOperationGetNumDiscardableAttributes(MlirOperation op); 618 619 /// Return `pos`-th discardable attribute of the operation. 620 MLIR_CAPI_EXPORTED MlirNamedAttribute 621 mlirOperationGetDiscardableAttribute(MlirOperation op, intptr_t pos); 622 623 /// Returns a discardable attribute attached to the operation given its name. 624 MLIR_CAPI_EXPORTED MlirAttribute mlirOperationGetDiscardableAttributeByName( 625 MlirOperation op, MlirStringRef name); 626 627 /// Sets a discardable attribute by name, replacing the existing if it exists or 628 /// adding a new one otherwise. The new `attr` Attribute is not allowed to be 629 /// null, use `mlirOperationRemoveDiscardableAttributeByName` to remove an 630 /// Attribute instead. 631 MLIR_CAPI_EXPORTED void 632 mlirOperationSetDiscardableAttributeByName(MlirOperation op, MlirStringRef name, 633 MlirAttribute attr); 634 635 /// Removes a discardable attribute by name. Returns false if the attribute was 636 /// not found and true if removed. 637 MLIR_CAPI_EXPORTED bool 638 mlirOperationRemoveDiscardableAttributeByName(MlirOperation op, 639 MlirStringRef name); 640 641 /// Returns the number of attributes attached to the operation. 642 /// Deprecated, please use `mlirOperationGetNumInherentAttributes` or 643 /// `mlirOperationGetNumDiscardableAttributes`. 644 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op); 645 646 /// Return `pos`-th attribute of the operation. 647 /// Deprecated, please use `mlirOperationGetInherentAttribute` or 648 /// `mlirOperationGetDiscardableAttribute`. 649 MLIR_CAPI_EXPORTED MlirNamedAttribute 650 mlirOperationGetAttribute(MlirOperation op, intptr_t pos); 651 652 /// Returns an attribute attached to the operation given its name. 653 /// Deprecated, please use `mlirOperationGetInherentAttributeByName` or 654 /// `mlirOperationGetDiscardableAttributeByName`. 655 MLIR_CAPI_EXPORTED MlirAttribute 656 mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name); 657 658 /// Sets an attribute by name, replacing the existing if it exists or 659 /// adding a new one otherwise. 660 /// Deprecated, please use `mlirOperationSetInherentAttributeByName` or 661 /// `mlirOperationSetDiscardableAttributeByName`. 662 MLIR_CAPI_EXPORTED void mlirOperationSetAttributeByName(MlirOperation op, 663 MlirStringRef name, 664 MlirAttribute attr); 665 666 /// Removes an attribute by name. Returns false if the attribute was not found 667 /// and true if removed. 668 /// Deprecated, please use `mlirOperationRemoveInherentAttributeByName` or 669 /// `mlirOperationRemoveDiscardableAttributeByName`. 670 MLIR_CAPI_EXPORTED bool mlirOperationRemoveAttributeByName(MlirOperation op, 671 MlirStringRef name); 672 673 /// Prints an operation by sending chunks of the string representation and 674 /// forwarding `userData to `callback`. Note that the callback may be called 675 /// several times with consecutive chunks of the string. 676 MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op, 677 MlirStringCallback callback, 678 void *userData); 679 680 /// Same as mlirOperationPrint but accepts flags controlling the printing 681 /// behavior. 682 MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op, 683 MlirOpPrintingFlags flags, 684 MlirStringCallback callback, 685 void *userData); 686 687 /// Same as mlirOperationPrint but accepts AsmState controlling the printing 688 /// behavior as well as caching computed names. 689 MLIR_CAPI_EXPORTED void mlirOperationPrintWithState(MlirOperation op, 690 MlirAsmState state, 691 MlirStringCallback callback, 692 void *userData); 693 694 /// Same as mlirOperationPrint but writing the bytecode format. 695 MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op, 696 MlirStringCallback callback, 697 void *userData); 698 699 /// Same as mlirOperationWriteBytecode but with writer config and returns 700 /// failure only if desired bytecode could not be honored. 701 MLIR_CAPI_EXPORTED MlirLogicalResult mlirOperationWriteBytecodeWithConfig( 702 MlirOperation op, MlirBytecodeWriterConfig config, 703 MlirStringCallback callback, void *userData); 704 705 /// Prints an operation to stderr. 706 MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op); 707 708 /// Verify the operation and return true if it passes, false if it fails. 709 MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op); 710 711 /// Moves the given operation immediately after the other operation in its 712 /// parent block. The given operation may be owned by the caller or by its 713 /// current block. The other operation must belong to a block. In any case, the 714 /// ownership is transferred to the block of the other operation. 715 MLIR_CAPI_EXPORTED void mlirOperationMoveAfter(MlirOperation op, 716 MlirOperation other); 717 718 /// Moves the given operation immediately before the other operation in its 719 /// parent block. The given operation may be owner by the caller or by its 720 /// current block. The other operation must belong to a block. In any case, the 721 /// ownership is transferred to the block of the other operation. 722 MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op, 723 MlirOperation other); 724 725 /// Operation walk result. 726 typedef enum MlirWalkResult { 727 MlirWalkResultAdvance, 728 MlirWalkResultInterrupt, 729 MlirWalkResultSkip 730 } MlirWalkResult; 731 732 /// Traversal order for operation walk. 733 typedef enum MlirWalkOrder { 734 MlirWalkPreOrder, 735 MlirWalkPostOrder 736 } MlirWalkOrder; 737 738 /// Operation walker type. The handler is passed an (opaque) reference to an 739 /// operation and a pointer to a `userData`. 740 typedef MlirWalkResult (*MlirOperationWalkCallback)(MlirOperation, 741 void *userData); 742 743 /// Walks operation `op` in `walkOrder` and calls `callback` on that operation. 744 /// `*userData` is passed to the callback as well and can be used to tunnel some 745 /// context or other data into the callback. 746 MLIR_CAPI_EXPORTED 747 void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback, 748 void *userData, MlirWalkOrder walkOrder); 749 750 //===----------------------------------------------------------------------===// 751 // Region API. 752 //===----------------------------------------------------------------------===// 753 754 /// Creates a new empty region and transfers ownership to the caller. 755 MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void); 756 757 /// Takes a region owned by the caller and destroys it. 758 MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region); 759 760 /// Checks whether a region is null. 761 static inline bool mlirRegionIsNull(MlirRegion region) { return !region.ptr; } 762 763 /// Checks whether two region handles point to the same region. This does not 764 /// perform deep comparison. 765 MLIR_CAPI_EXPORTED bool mlirRegionEqual(MlirRegion region, MlirRegion other); 766 767 /// Gets the first block in the region. 768 MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region); 769 770 /// Takes a block owned by the caller and appends it to the given region. 771 MLIR_CAPI_EXPORTED void mlirRegionAppendOwnedBlock(MlirRegion region, 772 MlirBlock block); 773 774 /// Takes a block owned by the caller and inserts it at `pos` to the given 775 /// region. This is an expensive operation that linearly scans the region, 776 /// prefer insertAfter/Before instead. 777 MLIR_CAPI_EXPORTED void 778 mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block); 779 780 /// Takes a block owned by the caller and inserts it after the (non-owned) 781 /// reference block in the given region. The reference block must belong to the 782 /// region. If the reference block is null, prepends the block to the region. 783 MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockAfter(MlirRegion region, 784 MlirBlock reference, 785 MlirBlock block); 786 787 /// Takes a block owned by the caller and inserts it before the (non-owned) 788 /// reference block in the given region. The reference block must belong to the 789 /// region. If the reference block is null, appends the block to the region. 790 MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockBefore(MlirRegion region, 791 MlirBlock reference, 792 MlirBlock block); 793 794 /// Returns first region attached to the operation. 795 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op); 796 797 /// Returns the region immediately following the given region in its parent 798 /// operation. 799 MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region); 800 801 /// Moves the entire content of the source region to the target region. 802 MLIR_CAPI_EXPORTED void mlirRegionTakeBody(MlirRegion target, 803 MlirRegion source); 804 805 //===----------------------------------------------------------------------===// 806 // Block API. 807 //===----------------------------------------------------------------------===// 808 809 /// Creates a new empty block with the given argument types and transfers 810 /// ownership to the caller. 811 MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs, 812 MlirType const *args, 813 MlirLocation const *locs); 814 815 /// Takes a block owned by the caller and destroys it. 816 MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block); 817 818 /// Detach a block from the owning region and assume ownership. 819 MLIR_CAPI_EXPORTED void mlirBlockDetach(MlirBlock block); 820 821 /// Checks whether a block is null. 822 static inline bool mlirBlockIsNull(MlirBlock block) { return !block.ptr; } 823 824 /// Checks whether two blocks handles point to the same block. This does not 825 /// perform deep comparison. 826 MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other); 827 828 /// Returns the closest surrounding operation that contains this block. 829 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock); 830 831 /// Returns the region that contains this block. 832 MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block); 833 834 /// Returns the block immediately following the given block in its parent 835 /// region. 836 MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block); 837 838 /// Returns the first operation in the block. 839 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block); 840 841 /// Returns the terminator operation in the block or null if no terminator. 842 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block); 843 844 /// Takes an operation owned by the caller and appends it to the block. 845 MLIR_CAPI_EXPORTED void mlirBlockAppendOwnedOperation(MlirBlock block, 846 MlirOperation operation); 847 848 /// Takes an operation owned by the caller and inserts it as `pos` to the block. 849 /// This is an expensive operation that scans the block linearly, prefer 850 /// insertBefore/After instead. 851 MLIR_CAPI_EXPORTED void mlirBlockInsertOwnedOperation(MlirBlock block, 852 intptr_t pos, 853 MlirOperation operation); 854 855 /// Takes an operation owned by the caller and inserts it after the (non-owned) 856 /// reference operation in the given block. If the reference is null, prepends 857 /// the operation. Otherwise, the reference must belong to the block. 858 MLIR_CAPI_EXPORTED void 859 mlirBlockInsertOwnedOperationAfter(MlirBlock block, MlirOperation reference, 860 MlirOperation operation); 861 862 /// Takes an operation owned by the caller and inserts it before the (non-owned) 863 /// reference operation in the given block. If the reference is null, appends 864 /// the operation. Otherwise, the reference must belong to the block. 865 MLIR_CAPI_EXPORTED void 866 mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference, 867 MlirOperation operation); 868 869 /// Returns the number of arguments of the block. 870 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block); 871 872 /// Appends an argument of the specified type to the block. Returns the newly 873 /// added argument. 874 MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block, 875 MlirType type, 876 MlirLocation loc); 877 878 /// Erase the argument at 'index' and remove it from the argument list. 879 MLIR_CAPI_EXPORTED void mlirBlockEraseArgument(MlirBlock block, unsigned index); 880 881 /// Inserts an argument of the specified type at a specified index to the block. 882 /// Returns the newly added argument. 883 MLIR_CAPI_EXPORTED MlirValue mlirBlockInsertArgument(MlirBlock block, 884 intptr_t pos, 885 MlirType type, 886 MlirLocation loc); 887 888 /// Returns `pos`-th argument of the block. 889 MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block, 890 intptr_t pos); 891 892 /// Prints a block by sending chunks of the string representation and 893 /// forwarding `userData to `callback`. Note that the callback may be called 894 /// several times with consecutive chunks of the string. 895 MLIR_CAPI_EXPORTED void 896 mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData); 897 898 //===----------------------------------------------------------------------===// 899 // Value API. 900 //===----------------------------------------------------------------------===// 901 902 /// Returns whether the value is null. 903 static inline bool mlirValueIsNull(MlirValue value) { return !value.ptr; } 904 905 /// Returns 1 if two values are equal, 0 otherwise. 906 MLIR_CAPI_EXPORTED bool mlirValueEqual(MlirValue value1, MlirValue value2); 907 908 /// Returns 1 if the value is a block argument, 0 otherwise. 909 MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value); 910 911 /// Returns 1 if the value is an operation result, 0 otherwise. 912 MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value); 913 914 /// Returns the block in which this value is defined as an argument. Asserts if 915 /// the value is not a block argument. 916 MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value); 917 918 /// Returns the position of the value in the argument list of its block. 919 MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value); 920 921 /// Sets the type of the block argument to the given type. 922 MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value, 923 MlirType type); 924 925 /// Returns an operation that produced this value as its result. Asserts if the 926 /// value is not an op result. 927 MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value); 928 929 /// Returns the position of the value in the list of results of the operation 930 /// that produced it. 931 MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value); 932 933 /// Returns the type of the value. 934 MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value); 935 936 /// Set the type of the value. 937 MLIR_CAPI_EXPORTED void mlirValueSetType(MlirValue value, MlirType type); 938 939 /// Prints the value to the standard error stream. 940 MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value); 941 942 /// Prints a value by sending chunks of the string representation and 943 /// forwarding `userData to `callback`. Note that the callback may be called 944 /// several times with consecutive chunks of the string. 945 MLIR_CAPI_EXPORTED void 946 mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData); 947 948 /// Prints a value as an operand (i.e., the ValueID). 949 MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value, 950 MlirAsmState state, 951 MlirStringCallback callback, 952 void *userData); 953 954 /// Returns an op operand representing the first use of the value, or a null op 955 /// operand if there are no uses. 956 MLIR_CAPI_EXPORTED MlirOpOperand mlirValueGetFirstUse(MlirValue value); 957 958 /// Replace all uses of 'of' value with the 'with' value, updating anything in 959 /// the IR that uses 'of' to use the other value instead. When this returns 960 /// there are zero uses of 'of'. 961 MLIR_CAPI_EXPORTED void mlirValueReplaceAllUsesOfWith(MlirValue of, 962 MlirValue with); 963 964 /// Replace all uses of 'of' value with 'with' value, updating anything in the 965 /// IR that uses 'of' to use 'with' instead, except if the user is listed in 966 /// 'exceptions'. The 'exceptions' parameter is an array of MlirOperation 967 /// pointers with a length of 'numExceptions'. 968 MLIR_CAPI_EXPORTED void 969 mlirValueReplaceAllUsesExcept(MlirValue of, MlirValue with, 970 intptr_t numExceptions, 971 MlirOperation *exceptions); 972 973 //===----------------------------------------------------------------------===// 974 // OpOperand API. 975 //===----------------------------------------------------------------------===// 976 977 /// Returns whether the op operand is null. 978 MLIR_CAPI_EXPORTED bool mlirOpOperandIsNull(MlirOpOperand opOperand); 979 980 /// Returns the value of an op operand. 981 MLIR_CAPI_EXPORTED MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand); 982 983 /// Returns the owner operation of an op operand. 984 MLIR_CAPI_EXPORTED MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand); 985 986 /// Returns the operand number of an op operand. 987 MLIR_CAPI_EXPORTED unsigned 988 mlirOpOperandGetOperandNumber(MlirOpOperand opOperand); 989 990 /// Returns an op operand representing the next use of the value, or a null op 991 /// operand if there is no next use. 992 MLIR_CAPI_EXPORTED MlirOpOperand 993 mlirOpOperandGetNextUse(MlirOpOperand opOperand); 994 995 //===----------------------------------------------------------------------===// 996 // Type API. 997 //===----------------------------------------------------------------------===// 998 999 /// Parses a type. The type is owned by the context. 1000 MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context, 1001 MlirStringRef type); 1002 1003 /// Gets the context that a type was created with. 1004 MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type); 1005 1006 /// Gets the type ID of the type. 1007 MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(MlirType type); 1008 1009 /// Gets the dialect a type belongs to. 1010 MLIR_CAPI_EXPORTED MlirDialect mlirTypeGetDialect(MlirType type); 1011 1012 /// Checks whether a type is null. 1013 static inline bool mlirTypeIsNull(MlirType type) { return !type.ptr; } 1014 1015 /// Checks if two types are equal. 1016 MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2); 1017 1018 /// Prints a location by sending chunks of the string representation and 1019 /// forwarding `userData to `callback`. Note that the callback may be called 1020 /// several times with consecutive chunks of the string. 1021 MLIR_CAPI_EXPORTED void 1022 mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData); 1023 1024 /// Prints the type to the standard error stream. 1025 MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type); 1026 1027 //===----------------------------------------------------------------------===// 1028 // Attribute API. 1029 //===----------------------------------------------------------------------===// 1030 1031 /// Parses an attribute. The attribute is owned by the context. 1032 MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context, 1033 MlirStringRef attr); 1034 1035 /// Gets the context that an attribute was created with. 1036 MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute); 1037 1038 /// Gets the type of this attribute. 1039 MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute); 1040 1041 /// Gets the type id of the attribute. 1042 MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(MlirAttribute attribute); 1043 1044 /// Gets the dialect of the attribute. 1045 MLIR_CAPI_EXPORTED MlirDialect mlirAttributeGetDialect(MlirAttribute attribute); 1046 1047 /// Checks whether an attribute is null. 1048 static inline bool mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; } 1049 1050 /// Checks if two attributes are equal. 1051 MLIR_CAPI_EXPORTED bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2); 1052 1053 /// Prints an attribute by sending chunks of the string representation and 1054 /// forwarding `userData to `callback`. Note that the callback may be called 1055 /// several times with consecutive chunks of the string. 1056 MLIR_CAPI_EXPORTED void mlirAttributePrint(MlirAttribute attr, 1057 MlirStringCallback callback, 1058 void *userData); 1059 1060 /// Prints the attribute to the standard error stream. 1061 MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr); 1062 1063 /// Associates an attribute with the name. Takes ownership of neither. 1064 MLIR_CAPI_EXPORTED MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name, 1065 MlirAttribute attr); 1066 1067 //===----------------------------------------------------------------------===// 1068 // Identifier API. 1069 //===----------------------------------------------------------------------===// 1070 1071 /// Gets an identifier with the given string value. 1072 MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context, 1073 MlirStringRef str); 1074 1075 /// Returns the context associated with this identifier 1076 MLIR_CAPI_EXPORTED MlirContext mlirIdentifierGetContext(MlirIdentifier); 1077 1078 /// Checks whether two identifiers are the same. 1079 MLIR_CAPI_EXPORTED bool mlirIdentifierEqual(MlirIdentifier ident, 1080 MlirIdentifier other); 1081 1082 /// Gets the string value of the identifier. 1083 MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident); 1084 1085 //===----------------------------------------------------------------------===// 1086 // Symbol and SymbolTable API. 1087 //===----------------------------------------------------------------------===// 1088 1089 /// Returns the name of the attribute used to store symbol names compatible with 1090 /// symbol tables. 1091 MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName(void); 1092 1093 /// Returns the name of the attribute used to store symbol visibility. 1094 MLIR_CAPI_EXPORTED MlirStringRef 1095 mlirSymbolTableGetVisibilityAttributeName(void); 1096 1097 /// Creates a symbol table for the given operation. If the operation does not 1098 /// have the SymbolTable trait, returns a null symbol table. 1099 MLIR_CAPI_EXPORTED MlirSymbolTable 1100 mlirSymbolTableCreate(MlirOperation operation); 1101 1102 /// Returns true if the symbol table is null. 1103 static inline bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable) { 1104 return !symbolTable.ptr; 1105 } 1106 1107 /// Destroys the symbol table created with mlirSymbolTableCreate. This does not 1108 /// affect the operations in the table. 1109 MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable); 1110 1111 /// Looks up a symbol with the given name in the given symbol table and returns 1112 /// the operation that corresponds to the symbol. If the symbol cannot be found, 1113 /// returns a null operation. 1114 MLIR_CAPI_EXPORTED MlirOperation 1115 mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name); 1116 1117 /// Inserts the given operation into the given symbol table. The operation must 1118 /// have the symbol trait. If the symbol table already has a symbol with the 1119 /// same name, renames the symbol being inserted to ensure name uniqueness. Note 1120 /// that this does not move the operation itself into the block of the symbol 1121 /// table operation, this should be done separately. Returns the name of the 1122 /// symbol after insertion. 1123 MLIR_CAPI_EXPORTED MlirAttribute 1124 mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation); 1125 1126 /// Removes the given operation from the symbol table and erases it. 1127 MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable, 1128 MlirOperation operation); 1129 1130 /// Attempt to replace all uses that are nested within the given operation 1131 /// of the given symbol 'oldSymbol' with the provided 'newSymbol'. This does 1132 /// not traverse into nested symbol tables. Will fail atomically if there are 1133 /// any unknown operations that may be potential symbol tables. 1134 MLIR_CAPI_EXPORTED MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses( 1135 MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from); 1136 1137 /// Walks all symbol table operations nested within, and including, `op`. For 1138 /// each symbol table operation, the provided callback is invoked with the op 1139 /// and a boolean signifying if the symbols within that symbol table can be 1140 /// treated as if all uses within the IR are visible to the caller. 1141 /// `allSymUsesVisible` identifies whether all of the symbol uses of symbols 1142 /// within `op` are visible. 1143 MLIR_CAPI_EXPORTED void mlirSymbolTableWalkSymbolTables( 1144 MlirOperation from, bool allSymUsesVisible, 1145 void (*callback)(MlirOperation, bool, void *userData), void *userData); 1146 1147 #ifdef __cplusplus 1148 } 1149 #endif 1150 1151 #endif // MLIR_C_IR_H 1152