xref: /llvm-project-15.0.7/mlir/lib/CAPI/IR/IR.cpp (revision 2e15f4ac) 
1 //===- IR.cpp - C Interface for Core MLIR APIs ----------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "mlir-c/IR.h"
10 #include "mlir-c/Support.h"
11 
12 #include "mlir/CAPI/IR.h"
13 #include "mlir/CAPI/Support.h"
14 #include "mlir/CAPI/Utils.h"
15 #include "mlir/IR/Attributes.h"
16 #include "mlir/IR/Dialect.h"
17 #include "mlir/IR/Module.h"
18 #include "mlir/IR/Operation.h"
19 #include "mlir/IR/Types.h"
20 #include "mlir/Parser.h"
21 
22 using namespace mlir;
23 
24 /* ========================================================================== */
25 /* Context API.                                                               */
26 /* ========================================================================== */
27 
28 MlirContext mlirContextCreate() {
29   auto *context = new MLIRContext;
30   return wrap(context);
31 }
32 
33 int mlirContextEqual(MlirContext ctx1, MlirContext ctx2) {
34   return unwrap(ctx1) == unwrap(ctx2);
35 }
36 
37 void mlirContextDestroy(MlirContext context) { delete unwrap(context); }
38 
39 void mlirContextSetAllowUnregisteredDialects(MlirContext context, int allow) {
40   unwrap(context)->allowUnregisteredDialects(allow);
41 }
42 
43 int mlirContextGetAllowUnregisteredDialects(MlirContext context) {
44   return unwrap(context)->allowsUnregisteredDialects();
45 }
46 intptr_t mlirContextGetNumRegisteredDialects(MlirContext context) {
47   return static_cast<intptr_t>(unwrap(context)->getAvailableDialects().size());
48 }
49 
50 // TODO: expose a cheaper way than constructing + sorting a vector only to take
51 // its size.
52 intptr_t mlirContextGetNumLoadedDialects(MlirContext context) {
53   return static_cast<intptr_t>(unwrap(context)->getLoadedDialects().size());
54 }
55 
56 MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
57                                         MlirStringRef name) {
58   return wrap(unwrap(context)->getOrLoadDialect(unwrap(name)));
59 }
60 
61 /* ========================================================================== */
62 /* Dialect API.                                                               */
63 /* ========================================================================== */
64 
65 MlirContext mlirDialectGetContext(MlirDialect dialect) {
66   return wrap(unwrap(dialect)->getContext());
67 }
68 
69 int mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2) {
70   return unwrap(dialect1) == unwrap(dialect2);
71 }
72 
73 MlirStringRef mlirDialectGetNamespace(MlirDialect dialect) {
74   return wrap(unwrap(dialect)->getNamespace());
75 }
76 
77 /* ========================================================================== */
78 /* Printing flags API.                                                        */
79 /* ========================================================================== */
80 
81 MlirOpPrintingFlags mlirOpPrintingFlagsCreate() {
82   return wrap(new OpPrintingFlags());
83 }
84 
85 void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags) {
86   delete unwrap(flags);
87 }
88 
89 void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
90                                                 intptr_t largeElementLimit) {
91   unwrap(flags)->elideLargeElementsAttrs(largeElementLimit);
92 }
93 
94 void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags,
95                                         int prettyForm) {
96   unwrap(flags)->enableDebugInfo(/*prettyForm=*/prettyForm);
97 }
98 
99 void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags) {
100   unwrap(flags)->printGenericOpForm();
101 }
102 
103 void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags) {
104   unwrap(flags)->useLocalScope();
105 }
106 
107 /* ========================================================================== */
108 /* Location API.                                                              */
109 /* ========================================================================== */
110 
111 MlirLocation mlirLocationFileLineColGet(MlirContext context,
112                                         const char *filename, unsigned line,
113                                         unsigned col) {
114   return wrap(FileLineColLoc::get(filename, line, col, unwrap(context)));
115 }
116 
117 MlirLocation mlirLocationUnknownGet(MlirContext context) {
118   return wrap(UnknownLoc::get(unwrap(context)));
119 }
120 
121 MlirContext mlirLocationGetContext(MlirLocation location) {
122   return wrap(unwrap(location).getContext());
123 }
124 
125 void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
126                        void *userData) {
127   detail::CallbackOstream stream(callback, userData);
128   unwrap(location).print(stream);
129   stream.flush();
130 }
131 
132 /* ========================================================================== */
133 /* Module API.                                                                */
134 /* ========================================================================== */
135 
136 MlirModule mlirModuleCreateEmpty(MlirLocation location) {
137   return wrap(ModuleOp::create(unwrap(location)));
138 }
139 
140 MlirModule mlirModuleCreateParse(MlirContext context, const char *module) {
141   OwningModuleRef owning = parseSourceString(module, unwrap(context));
142   if (!owning)
143     return MlirModule{nullptr};
144   return MlirModule{owning.release().getOperation()};
145 }
146 
147 MlirContext mlirModuleGetContext(MlirModule module) {
148   return wrap(unwrap(module).getContext());
149 }
150 
151 MlirBlock mlirModuleGetBody(MlirModule module) {
152   return wrap(unwrap(module).getBody());
153 }
154 
155 void mlirModuleDestroy(MlirModule module) {
156   // Transfer ownership to an OwningModuleRef so that its destructor is called.
157   OwningModuleRef(unwrap(module));
158 }
159 
160 MlirOperation mlirModuleGetOperation(MlirModule module) {
161   return wrap(unwrap(module).getOperation());
162 }
163 
164 /* ========================================================================== */
165 /* Operation state API.                                                       */
166 /* ========================================================================== */
167 
168 MlirOperationState mlirOperationStateGet(const char *name, MlirLocation loc) {
169   MlirOperationState state;
170   state.name = name;
171   state.location = loc;
172   state.nResults = 0;
173   state.results = nullptr;
174   state.nOperands = 0;
175   state.operands = nullptr;
176   state.nRegions = 0;
177   state.regions = nullptr;
178   state.nSuccessors = 0;
179   state.successors = nullptr;
180   state.nAttributes = 0;
181   state.attributes = nullptr;
182   return state;
183 }
184 
185 #define APPEND_ELEMS(type, sizeName, elemName)                                 \
186   state->elemName =                                                            \
187       (type *)realloc(state->elemName, (state->sizeName + n) * sizeof(type));  \
188   memcpy(state->elemName + state->sizeName, elemName, n * sizeof(type));       \
189   state->sizeName += n;
190 
191 void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n,
192                                   MlirType *results) {
193   APPEND_ELEMS(MlirType, nResults, results);
194 }
195 
196 void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
197                                    MlirValue *operands) {
198   APPEND_ELEMS(MlirValue, nOperands, operands);
199 }
200 void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
201                                        MlirRegion *regions) {
202   APPEND_ELEMS(MlirRegion, nRegions, regions);
203 }
204 void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
205                                      MlirBlock *successors) {
206   APPEND_ELEMS(MlirBlock, nSuccessors, successors);
207 }
208 void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
209                                      MlirNamedAttribute *attributes) {
210   APPEND_ELEMS(MlirNamedAttribute, nAttributes, attributes);
211 }
212 
213 /* ========================================================================== */
214 /* Operation API.                                                             */
215 /* ========================================================================== */
216 
217 MlirOperation mlirOperationCreate(const MlirOperationState *state) {
218   assert(state);
219   OperationState cppState(unwrap(state->location), state->name);
220   SmallVector<Type, 4> resultStorage;
221   SmallVector<Value, 8> operandStorage;
222   SmallVector<Block *, 2> successorStorage;
223   cppState.addTypes(unwrapList(state->nResults, state->results, resultStorage));
224   cppState.addOperands(
225       unwrapList(state->nOperands, state->operands, operandStorage));
226   cppState.addSuccessors(
227       unwrapList(state->nSuccessors, state->successors, successorStorage));
228 
229   cppState.attributes.reserve(state->nAttributes);
230   for (intptr_t i = 0; i < state->nAttributes; ++i)
231     cppState.addAttribute(state->attributes[i].name,
232                           unwrap(state->attributes[i].attribute));
233 
234   for (intptr_t i = 0; i < state->nRegions; ++i)
235     cppState.addRegion(std::unique_ptr<Region>(unwrap(state->regions[i])));
236 
237   MlirOperation result = wrap(Operation::create(cppState));
238   free(state->results);
239   free(state->operands);
240   free(state->successors);
241   free(state->regions);
242   free(state->attributes);
243   return result;
244 }
245 
246 void mlirOperationDestroy(MlirOperation op) { unwrap(op)->erase(); }
247 
248 int mlirOperationEqual(MlirOperation op, MlirOperation other) {
249   return unwrap(op) == unwrap(other);
250 }
251 
252 MlirIdentifier mlirOperationGetName(MlirOperation op) {
253   return wrap(unwrap(op)->getName().getIdentifier());
254 }
255 
256 MlirBlock mlirOperationGetBlock(MlirOperation op) {
257   return wrap(unwrap(op)->getBlock());
258 }
259 
260 MlirOperation mlirOperationGetParentOperation(MlirOperation op) {
261   return wrap(unwrap(op)->getParentOp());
262 }
263 
264 intptr_t mlirOperationGetNumRegions(MlirOperation op) {
265   return static_cast<intptr_t>(unwrap(op)->getNumRegions());
266 }
267 
268 MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos) {
269   return wrap(&unwrap(op)->getRegion(static_cast<unsigned>(pos)));
270 }
271 
272 MlirOperation mlirOperationGetNextInBlock(MlirOperation op) {
273   return wrap(unwrap(op)->getNextNode());
274 }
275 
276 intptr_t mlirOperationGetNumOperands(MlirOperation op) {
277   return static_cast<intptr_t>(unwrap(op)->getNumOperands());
278 }
279 
280 MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos) {
281   return wrap(unwrap(op)->getOperand(static_cast<unsigned>(pos)));
282 }
283 
284 intptr_t mlirOperationGetNumResults(MlirOperation op) {
285   return static_cast<intptr_t>(unwrap(op)->getNumResults());
286 }
287 
288 MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos) {
289   return wrap(unwrap(op)->getResult(static_cast<unsigned>(pos)));
290 }
291 
292 intptr_t mlirOperationGetNumSuccessors(MlirOperation op) {
293   return static_cast<intptr_t>(unwrap(op)->getNumSuccessors());
294 }
295 
296 MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos) {
297   return wrap(unwrap(op)->getSuccessor(static_cast<unsigned>(pos)));
298 }
299 
300 intptr_t mlirOperationGetNumAttributes(MlirOperation op) {
301   return static_cast<intptr_t>(unwrap(op)->getAttrs().size());
302 }
303 
304 MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos) {
305   NamedAttribute attr = unwrap(op)->getAttrs()[pos];
306   return MlirNamedAttribute{attr.first.c_str(), wrap(attr.second)};
307 }
308 
309 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
310                                               const char *name) {
311   return wrap(unwrap(op)->getAttr(name));
312 }
313 
314 void mlirOperationSetAttributeByName(MlirOperation op, const char *name,
315                                      MlirAttribute attr) {
316   unwrap(op)->setAttr(name, unwrap(attr));
317 }
318 
319 int mlirOperationRemoveAttributeByName(MlirOperation op, const char *name) {
320   auto removeResult = unwrap(op)->removeAttr(name);
321   return removeResult == MutableDictionaryAttr::RemoveResult::Removed;
322 }
323 
324 void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
325                         void *userData) {
326   detail::CallbackOstream stream(callback, userData);
327   unwrap(op)->print(stream);
328   stream.flush();
329 }
330 
331 void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags,
332                                  MlirStringCallback callback, void *userData) {
333   detail::CallbackOstream stream(callback, userData);
334   unwrap(op)->print(stream, *unwrap(flags));
335   stream.flush();
336 }
337 
338 void mlirOperationDump(MlirOperation op) { return unwrap(op)->dump(); }
339 
340 /* ========================================================================== */
341 /* Region API.                                                                */
342 /* ========================================================================== */
343 
344 MlirRegion mlirRegionCreate() { return wrap(new Region); }
345 
346 MlirBlock mlirRegionGetFirstBlock(MlirRegion region) {
347   Region *cppRegion = unwrap(region);
348   if (cppRegion->empty())
349     return wrap(static_cast<Block *>(nullptr));
350   return wrap(&cppRegion->front());
351 }
352 
353 void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block) {
354   unwrap(region)->push_back(unwrap(block));
355 }
356 
357 void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos,
358                                 MlirBlock block) {
359   auto &blockList = unwrap(region)->getBlocks();
360   blockList.insert(std::next(blockList.begin(), pos), unwrap(block));
361 }
362 
363 void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference,
364                                      MlirBlock block) {
365   Region *cppRegion = unwrap(region);
366   if (mlirBlockIsNull(reference)) {
367     cppRegion->getBlocks().insert(cppRegion->begin(), unwrap(block));
368     return;
369   }
370 
371   assert(unwrap(reference)->getParent() == unwrap(region) &&
372          "expected reference block to belong to the region");
373   cppRegion->getBlocks().insertAfter(Region::iterator(unwrap(reference)),
374                                      unwrap(block));
375 }
376 
377 void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference,
378                                       MlirBlock block) {
379   if (mlirBlockIsNull(reference))
380     return mlirRegionAppendOwnedBlock(region, block);
381 
382   assert(unwrap(reference)->getParent() == unwrap(region) &&
383          "expected reference block to belong to the region");
384   unwrap(region)->getBlocks().insert(Region::iterator(unwrap(reference)),
385                                      unwrap(block));
386 }
387 
388 void mlirRegionDestroy(MlirRegion region) {
389   delete static_cast<Region *>(region.ptr);
390 }
391 
392 /* ========================================================================== */
393 /* Block API.                                                                 */
394 /* ========================================================================== */
395 
396 MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType *args) {
397   Block *b = new Block;
398   for (intptr_t i = 0; i < nArgs; ++i)
399     b->addArgument(unwrap(args[i]));
400   return wrap(b);
401 }
402 
403 int mlirBlockEqual(MlirBlock block, MlirBlock other) {
404   return unwrap(block) == unwrap(other);
405 }
406 
407 MlirBlock mlirBlockGetNextInRegion(MlirBlock block) {
408   return wrap(unwrap(block)->getNextNode());
409 }
410 
411 MlirOperation mlirBlockGetFirstOperation(MlirBlock block) {
412   Block *cppBlock = unwrap(block);
413   if (cppBlock->empty())
414     return wrap(static_cast<Operation *>(nullptr));
415   return wrap(&cppBlock->front());
416 }
417 
418 MlirOperation mlirBlockGetTerminator(MlirBlock block) {
419   Block *cppBlock = unwrap(block);
420   if (cppBlock->empty())
421     return wrap(static_cast<Operation *>(nullptr));
422   Operation &back = cppBlock->back();
423   if (!back.isKnownTerminator())
424     return wrap(static_cast<Operation *>(nullptr));
425   return wrap(&back);
426 }
427 
428 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation) {
429   unwrap(block)->push_back(unwrap(operation));
430 }
431 
432 void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos,
433                                    MlirOperation operation) {
434   auto &opList = unwrap(block)->getOperations();
435   opList.insert(std::next(opList.begin(), pos), unwrap(operation));
436 }
437 
438 void mlirBlockInsertOwnedOperationAfter(MlirBlock block,
439                                         MlirOperation reference,
440                                         MlirOperation operation) {
441   Block *cppBlock = unwrap(block);
442   if (mlirOperationIsNull(reference)) {
443     cppBlock->getOperations().insert(cppBlock->begin(), unwrap(operation));
444     return;
445   }
446 
447   assert(unwrap(reference)->getBlock() == unwrap(block) &&
448          "expected reference operation to belong to the block");
449   cppBlock->getOperations().insertAfter(Block::iterator(unwrap(reference)),
450                                         unwrap(operation));
451 }
452 
453 void mlirBlockInsertOwnedOperationBefore(MlirBlock block,
454                                          MlirOperation reference,
455                                          MlirOperation operation) {
456   if (mlirOperationIsNull(reference))
457     return mlirBlockAppendOwnedOperation(block, operation);
458 
459   assert(unwrap(reference)->getBlock() == unwrap(block) &&
460          "expected reference operation to belong to the block");
461   unwrap(block)->getOperations().insert(Block::iterator(unwrap(reference)),
462                                         unwrap(operation));
463 }
464 
465 void mlirBlockDestroy(MlirBlock block) { delete unwrap(block); }
466 
467 intptr_t mlirBlockGetNumArguments(MlirBlock block) {
468   return static_cast<intptr_t>(unwrap(block)->getNumArguments());
469 }
470 
471 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
472   return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
473 }
474 
475 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
476                     void *userData) {
477   detail::CallbackOstream stream(callback, userData);
478   unwrap(block)->print(stream);
479   stream.flush();
480 }
481 
482 /* ========================================================================== */
483 /* Value API.                                                                 */
484 /* ========================================================================== */
485 
486 int mlirValueIsABlockArgument(MlirValue value) {
487   return unwrap(value).isa<BlockArgument>();
488 }
489 
490 int mlirValueIsAOpResult(MlirValue value) {
491   return unwrap(value).isa<OpResult>();
492 }
493 
494 MlirBlock mlirBlockArgumentGetOwner(MlirValue value) {
495   return wrap(unwrap(value).cast<BlockArgument>().getOwner());
496 }
497 
498 intptr_t mlirBlockArgumentGetArgNumber(MlirValue value) {
499   return static_cast<intptr_t>(
500       unwrap(value).cast<BlockArgument>().getArgNumber());
501 }
502 
503 void mlirBlockArgumentSetType(MlirValue value, MlirType type) {
504   unwrap(value).cast<BlockArgument>().setType(unwrap(type));
505 }
506 
507 MlirOperation mlirOpResultGetOwner(MlirValue value) {
508   return wrap(unwrap(value).cast<OpResult>().getOwner());
509 }
510 
511 intptr_t mlirOpResultGetResultNumber(MlirValue value) {
512   return static_cast<intptr_t>(
513       unwrap(value).cast<OpResult>().getResultNumber());
514 }
515 
516 MlirType mlirValueGetType(MlirValue value) {
517   return wrap(unwrap(value).getType());
518 }
519 
520 void mlirValueDump(MlirValue value) { unwrap(value).dump(); }
521 
522 void mlirValuePrint(MlirValue value, MlirStringCallback callback,
523                     void *userData) {
524   detail::CallbackOstream stream(callback, userData);
525   unwrap(value).print(stream);
526   stream.flush();
527 }
528 
529 /* ========================================================================== */
530 /* Type API.                                                                  */
531 /* ========================================================================== */
532 
533 MlirType mlirTypeParseGet(MlirContext context, const char *type) {
534   return wrap(mlir::parseType(type, unwrap(context)));
535 }
536 
537 MlirContext mlirTypeGetContext(MlirType type) {
538   return wrap(unwrap(type).getContext());
539 }
540 
541 int mlirTypeEqual(MlirType t1, MlirType t2) { return unwrap(t1) == unwrap(t2); }
542 
543 void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData) {
544   detail::CallbackOstream stream(callback, userData);
545   unwrap(type).print(stream);
546   stream.flush();
547 }
548 
549 void mlirTypeDump(MlirType type) { unwrap(type).dump(); }
550 
551 /* ========================================================================== */
552 /* Attribute API.                                                             */
553 /* ========================================================================== */
554 
555 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr) {
556   return wrap(mlir::parseAttribute(attr, unwrap(context)));
557 }
558 
559 MlirContext mlirAttributeGetContext(MlirAttribute attribute) {
560   return wrap(unwrap(attribute).getContext());
561 }
562 
563 MlirType mlirAttributeGetType(MlirAttribute attribute) {
564   return wrap(unwrap(attribute).getType());
565 }
566 
567 int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2) {
568   return unwrap(a1) == unwrap(a2);
569 }
570 
571 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
572                         void *userData) {
573   detail::CallbackOstream stream(callback, userData);
574   unwrap(attr).print(stream);
575   stream.flush();
576 }
577 
578 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
579 
580 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr) {
581   return MlirNamedAttribute{name, attr};
582 }
583 
584 /*============================================================================*/
585 /* Identifier API.                                                            */
586 /*============================================================================*/
587 
588 MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str) {
589   return wrap(Identifier::get(unwrap(str), unwrap(context)));
590 }
591 
592 int mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other) {
593   return unwrap(ident) == unwrap(other);
594 }
595 
596 MlirStringRef mlirIdentifierStr(MlirIdentifier ident) {
597   return wrap(unwrap(ident).strref());
598 }
599