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

source code of mlir/include/mlir-c/IR.h