MLIR  17.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(MlirBytecodeWriterConfig, void);
52 DEFINE_C_API_STRUCT(MlirContext, void);
53 DEFINE_C_API_STRUCT(MlirDialect, void);
54 DEFINE_C_API_STRUCT(MlirDialectRegistry, void);
55 DEFINE_C_API_STRUCT(MlirOperation, void);
56 DEFINE_C_API_STRUCT(MlirOpOperand, void);
57 DEFINE_C_API_STRUCT(MlirOpPrintingFlags, void);
58 DEFINE_C_API_STRUCT(MlirBlock, void);
59 DEFINE_C_API_STRUCT(MlirRegion, void);
60 DEFINE_C_API_STRUCT(MlirSymbolTable, void);
61 
62 DEFINE_C_API_STRUCT(MlirAttribute, const void);
63 DEFINE_C_API_STRUCT(MlirIdentifier, const void);
64 DEFINE_C_API_STRUCT(MlirLocation, const void);
65 DEFINE_C_API_STRUCT(MlirModule, const void);
66 DEFINE_C_API_STRUCT(MlirType, const void);
67 DEFINE_C_API_STRUCT(MlirValue, const void);
68 
69 #undef DEFINE_C_API_STRUCT
70 
71 /// Named MLIR attribute.
72 ///
73 /// A named attribute is essentially a (name, attribute) pair where the name is
74 /// a string.
75 
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 MLIR_CAPI_EXPORTED MlirContext mlirContextCreate(void);
88 
89 /// Checks if two contexts are equal.
90 MLIR_CAPI_EXPORTED bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2);
91 
92 /// Checks whether a context is null.
93 static inline bool mlirContextIsNull(MlirContext context) {
94  return !context.ptr;
95 }
96 
97 /// Takes an MLIR context owned by the caller and destroys it.
98 MLIR_CAPI_EXPORTED void mlirContextDestroy(MlirContext context);
99 
100 /// Sets whether unregistered dialects are allowed in this context.
102 mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow);
103 
104 /// Returns whether the context allows unregistered dialects.
106 mlirContextGetAllowUnregisteredDialects(MlirContext context);
107 
108 /// Returns the number of dialects registered with the given context. A
109 /// registered dialect will be loaded if needed by the parser.
110 MLIR_CAPI_EXPORTED intptr_t
111 mlirContextGetNumRegisteredDialects(MlirContext context);
112 
113 /// Append the contents of the given dialect registry to the registry associated
114 /// with the context.
116 mlirContextAppendDialectRegistry(MlirContext ctx, MlirDialectRegistry registry);
117 
118 /// Returns the number of dialects loaded by the context.
119 
120 MLIR_CAPI_EXPORTED intptr_t
121 mlirContextGetNumLoadedDialects(MlirContext context);
122 
123 /// Gets the dialect instance owned by the given context using the dialect
124 /// namespace to identify it, loads (i.e., constructs the instance of) the
125 /// dialect if necessary. If the dialect is not registered with the context,
126 /// returns null. Use mlirContextLoad<Name>Dialect to load an unregistered
127 /// dialect.
128 MLIR_CAPI_EXPORTED MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
130 
131 /// Set threading mode (must be set to false to mlir-print-ir-after-all).
132 MLIR_CAPI_EXPORTED void mlirContextEnableMultithreading(MlirContext context,
133  bool enable);
134 
135 /// Eagerly loads all available dialects registered with a context, making
136 /// them available for use for IR construction.
138 mlirContextLoadAllAvailableDialects(MlirContext context);
139 
140 /// Returns whether the given fully-qualified operation (i.e.
141 /// 'dialect.operation') is registered with the context. This will return true
142 /// if the dialect is loaded and the operation is registered within the
143 /// dialect.
146 
147 //===----------------------------------------------------------------------===//
148 // Dialect API.
149 //===----------------------------------------------------------------------===//
150 
151 /// Returns the context that owns the dialect.
152 MLIR_CAPI_EXPORTED MlirContext mlirDialectGetContext(MlirDialect dialect);
153 
154 /// Checks if the dialect is null.
155 static inline bool mlirDialectIsNull(MlirDialect dialect) {
156  return !dialect.ptr;
157 }
158 
159 /// Checks if two dialects that belong to the same context are equal. Dialects
160 /// from different contexts will not compare equal.
161 MLIR_CAPI_EXPORTED bool mlirDialectEqual(MlirDialect dialect1,
162  MlirDialect dialect2);
163 
164 /// Returns the namespace of the given dialect.
166 
167 //===----------------------------------------------------------------------===//
168 // DialectHandle API.
169 // Registration entry-points for each dialect are declared using the common
170 // MLIR_DECLARE_DIALECT_REGISTRATION_CAPI macro, which takes the dialect
171 // API name (i.e. "Func", "Tensor", "Linalg") and namespace (i.e. "func",
172 // "tensor", "linalg"). The following declarations are produced:
173 //
174 // /// Gets the above hook methods in struct form for a dialect by namespace.
175 // /// This is intended to facilitate dynamic lookup and registration of
176 // /// dialects via a plugin facility based on shared library symbol lookup.
177 // const MlirDialectHandle *mlirGetDialectHandle__{NAMESPACE}__();
178 //
179 // This is done via a common macro to facilitate future expansion to
180 // registration schemes.
181 //===----------------------------------------------------------------------===//
182 
184  const void *ptr;
185 };
186 typedef struct MlirDialectHandle MlirDialectHandle;
187 
188 #define MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(Name, Namespace) \
189  MLIR_CAPI_EXPORTED MlirDialectHandle mlirGetDialectHandle__##Namespace##__( \
190  void)
191 
192 /// Returns the namespace associated with the provided dialect handle.
195 
196 /// Inserts the dialect associated with the provided dialect handle into the
197 /// provided dialect registry
199  MlirDialectRegistry);
200 
201 /// Registers the dialect associated with the provided dialect handle.
203  MlirContext);
204 
205 /// Loads the dialect associated with the provided dialect handle.
207  MlirContext);
208 
209 //===----------------------------------------------------------------------===//
210 // DialectRegistry API.
211 //===----------------------------------------------------------------------===//
212 
213 /// Creates a dialect registry and transfers its ownership to the caller.
214 MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate(void);
215 
216 /// Checks if the dialect registry is null.
217 static inline bool mlirDialectRegistryIsNull(MlirDialectRegistry registry) {
218  return !registry.ptr;
219 }
220 
221 /// Takes a dialect registry owned by the caller and destroys it.
223 mlirDialectRegistryDestroy(MlirDialectRegistry registry);
224 
225 //===----------------------------------------------------------------------===//
226 // Location API.
227 //===----------------------------------------------------------------------===//
228 
229 /// Returns the underlying location attribute of this location.
230 MLIR_CAPI_EXPORTED MlirAttribute
231 mlirLocationGetAttribute(MlirLocation location);
232 
233 /// Creates a location from a location attribute.
234 MLIR_CAPI_EXPORTED MlirLocation
235 mlirLocationFromAttribute(MlirAttribute attribute);
236 
237 /// Creates an File/Line/Column location owned by the given context.
239  MlirContext context, MlirStringRef filename, unsigned line, unsigned col);
240 
241 /// Creates a call site location with a callee and a caller.
242 MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee,
243  MlirLocation caller);
244 
245 /// Creates a fused location with an array of locations and metadata.
246 MLIR_CAPI_EXPORTED MlirLocation
247 mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations,
248  MlirLocation const *locations, MlirAttribute metadata);
249 
250 /// Creates a name location owned by the given context. Providing null location
251 /// for childLoc is allowed and if childLoc is null location, then the behavior
252 /// is the same as having unknown child location.
253 MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context,
254  MlirStringRef name,
255  MlirLocation childLoc);
256 
257 /// Creates a location with unknown position owned by the given context.
258 MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context);
259 
260 /// Gets the context that a location was created with.
261 MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location);
262 
263 /// Checks if the location is null.
264 static inline bool mlirLocationIsNull(MlirLocation location) {
265  return !location.ptr;
266 }
267 
268 /// Checks if two locations are equal.
269 MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2);
270 
271 /// Prints a location by sending chunks of the string representation and
272 /// forwarding `userData to `callback`. Note that the callback may be called
273 /// several times with consecutive chunks of the string.
274 MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location,
275  MlirStringCallback callback,
276  void *userData);
277 
278 //===----------------------------------------------------------------------===//
279 // Module API.
280 //===----------------------------------------------------------------------===//
281 
282 /// Creates a new, empty module and transfers ownership to the caller.
283 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location);
284 
285 /// Parses a module from the string and transfers ownership to the caller.
286 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context,
287  MlirStringRef module);
288 
289 /// Gets the context that a module was created with.
290 MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module);
291 
292 /// Gets the body of the module, i.e. the only block it contains.
293 MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module);
294 
295 /// Checks whether a module is null.
296 static inline bool mlirModuleIsNull(MlirModule module) { return !module.ptr; }
297 
298 /// Takes a module owned by the caller and deletes it.
299 MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module);
300 
301 /// Views the module as a generic operation.
302 MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module);
303 
304 /// Views the generic operation as a module.
305 /// The returned module is null when the input operation was not a ModuleOp.
306 MLIR_CAPI_EXPORTED MlirModule mlirModuleFromOperation(MlirOperation op);
307 
308 //===----------------------------------------------------------------------===//
309 // Operation state.
310 //===----------------------------------------------------------------------===//
311 
312 /// An auxiliary class for constructing operations.
313 ///
314 /// This class contains all the information necessary to construct the
315 /// operation. It owns the MlirRegions it has pointers to and does not own
316 /// anything else. By default, the state can be constructed from a name and
317 /// location, the latter being also used to access the context, and has no other
318 /// components. These components can be added progressively until the operation
319 /// is constructed. Users are not expected to rely on the internals of this
320 /// class and should use mlirOperationState* functions instead.
321 
324  MlirLocation location;
325  intptr_t nResults;
326  MlirType *results;
327  intptr_t nOperands;
328  MlirValue *operands;
329  intptr_t nRegions;
330  MlirRegion *regions;
331  intptr_t nSuccessors;
332  MlirBlock *successors;
333  intptr_t nAttributes;
336 };
338 
339 /// Constructs an operation state from a name and a location.
341  MlirLocation loc);
342 
343 /// Adds a list of components to the operation state.
345  intptr_t n,
346  MlirType const *results);
349  MlirValue const *operands);
352  MlirRegion const *regions);
355  MlirBlock const *successors);
359 
360 /// Enables result type inference for the operation under construction. If
361 /// enabled, then the caller must not have called
362 /// mlirOperationStateAddResults(). Note that if enabled, the
363 /// mlirOperationCreate() call is failable: it will return a null operation
364 /// on inference failure and will emit diagnostics.
367 
368 //===----------------------------------------------------------------------===//
369 // Op Printing flags API.
370 // While many of these are simple settings that could be represented in a
371 // struct, they are wrapped in a heap allocated object and accessed via
372 // functions to maximize the possibility of compatibility over time.
373 //===----------------------------------------------------------------------===//
374 
375 /// Creates new printing flags with defaults, intended for customization.
376 /// Must be freed with a call to mlirOpPrintingFlagsDestroy().
377 MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void);
378 
379 /// Destroys printing flags created with mlirOpPrintingFlagsCreate.
380 MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags);
381 
382 /// Enables the elision of large elements attributes by printing a lexically
383 /// valid but otherwise meaningless form instead of the element data. The
384 /// `largeElementLimit` is used to configure what is considered to be a "large"
385 /// ElementsAttr by providing an upper limit to the number of elements.
387 mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
388  intptr_t largeElementLimit);
389 
390 /// Enable or disable printing of debug information (based on `enable`). If
391 /// 'prettyForm' is set to true, debug information is printed in a more readable
392 /// 'pretty' form. Note: The IR generated with 'prettyForm' is not parsable.
394 mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable,
395  bool prettyForm);
396 
397 /// Always print operations in the generic form.
399 mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags);
400 
401 /// Use local scope when printing the operation. This allows for using the
402 /// printer in a more localized and thread-safe setting, but may not
403 /// necessarily be identical to what the IR will look like when dumping
404 /// the full module.
406 mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags);
407 
408 /// Do not verify the operation when using custom operation printers.
410 mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags);
411 
412 //===----------------------------------------------------------------------===//
413 // Bytecode printing flags API.
414 //===----------------------------------------------------------------------===//
415 
416 /// Creates new printing flags with defaults, intended for customization.
417 /// Must be freed with a call to mlirBytecodeWriterConfigDestroy().
418 MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig
420 
421 /// Destroys printing flags created with mlirBytecodeWriterConfigCreate.
423 mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config);
424 
425 /// Sets the version to emit in the writer config.
427 mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags,
428  int64_t version);
429 
430 //===----------------------------------------------------------------------===//
431 // Operation API.
432 //===----------------------------------------------------------------------===//
433 
434 /// Creates an operation and transfers ownership to the caller.
435 /// Note that caller owned child objects are transferred in this call and must
436 /// not be further used. Particularly, this applies to any regions added to
437 /// the state (the implementation may invalidate any such pointers).
438 ///
439 /// This call can fail under the following conditions, in which case, it will
440 /// return a null operation and emit diagnostics:
441 /// - Result type inference is enabled and cannot be performed.
443 
444 /// Parses an operation, giving ownership to the caller. If parsing fails a null
445 /// operation will be returned, and an error diagnostic emitted.
446 ///
447 /// `sourceStr` may be either the text assembly format, or binary bytecode
448 /// format. `sourceName` is used as the file name of the source; any IR without
449 /// locations will get a `FileLineColLoc` location with `sourceName` as the file
450 /// name.
452  MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName);
453 
454 /// Creates a deep copy of an operation. The operation is not inserted and
455 /// ownership is transferred to the caller.
456 MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op);
457 
458 /// Takes an operation owned by the caller and destroys it.
459 MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op);
460 
461 /// Removes the given operation from its parent block. The operation is not
462 /// destroyed. The ownership of the operation is transferred to the caller.
464 
465 /// Checks whether the underlying operation is null.
466 static inline bool mlirOperationIsNull(MlirOperation op) { return !op.ptr; }
467 
468 /// Checks whether two operation handles point to the same operation. This does
469 /// not perform deep comparison.
470 MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op,
471  MlirOperation other);
472 
473 /// Gets the context this operation is associated with
474 MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op);
475 
476 /// Gets the location of the operation.
477 MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op);
478 
479 /// Gets the type id of the operation.
480 /// Returns null if the operation does not have a registered operation
481 /// description.
482 MLIR_CAPI_EXPORTED MlirTypeID mlirOperationGetTypeID(MlirOperation op);
483 
484 /// Gets the name of the operation as an identifier.
485 MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op);
486 
487 /// Gets the block that owns this operation, returning null if the operation is
488 /// not owned.
489 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op);
490 
491 /// Gets the operation that owns this operation, returning null if the operation
492 /// is not owned.
493 MLIR_CAPI_EXPORTED MlirOperation
494 mlirOperationGetParentOperation(MlirOperation op);
495 
496 /// Returns the number of regions attached to the given operation.
497 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op);
498 
499 /// Returns `pos`-th region attached to the operation.
500 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op,
501  intptr_t pos);
502 
503 /// Returns an operation immediately following the given operation it its
504 /// enclosing block.
505 MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op);
506 
507 /// Returns the number of operands of the operation.
508 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op);
509 
510 /// Returns `pos`-th operand of the operation.
511 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op,
512  intptr_t pos);
513 
514 /// Sets the `pos`-th operand of the operation.
515 MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
516  MlirValue newValue);
517 
518 /// Returns the number of results of the operation.
519 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op);
520 
521 /// Returns `pos`-th result of the operation.
522 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op,
523  intptr_t pos);
524 
525 /// Returns the number of successor blocks of the operation.
526 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op);
527 
528 /// Returns `pos`-th successor of the operation.
529 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op,
530  intptr_t pos);
531 
532 /// Returns the number of attributes attached to the operation.
533 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op);
534 
535 /// Return `pos`-th attribute of the operation.
537 mlirOperationGetAttribute(MlirOperation op, intptr_t pos);
538 
539 /// Returns an attribute attached to the operation given its name.
540 MLIR_CAPI_EXPORTED MlirAttribute
542 
543 /// Sets an attribute by name, replacing the existing if it exists or
544 /// adding a new one otherwise.
547  MlirAttribute attr);
548 
549 /// Removes an attribute by name. Returns false if the attribute was not found
550 /// and true if removed.
553 
554 /// Prints an operation by sending chunks of the string representation and
555 /// forwarding `userData to `callback`. Note that the callback may be called
556 /// several times with consecutive chunks of the string.
557 MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op,
558  MlirStringCallback callback,
559  void *userData);
560 
561 /// Same as mlirOperationPrint but accepts flags controlling the printing
562 /// behavior.
563 MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op,
564  MlirOpPrintingFlags flags,
565  MlirStringCallback callback,
566  void *userData);
567 
568 /// Same as mlirOperationPrint but writing the bytecode format.
569 MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op,
570  MlirStringCallback callback,
571  void *userData);
572 
573 /// Same as mlirOperationWriteBytecode but with writer config and returns
574 /// failure only if desired bytecode could not be honored.
576  MlirOperation op, MlirBytecodeWriterConfig config,
577  MlirStringCallback callback, void *userData);
578 
579 /// Prints an operation to stderr.
580 MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op);
581 
582 /// Verify the operation and return true if it passes, false if it fails.
583 MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op);
584 
585 /// Moves the given operation immediately after the other operation in its
586 /// parent block. The given operation may be owned by the caller or by its
587 /// current block. The other operation must belong to a block. In any case, the
588 /// ownership is transferred to the block of the other operation.
589 MLIR_CAPI_EXPORTED void mlirOperationMoveAfter(MlirOperation op,
590  MlirOperation other);
591 
592 /// Moves the given operation immediately before the other operation in its
593 /// parent block. The given operation may be owner by the caller or by its
594 /// current block. The other operation must belong to a block. In any case, the
595 /// ownership is transferred to the block of the other operation.
596 MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op,
597  MlirOperation other);
598 //===----------------------------------------------------------------------===//
599 // Region API.
600 //===----------------------------------------------------------------------===//
601 
602 /// Creates a new empty region and transfers ownership to the caller.
603 MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void);
604 
605 /// Takes a region owned by the caller and destroys it.
606 MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region);
607 
608 /// Checks whether a region is null.
609 static inline bool mlirRegionIsNull(MlirRegion region) { return !region.ptr; }
610 
611 /// Checks whether two region handles point to the same region. This does not
612 /// perform deep comparison.
613 MLIR_CAPI_EXPORTED bool mlirRegionEqual(MlirRegion region, MlirRegion other);
614 
615 /// Gets the first block in the region.
616 MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region);
617 
618 /// Takes a block owned by the caller and appends it to the given region.
619 MLIR_CAPI_EXPORTED void mlirRegionAppendOwnedBlock(MlirRegion region,
620  MlirBlock block);
621 
622 /// Takes a block owned by the caller and inserts it at `pos` to the given
623 /// region. This is an expensive operation that linearly scans the region,
624 /// prefer insertAfter/Before instead.
626 mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block);
627 
628 /// Takes a block owned by the caller and inserts it after the (non-owned)
629 /// reference block in the given region. The reference block must belong to the
630 /// region. If the reference block is null, prepends the block to the region.
632  MlirBlock reference,
633  MlirBlock block);
634 
635 /// Takes a block owned by the caller and inserts it before the (non-owned)
636 /// reference block in the given region. The reference block must belong to the
637 /// region. If the reference block is null, appends the block to the region.
639  MlirBlock reference,
640  MlirBlock block);
641 
642 /// Returns first region attached to the operation.
643 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op);
644 
645 /// Returns the region immediately following the given region in its parent
646 /// operation.
647 MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region);
648 
649 //===----------------------------------------------------------------------===//
650 // Block API.
651 //===----------------------------------------------------------------------===//
652 
653 /// Creates a new empty block with the given argument types and transfers
654 /// ownership to the caller.
655 MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs,
656  MlirType const *args,
657  MlirLocation const *locs);
658 
659 /// Takes a block owned by the caller and destroys it.
660 MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block);
661 
662 /// Detach a block from the owning region and assume ownership.
663 MLIR_CAPI_EXPORTED void mlirBlockDetach(MlirBlock block);
664 
665 /// Checks whether a block is null.
666 static inline bool mlirBlockIsNull(MlirBlock block) { return !block.ptr; }
667 
668 /// Checks whether two blocks handles point to the same block. This does not
669 /// perform deep comparison.
670 MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other);
671 
672 /// Returns the closest surrounding operation that contains this block.
673 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock);
674 
675 /// Returns the region that contains this block.
676 MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block);
677 
678 /// Returns the block immediately following the given block in its parent
679 /// region.
680 MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block);
681 
682 /// Returns the first operation in the block.
683 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block);
684 
685 /// Returns the terminator operation in the block or null if no terminator.
686 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block);
687 
688 /// Takes an operation owned by the caller and appends it to the block.
690  MlirOperation operation);
691 
692 /// Takes an operation owned by the caller and inserts it as `pos` to the block.
693 /// This is an expensive operation that scans the block linearly, prefer
694 /// insertBefore/After instead.
696  intptr_t pos,
697  MlirOperation operation);
698 
699 /// Takes an operation owned by the caller and inserts it after the (non-owned)
700 /// reference operation in the given block. If the reference is null, prepends
701 /// the operation. Otherwise, the reference must belong to the block.
703 mlirBlockInsertOwnedOperationAfter(MlirBlock block, MlirOperation reference,
704  MlirOperation operation);
705 
706 /// Takes an operation owned by the caller and inserts it before the (non-owned)
707 /// reference operation in the given block. If the reference is null, appends
708 /// the operation. Otherwise, the reference must belong to the block.
710 mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference,
711  MlirOperation operation);
712 
713 /// Returns the number of arguments of the block.
714 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block);
715 
716 /// Appends an argument of the specified type to the block. Returns the newly
717 /// added argument.
718 MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block,
719  MlirType type,
720  MlirLocation loc);
721 
722 /// Returns `pos`-th argument of the block.
723 MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block,
724  intptr_t pos);
725 
726 /// Prints a block by sending chunks of the string representation and
727 /// forwarding `userData to `callback`. Note that the callback may be called
728 /// several times with consecutive chunks of the string.
730 mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData);
731 
732 //===----------------------------------------------------------------------===//
733 // Value API.
734 //===----------------------------------------------------------------------===//
735 
736 /// Returns whether the value is null.
737 static inline bool mlirValueIsNull(MlirValue value) { return !value.ptr; }
738 
739 /// Returns 1 if two values are equal, 0 otherwise.
740 MLIR_CAPI_EXPORTED bool mlirValueEqual(MlirValue value1, MlirValue value2);
741 
742 /// Returns 1 if the value is a block argument, 0 otherwise.
743 MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value);
744 
745 /// Returns 1 if the value is an operation result, 0 otherwise.
746 MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value);
747 
748 /// Returns the block in which this value is defined as an argument. Asserts if
749 /// the value is not a block argument.
750 MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value);
751 
752 /// Returns the position of the value in the argument list of its block.
753 MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value);
754 
755 /// Sets the type of the block argument to the given type.
756 MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value,
757  MlirType type);
758 
759 /// Returns an operation that produced this value as its result. Asserts if the
760 /// value is not an op result.
761 MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value);
762 
763 /// Returns the position of the value in the list of results of the operation
764 /// that produced it.
765 MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value);
766 
767 /// Returns the type of the value.
768 MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value);
769 
770 /// Prints the value to the standard error stream.
771 MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value);
772 
773 /// Prints a value 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.
777 mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData);
778 
779 /// Prints a value as an operand (i.e., the ValueID).
780 MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value,
781  MlirOpPrintingFlags flags,
782  MlirStringCallback callback,
783  void *userData);
784 
785 /// Returns an op operand representing the first use of the value, or a null op
786 /// operand if there are no uses.
787 MLIR_CAPI_EXPORTED MlirOpOperand mlirValueGetFirstUse(MlirValue value);
788 
789 /// Replace all uses of 'of' value with the 'with' value, updating anything in
790 /// the IR that uses 'of' to use the other value instead. When this returns
791 /// there are zero uses of 'of'.
793  MlirValue with);
794 
795 //===----------------------------------------------------------------------===//
796 // OpOperand API.
797 //===----------------------------------------------------------------------===//
798 
799 /// Returns whether the op operand is null.
800 MLIR_CAPI_EXPORTED bool mlirOpOperandIsNull(MlirOpOperand opOperand);
801 
802 /// Returns the owner operation of an op operand.
803 MLIR_CAPI_EXPORTED MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand);
804 
805 /// Returns the operand number of an op operand.
806 MLIR_CAPI_EXPORTED unsigned
807 mlirOpOperandGetOperandNumber(MlirOpOperand opOperand);
808 
809 /// Returns an op operand representing the next use of the value, or a null op
810 /// operand if there is no next use.
811 MLIR_CAPI_EXPORTED MlirOpOperand
812 mlirOpOperandGetNextUse(MlirOpOperand opOperand);
813 
814 //===----------------------------------------------------------------------===//
815 // Type API.
816 //===----------------------------------------------------------------------===//
817 
818 /// Parses a type. The type is owned by the context.
819 MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context,
820  MlirStringRef type);
821 
822 /// Gets the context that a type was created with.
823 MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type);
824 
825 /// Gets the type ID of the type.
826 MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(MlirType type);
827 
828 /// Gets the dialect a type belongs to.
829 MLIR_CAPI_EXPORTED MlirDialect mlirTypeGetDialect(MlirType type);
830 
831 /// Checks whether a type is null.
832 static inline bool mlirTypeIsNull(MlirType type) { return !type.ptr; }
833 
834 /// Checks if two types are equal.
835 MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2);
836 
837 /// Prints a location by sending chunks of the string representation and
838 /// forwarding `userData to `callback`. Note that the callback may be called
839 /// several times with consecutive chunks of the string.
841 mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData);
842 
843 /// Prints the type to the standard error stream.
844 MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type);
845 
846 //===----------------------------------------------------------------------===//
847 // Attribute API.
848 //===----------------------------------------------------------------------===//
849 
850 /// Parses an attribute. The attribute is owned by the context.
851 MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context,
852  MlirStringRef attr);
853 
854 /// Gets the context that an attribute was created with.
855 MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute);
856 
857 /// Gets the type of this attribute.
858 MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute);
859 
860 /// Gets the type id of the attribute.
861 MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(MlirAttribute attribute);
862 
863 /// Gets the dialect of the attribute.
864 MLIR_CAPI_EXPORTED MlirDialect mlirAttributeGetDialect(MlirAttribute attribute);
865 
866 /// Checks whether an attribute is null.
867 static inline bool mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; }
868 
869 /// Checks if two attributes are equal.
870 MLIR_CAPI_EXPORTED bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
871 
872 /// Prints an attribute by sending chunks of the string representation and
873 /// forwarding `userData to `callback`. Note that the callback may be called
874 /// several times with consecutive chunks of the string.
875 MLIR_CAPI_EXPORTED void mlirAttributePrint(MlirAttribute attr,
876  MlirStringCallback callback,
877  void *userData);
878 
879 /// Prints the attribute to the standard error stream.
880 MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr);
881 
882 /// Associates an attribute with the name. Takes ownership of neither.
884  MlirAttribute attr);
885 
886 //===----------------------------------------------------------------------===//
887 // Identifier API.
888 //===----------------------------------------------------------------------===//
889 
890 /// Gets an identifier with the given string value.
891 MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context,
892  MlirStringRef str);
893 
894 /// Returns the context associated with this identifier
895 MLIR_CAPI_EXPORTED MlirContext mlirIdentifierGetContext(MlirIdentifier);
896 
897 /// Checks whether two identifiers are the same.
898 MLIR_CAPI_EXPORTED bool mlirIdentifierEqual(MlirIdentifier ident,
899  MlirIdentifier other);
900 
901 /// Gets the string value of the identifier.
903 
904 //===----------------------------------------------------------------------===//
905 // Symbol and SymbolTable API.
906 //===----------------------------------------------------------------------===//
907 
908 /// Returns the name of the attribute used to store symbol names compatible with
909 /// symbol tables.
911 
912 /// Returns the name of the attribute used to store symbol visibility.
915 
916 /// Creates a symbol table for the given operation. If the operation does not
917 /// have the SymbolTable trait, returns a null symbol table.
918 MLIR_CAPI_EXPORTED MlirSymbolTable
919 mlirSymbolTableCreate(MlirOperation operation);
920 
921 /// Returns true if the symbol table is null.
922 static inline bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable) {
923  return !symbolTable.ptr;
924 }
925 
926 /// Destroys the symbol table created with mlirSymbolTableCreate. This does not
927 /// affect the operations in the table.
928 MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable);
929 
930 /// Looks up a symbol with the given name in the given symbol table and returns
931 /// the operation that corresponds to the symbol. If the symbol cannot be found,
932 /// returns a null operation.
933 MLIR_CAPI_EXPORTED MlirOperation
934 mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name);
935 
936 /// Inserts the given operation into the given symbol table. The operation must
937 /// have the symbol trait. If the symbol table already has a symbol with the
938 /// same name, renames the symbol being inserted to ensure name uniqueness. Note
939 /// that this does not move the operation itself into the block of the symbol
940 /// table operation, this should be done separately. Returns the name of the
941 /// symbol after insertion.
942 MLIR_CAPI_EXPORTED MlirAttribute
943 mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation);
944 
945 /// Removes the given operation from the symbol table and erases it.
946 MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable,
947  MlirOperation operation);
948 
949 /// Attempt to replace all uses that are nested within the given operation
950 /// of the given symbol 'oldSymbol' with the provided 'newSymbol'. This does
951 /// not traverse into nested symbol tables. Will fail atomically if there are
952 /// any unknown operations that may be potential symbol tables.
954  MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from);
955 
956 /// Walks all symbol table operations nested within, and including, `op`. For
957 /// each symbol table operation, the provided callback is invoked with the op
958 /// and a boolean signifying if the symbols within that symbol table can be
959 /// treated as if all uses within the IR are visible to the caller.
960 /// `allSymUsesVisible` identifies whether all of the symbol uses of symbols
961 /// within `op` are visible.
963  MlirOperation from, bool allSymUsesVisible,
964  void (*callback)(MlirOperation, bool, void *userData), void *userData);
965 
966 #ifdef __cplusplus
967 }
968 #endif
969 
970 #endif // MLIR_C_IR_H
MLIR_CAPI_EXPORTED MlirAttribute mlirLocationGetAttribute(MlirLocation location)
Returns the underlying location attribute of this location.
Definition: IR.cpp:170
MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value)
Returns the position of the value in the argument list of its block.
Definition: IR.cpp:741
static bool mlirAttributeIsNull(MlirAttribute attr)
Checks whether an attribute is null.
Definition: IR.h:867
MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but writing the bytecode format.
Definition: IR.cpp:529
MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op)
Gets the name of the operation as an identifier.
Definition: IR.cpp:425
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:178
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:962
MLIR_CAPI_EXPORTED MlirStringRef mlirDialectGetNamespace(MlirDialect dialect)
Returns the namespace of the given dialect.
Definition: IR.cpp:99
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op)
Returns the number of results of the operation.
Definition: IR.cpp:478
MLIR_CAPI_EXPORTED MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation)
Inserts the given operation into the given symbol table.
Definition: IR.cpp:941
MLIR_CAPI_EXPORTED MlirDialect mlirDialectHandleLoadDialect(MlirDialectHandle, MlirContext)
Loads the dialect associated with the provided dialect handle.
MLIR_CAPI_EXPORTED MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos)
Return pos-th attribute of the operation.
Definition: IR.cpp:498
MLIR_CAPI_EXPORTED void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n, MlirValue const *operands)
Definition: IR.cpp:295
MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module)
Takes a module owned by the caller and deletes it.
Definition: IR.cpp:248
MLIR_CAPI_EXPORTED MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name, MlirAttribute attr)
Associates an attribute with the name. Takes ownership of neither.
Definition: IR.cpp:889
MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable, MlirOperation operation)
Removes the given operation from the symbol table and erases it.
Definition: IR.cpp:946
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags)
Use local scope when printing the operation.
Definition: IR.cpp:141
MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value)
Returns 1 if the value is a block argument, 0 otherwise.
Definition: IR.cpp:729
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:59
MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident)
Gets the string value of the identifier.
Definition: IR.cpp:910
MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value, MlirOpPrintingFlags flags, MlirStringCallback callback, void *userData)
Prints a value as an operand (i.e., the ValueID).
Definition: IR.cpp:771
static bool mlirModuleIsNull(MlirModule module)
Checks whether a module is null.
Definition: IR.h:296
MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context, MlirStringRef type)
Parses a type. The type is owned by the context.
Definition: IR.cpp:823
MLIR_CAPI_EXPORTED void mlirDialectRegistryDestroy(MlirDialectRegistry registry)
Takes a dialect registry owned by the caller and destroys it.
Definition: IR.cpp:111
MLIR_CAPI_EXPORTED MlirTypeID mlirOperationGetTypeID(MlirOperation op)
Gets the type id of the operation.
Definition: IR.cpp:419
MLIR_CAPI_EXPORTED intptr_t mlirContextGetNumLoadedDialects(MlirContext context)
Returns the number of dialects loaded by the context.
Definition: IR.cpp:66
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:806
MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute)
Gets the type of this attribute.
Definition: IR.cpp:862
MLIR_CAPI_EXPORTED void mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow)
Sets whether unregistered dialects are allowed in this context.
Definition: IR.cpp:48
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:598
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:788
MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos)
Returns pos-th successor of the operation.
Definition: IR.cpp:490
MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context)
Creates a location with unknown position owned by the given context.
Definition: IR.cpp:206
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:843
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:508
MLIR_CAPI_EXPORTED MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand)
Returns the owner operation of an op operand.
Definition: IR.cpp:798
MLIR_CAPI_EXPORTED bool mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other)
Checks whether two identifiers are the same.
Definition: IR.cpp:906
MLIR_CAPI_EXPORTED MlirDialect mlirAttributeGetDialect(MlirAttribute attribute)
Gets the dialect of the attribute.
Definition: IR.cpp:873
MLIR_CAPI_EXPORTED intptr_t mlirContextGetNumRegisteredDialects(MlirContext context)
Returns the number of dialects registered with the given context.
Definition: IR.cpp:55
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:881
MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block)
Returns the region that contains this block.
Definition: IR.cpp:633
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:553
static bool mlirValueIsNull(MlirValue value)
Returns whether the value is null.
Definition: IR.h:737
MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block)
Takes a block owned by the caller and destroys it.
Definition: IR.cpp:695
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:578
MLIR_CAPI_EXPORTED MlirAttribute mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name)
Returns an attribute attached to the operation given its name.
Definition: IR.cpp:503
static bool mlirTypeIsNull(MlirType type)
Checks whether a type is null.
Definition: IR.h:832
MLIR_CAPI_EXPORTED bool mlirRegionEqual(MlirRegion region, MlirRegion other)
Checks whether two region handles point to the same region.
Definition: IR.cpp:563
MLIR_CAPI_EXPORTED bool mlirContextIsRegisteredOperation(MlirContext context, MlirStringRef name)
Returns whether the given fully-qualified operation (i.e.
Definition: IR.cpp:75
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op)
Returns the number of successor blocks of the operation.
Definition: IR.cpp:486
MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op)
Creates a deep copy of an operation.
Definition: IR.cpp:399
MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block)
Returns the number of arguments of the block.
Definition: IR.cpp:702
MLIR_CAPI_EXPORTED void mlirOperationStateEnableResultTypeInference(MlirOperationState *state)
Enables result type inference for the operation under construction.
Definition: IR.cpp:312
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags)
Always print operations in the generic form.
Definition: IR.cpp:137
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:189
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:683
static bool mlirContextIsNull(MlirContext context)
Checks whether a context is null.
Definition: IR.h:93
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:70
MLIR_CAPI_EXPORTED void mlirDialectHandleRegisterDialect(MlirDialectHandle, MlirContext)
Registers the dialect associated with the provided dialect handle.
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:127
#define DEFINE_C_API_STRUCT(name, storage)
Opaque type declarations.
Definition: IR.h:45
MLIR_CAPI_EXPORTED bool mlirValueEqual(MlirValue value1, MlirValue value2)
Returns 1 if two values are equal, 0 otherwise.
Definition: IR.cpp:725
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:584
MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value, MlirType type)
Sets the type of the block argument to the given type.
Definition: IR.cpp:746
MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op)
Gets the context this operation is associated with.
Definition: IR.cpp:411
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:617
static bool mlirBlockIsNull(MlirBlock block)
Checks whether a block is null.
Definition: IR.h:666
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:658
MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos)
Returns pos-th argument of the block.
Definition: IR.cpp:711
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:936
MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type)
Gets the context that a type was created with.
Definition: IR.cpp:827
MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value)
Prints the value to the standard error stream.
Definition: IR.cpp:763
MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location)
Creates a new, empty module and transfers ownership to the caller.
Definition: IR.cpp:228
MLIR_CAPI_EXPORTED bool mlirOpOperandIsNull(MlirOpOperand opOperand)
Returns whether the op operand is null.
Definition: IR.cpp:796
MLIR_CAPI_EXPORTED MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation)
Creates a symbol table for the given operation.
Definition: IR.cpp:926
MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2)
Checks if two locations are equal.
Definition: IR.cpp:210
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:429
static bool mlirLocationIsNull(MlirLocation location)
Checks if the location is null.
Definition: IR.h:264
MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op, MlirOperation other)
Checks whether two operation handles point to the same operation.
Definition: IR.cpp:407
MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type, MlirLocation loc)
Appends an argument of the specified type to the block.
Definition: IR.cpp:706
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:523
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:778
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:218
MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op)
Verify the operation and return true if it passes, false if it fails.
Definition: IR.cpp:545
MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module)
Views the module as a generic operation.
Definition: IR.cpp:254
MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2)
Checks if two types are equal.
Definition: IR.cpp:839
MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable)
Destroys the symbol table created with mlirSymbolTableCreate.
Definition: IR.cpp:932
MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(MlirStringRef name, MlirLocation loc)
Constructs an operation state from a name and a location.
Definition: IR.cpp:266
MLIR_CAPI_EXPORTED unsigned mlirOpOperandGetOperandNumber(MlirOpOperand opOperand)
Returns the operand number of an op operand.
Definition: IR.cpp:802
MLIR_CAPI_EXPORTED MlirContext mlirDialectGetContext(MlirDialect dialect)
Returns the context that owns the dialect.
Definition: IR.cpp:91
MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other)
Checks whether two blocks handles point to the same block.
Definition: IR.cpp:625
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block)
Returns the terminator operation in the block or null if no terminator.
Definition: IR.cpp:648
MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region)
Takes a region owned by the caller and destroys it.
Definition: IR.cpp:609
MLIR_CAPI_EXPORTED MlirContext mlirIdentifierGetContext(MlirIdentifier)
Returns the context associated with this identifier.
Definition: IR.cpp:902
MLIR_CAPI_EXPORTED MlirStringRef mlirDialectHandleGetNamespace(MlirDialectHandle)
Returns the namespace associated with the provided dialect handle.
MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op)
Returns an operation immediately following the given operation it its enclosing block.
Definition: IR.cpp:461
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:433
MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module)
Gets the context that a module was created with.
Definition: IR.cpp:240
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFromAttribute(MlirAttribute attribute)
Creates a location from a location attribute.
Definition: IR.cpp:174
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags)
Do not verify the operation when using custom operation printers.
Definition: IR.cpp:145
MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(MlirType type)
Gets the type ID of the type.
Definition: IR.cpp:831
MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetVisibilityAttributeName(void)
Returns the name of the attribute used to store symbol visibility.
Definition: IR.cpp:922
static bool mlirDialectIsNull(MlirDialect dialect)
Checks if the dialect is null.
Definition: IR.h:155
MLIR_CAPI_EXPORTED void mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config)
Destroys printing flags created with mlirBytecodeWriterConfigCreate.
Definition: IR.cpp:157
MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos)
Returns pos-th operand of the operation.
Definition: IR.cpp:469
MLIR_CAPI_EXPORTED void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n, MlirNamedAttribute const *attributes)
Definition: IR.cpp:307
MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block)
Returns the block immediately following the given block in its parent region.
Definition: IR.cpp:637
MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee, MlirLocation caller)
Creates a call site location with a callee and a caller.
Definition: IR.cpp:185
MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value)
Returns an operation that produced this value as its result.
Definition: IR.cpp:750
MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value)
Returns 1 if the value is an operation result, 0 otherwise.
Definition: IR.cpp:733
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op)
Returns the number of operands of the operation.
Definition: IR.cpp:465
static bool mlirDialectRegistryIsNull(MlirDialectRegistry registry)
Checks if the dialect registry is null.
Definition: IR.h:217
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock)
Returns the closest surrounding operation that contains this block.
Definition: IR.cpp:629
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op)
Returns the number of regions attached to the given operation.
Definition: IR.cpp:437
MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location)
Gets the context that a location was created with.
Definition: IR.cpp:214
MLIR_CAPI_EXPORTED bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name)
Removes an attribute by name.
Definition: IR.cpp:513
MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr)
Prints the attribute to the standard error stream.
Definition: IR.cpp:887
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:951
MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context, MlirStringRef attr)
Parses an attribute. The attribute is owned by the context.
Definition: IR.cpp:854
MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module)
Parses a module from the string and transfers ownership to the caller.
Definition: IR.cpp:232
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:574
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block)
Returns the first operation in the block.
Definition: IR.cpp:641
MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type)
Prints the type to the standard error stream.
Definition: IR.cpp:848
MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos)
Returns pos-th result of the operation.
Definition: IR.cpp:482
MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig mlirBytecodeWriterConfigCreate(void)
Creates new printing flags with defaults, intended for customization.
Definition: IR.cpp:153
MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute)
Gets the context that an attribute was created with.
Definition: IR.cpp:858
MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value)
Returns the block in which this value is defined as an argument.
Definition: IR.cpp:737
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:517
static bool mlirRegionIsNull(MlirRegion region)
Checks whether a region is null.
Definition: IR.h:609
MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op)
Takes an operation owned by the caller and destroys it.
Definition: IR.cpp:403
MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos)
Returns pos-th region attached to the operation.
Definition: IR.cpp:441
MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region)
Returns the region immediately following the given region in its parent operation.
Definition: IR.cpp:452
MLIR_CAPI_EXPORTED MlirDialect mlirTypeGetDialect(MlirType type)
Gets the dialect a type belongs to.
Definition: IR.cpp:835
MLIR_CAPI_EXPORTED MlirModule mlirModuleFromOperation(MlirOperation op)
Views the generic operation as a module.
Definition: IR.cpp:258
MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str)
Gets an identifier with the given string value.
Definition: IR.cpp:898
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:83
MLIR_CAPI_EXPORTED void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n, MlirRegion const *regions)
Definition: IR.cpp:299
MLIR_CAPI_EXPORTED void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n, MlirBlock const *successors)
Definition: IR.cpp:303
MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module)
Gets the body of the module, i.e. the only block it contains.
Definition: IR.cpp:244
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags)
Destroys printing flags created with mlirOpPrintingFlagsCreate.
Definition: IR.cpp:123
MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate(void)
Creates a dialect registry and transfers its ownership to the caller.
Definition: IR.cpp:107
MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context, MlirStringRef name, MlirLocation childLoc)
Creates a name location owned by the given context.
Definition: IR.cpp:197
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:79
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:715
MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op)
Returns first region attached to the operation.
Definition: IR.cpp:445
MLIR_CAPI_EXPORTED void mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags, int64_t version)
Sets the version to emit in the writer config.
Definition: IR.cpp:161
MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName(void)
Returns the name of the attribute used to store symbol names compatible with symbol tables.
Definition: IR.cpp:918
MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void)
Creates a new empty region and transfers ownership to the caller.
Definition: IR.cpp:561
MLIR_CAPI_EXPORTED void mlirBlockDetach(MlirBlock block)
Detach a block from the owning region and assume ownership.
Definition: IR.cpp:697
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:290
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable, bool prettyForm)
Enable or disable printing of debug information (based on enable).
Definition: IR.cpp:132
MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op)
Gets the location of the operation.
Definition: IR.cpp:415
MLIR_CAPI_EXPORTED void mlirDialectHandleInsertDialect(MlirDialectHandle, MlirDialectRegistry)
Inserts the dialect associated with the provided dialect handle into the provided dialect registry.
MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(MlirAttribute attribute)
Gets the type id of the attribute.
Definition: IR.cpp:869
MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos, MlirValue newValue)
Sets the pos-th operand of the operation.
Definition: IR.cpp:473
MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op)
Prints an operation to stderr.
Definition: IR.cpp:543
MLIR_CAPI_EXPORTED bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2)
Checks if two contexts are equal.
Definition: IR.cpp:42
MLIR_CAPI_EXPORTED bool mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2)
Checks if two dialects that belong to the same context are equal.
Definition: IR.cpp:95
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:754
MLIR_CAPI_EXPORTED void mlirOperationRemoveFromParent(MlirOperation op)
Removes the given operation from its parent block.
Definition: IR.cpp:405
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:662
MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void)
Creates new printing flags with defaults, intended for customization.
Definition: IR.cpp:119
MLIR_CAPI_EXPORTED MlirContext mlirContextCreate(void)
Creates an MLIR context and transfers its ownership to the caller.
Definition: IR.cpp:37
MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreate(MlirOperationState *state)
Creates an operation and transfers ownership to the caller.
Definition: IR.cpp:352
static bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable)
Returns true if the symbol table is null.
Definition: IR.h:922
MLIR_CAPI_EXPORTED bool mlirContextGetAllowUnregisteredDialects(MlirContext context)
Returns whether the context allows unregistered dialects.
Definition: IR.cpp:52
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:549
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op)
Returns the number of attributes attached to the operation.
Definition: IR.cpp:494
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:765
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:668
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:536
MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value)
Returns the type of the value.
Definition: IR.cpp:759
MLIR_CAPI_EXPORTED void mlirContextDestroy(MlirContext context)
Takes an MLIR context owned by the caller and destroys it.
Definition: IR.cpp:46
MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreateParse(MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName)
Parses an operation, giving ownership to the caller.
Definition: IR.cpp:390
MLIR_CAPI_EXPORTED bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2)
Checks if two attributes are equal.
Definition: IR.cpp:877
static bool mlirOperationIsNull(MlirOperation op)
Checks whether the underlying operation is null.
Definition: IR.h:466
MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region)
Gets the first block in the region.
Definition: IR.cpp:567
#define MLIR_CAPI_EXPORTED
Definition: Support.h:46
void(* MlirStringCallback)(MlirStringRef, void *)
A callback for returning string references.
Definition: Support.h:103
const void * ptr
Definition: IR.h:184
A logical result value, essentially a boolean with named states.
Definition: Support.h:114
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:322
MlirBlock * successors
Definition: IR.h:332
intptr_t nAttributes
Definition: IR.h:333
bool enableResultTypeInference
Definition: IR.h:335
MlirLocation location
Definition: IR.h:324
intptr_t nSuccessors
Definition: IR.h:331
MlirStringRef name
Definition: IR.h:323
MlirType * results
Definition: IR.h:326
MlirValue * operands
Definition: IR.h:328
intptr_t nResults
Definition: IR.h:325
intptr_t nOperands
Definition: IR.h:327
MlirNamedAttribute * attributes
Definition: IR.h:334
intptr_t nRegions
Definition: IR.h:329
MlirRegion * regions
Definition: IR.h:330
A pointer to a sized fragment of a string, not necessarily null-terminated.
Definition: Support.h:71