MLIR  22.0.0git
IR.h
Go to the documentation of this file.
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.
77  MlirIdentifier name;
78  MlirAttribute attribute;
79 };
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.
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.
113 mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow);
114 
115 /// Returns whether the context allows unregistered dialects.
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.
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,
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.
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.
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 /// Gets the number of threads of the thread pool of the context when
166 /// multithreading is enabled. Returns 1 if no multithreading.
167 MLIR_CAPI_EXPORTED unsigned mlirContextGetNumThreads(MlirContext context);
168 
169 /// Gets the thread pool of the context when enabled multithreading, otherwise
170 /// an assertion is raised.
171 MLIR_CAPI_EXPORTED MlirLlvmThreadPool
172 mlirContextGetThreadPool(MlirContext context);
173 
174 //===----------------------------------------------------------------------===//
175 // Dialect API.
176 //===----------------------------------------------------------------------===//
177 
178 /// Returns the context that owns the dialect.
179 MLIR_CAPI_EXPORTED MlirContext mlirDialectGetContext(MlirDialect dialect);
180 
181 /// Checks if the dialect is null.
182 static inline bool mlirDialectIsNull(MlirDialect dialect) {
183  return !dialect.ptr;
184 }
185 
186 /// Checks if two dialects that belong to the same context are equal. Dialects
187 /// from different contexts will not compare equal.
188 MLIR_CAPI_EXPORTED bool mlirDialectEqual(MlirDialect dialect1,
189  MlirDialect dialect2);
190 
191 /// Returns the namespace of the given dialect.
193 
194 //===----------------------------------------------------------------------===//
195 // DialectHandle API.
196 // Registration entry-points for each dialect are declared using the common
197 // MLIR_DECLARE_DIALECT_REGISTRATION_CAPI macro, which takes the dialect
198 // API name (i.e. "Func", "Tensor", "Linalg") and namespace (i.e. "func",
199 // "tensor", "linalg"). The following declarations are produced:
200 //
201 // /// Gets the above hook methods in struct form for a dialect by namespace.
202 // /// This is intended to facilitate dynamic lookup and registration of
203 // /// dialects via a plugin facility based on shared library symbol lookup.
204 // const MlirDialectHandle *mlirGetDialectHandle__{NAMESPACE}__();
205 //
206 // This is done via a common macro to facilitate future expansion to
207 // registration schemes.
208 //===----------------------------------------------------------------------===//
209 
211  const void *ptr;
212 };
213 typedef struct MlirDialectHandle MlirDialectHandle;
214 
215 #define MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(Name, Namespace) \
216  MLIR_CAPI_EXPORTED MlirDialectHandle mlirGetDialectHandle__##Namespace##__( \
217  void)
218 
219 /// Returns the namespace associated with the provided dialect handle.
222 
223 /// Inserts the dialect associated with the provided dialect handle into the
224 /// provided dialect registry
226  MlirDialectRegistry);
227 
228 /// Registers the dialect associated with the provided dialect handle.
230  MlirContext);
231 
232 /// Loads the dialect associated with the provided dialect handle.
234  MlirContext);
235 
236 //===----------------------------------------------------------------------===//
237 // DialectRegistry API.
238 //===----------------------------------------------------------------------===//
239 
240 /// Creates a dialect registry and transfers its ownership to the caller.
241 MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate(void);
242 
243 /// Checks if the dialect registry is null.
244 static inline bool mlirDialectRegistryIsNull(MlirDialectRegistry registry) {
245  return !registry.ptr;
246 }
247 
248 /// Takes a dialect registry owned by the caller and destroys it.
250 mlirDialectRegistryDestroy(MlirDialectRegistry registry);
251 
252 //===----------------------------------------------------------------------===//
253 // Location API.
254 //===----------------------------------------------------------------------===//
255 
256 /// Returns the underlying location attribute of this location.
257 MLIR_CAPI_EXPORTED MlirAttribute
258 mlirLocationGetAttribute(MlirLocation location);
259 
260 /// Creates a location from a location attribute.
261 MLIR_CAPI_EXPORTED MlirLocation
262 mlirLocationFromAttribute(MlirAttribute attribute);
263 
264 /// Creates an File/Line/Column location owned by the given context.
266  MlirContext context, MlirStringRef filename, unsigned line, unsigned col);
267 
268 /// Creates an File/Line/Column range location owned by the given context.
270  MlirContext context, MlirStringRef filename, unsigned start_line,
271  unsigned start_col, unsigned end_line, unsigned end_col);
272 
273 /// Getter for filename of FileLineColRange.
274 MLIR_CAPI_EXPORTED MlirIdentifier
275 mlirLocationFileLineColRangeGetFilename(MlirLocation location);
276 
277 /// Getter for start_line of FileLineColRange.
279 mlirLocationFileLineColRangeGetStartLine(MlirLocation location);
280 
281 /// Getter for start_column of FileLineColRange.
283 mlirLocationFileLineColRangeGetStartColumn(MlirLocation location);
284 
285 /// Getter for end_line of FileLineColRange.
287 mlirLocationFileLineColRangeGetEndLine(MlirLocation location);
288 
289 /// Getter for end_column of FileLineColRange.
291 mlirLocationFileLineColRangeGetEndColumn(MlirLocation location);
292 
293 /// TypeID Getter for FileLineColRange.
295 
296 /// Checks whether the given location is an FileLineColRange.
297 MLIR_CAPI_EXPORTED bool mlirLocationIsAFileLineColRange(MlirLocation location);
298 
299 /// Creates a call site location with a callee and a caller.
300 MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee,
301  MlirLocation caller);
302 
303 /// Getter for callee of CallSite.
304 MLIR_CAPI_EXPORTED MlirLocation
305 mlirLocationCallSiteGetCallee(MlirLocation location);
306 
307 /// Getter for caller of CallSite.
308 MLIR_CAPI_EXPORTED MlirLocation
309 mlirLocationCallSiteGetCaller(MlirLocation location);
310 
311 /// TypeID Getter for CallSite.
313 
314 /// Checks whether the given location is an CallSite.
315 MLIR_CAPI_EXPORTED bool mlirLocationIsACallSite(MlirLocation location);
316 
317 /// Creates a fused location with an array of locations and metadata.
318 MLIR_CAPI_EXPORTED MlirLocation
319 mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations,
320  MlirLocation const *locations, MlirAttribute metadata);
321 
322 /// Getter for number of locations fused together.
323 MLIR_CAPI_EXPORTED unsigned
324 mlirLocationFusedGetNumLocations(MlirLocation location);
325 
326 /// Getter for locations of Fused. Requires pre-allocated memory of
327 /// #fusedLocations X sizeof(MlirLocation).
329 mlirLocationFusedGetLocations(MlirLocation location,
330  MlirLocation *locationsCPtr);
331 
332 /// Getter for metadata of Fused.
333 MLIR_CAPI_EXPORTED MlirAttribute
334 mlirLocationFusedGetMetadata(MlirLocation location);
335 
336 /// TypeID Getter for Fused.
338 
339 /// Checks whether the given location is an Fused.
340 MLIR_CAPI_EXPORTED bool mlirLocationIsAFused(MlirLocation location);
341 
342 /// Creates a name location owned by the given context. Providing null location
343 /// for childLoc is allowed and if childLoc is null location, then the behavior
344 /// is the same as having unknown child location.
345 MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context,
346  MlirStringRef name,
347  MlirLocation childLoc);
348 
349 /// Getter for name of Name.
350 MLIR_CAPI_EXPORTED MlirIdentifier
351 mlirLocationNameGetName(MlirLocation location);
352 
353 /// Getter for childLoc of Name.
354 MLIR_CAPI_EXPORTED MlirLocation
355 mlirLocationNameGetChildLoc(MlirLocation location);
356 
357 /// TypeID Getter for Name.
359 
360 /// Checks whether the given location is an Name.
361 MLIR_CAPI_EXPORTED bool mlirLocationIsAName(MlirLocation location);
362 
363 /// Creates a location with unknown position owned by the given context.
364 MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context);
365 
366 /// Gets the context that a location was created with.
367 MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location);
368 
369 /// Checks if the location is null.
370 static inline bool mlirLocationIsNull(MlirLocation location) {
371  return !location.ptr;
372 }
373 
374 /// Checks if two locations are equal.
375 MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2);
376 
377 /// Prints a location by sending chunks of the string representation and
378 /// forwarding `userData to `callback`. Note that the callback may be called
379 /// several times with consecutive chunks of the string.
380 MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location,
381  MlirStringCallback callback,
382  void *userData);
383 
384 //===----------------------------------------------------------------------===//
385 // Module API.
386 //===----------------------------------------------------------------------===//
387 
388 /// Creates a new, empty module and transfers ownership to the caller.
389 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location);
390 
391 /// Parses a module from the string and transfers ownership to the caller.
392 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context,
393  MlirStringRef module);
394 
395 /// Parses a module from file and transfers ownership to the caller.
396 MLIR_CAPI_EXPORTED MlirModule
397 mlirModuleCreateParseFromFile(MlirContext context, MlirStringRef fileName);
398 
399 /// Gets the context that a module was created with.
400 MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module);
401 
402 /// Gets the body of the module, i.e. the only block it contains.
403 MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module);
404 
405 /// Checks whether a module is null.
406 static inline bool mlirModuleIsNull(MlirModule module) { return !module.ptr; }
407 
408 /// Takes a module owned by the caller and deletes it.
409 MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module);
410 
411 /// Views the module as a generic operation.
412 MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module);
413 
414 /// Views the generic operation as a module.
415 /// The returned module is null when the input operation was not a ModuleOp.
416 MLIR_CAPI_EXPORTED MlirModule mlirModuleFromOperation(MlirOperation op);
417 
418 /// Checks if two modules are equal.
419 MLIR_CAPI_EXPORTED bool mlirModuleEqual(MlirModule lhs, MlirModule rhs);
420 
421 /// Compute a hash for the given module.
423 
424 //===----------------------------------------------------------------------===//
425 // Operation state.
426 //===----------------------------------------------------------------------===//
427 
428 /// An auxiliary class for constructing operations.
429 ///
430 /// This class contains all the information necessary to construct the
431 /// operation. It owns the MlirRegions it has pointers to and does not own
432 /// anything else. By default, the state can be constructed from a name and
433 /// location, the latter being also used to access the context, and has no other
434 /// components. These components can be added progressively until the operation
435 /// is constructed. Users are not expected to rely on the internals of this
436 /// class and should use mlirOperationState* functions instead.
437 
440  MlirLocation location;
441  intptr_t nResults;
442  MlirType *results;
443  intptr_t nOperands;
444  MlirValue *operands;
445  intptr_t nRegions;
446  MlirRegion *regions;
447  intptr_t nSuccessors;
448  MlirBlock *successors;
449  intptr_t nAttributes;
452 };
454 
455 /// Constructs an operation state from a name and a location.
457  MlirLocation loc);
458 
459 /// Adds a list of components to the operation state.
461  intptr_t n,
462  MlirType const *results);
465  MlirValue const *operands);
468  MlirRegion const *regions);
471  MlirBlock const *successors);
475 
476 /// Enables result type inference for the operation under construction. If
477 /// enabled, then the caller must not have called
478 /// mlirOperationStateAddResults(). Note that if enabled, the
479 /// mlirOperationCreate() call is failable: it will return a null operation
480 /// on inference failure and will emit diagnostics.
483 
484 //===----------------------------------------------------------------------===//
485 // AsmState API.
486 // While many of these are simple settings that could be represented in a
487 // struct, they are wrapped in a heap allocated object and accessed via
488 // functions to maximize the possibility of compatibility over time.
489 //===----------------------------------------------------------------------===//
490 
491 /// Creates new AsmState, as with AsmState the IR should not be mutated
492 /// in-between using this state.
493 /// Must be freed with a call to mlirAsmStateDestroy().
494 // TODO: This should be expanded to handle location & resouce map.
495 MLIR_CAPI_EXPORTED MlirAsmState
496 mlirAsmStateCreateForOperation(MlirOperation op, MlirOpPrintingFlags flags);
497 
498 /// Creates new AsmState from value.
499 /// Must be freed with a call to mlirAsmStateDestroy().
500 // TODO: This should be expanded to handle location & resouce map.
501 MLIR_CAPI_EXPORTED MlirAsmState
502 mlirAsmStateCreateForValue(MlirValue value, MlirOpPrintingFlags flags);
503 
504 /// Destroys printing flags created with mlirAsmStateCreate.
505 MLIR_CAPI_EXPORTED void mlirAsmStateDestroy(MlirAsmState state);
506 
507 //===----------------------------------------------------------------------===//
508 // Op Printing flags API.
509 // While many of these are simple settings that could be represented in a
510 // struct, they are wrapped in a heap allocated object and accessed via
511 // functions to maximize the possibility of compatibility over time.
512 //===----------------------------------------------------------------------===//
513 
514 /// Creates new printing flags with defaults, intended for customization.
515 /// Must be freed with a call to mlirOpPrintingFlagsDestroy().
516 MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void);
517 
518 /// Destroys printing flags created with mlirOpPrintingFlagsCreate.
519 MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags);
520 
521 /// Enables the elision of large elements attributes by printing a lexically
522 /// valid but otherwise meaningless form instead of the element data. The
523 /// `largeElementLimit` is used to configure what is considered to be a "large"
524 /// ElementsAttr by providing an upper limit to the number of elements.
526 mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
527  intptr_t largeElementLimit);
528 
529 /// Enables the elision of large resources strings by omitting them from the
530 /// `dialect_resources` section. The `largeResourceLimit` is used to configure
531 /// what is considered to be a "large" resource by providing an upper limit to
532 /// the string size.
534 mlirOpPrintingFlagsElideLargeResourceString(MlirOpPrintingFlags flags,
535  intptr_t largeResourceLimit);
536 
537 /// Enable or disable printing of debug information (based on `enable`). If
538 /// 'prettyForm' is set to true, debug information is printed in a more readable
539 /// 'pretty' form. Note: The IR generated with 'prettyForm' is not parsable.
541 mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable,
542  bool prettyForm);
543 
544 /// Always print operations in the generic form.
546 mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags);
547 
548 /// Print the name and location, if NamedLoc, as a prefix to the SSA ID.
550 mlirOpPrintingFlagsPrintNameLocAsPrefix(MlirOpPrintingFlags flags);
551 
552 /// Use local scope when printing the operation. This allows for using the
553 /// printer in a more localized and thread-safe setting, but may not
554 /// necessarily be identical to what the IR will look like when dumping
555 /// the full module.
557 mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags);
558 
559 /// Do not verify the operation when using custom operation printers.
561 mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags);
562 
563 /// Skip printing regions.
565 mlirOpPrintingFlagsSkipRegions(MlirOpPrintingFlags flags);
566 
567 //===----------------------------------------------------------------------===//
568 // Bytecode printing flags API.
569 //===----------------------------------------------------------------------===//
570 
571 /// Creates new printing flags with defaults, intended for customization.
572 /// Must be freed with a call to mlirBytecodeWriterConfigDestroy().
573 MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig
575 
576 /// Destroys printing flags created with mlirBytecodeWriterConfigCreate.
578 mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config);
579 
580 /// Sets the version to emit in the writer config.
582 mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags,
583  int64_t version);
584 
585 //===----------------------------------------------------------------------===//
586 // Operation API.
587 //===----------------------------------------------------------------------===//
588 
589 /// Creates an operation and transfers ownership to the caller.
590 /// Note that caller owned child objects are transferred in this call and must
591 /// not be further used. Particularly, this applies to any regions added to
592 /// the state (the implementation may invalidate any such pointers).
593 ///
594 /// This call can fail under the following conditions, in which case, it will
595 /// return a null operation and emit diagnostics:
596 /// - Result type inference is enabled and cannot be performed.
598 
599 /// Parses an operation, giving ownership to the caller. If parsing fails a null
600 /// operation will be returned, and an error diagnostic emitted.
601 ///
602 /// `sourceStr` may be either the text assembly format, or binary bytecode
603 /// format. `sourceName` is used as the file name of the source; any IR without
604 /// locations will get a `FileLineColLoc` location with `sourceName` as the file
605 /// name.
607  MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName);
608 
609 /// Creates a deep copy of an operation. The operation is not inserted and
610 /// ownership is transferred to the caller.
611 MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op);
612 
613 /// Takes an operation owned by the caller and destroys it.
614 MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op);
615 
616 /// Removes the given operation from its parent block. The operation is not
617 /// destroyed. The ownership of the operation is transferred to the caller.
619 
620 /// Checks whether the underlying operation is null.
621 static inline bool mlirOperationIsNull(MlirOperation op) { return !op.ptr; }
622 
623 /// Checks whether two operation handles point to the same operation. This does
624 /// not perform deep comparison.
625 MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op,
626  MlirOperation other);
627 
628 /// Compute a hash for the given operation.
629 MLIR_CAPI_EXPORTED size_t mlirOperationHashValue(MlirOperation op);
630 
631 /// Gets the context this operation is associated with
632 MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op);
633 
634 /// Gets the location of the operation.
635 MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op);
636 
637 /// Gets the type id of the operation.
638 /// Returns null if the operation does not have a registered operation
639 /// description.
640 MLIR_CAPI_EXPORTED MlirTypeID mlirOperationGetTypeID(MlirOperation op);
641 
642 /// Gets the name of the operation as an identifier.
643 MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op);
644 
645 /// Gets the block that owns this operation, returning null if the operation is
646 /// not owned.
647 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op);
648 
649 /// Gets the operation that owns this operation, returning null if the operation
650 /// is not owned.
651 MLIR_CAPI_EXPORTED MlirOperation
652 mlirOperationGetParentOperation(MlirOperation op);
653 
654 /// Returns the number of regions attached to the given operation.
655 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op);
656 
657 /// Returns `pos`-th region attached to the operation.
658 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op,
659  intptr_t pos);
660 
661 /// Returns an operation immediately following the given operation it its
662 /// enclosing block.
663 MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op);
664 
665 /// Returns the number of operands of the operation.
666 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op);
667 
668 /// Returns `pos`-th operand of the operation.
669 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op,
670  intptr_t pos);
671 
672 /// Sets the `pos`-th operand of the operation.
673 MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
674  MlirValue newValue);
675 
676 /// Replaces the operands of the operation.
677 MLIR_CAPI_EXPORTED void mlirOperationSetOperands(MlirOperation op,
678  intptr_t nOperands,
679  MlirValue const *operands);
680 
681 /// Returns the number of results of the operation.
682 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op);
683 
684 /// Returns `pos`-th result of the operation.
685 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op,
686  intptr_t pos);
687 
688 /// Returns the number of successor blocks of the operation.
689 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op);
690 
691 /// Returns `pos`-th successor of the operation.
692 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op,
693  intptr_t pos);
694 
695 /// Set `pos`-th successor of the operation.
697 mlirOperationSetSuccessor(MlirOperation op, intptr_t pos, MlirBlock block);
698 
699 /// Returns true if this operation defines an inherent attribute with this name.
700 /// Note: the attribute can be optional, so
701 /// `mlirOperationGetInherentAttributeByName` can still return a null attribute.
704 
705 /// Returns an inherent attribute attached to the operation given its name.
706 MLIR_CAPI_EXPORTED MlirAttribute
708 
709 /// Sets an inherent attribute by name, replacing the existing if it exists.
710 /// This has no effect if "name" does not match an inherent attribute.
713  MlirAttribute attr);
714 
715 /// Returns the number of discardable attributes attached to the operation.
716 MLIR_CAPI_EXPORTED intptr_t
718 
719 /// Return `pos`-th discardable attribute of the operation.
721 mlirOperationGetDiscardableAttribute(MlirOperation op, intptr_t pos);
722 
723 /// Returns a discardable attribute attached to the operation given its name.
725  MlirOperation op, MlirStringRef name);
726 
727 /// Sets a discardable attribute by name, replacing the existing if it exists or
728 /// adding a new one otherwise. The new `attr` Attribute is not allowed to be
729 /// null, use `mlirOperationRemoveDiscardableAttributeByName` to remove an
730 /// Attribute instead.
733  MlirAttribute attr);
734 
735 /// Removes a discardable attribute by name. Returns false if the attribute was
736 /// not found and true if removed.
740 
741 /// Returns the number of attributes attached to the operation.
742 /// Deprecated, please use `mlirOperationGetNumInherentAttributes` or
743 /// `mlirOperationGetNumDiscardableAttributes`.
744 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op);
745 
746 /// Return `pos`-th attribute of the operation.
747 /// Deprecated, please use `mlirOperationGetInherentAttribute` or
748 /// `mlirOperationGetDiscardableAttribute`.
750 mlirOperationGetAttribute(MlirOperation op, intptr_t pos);
751 
752 /// Returns an attribute attached to the operation given its name.
753 /// Deprecated, please use `mlirOperationGetInherentAttributeByName` or
754 /// `mlirOperationGetDiscardableAttributeByName`.
755 MLIR_CAPI_EXPORTED MlirAttribute
757 
758 /// Sets an attribute by name, replacing the existing if it exists or
759 /// adding a new one otherwise.
760 /// Deprecated, please use `mlirOperationSetInherentAttributeByName` or
761 /// `mlirOperationSetDiscardableAttributeByName`.
764  MlirAttribute attr);
765 
766 /// Removes an attribute by name. Returns false if the attribute was not found
767 /// and true if removed.
768 /// Deprecated, please use `mlirOperationRemoveInherentAttributeByName` or
769 /// `mlirOperationRemoveDiscardableAttributeByName`.
772 
773 /// Prints an operation by sending chunks of the string representation and
774 /// forwarding `userData to `callback`. Note that the callback may be called
775 /// several times with consecutive chunks of the string.
776 MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op,
777  MlirStringCallback callback,
778  void *userData);
779 
780 /// Same as mlirOperationPrint but accepts flags controlling the printing
781 /// behavior.
782 MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op,
783  MlirOpPrintingFlags flags,
784  MlirStringCallback callback,
785  void *userData);
786 
787 /// Same as mlirOperationPrint but accepts AsmState controlling the printing
788 /// behavior as well as caching computed names.
789 MLIR_CAPI_EXPORTED void mlirOperationPrintWithState(MlirOperation op,
790  MlirAsmState state,
791  MlirStringCallback callback,
792  void *userData);
793 
794 /// Same as mlirOperationPrint but writing the bytecode format.
795 MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op,
796  MlirStringCallback callback,
797  void *userData);
798 
799 /// Same as mlirOperationWriteBytecode but with writer config and returns
800 /// failure only if desired bytecode could not be honored.
802  MlirOperation op, MlirBytecodeWriterConfig config,
803  MlirStringCallback callback, void *userData);
804 
805 /// Prints an operation to stderr.
806 MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op);
807 
808 /// Verify the operation and return true if it passes, false if it fails.
809 MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op);
810 
811 /// Moves the given operation immediately after the other operation in its
812 /// parent block. The given operation may be owned by the caller or by its
813 /// current block. The other operation must belong to a block. In any case, the
814 /// ownership is transferred to the block of the other operation.
815 MLIR_CAPI_EXPORTED void mlirOperationMoveAfter(MlirOperation op,
816  MlirOperation other);
817 
818 /// Moves the given operation immediately before the other operation in its
819 /// parent block. The given operation may be owner by the caller or by its
820 /// current block. The other operation must belong to a block. In any case, the
821 /// ownership is transferred to the block of the other operation.
822 MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op,
823  MlirOperation other);
824 
825 /// Given an operation 'other' that is within the same parent block, return
826 /// whether the current operation is before 'other' in the operation list
827 /// of the parent block.
828 /// Note: This function has an average complexity of O(1), but worst case may
829 /// take O(N) where N is the number of operations within the parent block.
831  MlirOperation other);
832 /// Operation walk result.
833 typedef enum MlirWalkResult {
838 
839 /// Traversal order for operation walk.
840 typedef enum MlirWalkOrder {
844 
845 /// Operation walker type. The handler is passed an (opaque) reference to an
846 /// operation and a pointer to a `userData`.
847 typedef MlirWalkResult (*MlirOperationWalkCallback)(MlirOperation,
848  void *userData);
849 
850 /// Walks operation `op` in `walkOrder` and calls `callback` on that operation.
851 /// `*userData` is passed to the callback as well and can be used to tunnel some
852 /// context or other data into the callback.
854 void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback,
855  void *userData, MlirWalkOrder walkOrder);
856 
857 //===----------------------------------------------------------------------===//
858 // Region API.
859 //===----------------------------------------------------------------------===//
860 
861 /// Creates a new empty region and transfers ownership to the caller.
862 MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void);
863 
864 /// Takes a region owned by the caller and destroys it.
865 MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region);
866 
867 /// Checks whether a region is null.
868 static inline bool mlirRegionIsNull(MlirRegion region) { return !region.ptr; }
869 
870 /// Checks whether two region handles point to the same region. This does not
871 /// perform deep comparison.
872 MLIR_CAPI_EXPORTED bool mlirRegionEqual(MlirRegion region, MlirRegion other);
873 
874 /// Gets the first block in the region.
875 MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region);
876 
877 /// Takes a block owned by the caller and appends it to the given region.
878 MLIR_CAPI_EXPORTED void mlirRegionAppendOwnedBlock(MlirRegion region,
879  MlirBlock block);
880 
881 /// Takes a block owned by the caller and inserts it at `pos` to the given
882 /// region. This is an expensive operation that linearly scans the region,
883 /// prefer insertAfter/Before instead.
885 mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block);
886 
887 /// Takes a block owned by the caller and inserts it after the (non-owned)
888 /// reference block in the given region. The reference block must belong to the
889 /// region. If the reference block is null, prepends the block to the region.
891  MlirBlock reference,
892  MlirBlock block);
893 
894 /// Takes a block owned by the caller and inserts it before the (non-owned)
895 /// reference block in the given region. The reference block must belong to the
896 /// region. If the reference block is null, appends the block to the region.
898  MlirBlock reference,
899  MlirBlock block);
900 
901 /// Returns first region attached to the operation.
902 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op);
903 
904 /// Returns the region immediately following the given region in its parent
905 /// operation.
906 MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region);
907 
908 /// Moves the entire content of the source region to the target region.
909 MLIR_CAPI_EXPORTED void mlirRegionTakeBody(MlirRegion target,
910  MlirRegion source);
911 
912 //===----------------------------------------------------------------------===//
913 // Block API.
914 //===----------------------------------------------------------------------===//
915 
916 /// Creates a new empty block with the given argument types and transfers
917 /// ownership to the caller.
918 MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs,
919  MlirType const *args,
920  MlirLocation const *locs);
921 
922 /// Takes a block owned by the caller and destroys it.
923 MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block);
924 
925 /// Detach a block from the owning region and assume ownership.
926 MLIR_CAPI_EXPORTED void mlirBlockDetach(MlirBlock block);
927 
928 /// Checks whether a block is null.
929 static inline bool mlirBlockIsNull(MlirBlock block) { return !block.ptr; }
930 
931 /// Checks whether two blocks handles point to the same block. This does not
932 /// perform deep comparison.
933 MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other);
934 
935 /// Returns the closest surrounding operation that contains this block.
936 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock);
937 
938 /// Returns the region that contains this block.
939 MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block);
940 
941 /// Returns the block immediately following the given block in its parent
942 /// region.
943 MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block);
944 
945 /// Returns the first operation in the block.
946 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block);
947 
948 /// Returns the terminator operation in the block or null if no terminator.
949 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block);
950 
951 /// Takes an operation owned by the caller and appends it to the block.
953  MlirOperation operation);
954 
955 /// Takes an operation owned by the caller and inserts it as `pos` to the block.
956 /// This is an expensive operation that scans the block linearly, prefer
957 /// insertBefore/After instead.
959  intptr_t pos,
960  MlirOperation operation);
961 
962 /// Takes an operation owned by the caller and inserts it after the (non-owned)
963 /// reference operation in the given block. If the reference is null, prepends
964 /// the operation. Otherwise, the reference must belong to the block.
966 mlirBlockInsertOwnedOperationAfter(MlirBlock block, MlirOperation reference,
967  MlirOperation operation);
968 
969 /// Takes an operation owned by the caller and inserts it before the (non-owned)
970 /// reference operation in the given block. If the reference is null, appends
971 /// the operation. Otherwise, the reference must belong to the block.
973 mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference,
974  MlirOperation operation);
975 
976 /// Returns the number of arguments of the block.
977 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block);
978 
979 /// Appends an argument of the specified type to the block. Returns the newly
980 /// added argument.
981 MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block,
982  MlirType type,
983  MlirLocation loc);
984 
985 /// Erase the argument at 'index' and remove it from the argument list.
986 MLIR_CAPI_EXPORTED void mlirBlockEraseArgument(MlirBlock block, unsigned index);
987 
988 /// Inserts an argument of the specified type at a specified index to the block.
989 /// Returns the newly added argument.
990 MLIR_CAPI_EXPORTED MlirValue mlirBlockInsertArgument(MlirBlock block,
991  intptr_t pos,
992  MlirType type,
993  MlirLocation loc);
994 
995 /// Returns `pos`-th argument of the block.
996 MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block,
997  intptr_t pos);
998 
999 /// Prints a block by sending chunks of the string representation and
1000 /// forwarding `userData to `callback`. Note that the callback may be called
1001 /// several times with consecutive chunks of the string.
1002 MLIR_CAPI_EXPORTED void
1003 mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData);
1004 
1005 /// Returns the number of successor blocks of the block.
1006 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumSuccessors(MlirBlock block);
1007 
1008 /// Returns `pos`-th successor of the block.
1009 MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetSuccessor(MlirBlock block,
1010  intptr_t pos);
1011 
1012 /// Returns the number of predecessor blocks of the block.
1013 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumPredecessors(MlirBlock block);
1014 
1015 /// Returns `pos`-th predecessor of the block.
1016 ///
1017 /// WARNING: This getter is more expensive than the others here because
1018 /// the impl actually iterates the use-def chain (of block operands) anew for
1019 /// each indexed access.
1020 MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetPredecessor(MlirBlock block,
1021  intptr_t pos);
1022 
1023 //===----------------------------------------------------------------------===//
1024 // Value API.
1025 //===----------------------------------------------------------------------===//
1026 
1027 /// Returns whether the value is null.
1028 static inline bool mlirValueIsNull(MlirValue value) { return !value.ptr; }
1029 
1030 /// Returns 1 if two values are equal, 0 otherwise.
1031 MLIR_CAPI_EXPORTED bool mlirValueEqual(MlirValue value1, MlirValue value2);
1032 
1033 /// Returns 1 if the value is a block argument, 0 otherwise.
1034 MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value);
1035 
1036 /// Returns 1 if the value is an operation result, 0 otherwise.
1037 MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value);
1038 
1039 /// Returns the block in which this value is defined as an argument. Asserts if
1040 /// the value is not a block argument.
1041 MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value);
1042 
1043 /// Returns the position of the value in the argument list of its block.
1044 MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value);
1045 
1046 /// Sets the type of the block argument to the given type.
1047 MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value,
1048  MlirType type);
1049 
1050 /// Returns an operation that produced this value as its result. Asserts if the
1051 /// value is not an op result.
1052 MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value);
1053 
1054 /// Returns the position of the value in the list of results of the operation
1055 /// that produced it.
1056 MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value);
1057 
1058 /// Returns the type of the value.
1059 MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value);
1060 
1061 /// Set the type of the value.
1062 MLIR_CAPI_EXPORTED void mlirValueSetType(MlirValue value, MlirType type);
1063 
1064 /// Prints the value to the standard error stream.
1065 MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value);
1066 
1067 /// Prints a value by sending chunks of the string representation and
1068 /// forwarding `userData to `callback`. Note that the callback may be called
1069 /// several times with consecutive chunks of the string.
1070 MLIR_CAPI_EXPORTED void
1071 mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData);
1072 
1073 /// Prints a value as an operand (i.e., the ValueID).
1074 MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value,
1075  MlirAsmState state,
1076  MlirStringCallback callback,
1077  void *userData);
1078 
1079 /// Returns an op operand representing the first use of the value, or a null op
1080 /// operand if there are no uses.
1081 MLIR_CAPI_EXPORTED MlirOpOperand mlirValueGetFirstUse(MlirValue value);
1082 
1083 /// Replace all uses of 'of' value with the 'with' value, updating anything in
1084 /// the IR that uses 'of' to use the other value instead. When this returns
1085 /// there are zero uses of 'of'.
1087  MlirValue with);
1088 
1089 /// Replace all uses of 'of' value with 'with' value, updating anything in the
1090 /// IR that uses 'of' to use 'with' instead, except if the user is listed in
1091 /// 'exceptions'. The 'exceptions' parameter is an array of MlirOperation
1092 /// pointers with a length of 'numExceptions'.
1093 MLIR_CAPI_EXPORTED void
1094 mlirValueReplaceAllUsesExcept(MlirValue of, MlirValue with,
1095  intptr_t numExceptions,
1096  MlirOperation *exceptions);
1097 
1098 /// Gets the location of the value.
1099 MLIR_CAPI_EXPORTED MlirLocation mlirValueGetLocation(MlirValue v);
1100 
1101 /// Gets the context that a value was created with.
1102 MLIR_CAPI_EXPORTED MlirContext mlirValueGetContext(MlirValue v);
1103 
1104 //===----------------------------------------------------------------------===//
1105 // OpOperand API.
1106 //===----------------------------------------------------------------------===//
1107 
1108 /// Returns whether the op operand is null.
1109 MLIR_CAPI_EXPORTED bool mlirOpOperandIsNull(MlirOpOperand opOperand);
1110 
1111 /// Returns the value of an op operand.
1112 MLIR_CAPI_EXPORTED MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand);
1113 
1114 /// Returns the owner operation of an op operand.
1115 MLIR_CAPI_EXPORTED MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand);
1116 
1117 /// Returns the operand number of an op operand.
1118 MLIR_CAPI_EXPORTED unsigned
1119 mlirOpOperandGetOperandNumber(MlirOpOperand opOperand);
1120 
1121 /// Returns an op operand representing the next use of the value, or a null op
1122 /// operand if there is no next use.
1123 MLIR_CAPI_EXPORTED MlirOpOperand
1124 mlirOpOperandGetNextUse(MlirOpOperand opOperand);
1125 
1126 //===----------------------------------------------------------------------===//
1127 // Type API.
1128 //===----------------------------------------------------------------------===//
1129 
1130 /// Parses a type. The type is owned by the context.
1131 MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context,
1132  MlirStringRef type);
1133 
1134 /// Gets the context that a type was created with.
1135 MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type);
1136 
1137 /// Gets the type ID of the type.
1138 MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(MlirType type);
1139 
1140 /// Gets the dialect a type belongs to.
1141 MLIR_CAPI_EXPORTED MlirDialect mlirTypeGetDialect(MlirType type);
1142 
1143 /// Checks whether a type is null.
1144 static inline bool mlirTypeIsNull(MlirType type) { return !type.ptr; }
1145 
1146 /// Checks if two types are equal.
1147 MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2);
1148 
1149 /// Prints a location by sending chunks of the string representation and
1150 /// forwarding `userData to `callback`. Note that the callback may be called
1151 /// several times with consecutive chunks of the string.
1152 MLIR_CAPI_EXPORTED void
1153 mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData);
1154 
1155 /// Prints the type to the standard error stream.
1156 MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type);
1157 
1158 //===----------------------------------------------------------------------===//
1159 // Attribute API.
1160 //===----------------------------------------------------------------------===//
1161 
1162 /// Parses an attribute. The attribute is owned by the context.
1163 MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context,
1164  MlirStringRef attr);
1165 
1166 /// Gets the context that an attribute was created with.
1167 MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute);
1168 
1169 /// Gets the type of this attribute.
1170 MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute);
1171 
1172 /// Gets the type id of the attribute.
1173 MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(MlirAttribute attribute);
1174 
1175 /// Gets the dialect of the attribute.
1176 MLIR_CAPI_EXPORTED MlirDialect mlirAttributeGetDialect(MlirAttribute attribute);
1177 
1178 /// Checks whether an attribute is null.
1179 static inline bool mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; }
1180 
1181 /// Checks if two attributes are equal.
1182 MLIR_CAPI_EXPORTED bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
1183 
1184 /// Prints an attribute by sending chunks of the string representation and
1185 /// forwarding `userData to `callback`. Note that the callback may be called
1186 /// several times with consecutive chunks of the string.
1187 MLIR_CAPI_EXPORTED void mlirAttributePrint(MlirAttribute attr,
1188  MlirStringCallback callback,
1189  void *userData);
1190 
1191 /// Prints the attribute to the standard error stream.
1192 MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr);
1193 
1194 /// Associates an attribute with the name. Takes ownership of neither.
1196  MlirAttribute attr);
1197 
1198 //===----------------------------------------------------------------------===//
1199 // Identifier API.
1200 //===----------------------------------------------------------------------===//
1201 
1202 /// Gets an identifier with the given string value.
1203 MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context,
1204  MlirStringRef str);
1205 
1206 /// Returns the context associated with this identifier
1207 MLIR_CAPI_EXPORTED MlirContext mlirIdentifierGetContext(MlirIdentifier);
1208 
1209 /// Checks whether two identifiers are the same.
1210 MLIR_CAPI_EXPORTED bool mlirIdentifierEqual(MlirIdentifier ident,
1211  MlirIdentifier other);
1212 
1213 /// Gets the string value of the identifier.
1214 MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident);
1215 
1216 //===----------------------------------------------------------------------===//
1217 // Symbol and SymbolTable API.
1218 //===----------------------------------------------------------------------===//
1219 
1220 /// Returns the name of the attribute used to store symbol names compatible with
1221 /// symbol tables.
1223 
1224 /// Returns the name of the attribute used to store symbol visibility.
1227 
1228 /// Creates a symbol table for the given operation. If the operation does not
1229 /// have the SymbolTable trait, returns a null symbol table.
1230 MLIR_CAPI_EXPORTED MlirSymbolTable
1231 mlirSymbolTableCreate(MlirOperation operation);
1232 
1233 /// Returns true if the symbol table is null.
1234 static inline bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable) {
1235  return !symbolTable.ptr;
1236 }
1237 
1238 /// Destroys the symbol table created with mlirSymbolTableCreate. This does not
1239 /// affect the operations in the table.
1240 MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable);
1241 
1242 /// Looks up a symbol with the given name in the given symbol table and returns
1243 /// the operation that corresponds to the symbol. If the symbol cannot be found,
1244 /// returns a null operation.
1245 MLIR_CAPI_EXPORTED MlirOperation
1246 mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name);
1247 
1248 /// Inserts the given operation into the given symbol table. The operation must
1249 /// have the symbol trait. If the symbol table already has a symbol with the
1250 /// same name, renames the symbol being inserted to ensure name uniqueness. Note
1251 /// that this does not move the operation itself into the block of the symbol
1252 /// table operation, this should be done separately. Returns the name of the
1253 /// symbol after insertion.
1254 MLIR_CAPI_EXPORTED MlirAttribute
1255 mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation);
1256 
1257 /// Removes the given operation from the symbol table and erases it.
1258 MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable,
1259  MlirOperation operation);
1260 
1261 /// Attempt to replace all uses that are nested within the given operation
1262 /// of the given symbol 'oldSymbol' with the provided 'newSymbol'. This does
1263 /// not traverse into nested symbol tables. Will fail atomically if there are
1264 /// any unknown operations that may be potential symbol tables.
1266  MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from);
1267 
1268 /// Walks all symbol table operations nested within, and including, `op`. For
1269 /// each symbol table operation, the provided callback is invoked with the op
1270 /// and a boolean signifying if the symbols within that symbol table can be
1271 /// treated as if all uses within the IR are visible to the caller.
1272 /// `allSymUsesVisible` identifies whether all of the symbol uses of symbols
1273 /// within `op` are visible.
1275  MlirOperation from, bool allSymUsesVisible,
1276  void (*callback)(MlirOperation, bool, void *userData), void *userData);
1277 
1278 #ifdef __cplusplus
1279 }
1280 #endif
1281 
1282 #endif // MLIR_C_IR_H
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumDiscardableAttributes(MlirOperation op)
Returns the number of discardable attributes attached to the operation.
Definition: IR.cpp:761
MLIR_CAPI_EXPORTED MlirAttribute mlirLocationGetAttribute(MlirLocation location)
Returns the underlying location attribute of this location.
Definition: IR.cpp:265
MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value)
Returns the position of the value in the argument list of its block.
Definition: IR.cpp:1118
static bool mlirAttributeIsNull(MlirAttribute attr)
Checks whether an attribute is null.
Definition: IR.h:1179
MlirWalkResult(* MlirOperationWalkCallback)(MlirOperation, void *userData)
Operation walker type.
Definition: IR.h:847
MLIR_CAPI_EXPORTED MlirLocation mlirValueGetLocation(MlirValue v)
Gets the location of the value.
Definition: IR.cpp:1188
MLIR_CAPI_EXPORTED unsigned mlirContextGetNumThreads(MlirContext context)
Gets the number of threads of the thread pool of the context when multithreading is enabled.
Definition: IR.cpp:117
MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but writing the bytecode format.
Definition: IR.cpp:837
MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op)
Gets the name of the operation as an identifier.
Definition: IR.cpp:665
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFileLineColGet(MlirContext context, MlirStringRef filename, unsigned line, unsigned col)
Creates an File/Line/Column location owned by the given context.
Definition: IR.cpp:273
MLIR_CAPI_EXPORTED void mlirSymbolTableWalkSymbolTables(MlirOperation from, bool allSymUsesVisible, void(*callback)(MlirOperation, bool, void *userData), void *userData)
Walks all symbol table operations nested within, and including, op.
Definition: IR.cpp:1370
MLIR_CAPI_EXPORTED MlirStringRef mlirDialectGetNamespace(MlirDialect dialect)
Returns the namespace of the given dialect.
Definition: IR.cpp:137
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op)
Returns the number of results of the operation.
Definition: IR.cpp:724
MLIR_CAPI_EXPORTED int mlirLocationFileLineColRangeGetEndColumn(MlirLocation location)
Getter for end_column of FileLineColRange.
Definition: IR.cpp:311
MLIR_CAPI_EXPORTED MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation)
Inserts the given operation into the given symbol table.
Definition: IR.cpp:1349
MLIR_CAPI_EXPORTED MlirDialect mlirDialectHandleLoadDialect(MlirDialectHandle, MlirContext)
Loads the dialect associated with the provided dialect handle.
MlirWalkOrder
Traversal order for operation walk.
Definition: IR.h:840
@ MlirWalkPreOrder
Definition: IR.h:841
@ MlirWalkPostOrder
Definition: IR.h:842
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsPrintNameLocAsPrefix(MlirOpPrintingFlags flags)
Print the name and location, if NamedLoc, as a prefix to the SSA ID.
Definition: IR.cpp:229
MLIR_CAPI_EXPORTED MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos)
Return pos-th attribute of the operation.
Definition: IR.cpp:798
MLIR_CAPI_EXPORTED void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n, MlirValue const *operands)
Definition: IR.cpp:509
MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module)
Takes a module owned by the caller and deletes it.
Definition: IR.cpp:454
MLIR_CAPI_EXPORTED MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name, MlirAttribute attr)
Associates an attribute with the name. Takes ownership of neither.
Definition: IR.cpp:1297
MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGetChildLoc(MlirLocation location)
Getter for childLoc of Name.
Definition: IR.cpp:392
MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable, MlirOperation operation)
Removes the given operation from the symbol table and erases it.
Definition: IR.cpp:1354
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags)
Use local scope when printing the operation.
Definition: IR.cpp:233
MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value)
Returns 1 if the value is a block argument, 0 otherwise.
Definition: IR.cpp:1106
MLIR_CAPI_EXPORTED void mlirContextAppendDialectRegistry(MlirContext ctx, MlirDialectRegistry registry)
Append the contents of the given dialect registry to the registry associated with the context.
Definition: IR.cpp:84
MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident)
Gets the string value of the identifier.
Definition: IR.cpp:1318
static bool mlirModuleIsNull(MlirModule module)
Checks whether a module is null.
Definition: IR.h:406
MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context, MlirStringRef type)
Parses a type. The type is owned by the context.
Definition: IR.cpp:1231
MLIR_CAPI_EXPORTED void mlirDialectRegistryDestroy(MlirDialectRegistry registry)
Takes a dialect registry owned by the caller and destroys it.
Definition: IR.cpp:149
MLIR_CAPI_EXPORTED MlirTypeID mlirOperationGetTypeID(MlirOperation op)
Gets the type id of the operation.
Definition: IR.cpp:659
MLIR_CAPI_EXPORTED intptr_t mlirContextGetNumLoadedDialects(MlirContext context)
Returns the number of dialects loaded by the context.
Definition: IR.cpp:91
MLIR_CAPI_EXPORTED MlirOpOperand mlirOpOperandGetNextUse(MlirOpOperand opOperand)
Returns an op operand representing the next use of the value, or a null op operand if there is no nex...
Definition: IR.cpp:1214
MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute)
Gets the type of this attribute.
Definition: IR.cpp:1270
MLIR_CAPI_EXPORTED void mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow)
Sets whether unregistered dialects are allowed in this context.
Definition: IR.cpp:73
MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference, MlirBlock block)
Takes a block owned by the caller and inserts it before the (non-owned) reference block in the given ...
Definition: IR.cpp:942
MLIR_CAPI_EXPORTED MlirNamedAttribute mlirOperationGetDiscardableAttribute(MlirOperation op, intptr_t pos)
Return pos-th discardable attribute of the operation.
Definition: IR.cpp:766
MLIR_CAPI_EXPORTED bool mlirLocationIsAFileLineColRange(MlirLocation location)
Checks whether the given location is an FileLineColRange.
Definition: IR.cpp:321
MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetSuccessor(MlirBlock block, intptr_t pos)
Returns pos-th successor of the block.
Definition: IR.cpp:1082
MLIR_CAPI_EXPORTED unsigned mlirLocationFusedGetNumLocations(MlirLocation location)
Getter for number of locations fused together.
Definition: IR.cpp:355
MLIR_CAPI_EXPORTED void mlirValueReplaceAllUsesOfWith(MlirValue of, MlirValue with)
Replace all uses of 'of' value with the 'with' value, updating anything in the IR that uses 'of' to u...
Definition: IR.cpp:1170
MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos)
Returns pos-th successor of the operation.
Definition: IR.cpp:736
MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value, MlirAsmState state, MlirStringCallback callback, void *userData)
Prints a value as an operand (i.e., the ValueID).
Definition: IR.cpp:1153
MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context)
Creates a location with unknown position owned by the given context.
Definition: IR.cpp:403
MLIR_CAPI_EXPORTED void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData)
Prints a location by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:1251
MLIR_CAPI_EXPORTED void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name, MlirAttribute attr)
Sets an attribute by name, replacing the existing if it exists or adding a new one otherwise.
Definition: IR.cpp:808
MLIR_CAPI_EXPORTED MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand)
Returns the owner operation of an op operand.
Definition: IR.cpp:1202
MLIR_CAPI_EXPORTED bool mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other)
Checks whether two identifiers are the same.
Definition: IR.cpp:1314
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsElideLargeResourceString(MlirOpPrintingFlags flags, intptr_t largeResourceLimit)
Enables the elision of large resources strings by omitting them from the dialect_resources section.
Definition: IR.cpp:215
MLIR_CAPI_EXPORTED MlirIdentifier mlirLocationFileLineColRangeGetFilename(MlirLocation location)
Getter for filename of FileLineColRange.
Definition: IR.cpp:289
MLIR_CAPI_EXPORTED MlirDialect mlirAttributeGetDialect(MlirAttribute attribute)
Gets the dialect of the attribute.
Definition: IR.cpp:1281
MLIR_CAPI_EXPORTED void mlirLocationFusedGetLocations(MlirLocation location, MlirLocation *locationsCPtr)
Getter for locations of Fused.
Definition: IR.cpp:361
MLIR_CAPI_EXPORTED intptr_t mlirContextGetNumRegisteredDialects(MlirContext context)
Returns the number of dialects registered with the given context.
Definition: IR.cpp:80
MLIR_CAPI_EXPORTED void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback, void *userData)
Prints an attribute by sending chunks of the string representation and forwarding userData tocallback...
Definition: IR.cpp:1289
MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block)
Returns the region that contains this block.
Definition: IR.cpp:981
MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op, MlirOperation other)
Moves the given operation immediately before the other operation in its parent block.
Definition: IR.cpp:861
static bool mlirValueIsNull(MlirValue value)
Returns whether the value is null.
Definition: IR.h:1028
MLIR_CAPI_EXPORTED void mlirValueReplaceAllUsesExcept(MlirValue of, MlirValue with, intptr_t numExceptions, MlirOperation *exceptions)
Replace all uses of 'of' value with 'with' value, updating anything in the IR that uses 'of' to use '...
Definition: IR.cpp:1174
MLIR_CAPI_EXPORTED void mlirOperationPrintWithState(MlirOperation op, MlirAsmState state, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but accepts AsmState controlling the printing behavior as well as caching ...
Definition: IR.cpp:829
MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block)
Takes a block owned by the caller and destroys it.
Definition: IR.cpp:1043
MlirWalkResult
Operation walk result.
Definition: IR.h:833
@ MlirWalkResultInterrupt
Definition: IR.h:835
@ MlirWalkResultSkip
Definition: IR.h:836
@ MlirWalkResultAdvance
Definition: IR.h:834
MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block)
Takes a block owned by the caller and inserts it at pos to the given region.
Definition: IR.cpp:922
MLIR_CAPI_EXPORTED MlirAttribute mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name)
Returns an attribute attached to the operation given its name.
Definition: IR.cpp:803
static bool mlirTypeIsNull(MlirType type)
Checks whether a type is null.
Definition: IR.h:1144
MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetPredecessor(MlirBlock block, intptr_t pos)
Returns pos-th predecessor of the block.
Definition: IR.cpp:1091
MLIR_CAPI_EXPORTED bool mlirRegionEqual(MlirRegion region, MlirRegion other)
Checks whether two region handles point to the same region.
Definition: IR.cpp:907
MLIR_CAPI_EXPORTED bool mlirContextIsRegisteredOperation(MlirContext context, MlirStringRef name)
Returns whether the given fully-qualified operation (i.e.
Definition: IR.cpp:100
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op)
Returns the number of successor blocks of the operation.
Definition: IR.cpp:732
MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op)
Creates a deep copy of an operation.
Definition: IR.cpp:635
MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block)
Returns the number of arguments of the block.
Definition: IR.cpp:1050
MLIR_CAPI_EXPORTED int mlirLocationFileLineColRangeGetStartLine(MlirLocation location)
Getter for start_line of FileLineColRange.
Definition: IR.cpp:293
MLIR_CAPI_EXPORTED void mlirOperationStateEnableResultTypeInference(MlirOperationState *state)
Enables result type inference for the operation under construction.
Definition: IR.cpp:526
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags)
Always print operations in the generic form.
Definition: IR.cpp:225
MLIR_CAPI_EXPORTED bool mlirModuleEqual(MlirModule lhs, MlirModule rhs)
Checks if two modules are equal.
Definition: IR.cpp:468
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations, MlirLocation const *locations, MlirAttribute metadata)
Creates a fused location with an array of locations and metadata.
Definition: IR.cpp:347
MLIR_CAPI_EXPORTED void mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference, MlirOperation operation)
Takes an operation owned by the caller and inserts it before the (non-owned) reference operation in t...
Definition: IR.cpp:1031
MLIR_CAPI_EXPORTED void mlirAsmStateDestroy(MlirAsmState state)
Destroys printing flags created with mlirAsmStateCreate.
Definition: IR.cpp:196
static bool mlirContextIsNull(MlirContext context)
Checks whether a context is null.
Definition: IR.h:104
MLIR_CAPI_EXPORTED MlirDialect mlirContextGetOrLoadDialect(MlirContext context, MlirStringRef name)
Gets the dialect instance owned by the given context using the dialect namespace to identify it,...
Definition: IR.cpp:95
MLIR_CAPI_EXPORTED void mlirDialectHandleRegisterDialect(MlirDialectHandle, MlirContext)
Registers the dialect associated with the provided dialect handle.
MLIR_CAPI_EXPORTED bool mlirLocationIsACallSite(MlirLocation location)
Checks whether the given location is an CallSite.
Definition: IR.cpp:343
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags, intptr_t largeElementLimit)
Enables the elision of large elements attributes by printing a lexically valid but otherwise meaningl...
Definition: IR.cpp:210
#define DEFINE_C_API_STRUCT(name, storage)
Opaque type declarations.
Definition: IR.h:45
MLIR_CAPI_EXPORTED bool mlirOperationRemoveDiscardableAttributeByName(MlirOperation op, MlirStringRef name)
Removes a discardable attribute by name.
Definition: IR.cpp:784
MLIR_CAPI_EXPORTED bool mlirValueEqual(MlirValue value1, MlirValue value2)
Returns 1 if two values are equal, 0 otherwise.
Definition: IR.cpp:1102
MLIR_CAPI_EXPORTED MlirAttribute mlirOperationGetDiscardableAttributeByName(MlirOperation op, MlirStringRef name)
Returns a discardable attribute attached to the operation given its name.
Definition: IR.cpp:773
MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference, MlirBlock block)
Takes a block owned by the caller and inserts it after the (non-owned) reference block in the given r...
Definition: IR.cpp:928
MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value, MlirType type)
Sets the type of the block argument to the given type.
Definition: IR.cpp:1123
MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op)
Gets the context this operation is associated with.
Definition: IR.cpp:651
MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args, MlirLocation const *locs)
Creates a new empty block with the given argument types and transfers ownership to the caller.
Definition: IR.cpp:965
MLIR_CAPI_EXPORTED MlirAsmState mlirAsmStateCreateForOperation(MlirOperation op, MlirOpPrintingFlags flags)
Creates new AsmState, as with AsmState the IR should not be mutated in-between using this state.
Definition: IR.cpp:157
static bool mlirBlockIsNull(MlirBlock block)
Checks whether a block is null.
Definition: IR.h:929
MLIR_CAPI_EXPORTED void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation)
Takes an operation owned by the caller and appends it to the block.
Definition: IR.cpp:1006
MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos)
Returns pos-th argument of the block.
Definition: IR.cpp:1068
MLIR_CAPI_EXPORTED MlirOperation mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name)
Looks up a symbol with the given name in the given symbol table and returns the operation that corres...
Definition: IR.cpp:1344
MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type)
Gets the context that a type was created with.
Definition: IR.cpp:1235
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFileLineColRangeGet(MlirContext context, MlirStringRef filename, unsigned start_line, unsigned start_col, unsigned end_line, unsigned end_col)
Creates an File/Line/Column range location owned by the given context.
Definition: IR.cpp:281
MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value)
Prints the value to the standard error stream.
Definition: IR.cpp:1145
MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location)
Creates a new, empty module and transfers ownership to the caller.
Definition: IR.cpp:425
MLIR_CAPI_EXPORTED void mlirOperationSetDiscardableAttributeByName(MlirOperation op, MlirStringRef name, MlirAttribute attr)
Sets a discardable attribute by name, replacing the existing if it exists or adding a new one otherwi...
Definition: IR.cpp:778
MLIR_CAPI_EXPORTED bool mlirOpOperandIsNull(MlirOpOperand opOperand)
Returns whether the op operand is null.
Definition: IR.cpp:1200
MLIR_CAPI_EXPORTED MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation)
Creates a symbol table for the given operation.
Definition: IR.cpp:1334
MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2)
Checks if two locations are equal.
Definition: IR.cpp:407
MLIR_CAPI_EXPORTED int mlirLocationFileLineColRangeGetStartColumn(MlirLocation location)
Getter for start_column of FileLineColRange.
Definition: IR.cpp:299
MLIR_CAPI_EXPORTED bool mlirLocationIsAFused(MlirLocation location)
Checks whether the given location is an Fused.
Definition: IR.cpp:375
MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op)
Gets the block that owns this operation, returning null if the operation is not owned.
Definition: IR.cpp:669
static bool mlirLocationIsNull(MlirLocation location)
Checks if the location is null.
Definition: IR.h:370
MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumPredecessors(MlirBlock block)
Returns the number of predecessor blocks of the block.
Definition: IR.cpp:1086
MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op, MlirOperation other)
Checks whether two operation handles point to the same operation.
Definition: IR.cpp:643
MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type, MlirLocation loc)
Appends an argument of the specified type to the block.
Definition: IR.cpp:1054
MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but accepts flags controlling the printing behavior.
Definition: IR.cpp:823
MLIR_CAPI_EXPORTED MlirOpOperand mlirValueGetFirstUse(MlirValue value)
Returns an op operand representing the first use of the value, or a null op operand if there are no u...
Definition: IR.cpp:1160
MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location, MlirStringCallback callback, void *userData)
Prints a location by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:415
MLIR_CAPI_EXPORTED void mlirContextSetThreadPool(MlirContext context, MlirLlvmThreadPool threadPool)
Sets the thread pool of the context explicitly, enabling multithreading in the process.
Definition: IR.cpp:112
MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op)
Verify the operation and return true if it passes, false if it fails.
Definition: IR.cpp:853
MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module)
Views the module as a generic operation.
Definition: IR.cpp:460
MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2)
Checks if two types are equal.
Definition: IR.cpp:1247
MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable)
Destroys the symbol table created with mlirSymbolTableCreate.
Definition: IR.cpp:1340
MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(MlirStringRef name, MlirLocation loc)
Constructs an operation state from a name and a location.
Definition: IR.cpp:480
MLIR_CAPI_EXPORTED unsigned mlirOpOperandGetOperandNumber(MlirOpOperand opOperand)
Returns the operand number of an op operand.
Definition: IR.cpp:1210
MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGetCaller(MlirLocation location)
Getter for caller of CallSite.
Definition: IR.cpp:334
MLIR_CAPI_EXPORTED MlirContext mlirDialectGetContext(MlirDialect dialect)
Returns the context that owns the dialect.
Definition: IR.cpp:129
MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other)
Checks whether two blocks handles point to the same block.
Definition: IR.cpp:973
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block)
Returns the terminator operation in the block or null if no terminator.
Definition: IR.cpp:996
MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region)
Takes a region owned by the caller and destroys it.
Definition: IR.cpp:953
MLIR_CAPI_EXPORTED MlirContext mlirIdentifierGetContext(MlirIdentifier)
Returns the context associated with this identifier.
Definition: IR.cpp:1310
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsSkipRegions(MlirOpPrintingFlags flags)
Skip printing regions.
Definition: IR.cpp:241
MLIR_CAPI_EXPORTED MlirStringRef mlirDialectHandleGetNamespace(MlirDialectHandle)
Returns the namespace associated with the provided dialect handle.
MLIR_CAPI_EXPORTED MlirIdentifier mlirLocationNameGetName(MlirLocation location)
Getter for name of Name.
Definition: IR.cpp:388
MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op)
Returns an operation immediately following the given operation it its enclosing block.
Definition: IR.cpp:701
MLIR_CAPI_EXPORTED bool mlirOperationIsBeforeInBlock(MlirOperation op, MlirOperation other)
Given an operation 'other' that is within the same parent block, return whether the current operation...
Definition: IR.cpp:865
MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetParentOperation(MlirOperation op)
Gets the operation that owns this operation, returning null if the operation is not owned.
Definition: IR.cpp:673
MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module)
Gets the context that a module was created with.
Definition: IR.cpp:446
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFromAttribute(MlirAttribute attribute)
Creates a location from a location attribute.
Definition: IR.cpp:269
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags)
Do not verify the operation when using custom operation printers.
Definition: IR.cpp:237
MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(MlirType type)
Gets the type ID of the type.
Definition: IR.cpp:1239
MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetVisibilityAttributeName(void)
Returns the name of the attribute used to store symbol visibility.
Definition: IR.cpp:1330
static bool mlirDialectIsNull(MlirDialect dialect)
Checks if the dialect is null.
Definition: IR.h:182
MLIR_CAPI_EXPORTED void mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config)
Destroys printing flags created with mlirBytecodeWriterConfigCreate.
Definition: IR.cpp:252
MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos)
Returns pos-th operand of the operation.
Definition: IR.cpp:709
MLIR_CAPI_EXPORTED MlirAttribute mlirLocationFusedGetMetadata(MlirLocation location)
Getter for metadata of Fused.
Definition: IR.cpp:369
MLIR_CAPI_EXPORTED void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n, MlirNamedAttribute const *attributes)
Definition: IR.cpp:521
MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block)
Returns the block immediately following the given block in its parent region.
Definition: IR.cpp:985
MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee, MlirLocation caller)
Creates a call site location with a callee and a caller.
Definition: IR.cpp:325
MLIR_CAPI_EXPORTED bool mlirLocationIsAName(MlirLocation location)
Checks whether the given location is an Name.
Definition: IR.cpp:399
MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value)
Returns an operation that produced this value as its result.
Definition: IR.cpp:1128
MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value)
Returns 1 if the value is an operation result, 0 otherwise.
Definition: IR.cpp:1110
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op)
Returns the number of operands of the operation.
Definition: IR.cpp:705
static bool mlirDialectRegistryIsNull(MlirDialectRegistry registry)
Checks if the dialect registry is null.
Definition: IR.h:244
MLIR_CAPI_EXPORTED void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback, void *userData, MlirWalkOrder walkOrder)
Walks operation op in walkOrder and calls callback on that operation.
Definition: IR.cpp:883
MLIR_CAPI_EXPORTED void mlirOperationSetOperands(MlirOperation op, intptr_t nOperands, MlirValue const *operands)
Replaces the operands of the operation.
Definition: IR.cpp:718
MLIR_CAPI_EXPORTED MlirContext mlirContextCreateWithThreading(bool threadingEnabled)
Creates an MLIR context with an explicit setting of the multithreading setting and transfers its owne...
Definition: IR.cpp:55
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock)
Returns the closest surrounding operation that contains this block.
Definition: IR.cpp:977
MLIR_CAPI_EXPORTED void mlirRegionTakeBody(MlirRegion target, MlirRegion source)
Moves the entire content of the source region to the target region.
Definition: IR.cpp:957
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op)
Returns the number of regions attached to the given operation.
Definition: IR.cpp:677
MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location)
Gets the context that a location was created with.
Definition: IR.cpp:411
MLIR_CAPI_EXPORTED void mlirBlockEraseArgument(MlirBlock block, unsigned index)
Erase the argument at 'index' and remove it from the argument list.
Definition: IR.cpp:1059
MLIR_CAPI_EXPORTED bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name)
Removes an attribute by name.
Definition: IR.cpp:813
MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr)
Prints the attribute to the standard error stream.
Definition: IR.cpp:1295
MLIR_CAPI_EXPORTED bool mlirOperationHasInherentAttributeByName(MlirOperation op, MlirStringRef name)
Returns true if this operation defines an inherent attribute with this name.
Definition: IR.cpp:741
MLIR_CAPI_EXPORTED MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses(MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from)
Attempt to replace all uses that are nested within the given operation of the given symbol 'oldSymbol...
Definition: IR.cpp:1359
MLIR_CAPI_EXPORTED MlirTypeID mlirLocationFileLineColRangeGetTypeID(void)
TypeID Getter for FileLineColRange.
Definition: IR.cpp:317
MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context, MlirStringRef attr)
Parses an attribute. The attribute is owned by the context.
Definition: IR.cpp:1262
MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module)
Parses a module from the string and transfers ownership to the caller.
Definition: IR.cpp:429
MLIR_CAPI_EXPORTED size_t mlirOperationHashValue(MlirOperation op)
Compute a hash for the given operation.
Definition: IR.cpp:647
MLIR_CAPI_EXPORTED void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block)
Takes a block owned by the caller and appends it to the given region.
Definition: IR.cpp:918
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block)
Returns the first operation in the block.
Definition: IR.cpp:989
MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type)
Prints the type to the standard error stream.
Definition: IR.cpp:1256
MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos)
Returns pos-th result of the operation.
Definition: IR.cpp:728
MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig mlirBytecodeWriterConfigCreate(void)
Creates new printing flags with defaults, intended for customization.
Definition: IR.cpp:248
MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute)
Gets the context that an attribute was created with.
Definition: IR.cpp:1266
MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value)
Returns the block in which this value is defined as an argument.
Definition: IR.cpp:1114
MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op, MlirStringCallback callback, void *userData)
Prints an operation by sending chunks of the string representation and forwarding userData tocallback...
Definition: IR.cpp:817
static bool mlirRegionIsNull(MlirRegion region)
Checks whether a region is null.
Definition: IR.h:868
MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op)
Takes an operation owned by the caller and destroys it.
Definition: IR.cpp:639
MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumSuccessors(MlirBlock block)
Returns the number of successor blocks of the block.
Definition: IR.cpp:1078
MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos)
Returns pos-th region attached to the operation.
Definition: IR.cpp:681
MLIR_CAPI_EXPORTED MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand)
Returns the value of an op operand.
Definition: IR.cpp:1206
MLIR_CAPI_EXPORTED void mlirOperationSetInherentAttributeByName(MlirOperation op, MlirStringRef name, MlirAttribute attr)
Sets an inherent attribute by name, replacing the existing if it exists.
Definition: IR.cpp:754
MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region)
Returns the region immediately following the given region in its parent operation.
Definition: IR.cpp:692
MLIR_CAPI_EXPORTED MlirValue mlirBlockInsertArgument(MlirBlock block, intptr_t pos, MlirType type, MlirLocation loc)
Inserts an argument of the specified type at a specified index to the block.
Definition: IR.cpp:1063
MLIR_CAPI_EXPORTED MlirDialect mlirTypeGetDialect(MlirType type)
Gets the dialect a type belongs to.
Definition: IR.cpp:1243
MLIR_CAPI_EXPORTED MlirModule mlirModuleFromOperation(MlirOperation op)
Views the generic operation as a module.
Definition: IR.cpp:464
MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str)
Gets an identifier with the given string value.
Definition: IR.cpp:1306
MLIR_CAPI_EXPORTED void mlirOperationSetSuccessor(MlirOperation op, intptr_t pos, MlirBlock block)
Set pos-th successor of the operation.
Definition: IR.cpp:789
MLIR_CAPI_EXPORTED void mlirContextLoadAllAvailableDialects(MlirContext context)
Eagerly loads all available dialects registered with a context, making them available for use for IR ...
Definition: IR.cpp:108
MLIR_CAPI_EXPORTED MlirTypeID mlirLocationCallSiteGetTypeID(void)
TypeID Getter for CallSite.
Definition: IR.cpp:339
MLIR_CAPI_EXPORTED void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n, MlirRegion const *regions)
Definition: IR.cpp:513
MLIR_CAPI_EXPORTED void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n, MlirBlock const *successors)
Definition: IR.cpp:517
MLIR_CAPI_EXPORTED MlirLlvmThreadPool mlirContextGetThreadPool(MlirContext context)
Gets the thread pool of the context when enabled multithreading, otherwise an assertion is raised.
Definition: IR.cpp:121
MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module)
Gets the body of the module, i.e. the only block it contains.
Definition: IR.cpp:450
MLIR_CAPI_EXPORTED int mlirLocationFileLineColRangeGetEndLine(MlirLocation location)
Getter for end_line of FileLineColRange.
Definition: IR.cpp:305
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags)
Destroys printing flags created with mlirOpPrintingFlagsCreate.
Definition: IR.cpp:206
MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate(void)
Creates a dialect registry and transfers its ownership to the caller.
Definition: IR.cpp:145
MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context, MlirStringRef name, MlirLocation childLoc)
Creates a name location owned by the given context.
Definition: IR.cpp:379
MLIR_CAPI_EXPORTED MlirContext mlirContextCreateWithRegistry(MlirDialectRegistry registry, bool threadingEnabled)
Creates an MLIR context, setting the multithreading setting explicitly and pre-loading the dialects f...
Definition: IR.cpp:60
MLIR_CAPI_EXPORTED void mlirContextEnableMultithreading(MlirContext context, bool enable)
Set threading mode (must be set to false to mlir-print-ir-after-all).
Definition: IR.cpp:104
MLIR_CAPI_EXPORTED void mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData)
Prints a block by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:1072
MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op)
Returns first region attached to the operation.
Definition: IR.cpp:685
MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGetCallee(MlirLocation location)
Getter for callee of CallSite.
Definition: IR.cpp:329
MLIR_CAPI_EXPORTED MlirTypeID mlirLocationNameGetTypeID(void)
TypeID Getter for Name.
Definition: IR.cpp:397
MLIR_CAPI_EXPORTED MlirContext mlirValueGetContext(MlirValue v)
Gets the context that a value was created with.
Definition: IR.cpp:1192
MLIR_CAPI_EXPORTED void mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags, int64_t version)
Sets the version to emit in the writer config.
Definition: IR.cpp:256
MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName(void)
Returns the name of the attribute used to store symbol names compatible with symbol tables.
Definition: IR.cpp:1326
MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void)
Creates a new empty region and transfers ownership to the caller.
Definition: IR.cpp:905
MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParseFromFile(MlirContext context, MlirStringRef fileName)
Parses a module from file and transfers ownership to the caller.
Definition: IR.cpp:437
MLIR_CAPI_EXPORTED MlirTypeID mlirLocationFusedGetTypeID(void)
TypeID Getter for Fused.
Definition: IR.cpp:373
MLIR_CAPI_EXPORTED void mlirBlockDetach(MlirBlock block)
Detach a block from the owning region and assume ownership.
Definition: IR.cpp:1045
MLIR_CAPI_EXPORTED void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n, MlirType const *results)
Adds a list of components to the operation state.
Definition: IR.cpp:504
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable, bool prettyForm)
Enable or disable printing of debug information (based on enable).
Definition: IR.cpp:220
MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op)
Gets the location of the operation.
Definition: IR.cpp:655
MLIR_CAPI_EXPORTED void mlirDialectHandleInsertDialect(MlirDialectHandle, MlirDialectRegistry)
Inserts the dialect associated with the provided dialect handle into the provided dialect registry.
MLIR_CAPI_EXPORTED MlirAttribute mlirOperationGetInherentAttributeByName(MlirOperation op, MlirStringRef name)
Returns an inherent attribute attached to the operation given its name.
Definition: IR.cpp:746
MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(MlirAttribute attribute)
Gets the type id of the attribute.
Definition: IR.cpp:1277
MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos, MlirValue newValue)
Sets the pos-th operand of the operation.
Definition: IR.cpp:713
MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op)
Prints an operation to stderr.
Definition: IR.cpp:851
MLIR_CAPI_EXPORTED bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2)
Checks if two contexts are equal.
Definition: IR.cpp:67
MLIR_CAPI_EXPORTED bool mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2)
Checks if two dialects that belong to the same context are equal.
Definition: IR.cpp:133
MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value)
Returns the position of the value in the list of results of the operation that produced it.
Definition: IR.cpp:1132
MLIR_CAPI_EXPORTED void mlirOperationRemoveFromParent(MlirOperation op)
Removes the given operation from its parent block.
Definition: IR.cpp:641
MLIR_CAPI_EXPORTED void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos, MlirOperation operation)
Takes an operation owned by the caller and inserts it as pos to the block.
Definition: IR.cpp:1010
MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void)
Creates new printing flags with defaults, intended for customization.
Definition: IR.cpp:202
MLIR_CAPI_EXPORTED MlirContext mlirContextCreate(void)
Creates an MLIR context and transfers its ownership to the caller.
Definition: IR.cpp:45
MLIR_CAPI_EXPORTED MlirAsmState mlirAsmStateCreateForValue(MlirValue value, MlirOpPrintingFlags flags)
Creates new AsmState from value.
Definition: IR.cpp:178
MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreate(MlirOperationState *state)
Creates an operation and transfers ownership to the caller.
Definition: IR.cpp:589
static bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable)
Returns true if the symbol table is null.
Definition: IR.h:1234
MLIR_CAPI_EXPORTED bool mlirContextGetAllowUnregisteredDialects(MlirContext context)
Returns whether the context allows unregistered dialects.
Definition: IR.cpp:77
MLIR_CAPI_EXPORTED void mlirOperationMoveAfter(MlirOperation op, MlirOperation other)
Moves the given operation immediately after the other operation in its parent block.
Definition: IR.cpp:857
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op)
Returns the number of attributes attached to the operation.
Definition: IR.cpp:794
MLIR_CAPI_EXPORTED void mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData)
Prints a value by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:1147
MLIR_CAPI_EXPORTED void mlirBlockInsertOwnedOperationAfter(MlirBlock block, MlirOperation reference, MlirOperation operation)
Takes an operation owned by the caller and inserts it after the (non-owned) reference operation in th...
Definition: IR.cpp:1016
MLIR_CAPI_EXPORTED MlirLogicalResult mlirOperationWriteBytecodeWithConfig(MlirOperation op, MlirBytecodeWriterConfig config, MlirStringCallback callback, void *userData)
Same as mlirOperationWriteBytecode but with writer config and returns failure only if desired bytecod...
Definition: IR.cpp:844
MLIR_CAPI_EXPORTED void mlirValueSetType(MlirValue value, MlirType type)
Set the type of the value.
Definition: IR.cpp:1141
MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value)
Returns the type of the value.
Definition: IR.cpp:1137
MLIR_CAPI_EXPORTED void mlirContextDestroy(MlirContext context)
Takes an MLIR context owned by the caller and destroys it.
Definition: IR.cpp:71
MLIR_CAPI_EXPORTED size_t mlirModuleHashValue(MlirModule mod)
Compute a hash for the given module.
Definition: IR.cpp:472
MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreateParse(MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName)
Parses an operation, giving ownership to the caller.
Definition: IR.cpp:626
MLIR_CAPI_EXPORTED bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2)
Checks if two attributes are equal.
Definition: IR.cpp:1285
static bool mlirOperationIsNull(MlirOperation op)
Checks whether the underlying operation is null.
Definition: IR.h:621
MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region)
Gets the first block in the region.
Definition: IR.cpp:911
#define MLIR_CAPI_EXPORTED
Definition: Support.h:46
void(* MlirStringCallback)(MlirStringRef, void *)
A callback for returning string references.
Definition: Support.h:105
const FrozenRewritePatternSet GreedyRewriteConfig config
const void * ptr
Definition: IR.h:211
A logical result value, essentially a boolean with named states.
Definition: Support.h:116
Named MLIR attribute.
Definition: IR.h:76
MlirAttribute attribute
Definition: IR.h:78
MlirIdentifier name
Definition: IR.h:77
An auxiliary class for constructing operations.
Definition: IR.h:438
MlirBlock * successors
Definition: IR.h:448
intptr_t nAttributes
Definition: IR.h:449
bool enableResultTypeInference
Definition: IR.h:451
MlirLocation location
Definition: IR.h:440
intptr_t nSuccessors
Definition: IR.h:447
MlirStringRef name
Definition: IR.h:439
MlirType * results
Definition: IR.h:442
MlirValue * operands
Definition: IR.h:444
intptr_t nResults
Definition: IR.h:441
intptr_t nOperands
Definition: IR.h:443
MlirNamedAttribute * attributes
Definition: IR.h:450
intptr_t nRegions
Definition: IR.h:445
MlirRegion * regions
Definition: IR.h:446
A pointer to a sized fragment of a string, not necessarily null-terminated.
Definition: Support.h:73