MLIR  22.0.0git
IR.cpp
Go to the documentation of this file.
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 
14 #include "mlir/CAPI/IR.h"
15 #include "mlir/CAPI/Support.h"
16 #include "mlir/CAPI/Utils.h"
17 #include "mlir/IR/Attributes.h"
19 #include "mlir/IR/BuiltinOps.h"
20 #include "mlir/IR/Diagnostics.h"
21 #include "mlir/IR/Dialect.h"
22 #include "mlir/IR/Location.h"
23 #include "mlir/IR/Operation.h"
25 #include "mlir/IR/OwningOpRef.h"
26 #include "mlir/IR/Types.h"
27 #include "mlir/IR/Value.h"
28 #include "mlir/IR/Verifier.h"
29 #include "mlir/IR/Visitors.h"
31 #include "mlir/Parser/Parser.h"
32 #include "llvm/ADT/SmallPtrSet.h"
33 #include "llvm/Support/ThreadPool.h"
34 
35 #include <cstddef>
36 #include <memory>
37 #include <optional>
38 
39 using namespace mlir;
40 
41 //===----------------------------------------------------------------------===//
42 // Context API.
43 //===----------------------------------------------------------------------===//
44 
45 MlirContext mlirContextCreate() {
46  auto *context = new MLIRContext;
47  return wrap(context);
48 }
49 
50 static inline MLIRContext::Threading toThreadingEnum(bool threadingEnabled) {
51  return threadingEnabled ? MLIRContext::Threading::ENABLED
53 }
54 
55 MlirContext mlirContextCreateWithThreading(bool threadingEnabled) {
56  auto *context = new MLIRContext(toThreadingEnum(threadingEnabled));
57  return wrap(context);
58 }
59 
60 MlirContext mlirContextCreateWithRegistry(MlirDialectRegistry registry,
61  bool threadingEnabled) {
62  auto *context =
63  new MLIRContext(*unwrap(registry), toThreadingEnum(threadingEnabled));
64  return wrap(context);
65 }
66 
67 bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2) {
68  return unwrap(ctx1) == unwrap(ctx2);
69 }
70 
71 void mlirContextDestroy(MlirContext context) { delete unwrap(context); }
72 
73 void mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow) {
74  unwrap(context)->allowUnregisteredDialects(allow);
75 }
76 
77 bool mlirContextGetAllowUnregisteredDialects(MlirContext context) {
78  return unwrap(context)->allowsUnregisteredDialects();
79 }
80 intptr_t mlirContextGetNumRegisteredDialects(MlirContext context) {
81  return static_cast<intptr_t>(unwrap(context)->getAvailableDialects().size());
82 }
83 
84 void mlirContextAppendDialectRegistry(MlirContext ctx,
85  MlirDialectRegistry registry) {
86  unwrap(ctx)->appendDialectRegistry(*unwrap(registry));
87 }
88 
89 // TODO: expose a cheaper way than constructing + sorting a vector only to take
90 // its size.
91 intptr_t mlirContextGetNumLoadedDialects(MlirContext context) {
92  return static_cast<intptr_t>(unwrap(context)->getLoadedDialects().size());
93 }
94 
95 MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
96  MlirStringRef name) {
97  return wrap(unwrap(context)->getOrLoadDialect(unwrap(name)));
98 }
99 
100 bool mlirContextIsRegisteredOperation(MlirContext context, MlirStringRef name) {
101  return unwrap(context)->isOperationRegistered(unwrap(name));
102 }
103 
104 void mlirContextEnableMultithreading(MlirContext context, bool enable) {
105  return unwrap(context)->enableMultithreading(enable);
106 }
107 
108 void mlirContextLoadAllAvailableDialects(MlirContext context) {
109  unwrap(context)->loadAllAvailableDialects();
110 }
111 
112 void mlirContextSetThreadPool(MlirContext context,
113  MlirLlvmThreadPool threadPool) {
114  unwrap(context)->setThreadPool(*unwrap(threadPool));
115 }
116 
117 unsigned mlirContextGetNumThreads(MlirContext context) {
118  return unwrap(context)->getNumThreads();
119 }
120 
121 MlirLlvmThreadPool mlirContextGetThreadPool(MlirContext context) {
122  return wrap(&unwrap(context)->getThreadPool());
123 }
124 
125 //===----------------------------------------------------------------------===//
126 // Dialect API.
127 //===----------------------------------------------------------------------===//
128 
129 MlirContext mlirDialectGetContext(MlirDialect dialect) {
130  return wrap(unwrap(dialect)->getContext());
131 }
132 
133 bool mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2) {
134  return unwrap(dialect1) == unwrap(dialect2);
135 }
136 
138  return wrap(unwrap(dialect)->getNamespace());
139 }
140 
141 //===----------------------------------------------------------------------===//
142 // DialectRegistry API.
143 //===----------------------------------------------------------------------===//
144 
145 MlirDialectRegistry mlirDialectRegistryCreate() {
146  return wrap(new DialectRegistry());
147 }
148 
149 void mlirDialectRegistryDestroy(MlirDialectRegistry registry) {
150  delete unwrap(registry);
151 }
152 
153 //===----------------------------------------------------------------------===//
154 // AsmState API.
155 //===----------------------------------------------------------------------===//
156 
157 MlirAsmState mlirAsmStateCreateForOperation(MlirOperation op,
158  MlirOpPrintingFlags flags) {
159  return wrap(new AsmState(unwrap(op), *unwrap(flags)));
160 }
161 
162 static Operation *findParent(Operation *op, bool shouldUseLocalScope) {
163  do {
164  // If we are printing local scope, stop at the first operation that is
165  // isolated from above.
166  if (shouldUseLocalScope && op->hasTrait<OpTrait::IsIsolatedFromAbove>())
167  break;
168 
169  // Otherwise, traverse up to the next parent.
170  Operation *parentOp = op->getParentOp();
171  if (!parentOp)
172  break;
173  op = parentOp;
174  } while (true);
175  return op;
176 }
177 
178 MlirAsmState mlirAsmStateCreateForValue(MlirValue value,
179  MlirOpPrintingFlags flags) {
180  Operation *op;
181  mlir::Value val = unwrap(value);
182  if (auto result = llvm::dyn_cast<OpResult>(val)) {
183  op = result.getOwner();
184  } else {
185  op = llvm::cast<BlockArgument>(val).getOwner()->getParentOp();
186  if (!op) {
187  emitError(val.getLoc()) << "<<UNKNOWN SSA VALUE>>";
188  return {nullptr};
189  }
190  }
191  op = findParent(op, unwrap(flags)->shouldUseLocalScope());
192  return wrap(new AsmState(op, *unwrap(flags)));
193 }
194 
195 /// Destroys printing flags created with mlirAsmStateCreate.
196 void mlirAsmStateDestroy(MlirAsmState state) { delete unwrap(state); }
197 
198 //===----------------------------------------------------------------------===//
199 // Printing flags API.
200 //===----------------------------------------------------------------------===//
201 
202 MlirOpPrintingFlags mlirOpPrintingFlagsCreate() {
203  return wrap(new OpPrintingFlags());
204 }
205 
206 void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags) {
207  delete unwrap(flags);
208 }
209 
210 void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
211  intptr_t largeElementLimit) {
212  unwrap(flags)->elideLargeElementsAttrs(largeElementLimit);
213 }
214 
215 void mlirOpPrintingFlagsElideLargeResourceString(MlirOpPrintingFlags flags,
216  intptr_t largeResourceLimit) {
217  unwrap(flags)->elideLargeResourceString(largeResourceLimit);
218 }
219 
220 void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable,
221  bool prettyForm) {
222  unwrap(flags)->enableDebugInfo(enable, /*prettyForm=*/prettyForm);
223 }
224 
225 void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags) {
226  unwrap(flags)->printGenericOpForm();
227 }
228 
229 void mlirOpPrintingFlagsPrintNameLocAsPrefix(MlirOpPrintingFlags flags) {
230  unwrap(flags)->printNameLocAsPrefix();
231 }
232 
233 void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags) {
234  unwrap(flags)->useLocalScope();
235 }
236 
237 void mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags) {
238  unwrap(flags)->assumeVerified();
239 }
240 
241 void mlirOpPrintingFlagsSkipRegions(MlirOpPrintingFlags flags) {
242  unwrap(flags)->skipRegions();
243 }
244 //===----------------------------------------------------------------------===//
245 // Bytecode printing flags API.
246 //===----------------------------------------------------------------------===//
247 
248 MlirBytecodeWriterConfig mlirBytecodeWriterConfigCreate() {
249  return wrap(new BytecodeWriterConfig());
250 }
251 
252 void mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config) {
253  delete unwrap(config);
254 }
255 
256 void mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags,
257  int64_t version) {
258  unwrap(flags)->setDesiredBytecodeVersion(version);
259 }
260 
261 //===----------------------------------------------------------------------===//
262 // Location API.
263 //===----------------------------------------------------------------------===//
264 
265 MlirAttribute mlirLocationGetAttribute(MlirLocation location) {
266  return wrap(LocationAttr(unwrap(location)));
267 }
268 
269 MlirLocation mlirLocationFromAttribute(MlirAttribute attribute) {
270  return wrap(Location(llvm::dyn_cast<LocationAttr>(unwrap(attribute))));
271 }
272 
273 MlirLocation mlirLocationFileLineColGet(MlirContext context,
274  MlirStringRef filename, unsigned line,
275  unsigned col) {
276  return wrap(Location(
277  FileLineColLoc::get(unwrap(context), unwrap(filename), line, col)));
278 }
279 
280 MlirLocation
281 mlirLocationFileLineColRangeGet(MlirContext context, MlirStringRef filename,
282  unsigned startLine, unsigned startCol,
283  unsigned endLine, unsigned endCol) {
284  return wrap(
285  Location(FileLineColRange::get(unwrap(context), unwrap(filename),
286  startLine, startCol, endLine, endCol)));
287 }
288 
289 MlirIdentifier mlirLocationFileLineColRangeGetFilename(MlirLocation location) {
290  return wrap(llvm::dyn_cast<FileLineColRange>(unwrap(location)).getFilename());
291 }
292 
293 int mlirLocationFileLineColRangeGetStartLine(MlirLocation location) {
294  if (auto loc = llvm::dyn_cast<FileLineColRange>(unwrap(location)))
295  return loc.getStartLine();
296  return -1;
297 }
298 
299 int mlirLocationFileLineColRangeGetStartColumn(MlirLocation location) {
300  if (auto loc = llvm::dyn_cast<FileLineColRange>(unwrap(location)))
301  return loc.getStartColumn();
302  return -1;
303 }
304 
305 int mlirLocationFileLineColRangeGetEndLine(MlirLocation location) {
306  if (auto loc = llvm::dyn_cast<FileLineColRange>(unwrap(location)))
307  return loc.getEndLine();
308  return -1;
309 }
310 
311 int mlirLocationFileLineColRangeGetEndColumn(MlirLocation location) {
312  if (auto loc = llvm::dyn_cast<FileLineColRange>(unwrap(location)))
313  return loc.getEndColumn();
314  return -1;
315 }
316 
318  return wrap(FileLineColRange::getTypeID());
319 }
320 
321 bool mlirLocationIsAFileLineColRange(MlirLocation location) {
322  return isa<FileLineColRange>(unwrap(location));
323 }
324 
325 MlirLocation mlirLocationCallSiteGet(MlirLocation callee, MlirLocation caller) {
326  return wrap(Location(CallSiteLoc::get(unwrap(callee), unwrap(caller))));
327 }
328 
329 MlirLocation mlirLocationCallSiteGetCallee(MlirLocation location) {
330  return wrap(
331  Location(llvm::dyn_cast<CallSiteLoc>(unwrap(location)).getCallee()));
332 }
333 
334 MlirLocation mlirLocationCallSiteGetCaller(MlirLocation location) {
335  return wrap(
336  Location(llvm::dyn_cast<CallSiteLoc>(unwrap(location)).getCaller()));
337 }
338 
340  return wrap(CallSiteLoc::getTypeID());
341 }
342 
343 bool mlirLocationIsACallSite(MlirLocation location) {
344  return isa<CallSiteLoc>(unwrap(location));
345 }
346 
347 MlirLocation mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations,
348  MlirLocation const *locations,
349  MlirAttribute metadata) {
351  ArrayRef<Location> unwrappedLocs = unwrapList(nLocations, locations, locs);
352  return wrap(FusedLoc::get(unwrappedLocs, unwrap(metadata), unwrap(ctx)));
353 }
354 
355 unsigned mlirLocationFusedGetNumLocations(MlirLocation location) {
356  if (auto locationsArrRef = llvm::dyn_cast<FusedLoc>(unwrap(location)))
357  return locationsArrRef.getLocations().size();
358  return 0;
359 }
360 
361 void mlirLocationFusedGetLocations(MlirLocation location,
362  MlirLocation *locationsCPtr) {
363  if (auto locationsArrRef = llvm::dyn_cast<FusedLoc>(unwrap(location))) {
364  for (auto [i, location] : llvm::enumerate(locationsArrRef.getLocations()))
365  locationsCPtr[i] = wrap(location);
366  }
367 }
368 
369 MlirAttribute mlirLocationFusedGetMetadata(MlirLocation location) {
370  return wrap(llvm::dyn_cast<FusedLoc>(unwrap(location)).getMetadata());
371 }
372 
373 MlirTypeID mlirLocationFusedGetTypeID() { return wrap(FusedLoc::getTypeID()); }
374 
375 bool mlirLocationIsAFused(MlirLocation location) {
376  return isa<FusedLoc>(unwrap(location));
377 }
378 
379 MlirLocation mlirLocationNameGet(MlirContext context, MlirStringRef name,
380  MlirLocation childLoc) {
381  if (mlirLocationIsNull(childLoc))
382  return wrap(
383  Location(NameLoc::get(StringAttr::get(unwrap(context), unwrap(name)))));
384  return wrap(Location(NameLoc::get(
385  StringAttr::get(unwrap(context), unwrap(name)), unwrap(childLoc))));
386 }
387 
388 MlirIdentifier mlirLocationNameGetName(MlirLocation location) {
389  return wrap((llvm::dyn_cast<NameLoc>(unwrap(location)).getName()));
390 }
391 
392 MlirLocation mlirLocationNameGetChildLoc(MlirLocation location) {
393  return wrap(
394  Location(llvm::dyn_cast<NameLoc>(unwrap(location)).getChildLoc()));
395 }
396 
397 MlirTypeID mlirLocationNameGetTypeID() { return wrap(NameLoc::getTypeID()); }
398 
399 bool mlirLocationIsAName(MlirLocation location) {
400  return isa<NameLoc>(unwrap(location));
401 }
402 
403 MlirLocation mlirLocationUnknownGet(MlirContext context) {
404  return wrap(Location(UnknownLoc::get(unwrap(context))));
405 }
406 
407 bool mlirLocationEqual(MlirLocation l1, MlirLocation l2) {
408  return unwrap(l1) == unwrap(l2);
409 }
410 
411 MlirContext mlirLocationGetContext(MlirLocation location) {
412  return wrap(unwrap(location).getContext());
413 }
414 
415 void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
416  void *userData) {
417  detail::CallbackOstream stream(callback, userData);
418  unwrap(location).print(stream);
419 }
420 
421 //===----------------------------------------------------------------------===//
422 // Module API.
423 //===----------------------------------------------------------------------===//
424 
425 MlirModule mlirModuleCreateEmpty(MlirLocation location) {
426  return wrap(ModuleOp::create(unwrap(location)));
427 }
428 
429 MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module) {
430  OwningOpRef<ModuleOp> owning =
431  parseSourceString<ModuleOp>(unwrap(module), unwrap(context));
432  if (!owning)
433  return MlirModule{nullptr};
434  return MlirModule{owning.release().getOperation()};
435 }
436 
437 MlirModule mlirModuleCreateParseFromFile(MlirContext context,
438  MlirStringRef fileName) {
439  OwningOpRef<ModuleOp> owning =
440  parseSourceFile<ModuleOp>(unwrap(fileName), unwrap(context));
441  if (!owning)
442  return MlirModule{nullptr};
443  return MlirModule{owning.release().getOperation()};
444 }
445 
446 MlirContext mlirModuleGetContext(MlirModule module) {
447  return wrap(unwrap(module).getContext());
448 }
449 
450 MlirBlock mlirModuleGetBody(MlirModule module) {
451  return wrap(unwrap(module).getBody());
452 }
453 
454 void mlirModuleDestroy(MlirModule module) {
455  // Transfer ownership to an OwningOpRef<ModuleOp> so that its destructor is
456  // called.
457  OwningOpRef<ModuleOp>(unwrap(module));
458 }
459 
460 MlirOperation mlirModuleGetOperation(MlirModule module) {
461  return wrap(unwrap(module).getOperation());
462 }
463 
464 MlirModule mlirModuleFromOperation(MlirOperation op) {
465  return wrap(dyn_cast<ModuleOp>(unwrap(op)));
466 }
467 
468 bool mlirModuleEqual(MlirModule lhs, MlirModule rhs) {
469  return unwrap(lhs) == unwrap(rhs);
470 }
471 
472 size_t mlirModuleHashValue(MlirModule mod) {
473  return OperationEquivalence::computeHash(unwrap(mod).getOperation());
474 }
475 
476 //===----------------------------------------------------------------------===//
477 // Operation state API.
478 //===----------------------------------------------------------------------===//
479 
481  MlirOperationState state;
482  state.name = name;
483  state.location = loc;
484  state.nResults = 0;
485  state.results = nullptr;
486  state.nOperands = 0;
487  state.operands = nullptr;
488  state.nRegions = 0;
489  state.regions = nullptr;
490  state.nSuccessors = 0;
491  state.successors = nullptr;
492  state.nAttributes = 0;
493  state.attributes = nullptr;
494  state.enableResultTypeInference = false;
495  return state;
496 }
497 
498 #define APPEND_ELEMS(type, sizeName, elemName) \
499  state->elemName = \
500  (type *)realloc(state->elemName, (state->sizeName + n) * sizeof(type)); \
501  memcpy(state->elemName + state->sizeName, elemName, n * sizeof(type)); \
502  state->sizeName += n;
503 
505  MlirType const *results) {
506  APPEND_ELEMS(MlirType, nResults, results);
507 }
508 
510  MlirValue const *operands) {
511  APPEND_ELEMS(MlirValue, nOperands, operands);
512 }
514  MlirRegion const *regions) {
515  APPEND_ELEMS(MlirRegion, nRegions, regions);
516 }
518  MlirBlock const *successors) {
519  APPEND_ELEMS(MlirBlock, nSuccessors, successors);
520 }
522  MlirNamedAttribute const *attributes) {
523  APPEND_ELEMS(MlirNamedAttribute, nAttributes, attributes);
524 }
525 
527  state->enableResultTypeInference = true;
528 }
529 
530 //===----------------------------------------------------------------------===//
531 // Operation API.
532 //===----------------------------------------------------------------------===//
533 
534 static LogicalResult inferOperationTypes(OperationState &state) {
535  MLIRContext *context = state.getContext();
536  std::optional<RegisteredOperationName> info = state.name.getRegisteredInfo();
537  if (!info) {
538  emitError(state.location)
539  << "type inference was requested for the operation " << state.name
540  << ", but the operation was not registered; ensure that the dialect "
541  "containing the operation is linked into MLIR and registered with "
542  "the context";
543  return failure();
544  }
545 
546  auto *inferInterface = info->getInterface<InferTypeOpInterface>();
547  if (!inferInterface) {
548  emitError(state.location)
549  << "type inference was requested for the operation " << state.name
550  << ", but the operation does not support type inference; result "
551  "types must be specified explicitly";
552  return failure();
553  }
554 
555  DictionaryAttr attributes = state.attributes.getDictionary(context);
556  OpaqueProperties properties = state.getRawProperties();
557 
558  if (!properties && info->getOpPropertyByteSize() > 0 && !attributes.empty()) {
559  auto prop = std::make_unique<char[]>(info->getOpPropertyByteSize());
560  properties = OpaqueProperties(prop.get());
561  if (properties) {
562  auto emitError = [&]() {
563  return mlir::emitError(state.location)
564  << " failed properties conversion while building "
565  << state.name.getStringRef() << " with `" << attributes << "`: ";
566  };
567  if (failed(info->setOpPropertiesFromAttribute(state.name, properties,
568  attributes, emitError)))
569  return failure();
570  }
571  if (succeeded(inferInterface->inferReturnTypes(
572  context, state.location, state.operands, attributes, properties,
573  state.regions, state.types))) {
574  return success();
575  }
576  // Diagnostic emitted by interface.
577  return failure();
578  }
579 
580  if (succeeded(inferInterface->inferReturnTypes(
581  context, state.location, state.operands, attributes, properties,
582  state.regions, state.types)))
583  return success();
584 
585  // Diagnostic emitted by interface.
586  return failure();
587 }
588 
590  assert(state);
591  OperationState cppState(unwrap(state->location), unwrap(state->name));
592  SmallVector<Type, 4> resultStorage;
593  SmallVector<Value, 8> operandStorage;
594  SmallVector<Block *, 2> successorStorage;
595  cppState.addTypes(unwrapList(state->nResults, state->results, resultStorage));
596  cppState.addOperands(
597  unwrapList(state->nOperands, state->operands, operandStorage));
598  cppState.addSuccessors(
599  unwrapList(state->nSuccessors, state->successors, successorStorage));
600 
601  cppState.attributes.reserve(state->nAttributes);
602  for (intptr_t i = 0; i < state->nAttributes; ++i)
603  cppState.addAttribute(unwrap(state->attributes[i].name),
604  unwrap(state->attributes[i].attribute));
605 
606  for (intptr_t i = 0; i < state->nRegions; ++i)
607  cppState.addRegion(std::unique_ptr<Region>(unwrap(state->regions[i])));
608 
609  free(state->results);
610  free(state->operands);
611  free(state->successors);
612  free(state->regions);
613  free(state->attributes);
614 
615  // Infer result types.
616  if (state->enableResultTypeInference) {
617  assert(cppState.types.empty() &&
618  "result type inference enabled and result types provided");
619  if (failed(inferOperationTypes(cppState)))
620  return {nullptr};
621  }
622 
623  return wrap(Operation::create(cppState));
624 }
625 
626 MlirOperation mlirOperationCreateParse(MlirContext context,
627  MlirStringRef sourceStr,
628  MlirStringRef sourceName) {
629 
630  return wrap(
631  parseSourceString(unwrap(sourceStr), unwrap(context), unwrap(sourceName))
632  .release());
633 }
634 
635 MlirOperation mlirOperationClone(MlirOperation op) {
636  return wrap(unwrap(op)->clone());
637 }
638 
639 void mlirOperationDestroy(MlirOperation op) { unwrap(op)->erase(); }
640 
641 void mlirOperationRemoveFromParent(MlirOperation op) { unwrap(op)->remove(); }
642 
643 bool mlirOperationEqual(MlirOperation op, MlirOperation other) {
644  return unwrap(op) == unwrap(other);
645 }
646 
647 size_t mlirOperationHashValue(MlirOperation op) {
649 }
650 
651 MlirContext mlirOperationGetContext(MlirOperation op) {
652  return wrap(unwrap(op)->getContext());
653 }
654 
655 MlirLocation mlirOperationGetLocation(MlirOperation op) {
656  return wrap(unwrap(op)->getLoc());
657 }
658 
659 MlirTypeID mlirOperationGetTypeID(MlirOperation op) {
660  if (auto info = unwrap(op)->getRegisteredInfo())
661  return wrap(info->getTypeID());
662  return {nullptr};
663 }
664 
665 MlirIdentifier mlirOperationGetName(MlirOperation op) {
666  return wrap(unwrap(op)->getName().getIdentifier());
667 }
668 
669 MlirBlock mlirOperationGetBlock(MlirOperation op) {
670  return wrap(unwrap(op)->getBlock());
671 }
672 
673 MlirOperation mlirOperationGetParentOperation(MlirOperation op) {
674  return wrap(unwrap(op)->getParentOp());
675 }
676 
677 intptr_t mlirOperationGetNumRegions(MlirOperation op) {
678  return static_cast<intptr_t>(unwrap(op)->getNumRegions());
679 }
680 
681 MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos) {
682  return wrap(&unwrap(op)->getRegion(static_cast<unsigned>(pos)));
683 }
684 
685 MlirRegion mlirOperationGetFirstRegion(MlirOperation op) {
686  Operation *cppOp = unwrap(op);
687  if (cppOp->getNumRegions() == 0)
688  return wrap(static_cast<Region *>(nullptr));
689  return wrap(&cppOp->getRegion(0));
690 }
691 
692 MlirRegion mlirRegionGetNextInOperation(MlirRegion region) {
693  Region *cppRegion = unwrap(region);
694  Operation *parent = cppRegion->getParentOp();
695  intptr_t next = cppRegion->getRegionNumber() + 1;
696  if (parent->getNumRegions() > next)
697  return wrap(&parent->getRegion(next));
698  return wrap(static_cast<Region *>(nullptr));
699 }
700 
701 MlirOperation mlirOperationGetNextInBlock(MlirOperation op) {
702  return wrap(unwrap(op)->getNextNode());
703 }
704 
705 intptr_t mlirOperationGetNumOperands(MlirOperation op) {
706  return static_cast<intptr_t>(unwrap(op)->getNumOperands());
707 }
708 
709 MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos) {
710  return wrap(unwrap(op)->getOperand(static_cast<unsigned>(pos)));
711 }
712 
713 void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
714  MlirValue newValue) {
715  unwrap(op)->setOperand(static_cast<unsigned>(pos), unwrap(newValue));
716 }
717 
718 void mlirOperationSetOperands(MlirOperation op, intptr_t nOperands,
719  MlirValue const *operands) {
720  SmallVector<Value> ops;
721  unwrap(op)->setOperands(unwrapList(nOperands, operands, ops));
722 }
723 
724 intptr_t mlirOperationGetNumResults(MlirOperation op) {
725  return static_cast<intptr_t>(unwrap(op)->getNumResults());
726 }
727 
728 MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos) {
729  return wrap(unwrap(op)->getResult(static_cast<unsigned>(pos)));
730 }
731 
732 intptr_t mlirOperationGetNumSuccessors(MlirOperation op) {
733  return static_cast<intptr_t>(unwrap(op)->getNumSuccessors());
734 }
735 
736 MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos) {
737  return wrap(unwrap(op)->getSuccessor(static_cast<unsigned>(pos)));
738 }
739 
742  std::optional<Attribute> attr = unwrap(op)->getInherentAttr(unwrap(name));
743  return attr.has_value();
744 }
745 
746 MlirAttribute mlirOperationGetInherentAttributeByName(MlirOperation op,
747  MlirStringRef name) {
748  std::optional<Attribute> attr = unwrap(op)->getInherentAttr(unwrap(name));
749  if (attr.has_value())
750  return wrap(*attr);
751  return {};
752 }
753 
755  MlirStringRef name,
756  MlirAttribute attr) {
757  unwrap(op)->setInherentAttr(
758  StringAttr::get(unwrap(op)->getContext(), unwrap(name)), unwrap(attr));
759 }
760 
761 intptr_t mlirOperationGetNumDiscardableAttributes(MlirOperation op) {
762  return static_cast<intptr_t>(
763  llvm::range_size(unwrap(op)->getDiscardableAttrs()));
764 }
765 
767  intptr_t pos) {
768  NamedAttribute attr =
769  *std::next(unwrap(op)->getDiscardableAttrs().begin(), pos);
770  return MlirNamedAttribute{wrap(attr.getName()), wrap(attr.getValue())};
771 }
772 
773 MlirAttribute mlirOperationGetDiscardableAttributeByName(MlirOperation op,
774  MlirStringRef name) {
775  return wrap(unwrap(op)->getDiscardableAttr(unwrap(name)));
776 }
777 
779  MlirStringRef name,
780  MlirAttribute attr) {
781  unwrap(op)->setDiscardableAttr(unwrap(name), unwrap(attr));
782 }
783 
785  MlirStringRef name) {
786  return !!unwrap(op)->removeDiscardableAttr(unwrap(name));
787 }
788 
789 void mlirOperationSetSuccessor(MlirOperation op, intptr_t pos,
790  MlirBlock block) {
791  unwrap(op)->setSuccessor(unwrap(block), static_cast<unsigned>(pos));
792 }
793 
794 intptr_t mlirOperationGetNumAttributes(MlirOperation op) {
795  return static_cast<intptr_t>(unwrap(op)->getAttrs().size());
796 }
797 
798 MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos) {
799  NamedAttribute attr = unwrap(op)->getAttrs()[pos];
800  return MlirNamedAttribute{wrap(attr.getName()), wrap(attr.getValue())};
801 }
802 
803 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
804  MlirStringRef name) {
805  return wrap(unwrap(op)->getAttr(unwrap(name)));
806 }
807 
808 void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name,
809  MlirAttribute attr) {
810  unwrap(op)->setAttr(unwrap(name), unwrap(attr));
811 }
812 
813 bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name) {
814  return !!unwrap(op)->removeAttr(unwrap(name));
815 }
816 
817 void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
818  void *userData) {
819  detail::CallbackOstream stream(callback, userData);
820  unwrap(op)->print(stream);
821 }
822 
823 void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags,
824  MlirStringCallback callback, void *userData) {
825  detail::CallbackOstream stream(callback, userData);
826  unwrap(op)->print(stream, *unwrap(flags));
827 }
828 
829 void mlirOperationPrintWithState(MlirOperation op, MlirAsmState state,
830  MlirStringCallback callback, void *userData) {
831  detail::CallbackOstream stream(callback, userData);
832  if (state.ptr)
833  unwrap(op)->print(stream, *unwrap(state));
834  unwrap(op)->print(stream);
835 }
836 
837 void mlirOperationWriteBytecode(MlirOperation op, MlirStringCallback callback,
838  void *userData) {
839  detail::CallbackOstream stream(callback, userData);
840  // As no desired version is set, no failure can occur.
841  (void)writeBytecodeToFile(unwrap(op), stream);
842 }
843 
845  MlirOperation op, MlirBytecodeWriterConfig config,
846  MlirStringCallback callback, void *userData) {
847  detail::CallbackOstream stream(callback, userData);
848  return wrap(writeBytecodeToFile(unwrap(op), stream, *unwrap(config)));
849 }
850 
851 void mlirOperationDump(MlirOperation op) { return unwrap(op)->dump(); }
852 
853 bool mlirOperationVerify(MlirOperation op) {
854  return succeeded(verify(unwrap(op)));
855 }
856 
857 void mlirOperationMoveAfter(MlirOperation op, MlirOperation other) {
858  return unwrap(op)->moveAfter(unwrap(other));
859 }
860 
861 void mlirOperationMoveBefore(MlirOperation op, MlirOperation other) {
862  return unwrap(op)->moveBefore(unwrap(other));
863 }
864 
865 bool mlirOperationIsBeforeInBlock(MlirOperation op, MlirOperation other) {
866  return unwrap(op)->isBeforeInBlock(unwrap(other));
867 }
868 
870  switch (result) {
872  return mlir::WalkResult::advance();
873 
876 
877  case MlirWalkResultSkip:
878  return mlir::WalkResult::skip();
879  }
880  llvm_unreachable("unknown result in WalkResult::unwrap");
881 }
882 
883 void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback,
884  void *userData, MlirWalkOrder walkOrder) {
885  switch (walkOrder) {
886 
887  case MlirWalkPreOrder:
889  [callback, userData](Operation *op) {
890  return unwrap(callback(wrap(op), userData));
891  });
892  break;
893  case MlirWalkPostOrder:
895  [callback, userData](Operation *op) {
896  return unwrap(callback(wrap(op), userData));
897  });
898  }
899 }
900 
901 //===----------------------------------------------------------------------===//
902 // Region API.
903 //===----------------------------------------------------------------------===//
904 
905 MlirRegion mlirRegionCreate() { return wrap(new Region); }
906 
907 bool mlirRegionEqual(MlirRegion region, MlirRegion other) {
908  return unwrap(region) == unwrap(other);
909 }
910 
911 MlirBlock mlirRegionGetFirstBlock(MlirRegion region) {
912  Region *cppRegion = unwrap(region);
913  if (cppRegion->empty())
914  return wrap(static_cast<Block *>(nullptr));
915  return wrap(&cppRegion->front());
916 }
917 
918 void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block) {
919  unwrap(region)->push_back(unwrap(block));
920 }
921 
922 void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos,
923  MlirBlock block) {
924  auto &blockList = unwrap(region)->getBlocks();
925  blockList.insert(std::next(blockList.begin(), pos), unwrap(block));
926 }
927 
928 void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference,
929  MlirBlock block) {
930  Region *cppRegion = unwrap(region);
931  if (mlirBlockIsNull(reference)) {
932  cppRegion->getBlocks().insert(cppRegion->begin(), unwrap(block));
933  return;
934  }
935 
936  assert(unwrap(reference)->getParent() == unwrap(region) &&
937  "expected reference block to belong to the region");
938  cppRegion->getBlocks().insertAfter(Region::iterator(unwrap(reference)),
939  unwrap(block));
940 }
941 
942 void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference,
943  MlirBlock block) {
944  if (mlirBlockIsNull(reference))
945  return mlirRegionAppendOwnedBlock(region, block);
946 
947  assert(unwrap(reference)->getParent() == unwrap(region) &&
948  "expected reference block to belong to the region");
949  unwrap(region)->getBlocks().insert(Region::iterator(unwrap(reference)),
950  unwrap(block));
951 }
952 
953 void mlirRegionDestroy(MlirRegion region) {
954  delete static_cast<Region *>(region.ptr);
955 }
956 
957 void mlirRegionTakeBody(MlirRegion target, MlirRegion source) {
958  unwrap(target)->takeBody(*unwrap(source));
959 }
960 
961 //===----------------------------------------------------------------------===//
962 // Block API.
963 //===----------------------------------------------------------------------===//
964 
965 MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args,
966  MlirLocation const *locs) {
967  Block *b = new Block;
968  for (intptr_t i = 0; i < nArgs; ++i)
969  b->addArgument(unwrap(args[i]), unwrap(locs[i]));
970  return wrap(b);
971 }
972 
973 bool mlirBlockEqual(MlirBlock block, MlirBlock other) {
974  return unwrap(block) == unwrap(other);
975 }
976 
977 MlirOperation mlirBlockGetParentOperation(MlirBlock block) {
978  return wrap(unwrap(block)->getParentOp());
979 }
980 
981 MlirRegion mlirBlockGetParentRegion(MlirBlock block) {
982  return wrap(unwrap(block)->getParent());
983 }
984 
985 MlirBlock mlirBlockGetNextInRegion(MlirBlock block) {
986  return wrap(unwrap(block)->getNextNode());
987 }
988 
989 MlirOperation mlirBlockGetFirstOperation(MlirBlock block) {
990  Block *cppBlock = unwrap(block);
991  if (cppBlock->empty())
992  return wrap(static_cast<Operation *>(nullptr));
993  return wrap(&cppBlock->front());
994 }
995 
996 MlirOperation mlirBlockGetTerminator(MlirBlock block) {
997  Block *cppBlock = unwrap(block);
998  if (cppBlock->empty())
999  return wrap(static_cast<Operation *>(nullptr));
1000  Operation &back = cppBlock->back();
1001  if (!back.hasTrait<OpTrait::IsTerminator>())
1002  return wrap(static_cast<Operation *>(nullptr));
1003  return wrap(&back);
1004 }
1005 
1006 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation) {
1007  unwrap(block)->push_back(unwrap(operation));
1008 }
1009 
1010 void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos,
1011  MlirOperation operation) {
1012  auto &opList = unwrap(block)->getOperations();
1013  opList.insert(std::next(opList.begin(), pos), unwrap(operation));
1014 }
1015 
1017  MlirOperation reference,
1018  MlirOperation operation) {
1019  Block *cppBlock = unwrap(block);
1020  if (mlirOperationIsNull(reference)) {
1021  cppBlock->getOperations().insert(cppBlock->begin(), unwrap(operation));
1022  return;
1023  }
1024 
1025  assert(unwrap(reference)->getBlock() == unwrap(block) &&
1026  "expected reference operation to belong to the block");
1027  cppBlock->getOperations().insertAfter(Block::iterator(unwrap(reference)),
1028  unwrap(operation));
1029 }
1030 
1032  MlirOperation reference,
1033  MlirOperation operation) {
1034  if (mlirOperationIsNull(reference))
1035  return mlirBlockAppendOwnedOperation(block, operation);
1036 
1037  assert(unwrap(reference)->getBlock() == unwrap(block) &&
1038  "expected reference operation to belong to the block");
1039  unwrap(block)->getOperations().insert(Block::iterator(unwrap(reference)),
1040  unwrap(operation));
1041 }
1042 
1043 void mlirBlockDestroy(MlirBlock block) { delete unwrap(block); }
1044 
1045 void mlirBlockDetach(MlirBlock block) {
1046  Block *b = unwrap(block);
1047  b->getParent()->getBlocks().remove(b);
1048 }
1049 
1050 intptr_t mlirBlockGetNumArguments(MlirBlock block) {
1051  return static_cast<intptr_t>(unwrap(block)->getNumArguments());
1052 }
1053 
1054 MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type,
1055  MlirLocation loc) {
1056  return wrap(unwrap(block)->addArgument(unwrap(type), unwrap(loc)));
1057 }
1058 
1059 void mlirBlockEraseArgument(MlirBlock block, unsigned index) {
1060  return unwrap(block)->eraseArgument(index);
1061 }
1062 
1063 MlirValue mlirBlockInsertArgument(MlirBlock block, intptr_t pos, MlirType type,
1064  MlirLocation loc) {
1065  return wrap(unwrap(block)->insertArgument(pos, unwrap(type), unwrap(loc)));
1066 }
1067 
1068 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
1069  return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
1070 }
1071 
1072 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
1073  void *userData) {
1074  detail::CallbackOstream stream(callback, userData);
1075  unwrap(block)->print(stream);
1076 }
1077 
1078 intptr_t mlirBlockGetNumSuccessors(MlirBlock block) {
1079  return static_cast<intptr_t>(unwrap(block)->getNumSuccessors());
1080 }
1081 
1082 MlirBlock mlirBlockGetSuccessor(MlirBlock block, intptr_t pos) {
1083  return wrap(unwrap(block)->getSuccessor(static_cast<unsigned>(pos)));
1084 }
1085 
1086 intptr_t mlirBlockGetNumPredecessors(MlirBlock block) {
1087  Block *b = unwrap(block);
1088  return static_cast<intptr_t>(std::distance(b->pred_begin(), b->pred_end()));
1089 }
1090 
1091 MlirBlock mlirBlockGetPredecessor(MlirBlock block, intptr_t pos) {
1092  Block *b = unwrap(block);
1093  Block::pred_iterator it = b->pred_begin();
1094  std::advance(it, pos);
1095  return wrap(*it);
1096 }
1097 
1098 //===----------------------------------------------------------------------===//
1099 // Value API.
1100 //===----------------------------------------------------------------------===//
1101 
1102 bool mlirValueEqual(MlirValue value1, MlirValue value2) {
1103  return unwrap(value1) == unwrap(value2);
1104 }
1105 
1106 bool mlirValueIsABlockArgument(MlirValue value) {
1107  return llvm::isa<BlockArgument>(unwrap(value));
1108 }
1109 
1110 bool mlirValueIsAOpResult(MlirValue value) {
1111  return llvm::isa<OpResult>(unwrap(value));
1112 }
1113 
1114 MlirBlock mlirBlockArgumentGetOwner(MlirValue value) {
1115  return wrap(llvm::dyn_cast<BlockArgument>(unwrap(value)).getOwner());
1116 }
1117 
1118 intptr_t mlirBlockArgumentGetArgNumber(MlirValue value) {
1119  return static_cast<intptr_t>(
1120  llvm::dyn_cast<BlockArgument>(unwrap(value)).getArgNumber());
1121 }
1122 
1123 void mlirBlockArgumentSetType(MlirValue value, MlirType type) {
1124  if (auto blockArg = llvm::dyn_cast<BlockArgument>(unwrap(value)))
1125  blockArg.setType(unwrap(type));
1126 }
1127 
1128 MlirOperation mlirOpResultGetOwner(MlirValue value) {
1129  return wrap(llvm::dyn_cast<OpResult>(unwrap(value)).getOwner());
1130 }
1131 
1132 intptr_t mlirOpResultGetResultNumber(MlirValue value) {
1133  return static_cast<intptr_t>(
1134  llvm::dyn_cast<OpResult>(unwrap(value)).getResultNumber());
1135 }
1136 
1137 MlirType mlirValueGetType(MlirValue value) {
1138  return wrap(unwrap(value).getType());
1139 }
1140 
1141 void mlirValueSetType(MlirValue value, MlirType type) {
1142  unwrap(value).setType(unwrap(type));
1143 }
1144 
1145 void mlirValueDump(MlirValue value) { unwrap(value).dump(); }
1146 
1147 void mlirValuePrint(MlirValue value, MlirStringCallback callback,
1148  void *userData) {
1149  detail::CallbackOstream stream(callback, userData);
1150  unwrap(value).print(stream);
1151 }
1152 
1153 void mlirValuePrintAsOperand(MlirValue value, MlirAsmState state,
1154  MlirStringCallback callback, void *userData) {
1155  detail::CallbackOstream stream(callback, userData);
1156  Value cppValue = unwrap(value);
1157  cppValue.printAsOperand(stream, *unwrap(state));
1158 }
1159 
1160 MlirOpOperand mlirValueGetFirstUse(MlirValue value) {
1161  Value cppValue = unwrap(value);
1162  if (cppValue.use_empty())
1163  return {};
1164 
1165  OpOperand *opOperand = cppValue.use_begin().getOperand();
1166 
1167  return wrap(opOperand);
1168 }
1169 
1170 void mlirValueReplaceAllUsesOfWith(MlirValue oldValue, MlirValue newValue) {
1171  unwrap(oldValue).replaceAllUsesWith(unwrap(newValue));
1172 }
1173 
1174 void mlirValueReplaceAllUsesExcept(MlirValue oldValue, MlirValue newValue,
1175  intptr_t numExceptions,
1176  MlirOperation *exceptions) {
1177  Value oldValueCpp = unwrap(oldValue);
1178  Value newValueCpp = unwrap(newValue);
1179 
1181  for (intptr_t i = 0; i < numExceptions; ++i) {
1182  exceptionSet.insert(unwrap(exceptions[i]));
1183  }
1184 
1185  oldValueCpp.replaceAllUsesExcept(newValueCpp, exceptionSet);
1186 }
1187 
1188 MlirLocation mlirValueGetLocation(MlirValue v) {
1189  return wrap(unwrap(v).getLoc());
1190 }
1191 
1192 MlirContext mlirValueGetContext(MlirValue v) {
1193  return wrap(unwrap(v).getContext());
1194 }
1195 
1196 //===----------------------------------------------------------------------===//
1197 // OpOperand API.
1198 //===----------------------------------------------------------------------===//
1199 
1200 bool mlirOpOperandIsNull(MlirOpOperand opOperand) { return !opOperand.ptr; }
1201 
1202 MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand) {
1203  return wrap(unwrap(opOperand)->getOwner());
1204 }
1205 
1206 MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand) {
1207  return wrap(unwrap(opOperand)->get());
1208 }
1209 
1210 unsigned mlirOpOperandGetOperandNumber(MlirOpOperand opOperand) {
1211  return unwrap(opOperand)->getOperandNumber();
1212 }
1213 
1214 MlirOpOperand mlirOpOperandGetNextUse(MlirOpOperand opOperand) {
1215  if (mlirOpOperandIsNull(opOperand))
1216  return {};
1217 
1218  OpOperand *nextOpOperand = static_cast<OpOperand *>(
1219  unwrap(opOperand)->getNextOperandUsingThisValue());
1220 
1221  if (!nextOpOperand)
1222  return {};
1223 
1224  return wrap(nextOpOperand);
1225 }
1226 
1227 //===----------------------------------------------------------------------===//
1228 // Type API.
1229 //===----------------------------------------------------------------------===//
1230 
1231 MlirType mlirTypeParseGet(MlirContext context, MlirStringRef type) {
1232  return wrap(mlir::parseType(unwrap(type), unwrap(context)));
1233 }
1234 
1235 MlirContext mlirTypeGetContext(MlirType type) {
1236  return wrap(unwrap(type).getContext());
1237 }
1238 
1239 MlirTypeID mlirTypeGetTypeID(MlirType type) {
1240  return wrap(unwrap(type).getTypeID());
1241 }
1242 
1243 MlirDialect mlirTypeGetDialect(MlirType type) {
1244  return wrap(&unwrap(type).getDialect());
1245 }
1246 
1247 bool mlirTypeEqual(MlirType t1, MlirType t2) {
1248  return unwrap(t1) == unwrap(t2);
1249 }
1250 
1251 void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData) {
1252  detail::CallbackOstream stream(callback, userData);
1253  unwrap(type).print(stream);
1254 }
1255 
1256 void mlirTypeDump(MlirType type) { unwrap(type).dump(); }
1257 
1258 //===----------------------------------------------------------------------===//
1259 // Attribute API.
1260 //===----------------------------------------------------------------------===//
1261 
1262 MlirAttribute mlirAttributeParseGet(MlirContext context, MlirStringRef attr) {
1263  return wrap(mlir::parseAttribute(unwrap(attr), unwrap(context)));
1264 }
1265 
1266 MlirContext mlirAttributeGetContext(MlirAttribute attribute) {
1267  return wrap(unwrap(attribute).getContext());
1268 }
1269 
1270 MlirType mlirAttributeGetType(MlirAttribute attribute) {
1271  Attribute attr = unwrap(attribute);
1272  if (auto typedAttr = llvm::dyn_cast<TypedAttr>(attr))
1273  return wrap(typedAttr.getType());
1274  return wrap(NoneType::get(attr.getContext()));
1275 }
1276 
1277 MlirTypeID mlirAttributeGetTypeID(MlirAttribute attr) {
1278  return wrap(unwrap(attr).getTypeID());
1279 }
1280 
1281 MlirDialect mlirAttributeGetDialect(MlirAttribute attr) {
1282  return wrap(&unwrap(attr).getDialect());
1283 }
1284 
1285 bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2) {
1286  return unwrap(a1) == unwrap(a2);
1287 }
1288 
1289 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
1290  void *userData) {
1291  detail::CallbackOstream stream(callback, userData);
1292  unwrap(attr).print(stream);
1293 }
1294 
1295 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
1296 
1298  MlirAttribute attr) {
1299  return MlirNamedAttribute{name, attr};
1300 }
1301 
1302 //===----------------------------------------------------------------------===//
1303 // Identifier API.
1304 //===----------------------------------------------------------------------===//
1305 
1306 MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str) {
1307  return wrap(StringAttr::get(unwrap(context), unwrap(str)));
1308 }
1309 
1310 MlirContext mlirIdentifierGetContext(MlirIdentifier ident) {
1311  return wrap(unwrap(ident).getContext());
1312 }
1313 
1314 bool mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other) {
1315  return unwrap(ident) == unwrap(other);
1316 }
1317 
1318 MlirStringRef mlirIdentifierStr(MlirIdentifier ident) {
1319  return wrap(unwrap(ident).strref());
1320 }
1321 
1322 //===----------------------------------------------------------------------===//
1323 // Symbol and SymbolTable API.
1324 //===----------------------------------------------------------------------===//
1325 
1328 }
1329 
1332 }
1333 
1334 MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation) {
1335  if (!unwrap(operation)->hasTrait<OpTrait::SymbolTable>())
1336  return wrap(static_cast<SymbolTable *>(nullptr));
1337  return wrap(new SymbolTable(unwrap(operation)));
1338 }
1339 
1340 void mlirSymbolTableDestroy(MlirSymbolTable symbolTable) {
1341  delete unwrap(symbolTable);
1342 }
1343 
1344 MlirOperation mlirSymbolTableLookup(MlirSymbolTable symbolTable,
1345  MlirStringRef name) {
1346  return wrap(unwrap(symbolTable)->lookup(StringRef(name.data, name.length)));
1347 }
1348 
1349 MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable,
1350  MlirOperation operation) {
1351  return wrap((Attribute)unwrap(symbolTable)->insert(unwrap(operation)));
1352 }
1353 
1354 void mlirSymbolTableErase(MlirSymbolTable symbolTable,
1355  MlirOperation operation) {
1356  unwrap(symbolTable)->erase(unwrap(operation));
1357 }
1358 
1360  MlirStringRef newSymbol,
1361  MlirOperation from) {
1362  auto *cppFrom = unwrap(from);
1363  auto *context = cppFrom->getContext();
1364  auto oldSymbolAttr = StringAttr::get(context, unwrap(oldSymbol));
1365  auto newSymbolAttr = StringAttr::get(context, unwrap(newSymbol));
1366  return wrap(SymbolTable::replaceAllSymbolUses(oldSymbolAttr, newSymbolAttr,
1367  unwrap(from)));
1368 }
1369 
1370 void mlirSymbolTableWalkSymbolTables(MlirOperation from, bool allSymUsesVisible,
1371  void (*callback)(MlirOperation, bool,
1372  void *userData),
1373  void *userData) {
1374  SymbolTable::walkSymbolTables(unwrap(from), allSymUsesVisible,
1375  [&](Operation *foundOpCpp, bool isVisible) {
1376  callback(wrap(foundOpCpp), isVisible,
1377  userData);
1378  });
1379 }
unsigned mlirOpOperandGetOperandNumber(MlirOpOperand opOperand)
Returns the operand number of an op operand.
Definition: IR.cpp:1210
MlirLocation mlirValueGetLocation(MlirValue v)
Gets the location of the value.
Definition: IR.cpp:1188
void mlirContextDestroy(MlirContext context)
Takes an MLIR context owned by the caller and destroys it.
Definition: IR.cpp:71
void mlirOperationDump(MlirOperation op)
Prints an operation to stderr.
Definition: IR.cpp:851
MlirAttribute mlirOperationGetDiscardableAttributeByName(MlirOperation op, MlirStringRef name)
Returns a discardable attribute attached to the operation given its name.
Definition: IR.cpp:773
MlirOperation mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name)
Looks up a symbol with the given name in the given symbol table and returns the operation that corres...
Definition: IR.cpp:1344
MlirRegion mlirRegionCreate()
Creates a new empty region and transfers ownership to the caller.
Definition: IR.cpp:905
void mlirOperationPrint(MlirOperation op, MlirStringCallback callback, void *userData)
Prints an operation by sending chunks of the string representation and forwarding userData tocallback...
Definition: IR.cpp:817
MlirContext mlirModuleGetContext(MlirModule module)
Gets the context that a module was created with.
Definition: IR.cpp:446
void mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData)
Prints a value by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:1147
MlirContext mlirLocationGetContext(MlirLocation location)
Gets the context that a location was created with.
Definition: IR.cpp:411
size_t mlirModuleHashValue(MlirModule mod)
Compute a hash for the given module.
Definition: IR.cpp:472
intptr_t mlirBlockGetNumPredecessors(MlirBlock block)
Returns the number of predecessor blocks of the block.
Definition: IR.cpp:1086
bool mlirLocationIsAName(MlirLocation location)
Checks whether the given location is an Name.
Definition: IR.cpp:399
MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand)
Returns the owner operation of an op operand.
Definition: IR.cpp:1202
bool mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2)
Checks if two dialects that belong to the same context are equal.
Definition: IR.cpp:133
MlirRegion mlirRegionGetNextInOperation(MlirRegion region)
Returns the region immediately following the given region in its parent operation.
Definition: IR.cpp:692
MlirLogicalResult mlirOperationWriteBytecodeWithConfig(MlirOperation op, MlirBytecodeWriterConfig config, MlirStringCallback callback, void *userData)
Same as mlirOperationWriteBytecode but with writer config and returns failure only if desired bytecod...
Definition: IR.cpp:844
MlirIdentifier mlirOperationGetName(MlirOperation op)
Gets the name of the operation as an identifier.
Definition: IR.cpp:665
void mlirDialectRegistryDestroy(MlirDialectRegistry registry)
Takes a dialect registry owned by the caller and destroys it.
Definition: IR.cpp:149
bool mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other)
Checks whether two identifiers are the same.
Definition: IR.cpp:1314
void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but accepts flags controlling the printing behavior.
Definition: IR.cpp:823
bool mlirValueIsABlockArgument(MlirValue value)
Returns 1 if the value is a block argument, 0 otherwise.
Definition: IR.cpp:1106
MlirTypeID mlirTypeGetTypeID(MlirType type)
Gets the type ID of the type.
Definition: IR.cpp:1239
void mlirValueReplaceAllUsesOfWith(MlirValue oldValue, MlirValue newValue)
Replace all uses of 'of' value with the 'with' value, updating anything in the IR that uses 'of' to u...
Definition: IR.cpp:1170
MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type, MlirLocation loc)
Appends an argument of the specified type to the block.
Definition: IR.cpp:1054
intptr_t mlirOperationGetNumRegions(MlirOperation op)
Returns the number of regions attached to the given operation.
Definition: IR.cpp:677
MlirBlock mlirOperationGetBlock(MlirOperation op)
Gets the block that owns this operation, returning null if the operation is not owned.
Definition: IR.cpp:669
void mlirContextAppendDialectRegistry(MlirContext ctx, MlirDialectRegistry registry)
Append the contents of the given dialect registry to the registry associated with the context.
Definition: IR.cpp:84
MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str)
Gets an identifier with the given string value.
Definition: IR.cpp:1306
void mlirBlockArgumentSetType(MlirValue value, MlirType type)
Sets the type of the block argument to the given type.
Definition: IR.cpp:1123
MlirLocation mlirLocationFileLineColGet(MlirContext context, MlirStringRef filename, unsigned line, unsigned col)
Creates an File/Line/Column location owned by the given context.
Definition: IR.cpp:273
intptr_t mlirContextGetNumLoadedDialects(MlirContext context)
Returns the number of dialects loaded by the context.
Definition: IR.cpp:91
MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name, MlirAttribute attr)
Associates an attribute with the name. Takes ownership of neither.
Definition: IR.cpp:1297
MlirStringRef mlirSymbolTableGetVisibilityAttributeName()
Returns the name of the attribute used to store symbol visibility.
Definition: IR.cpp:1330
void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n, MlirNamedAttribute const *attributes)
Definition: IR.cpp:521
MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos)
Returns pos-th result of the operation.
Definition: IR.cpp:728
bool mlirLocationIsACallSite(MlirLocation location)
Checks whether the given location is an CallSite.
Definition: IR.cpp:343
void mlirSymbolTableWalkSymbolTables(MlirOperation from, bool allSymUsesVisible, void(*callback)(MlirOperation, bool, void *userData), void *userData)
Walks all symbol table operations nested within, and including, op.
Definition: IR.cpp:1370
void mlirContextLoadAllAvailableDialects(MlirContext context)
Eagerly loads all available dialects registered with a context, making them available for use for IR ...
Definition: IR.cpp:108
MlirModule mlirModuleCreateParseFromFile(MlirContext context, MlirStringRef fileName)
Parses a module from file and transfers ownership to the caller.
Definition: IR.cpp:437
void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback, void *userData)
Prints an attribute by sending chunks of the string representation and forwarding userData tocallback...
Definition: IR.cpp:1289
MlirBlock mlirRegionGetFirstBlock(MlirRegion region)
Gets the first block in the region.
Definition: IR.cpp:911
MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses(MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from)
Attempt to replace all uses that are nested within the given operation of the given symbol 'oldSymbol...
Definition: IR.cpp:1359
MlirLocation mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations, MlirLocation const *locations, MlirAttribute metadata)
Creates a fused location with an array of locations and metadata.
Definition: IR.cpp:347
MlirAsmState mlirAsmStateCreateForValue(MlirValue value, MlirOpPrintingFlags flags)
Creates new AsmState from value.
Definition: IR.cpp:178
intptr_t mlirOperationGetNumResults(MlirOperation op)
Returns the number of results of the operation.
Definition: IR.cpp:724
MlirOpOperand mlirValueGetFirstUse(MlirValue value)
Returns an op operand representing the first use of the value, or a null op operand if there are no u...
Definition: IR.cpp:1160
void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference, MlirBlock block)
Takes a block owned by the caller and inserts it after the (non-owned) reference block in the given r...
Definition: IR.cpp:928
void mlirOperationDestroy(MlirOperation op)
Takes an operation owned by the caller and destroys it.
Definition: IR.cpp:639
void mlirValueReplaceAllUsesExcept(MlirValue oldValue, MlirValue newValue, intptr_t numExceptions, MlirOperation *exceptions)
Replace all uses of 'of' value with 'with' value, updating anything in the IR that uses 'of' to use '...
Definition: IR.cpp:1174
void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation)
Takes an operation owned by the caller and appends it to the block.
Definition: IR.cpp:1006
MlirRegion mlirOperationGetFirstRegion(MlirOperation op)
Returns first region attached to the operation.
Definition: IR.cpp:685
MlirAttribute mlirOperationGetInherentAttributeByName(MlirOperation op, MlirStringRef name)
Returns an inherent attribute attached to the operation given its name.
Definition: IR.cpp:746
MlirDialect mlirContextGetOrLoadDialect(MlirContext context, MlirStringRef name)
Gets the dialect instance owned by the given context using the dialect namespace to identify it,...
Definition: IR.cpp:95
MlirContext mlirAttributeGetContext(MlirAttribute attribute)
Gets the context that an attribute was created with.
Definition: IR.cpp:1266
MlirStringRef mlirSymbolTableGetSymbolAttributeName()
Returns the name of the attribute used to store symbol names compatible with symbol tables.
Definition: IR.cpp:1326
void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos, MlirOperation operation)
Takes an operation owned by the caller and inserts it as pos to the block.
Definition: IR.cpp:1010
MlirRegion mlirBlockGetParentRegion(MlirBlock block)
Returns the region that contains this block.
Definition: IR.cpp:981
MlirType mlirValueGetType(MlirValue value)
Returns the type of the value.
Definition: IR.cpp:1137
void mlirOperationMoveAfter(MlirOperation op, MlirOperation other)
Moves the given operation immediately after the other operation in its parent block.
Definition: IR.cpp:857
void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block)
Takes a block owned by the caller and appends it to the given region.
Definition: IR.cpp:918
void mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData)
Prints a block by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:1072
void mlirOperationSetDiscardableAttributeByName(MlirOperation op, MlirStringRef name, MlirAttribute attr)
Sets a discardable attribute by name, replacing the existing if it exists or adding a new one otherwi...
Definition: IR.cpp:778
MlirOpPrintingFlags mlirOpPrintingFlagsCreate()
Creates new printing flags with defaults, intended for customization.
Definition: IR.cpp:202
bool mlirModuleEqual(MlirModule lhs, MlirModule rhs)
Checks if two modules are equal.
Definition: IR.cpp:468
void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags, intptr_t largeElementLimit)
Enables the elision of large elements attributes by printing a lexically valid but otherwise meaningl...
Definition: IR.cpp:210
MlirBlock mlirBlockGetNextInRegion(MlirBlock block)
Returns the block immediately following the given block in its parent region.
Definition: IR.cpp:985
void mlirOperationSetSuccessor(MlirOperation op, intptr_t pos, MlirBlock block)
Set pos-th successor of the operation.
Definition: IR.cpp:789
MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand)
Returns the value of an op operand.
Definition: IR.cpp:1206
#define APPEND_ELEMS(type, sizeName, elemName)
Definition: IR.cpp:498
bool mlirContextIsRegisteredOperation(MlirContext context, MlirStringRef name)
Returns whether the given fully-qualified operation (i.e.
Definition: IR.cpp:100
MlirOperation mlirOperationGetNextInBlock(MlirOperation op)
Returns an operation immediately following the given operation it its enclosing block.
Definition: IR.cpp:701
void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable, bool prettyForm)
Enable or disable printing of debug information (based on enable).
Definition: IR.cpp:220
MlirOperation mlirModuleGetOperation(MlirModule module)
Views the module as a generic operation.
Definition: IR.cpp:460
static mlir::WalkResult unwrap(MlirWalkResult result)
Definition: IR.cpp:869
void mlirOpPrintingFlagsElideLargeResourceString(MlirOpPrintingFlags flags, intptr_t largeResourceLimit)
Enables the elision of large resources strings by omitting them from the dialect_resources section.
Definition: IR.cpp:215
void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference, MlirBlock block)
Takes a block owned by the caller and inserts it before the (non-owned) reference block in the given ...
Definition: IR.cpp:942
MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos)
Returns pos-th argument of the block.
Definition: IR.cpp:1068
unsigned mlirLocationFusedGetNumLocations(MlirLocation location)
Getter for number of locations fused together.
Definition: IR.cpp:355
MlirStringRef mlirDialectGetNamespace(MlirDialect dialect)
Returns the namespace of the given dialect.
Definition: IR.cpp:137
void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags)
Use local scope when printing the operation.
Definition: IR.cpp:233
MlirTypeID mlirOperationGetTypeID(MlirOperation op)
Gets the type id of the operation.
Definition: IR.cpp:659
intptr_t mlirBlockArgumentGetArgNumber(MlirValue value)
Returns the position of the value in the argument list of its block.
Definition: IR.cpp:1118
void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback, void *userData, MlirWalkOrder walkOrder)
Walks operation op in walkOrder and calls callback on that operation.
Definition: IR.cpp:883
MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos)
Returns pos-th successor of the operation.
Definition: IR.cpp:736
void mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference, MlirOperation operation)
Takes an operation owned by the caller and inserts it before the (non-owned) reference operation in t...
Definition: IR.cpp:1031
bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2)
Checks if two attributes are equal.
Definition: IR.cpp:1285
MlirAsmState mlirAsmStateCreateForOperation(MlirOperation op, MlirOpPrintingFlags flags)
Creates new AsmState, as with AsmState the IR should not be mutated in-between using this state.
Definition: IR.cpp:157
bool mlirOperationEqual(MlirOperation op, MlirOperation other)
Checks whether two operation handles point to the same operation.
Definition: IR.cpp:643
void mlirOperationSetInherentAttributeByName(MlirOperation op, MlirStringRef name, MlirAttribute attr)
Sets an inherent attribute by name, replacing the existing if it exists.
Definition: IR.cpp:754
void mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags)
Do not verify the operation when using custom operation printers.
Definition: IR.cpp:237
bool mlirValueEqual(MlirValue value1, MlirValue value2)
Returns 1 if two values are equal, 0 otherwise.
Definition: IR.cpp:1102
MlirContext mlirIdentifierGetContext(MlirIdentifier ident)
Returns the context associated with this identifier.
Definition: IR.cpp:1310
void mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config)
Destroys printing flags created with mlirBytecodeWriterConfigCreate.
Definition: IR.cpp:252
MlirBlock mlirBlockGetSuccessor(MlirBlock block, intptr_t pos)
Returns pos-th successor of the block.
Definition: IR.cpp:1082
void mlirModuleDestroy(MlirModule module)
Takes a module owned by the caller and deletes it.
Definition: IR.cpp:454
MlirModule mlirModuleCreateEmpty(MlirLocation location)
Creates a new, empty module and transfers ownership to the caller.
Definition: IR.cpp:425
void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags)
Always print operations in the generic form.
Definition: IR.cpp:225
MlirOperation mlirOperationGetParentOperation(MlirOperation op)
Gets the operation that owns this operation, returning null if the operation is not owned.
Definition: IR.cpp:673
void mlirRegionTakeBody(MlirRegion target, MlirRegion source)
Moves the entire content of the source region to the target region.
Definition: IR.cpp:957
MlirLlvmThreadPool mlirContextGetThreadPool(MlirContext context)
Gets the thread pool of the context when enabled multithreading, otherwise an assertion is raised.
Definition: IR.cpp:121
MlirValue mlirBlockInsertArgument(MlirBlock block, intptr_t pos, MlirType type, MlirLocation loc)
Inserts an argument of the specified type at a specified index to the block.
Definition: IR.cpp:1063
void mlirValueSetType(MlirValue value, MlirType type)
Set the type of the value.
Definition: IR.cpp:1141
intptr_t mlirOperationGetNumSuccessors(MlirOperation op)
Returns the number of successor blocks of the operation.
Definition: IR.cpp:732
MlirDialect mlirAttributeGetDialect(MlirAttribute attr)
Gets the dialect of the attribute.
Definition: IR.cpp:1281
void mlirLocationPrint(MlirLocation location, MlirStringCallback callback, void *userData)
Prints a location by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:415
void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name, MlirAttribute attr)
Sets an attribute by name, replacing the existing if it exists or adding a new one otherwise.
Definition: IR.cpp:808
void mlirBlockDestroy(MlirBlock block)
Takes a block owned by the caller and destroys it.
Definition: IR.cpp:1043
void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block)
Takes a block owned by the caller and inserts it at pos to the given region.
Definition: IR.cpp:922
void mlirOperationSetOperand(MlirOperation op, intptr_t pos, MlirValue newValue)
Sets the pos-th operand of the operation.
Definition: IR.cpp:713
intptr_t mlirBlockGetNumArguments(MlirBlock block)
Returns the number of arguments of the block.
Definition: IR.cpp:1050
MlirTypeID mlirLocationFileLineColRangeGetTypeID()
TypeID Getter for FileLineColRange.
Definition: IR.cpp:317
MlirOperation mlirOpResultGetOwner(MlirValue value)
Returns an operation that produced this value as its result.
Definition: IR.cpp:1128
void mlirBlockEraseArgument(MlirBlock block, unsigned index)
Erase the argument at 'index' and remove it from the argument list.
Definition: IR.cpp:1059
bool mlirOpOperandIsNull(MlirOpOperand opOperand)
Returns whether the op operand is null.
Definition: IR.cpp:1200
MlirDialect mlirTypeGetDialect(MlirType type)
Gets the dialect a type belongs to.
Definition: IR.cpp:1243
MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module)
Parses a module from the string and transfers ownership to the caller.
Definition: IR.cpp:429
MlirContext mlirContextCreateWithRegistry(MlirDialectRegistry registry, bool threadingEnabled)
Creates an MLIR context, setting the multithreading setting explicitly and pre-loading the dialects f...
Definition: IR.cpp:60
size_t mlirOperationHashValue(MlirOperation op)
Compute a hash for the given operation.
Definition: IR.cpp:647
void mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow)
Sets whether unregistered dialects are allowed in this context.
Definition: IR.cpp:73
void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n, MlirType const *results)
Adds a list of components to the operation state.
Definition: IR.cpp:504
void mlirOperationMoveBefore(MlirOperation op, MlirOperation other)
Moves the given operation immediately before the other operation in its parent block.
Definition: IR.cpp:861
static LogicalResult inferOperationTypes(OperationState &state)
Definition: IR.cpp:534
MlirOperation mlirOperationClone(MlirOperation op)
Creates a deep copy of an operation.
Definition: IR.cpp:635
void mlirValuePrintAsOperand(MlirValue value, MlirAsmState state, MlirStringCallback callback, void *userData)
Prints a value as an operand (i.e., the ValueID).
Definition: IR.cpp:1153
MlirBlock mlirBlockArgumentGetOwner(MlirValue value)
Returns the block in which this value is defined as an argument.
Definition: IR.cpp:1114
MlirDialectRegistry mlirDialectRegistryCreate()
Creates a dialect registry and transfers its ownership to the caller.
Definition: IR.cpp:145
MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos)
Returns pos-th operand of the operation.
Definition: IR.cpp:709
bool mlirContextGetAllowUnregisteredDialects(MlirContext context)
Returns whether the context allows unregistered dialects.
Definition: IR.cpp:77
MlirAttribute mlirLocationGetAttribute(MlirLocation location)
Returns the underlying location attribute of this location.
Definition: IR.cpp:265
MlirModule mlirModuleFromOperation(MlirOperation op)
Views the generic operation as a module.
Definition: IR.cpp:464
MlirTypeID mlirLocationNameGetTypeID()
TypeID Getter for Name.
Definition: IR.cpp:397
MlirLocation mlirOperationGetLocation(MlirOperation op)
Gets the location of the operation.
Definition: IR.cpp:655
bool mlirTypeEqual(MlirType t1, MlirType t2)
Checks if two types are equal.
Definition: IR.cpp:1247
bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2)
Checks if two contexts are equal.
Definition: IR.cpp:67
MlirAttribute mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name)
Returns an attribute attached to the operation given its name.
Definition: IR.cpp:803
bool mlirOperationIsBeforeInBlock(MlirOperation op, MlirOperation other)
Given an operation 'other' that is within the same parent block, return whether the current operation...
Definition: IR.cpp:865
MlirTypeID mlirAttributeGetTypeID(MlirAttribute attr)
Gets the type id of the attribute.
Definition: IR.cpp:1277
static Operation * findParent(Operation *op, bool shouldUseLocalScope)
Definition: IR.cpp:162
MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation)
Inserts the given operation into the given symbol table.
Definition: IR.cpp:1349
bool mlirLocationIsAFileLineColRange(MlirLocation location)
Checks whether the given location is an FileLineColRange.
Definition: IR.cpp:321
intptr_t mlirOperationGetNumDiscardableAttributes(MlirOperation op)
Returns the number of discardable attributes attached to the operation.
Definition: IR.cpp:761
MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation)
Creates a symbol table for the given operation.
Definition: IR.cpp:1334
void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n, MlirRegion const *regions)
Definition: IR.cpp:513
MlirLocation mlirLocationUnknownGet(MlirContext context)
Creates a location with unknown position owned by the given context.
Definition: IR.cpp:403
MlirLocation mlirLocationCallSiteGetCallee(MlirLocation location)
Getter for callee of CallSite.
Definition: IR.cpp:329
MlirOperation mlirBlockGetFirstOperation(MlirBlock block)
Returns the first operation in the block.
Definition: IR.cpp:989
MlirType mlirAttributeGetType(MlirAttribute attribute)
Gets the type of this attribute.
Definition: IR.cpp:1270
bool mlirOperationRemoveDiscardableAttributeByName(MlirOperation op, MlirStringRef name)
Removes a discardable attribute by name.
Definition: IR.cpp:784
void mlirRegionDestroy(MlirRegion region)
Takes a region owned by the caller and destroys it.
Definition: IR.cpp:953
bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name)
Removes an attribute by name.
Definition: IR.cpp:813
bool mlirValueIsAOpResult(MlirValue value)
Returns 1 if the value is an operation result, 0 otherwise.
Definition: IR.cpp:1110
MLIR_CAPI_EXPORTED bool mlirOperationHasInherentAttributeByName(MlirOperation op, MlirStringRef name)
Returns true if this operation defines an inherent attribute with this name.
Definition: IR.cpp:741
MlirContext mlirContextCreateWithThreading(bool threadingEnabled)
Creates an MLIR context with an explicit setting of the multithreading setting and transfers its owne...
Definition: IR.cpp:55
MlirTypeID mlirLocationCallSiteGetTypeID()
TypeID Getter for CallSite.
Definition: IR.cpp:339
MlirBlock mlirBlockGetPredecessor(MlirBlock block, intptr_t pos)
Returns pos-th predecessor of the block.
Definition: IR.cpp:1091
MlirOperation mlirBlockGetTerminator(MlirBlock block)
Returns the terminator operation in the block or null if no terminator.
Definition: IR.cpp:996
bool mlirLocationEqual(MlirLocation l1, MlirLocation l2)
Checks if two locations are equal.
Definition: IR.cpp:407
MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos)
Returns pos-th region attached to the operation.
Definition: IR.cpp:681
int mlirLocationFileLineColRangeGetEndColumn(MlirLocation location)
Getter for end_column of FileLineColRange.
Definition: IR.cpp:311
MlirOperation mlirOperationCreate(MlirOperationState *state)
Creates an operation and transfers ownership to the caller.
Definition: IR.cpp:589
unsigned mlirContextGetNumThreads(MlirContext context)
Gets the number of threads of the thread pool of the context when multithreading is enabled.
Definition: IR.cpp:117
void mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags, int64_t version)
Sets the version to emit in the writer config.
Definition: IR.cpp:256
int mlirLocationFileLineColRangeGetStartColumn(MlirLocation location)
Getter for start_column of FileLineColRange.
Definition: IR.cpp:299
MlirAttribute mlirAttributeParseGet(MlirContext context, MlirStringRef attr)
Parses an attribute. The attribute is owned by the context.
Definition: IR.cpp:1262
void mlirLocationFusedGetLocations(MlirLocation location, MlirLocation *locationsCPtr)
Getter for locations of Fused.
Definition: IR.cpp:361
void mlirOperationRemoveFromParent(MlirOperation op)
Removes the given operation from its parent block.
Definition: IR.cpp:641
void mlirSymbolTableDestroy(MlirSymbolTable symbolTable)
Destroys the symbol table created with mlirSymbolTableCreate.
Definition: IR.cpp:1340
intptr_t mlirBlockGetNumSuccessors(MlirBlock block)
Returns the number of successor blocks of the block.
Definition: IR.cpp:1078
MlirContext mlirContextCreate()
Creates an MLIR context and transfers its ownership to the caller.
Definition: IR.cpp:45
void mlirOperationPrintWithState(MlirOperation op, MlirAsmState state, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but accepts AsmState controlling the printing behavior as well as caching ...
Definition: IR.cpp:829
bool mlirOperationVerify(MlirOperation op)
Verify the operation and return true if it passes, false if it fails.
Definition: IR.cpp:853
void mlirBlockDetach(MlirBlock block)
Detach a block from the owning region and assume ownership.
Definition: IR.cpp:1045
int mlirLocationFileLineColRangeGetEndLine(MlirLocation location)
Getter for end_line of FileLineColRange.
Definition: IR.cpp:305
MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos)
Return pos-th attribute of the operation.
Definition: IR.cpp:798
void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags)
Destroys printing flags created with mlirOpPrintingFlagsCreate.
Definition: IR.cpp:206
MlirLocation mlirLocationCallSiteGet(MlirLocation callee, MlirLocation caller)
Creates a call site location with a callee and a caller.
Definition: IR.cpp:325
void mlirOperationWriteBytecode(MlirOperation op, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but writing the bytecode format.
Definition: IR.cpp:837
void mlirValueDump(MlirValue value)
Prints the value to the standard error stream.
Definition: IR.cpp:1145
void mlirBlockInsertOwnedOperationAfter(MlirBlock block, MlirOperation reference, MlirOperation operation)
Takes an operation owned by the caller and inserts it after the (non-owned) reference operation in th...
Definition: IR.cpp:1016
intptr_t mlirContextGetNumRegisteredDialects(MlirContext context)
Returns the number of dialects registered with the given context.
Definition: IR.cpp:80
MlirTypeID mlirLocationFusedGetTypeID()
TypeID Getter for Fused.
Definition: IR.cpp:373
void mlirOperationSetOperands(MlirOperation op, intptr_t nOperands, MlirValue const *operands)
Replaces the operands of the operation.
Definition: IR.cpp:718
static MLIRContext::Threading toThreadingEnum(bool threadingEnabled)
Definition: IR.cpp:50
MlirIdentifier mlirLocationFileLineColRangeGetFilename(MlirLocation location)
Getter for filename of FileLineColRange.
Definition: IR.cpp:289
MlirContext mlirTypeGetContext(MlirType type)
Gets the context that a type was created with.
Definition: IR.cpp:1235
void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData)
Prints a location by sending chunks of the string representation and forwarding userData tocallback`.
Definition: IR.cpp:1251
MlirBlock mlirModuleGetBody(MlirModule module)
Gets the body of the module, i.e. the only block it contains.
Definition: IR.cpp:450
MlirContext mlirDialectGetContext(MlirDialect dialect)
Returns the context that owns the dialect.
Definition: IR.cpp:129
bool mlirRegionEqual(MlirRegion region, MlirRegion other)
Checks whether two region handles point to the same region.
Definition: IR.cpp:907
int mlirLocationFileLineColRangeGetStartLine(MlirLocation location)
Getter for start_line of FileLineColRange.
Definition: IR.cpp:293
MlirOperation mlirOperationCreateParse(MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName)
Parses an operation, giving ownership to the caller.
Definition: IR.cpp:626
MlirLocation mlirLocationCallSiteGetCaller(MlirLocation location)
Getter for caller of CallSite.
Definition: IR.cpp:334
void mlirAsmStateDestroy(MlirAsmState state)
Destroys printing flags created with mlirAsmStateCreate.
Definition: IR.cpp:196
MlirContext mlirOperationGetContext(MlirOperation op)
Gets the context this operation is associated with.
Definition: IR.cpp:651
intptr_t mlirOpResultGetResultNumber(MlirValue value)
Returns the position of the value in the list of results of the operation that produced it.
Definition: IR.cpp:1132
MlirLocation mlirLocationNameGet(MlirContext context, MlirStringRef name, MlirLocation childLoc)
Creates a name location owned by the given context.
Definition: IR.cpp:379
MlirLocation mlirLocationFileLineColRangeGet(MlirContext context, MlirStringRef filename, unsigned startLine, unsigned startCol, unsigned endLine, unsigned endCol)
Creates an File/Line/Column range location owned by the given context.
Definition: IR.cpp:281
bool mlirBlockEqual(MlirBlock block, MlirBlock other)
Checks whether two blocks handles point to the same block.
Definition: IR.cpp:973
bool mlirLocationIsAFused(MlirLocation location)
Checks whether the given location is an Fused.
Definition: IR.cpp:375
MlirAttribute mlirLocationFusedGetMetadata(MlirLocation location)
Getter for metadata of Fused.
Definition: IR.cpp:369
void mlirSymbolTableErase(MlirSymbolTable symbolTable, MlirOperation operation)
Removes the given operation from the symbol table and erases it.
Definition: IR.cpp:1354
MlirLocation mlirLocationNameGetChildLoc(MlirLocation location)
Getter for childLoc of Name.
Definition: IR.cpp:392
MlirNamedAttribute mlirOperationGetDiscardableAttribute(MlirOperation op, intptr_t pos)
Return pos-th discardable attribute of the operation.
Definition: IR.cpp:766
void mlirOperationStateEnableResultTypeInference(MlirOperationState *state)
Enables result type inference for the operation under construction.
Definition: IR.cpp:526
void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n, MlirBlock const *successors)
Definition: IR.cpp:517
MlirBytecodeWriterConfig mlirBytecodeWriterConfigCreate()
Creates new printing flags with defaults, intended for customization.
Definition: IR.cpp:248
void mlirAttributeDump(MlirAttribute attr)
Prints the attribute to the standard error stream.
Definition: IR.cpp:1295
void mlirOpPrintingFlagsPrintNameLocAsPrefix(MlirOpPrintingFlags flags)
Print the name and location, if NamedLoc, as a prefix to the SSA ID.
Definition: IR.cpp:229
MlirIdentifier mlirLocationNameGetName(MlirLocation location)
Getter for name of Name.
Definition: IR.cpp:388
MlirStringRef mlirIdentifierStr(MlirIdentifier ident)
Gets the string value of the identifier.
Definition: IR.cpp:1318
void mlirOpPrintingFlagsSkipRegions(MlirOpPrintingFlags flags)
Skip printing regions.
Definition: IR.cpp:241
void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n, MlirValue const *operands)
Definition: IR.cpp:509
MlirOperationState mlirOperationStateGet(MlirStringRef name, MlirLocation loc)
Constructs an operation state from a name and a location.
Definition: IR.cpp:480
MlirLocation mlirLocationFromAttribute(MlirAttribute attribute)
Creates a location from a location attribute.
Definition: IR.cpp:269
MlirOperation mlirBlockGetParentOperation(MlirBlock block)
Returns the closest surrounding operation that contains this block.
Definition: IR.cpp:977
MlirOpOperand mlirOpOperandGetNextUse(MlirOpOperand opOperand)
Returns an op operand representing the next use of the value, or a null op operand if there is no nex...
Definition: IR.cpp:1214
intptr_t mlirOperationGetNumOperands(MlirOperation op)
Returns the number of operands of the operation.
Definition: IR.cpp:705
void mlirContextSetThreadPool(MlirContext context, MlirLlvmThreadPool threadPool)
Sets the thread pool of the context explicitly, enabling multithreading in the process.
Definition: IR.cpp:112
MlirType mlirTypeParseGet(MlirContext context, MlirStringRef type)
Parses a type. The type is owned by the context.
Definition: IR.cpp:1231
MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args, MlirLocation const *locs)
Creates a new empty block with the given argument types and transfers ownership to the caller.
Definition: IR.cpp:965
void mlirContextEnableMultithreading(MlirContext context, bool enable)
Set threading mode (must be set to false to mlir-print-ir-after-all).
Definition: IR.cpp:104
void mlirTypeDump(MlirType type)
Prints the type to the standard error stream.
Definition: IR.cpp:1256
intptr_t mlirOperationGetNumAttributes(MlirOperation op)
Returns the number of attributes attached to the operation.
Definition: IR.cpp:794
MlirContext mlirValueGetContext(MlirValue v)
Gets the context that a value was created with.
Definition: IR.cpp:1192
static MLIRContext * getContext(OpFoldResult val)
static llvm::ArrayRef< CppTy > unwrapList(size_t size, CTy *first, llvm::SmallVectorImpl< CppTy > &storage)
Definition: Wrap.h:40
This class provides management for the lifetime of the state used when printing the IR.
Definition: AsmState.h:542
Attributes are known-constant values of operations.
Definition: Attributes.h:25
MLIRContext * getContext() const
Return the context this attribute belongs to.
Definition: Attributes.cpp:37
Block represents an ordered list of Operations.
Definition: Block.h:33
OpListType::iterator iterator
Definition: Block.h:140
bool empty()
Definition: Block.h:148
Operation & back()
Definition: Block.h:152
Region * getParent() const
Provide a 'getParent' method for ilist_node_with_parent methods.
Definition: Block.cpp:27
pred_iterator pred_begin()
Definition: Block.h:236
BlockArgument addArgument(Type type, Location loc)
Add one value to the argument list.
Definition: Block.cpp:153
OpListType & getOperations()
Definition: Block.h:137
Operation & front()
Definition: Block.h:153
iterator begin()
Definition: Block.h:143
pred_iterator pred_end()
Definition: Block.h:239
This class contains the configuration used for the bytecode writer.
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
static FileLineColLoc get(StringAttr filename, unsigned line, unsigned column)
Definition: Location.cpp:157
Location objects represent source locations information in MLIR.
Definition: Location.h:32
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:76
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:63
void reserve(size_type N)
NamedAttribute represents a combination of a name and an Attribute value.
Definition: Attributes.h:164
StringAttr getName() const
Return the name of the attribute.
Definition: Attributes.cpp:55
Attribute getValue() const
Return the value of the attribute.
Definition: Attributes.h:179
This class represents an operand of an operation.
Definition: Value.h:257
Set of flags used to control the behavior of the various IR print methods (e.g.
This class provides the API for ops that are known to be isolated from above.
This class provides the API for ops that are known to be terminators.
Definition: OpDefinition.h:773
Simple wrapper around a void* in order to express generically how to pass in op properties through AP...
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
bool hasTrait()
Returns true if the operation was registered with a particular trait, e.g.
Definition: Operation.h:749
unsigned getNumRegions()
Returns the number of regions held by this operation.
Definition: Operation.h:674
static Operation * create(Location location, OperationName name, TypeRange resultTypes, ValueRange operands, NamedAttrList &&attributes, OpaqueProperties properties, BlockRange successors, unsigned numRegions)
Create a new Operation with the specific fields.
Definition: Operation.cpp:66
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
Definition: Operation.h:234
Region & getRegion(unsigned index)
Returns the region held by this operation at position 'index'.
Definition: Operation.h:686
OpTy release()
Release the referenced op.
Definition: OwningOpRef.h:67
Implement a predecessor iterator for blocks.
Definition: BlockSupport.h:51
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
unsigned getRegionNumber()
Return the number of this region in the parent operation.
Definition: Region.cpp:62
Operation * getParentOp()
Return the parent operation this region is attached to.
Definition: Region.h:200
bool empty()
Definition: Region.h:60
iterator begin()
Definition: Region.h:55
BlockListType & getBlocks()
Definition: Region.h:45
Block & front()
Definition: Region.h:65
BlockListType::iterator iterator
Definition: Region.h:52
This class allows for representing and managing the symbol table used by operations with the 'SymbolT...
Definition: SymbolTable.h:24
static StringRef getSymbolAttrName()
Return the name of the attribute used for symbol names.
Definition: SymbolTable.h:76
static LogicalResult replaceAllSymbolUses(StringAttr oldSymbol, StringAttr newSymbol, Operation *from)
Attempt to replace all uses of the given symbol 'oldSymbol' with the provided symbol 'newSymbol' that...
static StringRef getVisibilityAttrName()
Return the name of the attribute used for symbol visibility.
Definition: SymbolTable.h:82
static void walkSymbolTables(Operation *op, bool allSymUsesVisible, function_ref< void(Operation *, bool)> callback)
Walks all symbol table operations nested within, and including, op.
OperandType * getOperand() const
Returns the current operands.
Definition: UseDefLists.h:314
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
bool use_empty() const
Returns true if this value has no uses.
Definition: Value.h:208
void replaceAllUsesExcept(Value newValue, const SmallPtrSetImpl< Operation * > &exceptions)
Replace all uses of 'this' value with 'newValue', updating anything in the IR that uses 'this' to use...
Definition: Value.cpp:71
void printAsOperand(raw_ostream &os, AsmState &state) const
Print this value as if it were an operand.
Location getLoc() const
Return the location of this value.
Definition: Value.cpp:24
use_iterator use_begin() const
Definition: Value.h:184
A utility result that is used to signal how to proceed with an ongoing walk:
Definition: WalkResult.h:29
static WalkResult skip()
Definition: WalkResult.h:48
static WalkResult advance()
Definition: WalkResult.h:47
static WalkResult interrupt()
Definition: WalkResult.h:46
A simple raw ostream subclass that forwards write_impl calls to the user-supplied callback together w...
Definition: Utils.h:30
MlirDiagnostic wrap(mlir::Diagnostic &diagnostic)
Definition: Diagnostics.h:24
MlirWalkResult(* MlirOperationWalkCallback)(MlirOperation, void *userData)
Operation walker type.
Definition: IR.h:847
MlirWalkOrder
Traversal order for operation walk.
Definition: IR.h:840
@ MlirWalkPreOrder
Definition: IR.h:841
@ MlirWalkPostOrder
Definition: IR.h:842
MlirWalkResult
Operation walk result.
Definition: IR.h:833
@ MlirWalkResultInterrupt
Definition: IR.h:835
@ MlirWalkResultSkip
Definition: IR.h:836
@ MlirWalkResultAdvance
Definition: IR.h:834
static bool mlirBlockIsNull(MlirBlock block)
Checks whether a block is null.
Definition: IR.h:929
static bool mlirLocationIsNull(MlirLocation location)
Checks if the location is null.
Definition: IR.h:370
static bool mlirOperationIsNull(MlirOperation op)
Checks whether the underlying operation is null.
Definition: IR.h:621
#define MLIR_CAPI_EXPORTED
Definition: Support.h:46
void(* MlirStringCallback)(MlirStringRef, void *)
A callback for returning string references.
Definition: Support.h:105
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
Definition: Matchers.h:344
detail::InFlightRemark failed(Location loc, RemarkOpts opts)
Report an optimization remark that failed.
Definition: Remarks.h:491
Include the generated interface declarations.
Type getType(OpFoldResult ofr)
Returns the int type of the integer in ofr.
Definition: Utils.cpp:304
const FrozenRewritePatternSet GreedyRewriteConfig config
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
Attribute parseAttribute(llvm::StringRef attrStr, MLIRContext *context, Type type={}, size_t *numRead=nullptr, bool isKnownNullTerminated=false)
This parses a single MLIR attribute to an MLIR context if it was valid.
LogicalResult parseSourceString(llvm::StringRef sourceStr, Block *block, const ParserConfig &config, StringRef sourceName="", LocationAttr *sourceFileLoc=nullptr)
This parses the IR string and appends parsed operations to the given block.
Definition: Parser.cpp:108
Operation * clone(OpBuilder &b, Operation *op, TypeRange newResultTypes, ValueRange newOperands)
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
Type parseType(llvm::StringRef typeStr, MLIRContext *context, size_t *numRead=nullptr, bool isKnownNullTerminated=false)
This parses a single MLIR type to an MLIR context if it was valid.
LogicalResult writeBytecodeToFile(Operation *op, raw_ostream &os, const BytecodeWriterConfig &config={})
Write the bytecode for the given operation to the provided output stream.
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...
Definition: Verifier.cpp:423
A logical result value, essentially a boolean with named states.
Definition: Support.h:116
Named MLIR attribute.
Definition: IR.h:76
An auxiliary class for constructing operations.
Definition: IR.h:438
A pointer to a sized fragment of a string, not necessarily null-terminated.
Definition: Support.h:73
const char * data
Pointer to the first symbol.
Definition: Support.h:74
size_t length
Length of the fragment.
Definition: Support.h:75
static llvm::hash_code computeHash(Operation *op, function_ref< llvm::hash_code(Value)> hashOperands=[](Value v) { return hash_value(v);}, function_ref< llvm::hash_code(Value)> hashResults=[](Value v) { return hash_value(v);}, Flags flags=Flags::None)
Compute a hash for the given operation.
This represents an operation in an abstracted form, suitable for use with the builder APIs.
void addOperands(ValueRange newOperands)
void addAttribute(StringRef name, Attribute attr)
Add an attribute with the specified name.
void addSuccessors(Block *successor)
Adds a successor to the operation sate. successor must not be null.
void addTypes(ArrayRef< Type > newTypes)
NamedAttrList attributes
SmallVector< Type, 4 > types
Types of the results of this operation.
Region * addRegion()
Create a region that should be attached to the operation.