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 void mlirOperationSetLocation(MlirOperation op, MlirLocation loc) {
660  unwrap(op)->setLoc(unwrap(loc));
661 }
662 
663 MlirTypeID mlirOperationGetTypeID(MlirOperation op) {
664  if (auto info = unwrap(op)->getRegisteredInfo())
665  return wrap(info->getTypeID());
666  return {nullptr};
667 }
668 
669 MlirIdentifier mlirOperationGetName(MlirOperation op) {
670  return wrap(unwrap(op)->getName().getIdentifier());
671 }
672 
673 MlirBlock mlirOperationGetBlock(MlirOperation op) {
674  return wrap(unwrap(op)->getBlock());
675 }
676 
677 MlirOperation mlirOperationGetParentOperation(MlirOperation op) {
678  return wrap(unwrap(op)->getParentOp());
679 }
680 
681 intptr_t mlirOperationGetNumRegions(MlirOperation op) {
682  return static_cast<intptr_t>(unwrap(op)->getNumRegions());
683 }
684 
685 MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos) {
686  return wrap(&unwrap(op)->getRegion(static_cast<unsigned>(pos)));
687 }
688 
689 MlirRegion mlirOperationGetFirstRegion(MlirOperation op) {
690  Operation *cppOp = unwrap(op);
691  if (cppOp->getNumRegions() == 0)
692  return wrap(static_cast<Region *>(nullptr));
693  return wrap(&cppOp->getRegion(0));
694 }
695 
696 MlirRegion mlirRegionGetNextInOperation(MlirRegion region) {
697  Region *cppRegion = unwrap(region);
698  Operation *parent = cppRegion->getParentOp();
699  intptr_t next = cppRegion->getRegionNumber() + 1;
700  if (parent->getNumRegions() > next)
701  return wrap(&parent->getRegion(next));
702  return wrap(static_cast<Region *>(nullptr));
703 }
704 
705 MlirOperation mlirOperationGetNextInBlock(MlirOperation op) {
706  return wrap(unwrap(op)->getNextNode());
707 }
708 
709 intptr_t mlirOperationGetNumOperands(MlirOperation op) {
710  return static_cast<intptr_t>(unwrap(op)->getNumOperands());
711 }
712 
713 MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos) {
714  return wrap(unwrap(op)->getOperand(static_cast<unsigned>(pos)));
715 }
716 
717 void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
718  MlirValue newValue) {
719  unwrap(op)->setOperand(static_cast<unsigned>(pos), unwrap(newValue));
720 }
721 
722 void mlirOperationSetOperands(MlirOperation op, intptr_t nOperands,
723  MlirValue const *operands) {
724  SmallVector<Value> ops;
725  unwrap(op)->setOperands(unwrapList(nOperands, operands, ops));
726 }
727 
728 intptr_t mlirOperationGetNumResults(MlirOperation op) {
729  return static_cast<intptr_t>(unwrap(op)->getNumResults());
730 }
731 
732 MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos) {
733  return wrap(unwrap(op)->getResult(static_cast<unsigned>(pos)));
734 }
735 
736 intptr_t mlirOperationGetNumSuccessors(MlirOperation op) {
737  return static_cast<intptr_t>(unwrap(op)->getNumSuccessors());
738 }
739 
740 MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos) {
741  return wrap(unwrap(op)->getSuccessor(static_cast<unsigned>(pos)));
742 }
743 
746  std::optional<Attribute> attr = unwrap(op)->getInherentAttr(unwrap(name));
747  return attr.has_value();
748 }
749 
750 MlirAttribute mlirOperationGetInherentAttributeByName(MlirOperation op,
751  MlirStringRef name) {
752  std::optional<Attribute> attr = unwrap(op)->getInherentAttr(unwrap(name));
753  if (attr.has_value())
754  return wrap(*attr);
755  return {};
756 }
757 
759  MlirStringRef name,
760  MlirAttribute attr) {
761  unwrap(op)->setInherentAttr(
762  StringAttr::get(unwrap(op)->getContext(), unwrap(name)), unwrap(attr));
763 }
764 
765 intptr_t mlirOperationGetNumDiscardableAttributes(MlirOperation op) {
766  return static_cast<intptr_t>(
767  llvm::range_size(unwrap(op)->getDiscardableAttrs()));
768 }
769 
771  intptr_t pos) {
772  NamedAttribute attr =
773  *std::next(unwrap(op)->getDiscardableAttrs().begin(), pos);
774  return MlirNamedAttribute{wrap(attr.getName()), wrap(attr.getValue())};
775 }
776 
777 MlirAttribute mlirOperationGetDiscardableAttributeByName(MlirOperation op,
778  MlirStringRef name) {
779  return wrap(unwrap(op)->getDiscardableAttr(unwrap(name)));
780 }
781 
783  MlirStringRef name,
784  MlirAttribute attr) {
785  unwrap(op)->setDiscardableAttr(unwrap(name), unwrap(attr));
786 }
787 
789  MlirStringRef name) {
790  return !!unwrap(op)->removeDiscardableAttr(unwrap(name));
791 }
792 
793 void mlirOperationSetSuccessor(MlirOperation op, intptr_t pos,
794  MlirBlock block) {
795  unwrap(op)->setSuccessor(unwrap(block), static_cast<unsigned>(pos));
796 }
797 
798 intptr_t mlirOperationGetNumAttributes(MlirOperation op) {
799  return static_cast<intptr_t>(unwrap(op)->getAttrs().size());
800 }
801 
802 MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos) {
803  NamedAttribute attr = unwrap(op)->getAttrs()[pos];
804  return MlirNamedAttribute{wrap(attr.getName()), wrap(attr.getValue())};
805 }
806 
807 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
808  MlirStringRef name) {
809  return wrap(unwrap(op)->getAttr(unwrap(name)));
810 }
811 
812 void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name,
813  MlirAttribute attr) {
814  unwrap(op)->setAttr(unwrap(name), unwrap(attr));
815 }
816 
817 bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name) {
818  return !!unwrap(op)->removeAttr(unwrap(name));
819 }
820 
821 void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
822  void *userData) {
823  detail::CallbackOstream stream(callback, userData);
824  unwrap(op)->print(stream);
825 }
826 
827 void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags,
828  MlirStringCallback callback, void *userData) {
829  detail::CallbackOstream stream(callback, userData);
830  unwrap(op)->print(stream, *unwrap(flags));
831 }
832 
833 void mlirOperationPrintWithState(MlirOperation op, MlirAsmState state,
834  MlirStringCallback callback, void *userData) {
835  detail::CallbackOstream stream(callback, userData);
836  if (state.ptr)
837  unwrap(op)->print(stream, *unwrap(state));
838  unwrap(op)->print(stream);
839 }
840 
841 void mlirOperationWriteBytecode(MlirOperation op, MlirStringCallback callback,
842  void *userData) {
843  detail::CallbackOstream stream(callback, userData);
844  // As no desired version is set, no failure can occur.
845  (void)writeBytecodeToFile(unwrap(op), stream);
846 }
847 
849  MlirOperation op, MlirBytecodeWriterConfig config,
850  MlirStringCallback callback, void *userData) {
851  detail::CallbackOstream stream(callback, userData);
852  return wrap(writeBytecodeToFile(unwrap(op), stream, *unwrap(config)));
853 }
854 
855 void mlirOperationDump(MlirOperation op) { return unwrap(op)->dump(); }
856 
857 bool mlirOperationVerify(MlirOperation op) {
858  return succeeded(verify(unwrap(op)));
859 }
860 
861 void mlirOperationMoveAfter(MlirOperation op, MlirOperation other) {
862  return unwrap(op)->moveAfter(unwrap(other));
863 }
864 
865 void mlirOperationMoveBefore(MlirOperation op, MlirOperation other) {
866  return unwrap(op)->moveBefore(unwrap(other));
867 }
868 
869 bool mlirOperationIsBeforeInBlock(MlirOperation op, MlirOperation other) {
870  return unwrap(op)->isBeforeInBlock(unwrap(other));
871 }
872 
874  switch (result) {
876  return mlir::WalkResult::advance();
877 
880 
881  case MlirWalkResultSkip:
882  return mlir::WalkResult::skip();
883  }
884  llvm_unreachable("unknown result in WalkResult::unwrap");
885 }
886 
887 void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback,
888  void *userData, MlirWalkOrder walkOrder) {
889  switch (walkOrder) {
890 
891  case MlirWalkPreOrder:
893  [callback, userData](Operation *op) {
894  return unwrap(callback(wrap(op), userData));
895  });
896  break;
897  case MlirWalkPostOrder:
899  [callback, userData](Operation *op) {
900  return unwrap(callback(wrap(op), userData));
901  });
902  }
903 }
904 
905 //===----------------------------------------------------------------------===//
906 // Region API.
907 //===----------------------------------------------------------------------===//
908 
909 MlirRegion mlirRegionCreate() { return wrap(new Region); }
910 
911 bool mlirRegionEqual(MlirRegion region, MlirRegion other) {
912  return unwrap(region) == unwrap(other);
913 }
914 
915 MlirBlock mlirRegionGetFirstBlock(MlirRegion region) {
916  Region *cppRegion = unwrap(region);
917  if (cppRegion->empty())
918  return wrap(static_cast<Block *>(nullptr));
919  return wrap(&cppRegion->front());
920 }
921 
922 void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block) {
923  unwrap(region)->push_back(unwrap(block));
924 }
925 
926 void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos,
927  MlirBlock block) {
928  auto &blockList = unwrap(region)->getBlocks();
929  blockList.insert(std::next(blockList.begin(), pos), unwrap(block));
930 }
931 
932 void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference,
933  MlirBlock block) {
934  Region *cppRegion = unwrap(region);
935  if (mlirBlockIsNull(reference)) {
936  cppRegion->getBlocks().insert(cppRegion->begin(), unwrap(block));
937  return;
938  }
939 
940  assert(unwrap(reference)->getParent() == unwrap(region) &&
941  "expected reference block to belong to the region");
942  cppRegion->getBlocks().insertAfter(Region::iterator(unwrap(reference)),
943  unwrap(block));
944 }
945 
946 void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference,
947  MlirBlock block) {
948  if (mlirBlockIsNull(reference))
949  return mlirRegionAppendOwnedBlock(region, block);
950 
951  assert(unwrap(reference)->getParent() == unwrap(region) &&
952  "expected reference block to belong to the region");
953  unwrap(region)->getBlocks().insert(Region::iterator(unwrap(reference)),
954  unwrap(block));
955 }
956 
957 void mlirRegionDestroy(MlirRegion region) {
958  delete static_cast<Region *>(region.ptr);
959 }
960 
961 void mlirRegionTakeBody(MlirRegion target, MlirRegion source) {
962  unwrap(target)->takeBody(*unwrap(source));
963 }
964 
965 //===----------------------------------------------------------------------===//
966 // Block API.
967 //===----------------------------------------------------------------------===//
968 
969 MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args,
970  MlirLocation const *locs) {
971  Block *b = new Block;
972  for (intptr_t i = 0; i < nArgs; ++i)
973  b->addArgument(unwrap(args[i]), unwrap(locs[i]));
974  return wrap(b);
975 }
976 
977 bool mlirBlockEqual(MlirBlock block, MlirBlock other) {
978  return unwrap(block) == unwrap(other);
979 }
980 
981 MlirOperation mlirBlockGetParentOperation(MlirBlock block) {
982  return wrap(unwrap(block)->getParentOp());
983 }
984 
985 MlirRegion mlirBlockGetParentRegion(MlirBlock block) {
986  return wrap(unwrap(block)->getParent());
987 }
988 
989 MlirBlock mlirBlockGetNextInRegion(MlirBlock block) {
990  return wrap(unwrap(block)->getNextNode());
991 }
992 
993 MlirOperation mlirBlockGetFirstOperation(MlirBlock block) {
994  Block *cppBlock = unwrap(block);
995  if (cppBlock->empty())
996  return wrap(static_cast<Operation *>(nullptr));
997  return wrap(&cppBlock->front());
998 }
999 
1000 MlirOperation mlirBlockGetTerminator(MlirBlock block) {
1001  Block *cppBlock = unwrap(block);
1002  if (cppBlock->empty())
1003  return wrap(static_cast<Operation *>(nullptr));
1004  Operation &back = cppBlock->back();
1005  if (!back.hasTrait<OpTrait::IsTerminator>())
1006  return wrap(static_cast<Operation *>(nullptr));
1007  return wrap(&back);
1008 }
1009 
1010 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation) {
1011  unwrap(block)->push_back(unwrap(operation));
1012 }
1013 
1014 void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos,
1015  MlirOperation operation) {
1016  auto &opList = unwrap(block)->getOperations();
1017  opList.insert(std::next(opList.begin(), pos), unwrap(operation));
1018 }
1019 
1021  MlirOperation reference,
1022  MlirOperation operation) {
1023  Block *cppBlock = unwrap(block);
1024  if (mlirOperationIsNull(reference)) {
1025  cppBlock->getOperations().insert(cppBlock->begin(), unwrap(operation));
1026  return;
1027  }
1028 
1029  assert(unwrap(reference)->getBlock() == unwrap(block) &&
1030  "expected reference operation to belong to the block");
1031  cppBlock->getOperations().insertAfter(Block::iterator(unwrap(reference)),
1032  unwrap(operation));
1033 }
1034 
1036  MlirOperation reference,
1037  MlirOperation operation) {
1038  if (mlirOperationIsNull(reference))
1039  return mlirBlockAppendOwnedOperation(block, operation);
1040 
1041  assert(unwrap(reference)->getBlock() == unwrap(block) &&
1042  "expected reference operation to belong to the block");
1043  unwrap(block)->getOperations().insert(Block::iterator(unwrap(reference)),
1044  unwrap(operation));
1045 }
1046 
1047 void mlirBlockDestroy(MlirBlock block) { delete unwrap(block); }
1048 
1049 void mlirBlockDetach(MlirBlock block) {
1050  Block *b = unwrap(block);
1051  b->getParent()->getBlocks().remove(b);
1052 }
1053 
1054 intptr_t mlirBlockGetNumArguments(MlirBlock block) {
1055  return static_cast<intptr_t>(unwrap(block)->getNumArguments());
1056 }
1057 
1058 MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type,
1059  MlirLocation loc) {
1060  return wrap(unwrap(block)->addArgument(unwrap(type), unwrap(loc)));
1061 }
1062 
1063 void mlirBlockEraseArgument(MlirBlock block, unsigned index) {
1064  return unwrap(block)->eraseArgument(index);
1065 }
1066 
1067 MlirValue mlirBlockInsertArgument(MlirBlock block, intptr_t pos, MlirType type,
1068  MlirLocation loc) {
1069  return wrap(unwrap(block)->insertArgument(pos, unwrap(type), unwrap(loc)));
1070 }
1071 
1072 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
1073  return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
1074 }
1075 
1076 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
1077  void *userData) {
1078  detail::CallbackOstream stream(callback, userData);
1079  unwrap(block)->print(stream);
1080 }
1081 
1082 intptr_t mlirBlockGetNumSuccessors(MlirBlock block) {
1083  return static_cast<intptr_t>(unwrap(block)->getNumSuccessors());
1084 }
1085 
1086 MlirBlock mlirBlockGetSuccessor(MlirBlock block, intptr_t pos) {
1087  return wrap(unwrap(block)->getSuccessor(static_cast<unsigned>(pos)));
1088 }
1089 
1090 intptr_t mlirBlockGetNumPredecessors(MlirBlock block) {
1091  Block *b = unwrap(block);
1092  return static_cast<intptr_t>(std::distance(b->pred_begin(), b->pred_end()));
1093 }
1094 
1095 MlirBlock mlirBlockGetPredecessor(MlirBlock block, intptr_t pos) {
1096  Block *b = unwrap(block);
1097  Block::pred_iterator it = b->pred_begin();
1098  std::advance(it, pos);
1099  return wrap(*it);
1100 }
1101 
1102 //===----------------------------------------------------------------------===//
1103 // Value API.
1104 //===----------------------------------------------------------------------===//
1105 
1106 bool mlirValueEqual(MlirValue value1, MlirValue value2) {
1107  return unwrap(value1) == unwrap(value2);
1108 }
1109 
1110 bool mlirValueIsABlockArgument(MlirValue value) {
1111  return llvm::isa<BlockArgument>(unwrap(value));
1112 }
1113 
1114 bool mlirValueIsAOpResult(MlirValue value) {
1115  return llvm::isa<OpResult>(unwrap(value));
1116 }
1117 
1118 MlirBlock mlirBlockArgumentGetOwner(MlirValue value) {
1119  return wrap(llvm::dyn_cast<BlockArgument>(unwrap(value)).getOwner());
1120 }
1121 
1122 intptr_t mlirBlockArgumentGetArgNumber(MlirValue value) {
1123  return static_cast<intptr_t>(
1124  llvm::dyn_cast<BlockArgument>(unwrap(value)).getArgNumber());
1125 }
1126 
1127 void mlirBlockArgumentSetType(MlirValue value, MlirType type) {
1128  if (auto blockArg = llvm::dyn_cast<BlockArgument>(unwrap(value)))
1129  blockArg.setType(unwrap(type));
1130 }
1131 
1132 MlirOperation mlirOpResultGetOwner(MlirValue value) {
1133  return wrap(llvm::dyn_cast<OpResult>(unwrap(value)).getOwner());
1134 }
1135 
1136 intptr_t mlirOpResultGetResultNumber(MlirValue value) {
1137  return static_cast<intptr_t>(
1138  llvm::dyn_cast<OpResult>(unwrap(value)).getResultNumber());
1139 }
1140 
1141 MlirType mlirValueGetType(MlirValue value) {
1142  return wrap(unwrap(value).getType());
1143 }
1144 
1145 void mlirValueSetType(MlirValue value, MlirType type) {
1146  unwrap(value).setType(unwrap(type));
1147 }
1148 
1149 void mlirValueDump(MlirValue value) { unwrap(value).dump(); }
1150 
1151 void mlirValuePrint(MlirValue value, MlirStringCallback callback,
1152  void *userData) {
1153  detail::CallbackOstream stream(callback, userData);
1154  unwrap(value).print(stream);
1155 }
1156 
1157 void mlirValuePrintAsOperand(MlirValue value, MlirAsmState state,
1158  MlirStringCallback callback, void *userData) {
1159  detail::CallbackOstream stream(callback, userData);
1160  Value cppValue = unwrap(value);
1161  cppValue.printAsOperand(stream, *unwrap(state));
1162 }
1163 
1164 MlirOpOperand mlirValueGetFirstUse(MlirValue value) {
1165  Value cppValue = unwrap(value);
1166  if (cppValue.use_empty())
1167  return {};
1168 
1169  OpOperand *opOperand = cppValue.use_begin().getOperand();
1170 
1171  return wrap(opOperand);
1172 }
1173 
1174 void mlirValueReplaceAllUsesOfWith(MlirValue oldValue, MlirValue newValue) {
1175  unwrap(oldValue).replaceAllUsesWith(unwrap(newValue));
1176 }
1177 
1178 void mlirValueReplaceAllUsesExcept(MlirValue oldValue, MlirValue newValue,
1179  intptr_t numExceptions,
1180  MlirOperation *exceptions) {
1181  Value oldValueCpp = unwrap(oldValue);
1182  Value newValueCpp = unwrap(newValue);
1183 
1185  for (intptr_t i = 0; i < numExceptions; ++i) {
1186  exceptionSet.insert(unwrap(exceptions[i]));
1187  }
1188 
1189  oldValueCpp.replaceAllUsesExcept(newValueCpp, exceptionSet);
1190 }
1191 
1192 MlirLocation mlirValueGetLocation(MlirValue v) {
1193  return wrap(unwrap(v).getLoc());
1194 }
1195 
1196 MlirContext mlirValueGetContext(MlirValue v) {
1197  return wrap(unwrap(v).getContext());
1198 }
1199 
1200 //===----------------------------------------------------------------------===//
1201 // OpOperand API.
1202 //===----------------------------------------------------------------------===//
1203 
1204 bool mlirOpOperandIsNull(MlirOpOperand opOperand) { return !opOperand.ptr; }
1205 
1206 MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand) {
1207  return wrap(unwrap(opOperand)->getOwner());
1208 }
1209 
1210 MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand) {
1211  return wrap(unwrap(opOperand)->get());
1212 }
1213 
1214 unsigned mlirOpOperandGetOperandNumber(MlirOpOperand opOperand) {
1215  return unwrap(opOperand)->getOperandNumber();
1216 }
1217 
1218 MlirOpOperand mlirOpOperandGetNextUse(MlirOpOperand opOperand) {
1219  if (mlirOpOperandIsNull(opOperand))
1220  return {};
1221 
1222  OpOperand *nextOpOperand = static_cast<OpOperand *>(
1223  unwrap(opOperand)->getNextOperandUsingThisValue());
1224 
1225  if (!nextOpOperand)
1226  return {};
1227 
1228  return wrap(nextOpOperand);
1229 }
1230 
1231 //===----------------------------------------------------------------------===//
1232 // Type API.
1233 //===----------------------------------------------------------------------===//
1234 
1235 MlirType mlirTypeParseGet(MlirContext context, MlirStringRef type) {
1236  return wrap(mlir::parseType(unwrap(type), unwrap(context)));
1237 }
1238 
1239 MlirContext mlirTypeGetContext(MlirType type) {
1240  return wrap(unwrap(type).getContext());
1241 }
1242 
1243 MlirTypeID mlirTypeGetTypeID(MlirType type) {
1244  return wrap(unwrap(type).getTypeID());
1245 }
1246 
1247 MlirDialect mlirTypeGetDialect(MlirType type) {
1248  return wrap(&unwrap(type).getDialect());
1249 }
1250 
1251 bool mlirTypeEqual(MlirType t1, MlirType t2) {
1252  return unwrap(t1) == unwrap(t2);
1253 }
1254 
1255 void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData) {
1256  detail::CallbackOstream stream(callback, userData);
1257  unwrap(type).print(stream);
1258 }
1259 
1260 void mlirTypeDump(MlirType type) { unwrap(type).dump(); }
1261 
1262 //===----------------------------------------------------------------------===//
1263 // Attribute API.
1264 //===----------------------------------------------------------------------===//
1265 
1266 MlirAttribute mlirAttributeParseGet(MlirContext context, MlirStringRef attr) {
1267  return wrap(mlir::parseAttribute(unwrap(attr), unwrap(context)));
1268 }
1269 
1270 MlirContext mlirAttributeGetContext(MlirAttribute attribute) {
1271  return wrap(unwrap(attribute).getContext());
1272 }
1273 
1274 MlirType mlirAttributeGetType(MlirAttribute attribute) {
1275  Attribute attr = unwrap(attribute);
1276  if (auto typedAttr = llvm::dyn_cast<TypedAttr>(attr))
1277  return wrap(typedAttr.getType());
1278  return wrap(NoneType::get(attr.getContext()));
1279 }
1280 
1281 MlirTypeID mlirAttributeGetTypeID(MlirAttribute attr) {
1282  return wrap(unwrap(attr).getTypeID());
1283 }
1284 
1285 MlirDialect mlirAttributeGetDialect(MlirAttribute attr) {
1286  return wrap(&unwrap(attr).getDialect());
1287 }
1288 
1289 bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2) {
1290  return unwrap(a1) == unwrap(a2);
1291 }
1292 
1293 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
1294  void *userData) {
1295  detail::CallbackOstream stream(callback, userData);
1296  unwrap(attr).print(stream);
1297 }
1298 
1299 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
1300 
1302  MlirAttribute attr) {
1303  return MlirNamedAttribute{name, attr};
1304 }
1305 
1306 //===----------------------------------------------------------------------===//
1307 // Identifier API.
1308 //===----------------------------------------------------------------------===//
1309 
1310 MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str) {
1311  return wrap(StringAttr::get(unwrap(context), unwrap(str)));
1312 }
1313 
1314 MlirContext mlirIdentifierGetContext(MlirIdentifier ident) {
1315  return wrap(unwrap(ident).getContext());
1316 }
1317 
1318 bool mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other) {
1319  return unwrap(ident) == unwrap(other);
1320 }
1321 
1322 MlirStringRef mlirIdentifierStr(MlirIdentifier ident) {
1323  return wrap(unwrap(ident).strref());
1324 }
1325 
1326 //===----------------------------------------------------------------------===//
1327 // Symbol and SymbolTable API.
1328 //===----------------------------------------------------------------------===//
1329 
1332 }
1333 
1336 }
1337 
1338 MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation) {
1339  if (!unwrap(operation)->hasTrait<OpTrait::SymbolTable>())
1340  return wrap(static_cast<SymbolTable *>(nullptr));
1341  return wrap(new SymbolTable(unwrap(operation)));
1342 }
1343 
1344 void mlirSymbolTableDestroy(MlirSymbolTable symbolTable) {
1345  delete unwrap(symbolTable);
1346 }
1347 
1348 MlirOperation mlirSymbolTableLookup(MlirSymbolTable symbolTable,
1349  MlirStringRef name) {
1350  return wrap(unwrap(symbolTable)->lookup(StringRef(name.data, name.length)));
1351 }
1352 
1353 MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable,
1354  MlirOperation operation) {
1355  return wrap((Attribute)unwrap(symbolTable)->insert(unwrap(operation)));
1356 }
1357 
1358 void mlirSymbolTableErase(MlirSymbolTable symbolTable,
1359  MlirOperation operation) {
1360  unwrap(symbolTable)->erase(unwrap(operation));
1361 }
1362 
1364  MlirStringRef newSymbol,
1365  MlirOperation from) {
1366  auto *cppFrom = unwrap(from);
1367  auto *context = cppFrom->getContext();
1368  auto oldSymbolAttr = StringAttr::get(context, unwrap(oldSymbol));
1369  auto newSymbolAttr = StringAttr::get(context, unwrap(newSymbol));
1370  return wrap(SymbolTable::replaceAllSymbolUses(oldSymbolAttr, newSymbolAttr,
1371  unwrap(from)));
1372 }
1373 
1374 void mlirSymbolTableWalkSymbolTables(MlirOperation from, bool allSymUsesVisible,
1375  void (*callback)(MlirOperation, bool,
1376  void *userData),
1377  void *userData) {
1378  SymbolTable::walkSymbolTables(unwrap(from), allSymUsesVisible,
1379  [&](Operation *foundOpCpp, bool isVisible) {
1380  callback(wrap(foundOpCpp), isVisible,
1381  userData);
1382  });
1383 }
unsigned mlirOpOperandGetOperandNumber(MlirOpOperand opOperand)
Returns the operand number of an op operand.
Definition: IR.cpp:1214
MlirLocation mlirValueGetLocation(MlirValue v)
Gets the location of the value.
Definition: IR.cpp:1192
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:855
MlirAttribute mlirOperationGetDiscardableAttributeByName(MlirOperation op, MlirStringRef name)
Returns a discardable attribute attached to the operation given its name.
Definition: IR.cpp:777
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:1348
MlirRegion mlirRegionCreate()
Creates a new empty region and transfers ownership to the caller.
Definition: IR.cpp:909
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:821
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:1151
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:1090
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:1206
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:696
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:848
MlirIdentifier mlirOperationGetName(MlirOperation op)
Gets the name of the operation as an identifier.
Definition: IR.cpp:669
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:1318
void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but accepts flags controlling the printing behavior.
Definition: IR.cpp:827
bool mlirValueIsABlockArgument(MlirValue value)
Returns 1 if the value is a block argument, 0 otherwise.
Definition: IR.cpp:1110
MlirTypeID mlirTypeGetTypeID(MlirType type)
Gets the type ID of the type.
Definition: IR.cpp:1243
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:1174
MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type, MlirLocation loc)
Appends an argument of the specified type to the block.
Definition: IR.cpp:1058
intptr_t mlirOperationGetNumRegions(MlirOperation op)
Returns the number of regions attached to the given operation.
Definition: IR.cpp:681
MlirBlock mlirOperationGetBlock(MlirOperation op)
Gets the block that owns this operation, returning null if the operation is not owned.
Definition: IR.cpp:673
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:1310
void mlirBlockArgumentSetType(MlirValue value, MlirType type)
Sets the type of the block argument to the given type.
Definition: IR.cpp:1127
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:1301
MlirStringRef mlirSymbolTableGetVisibilityAttributeName()
Returns the name of the attribute used to store symbol visibility.
Definition: IR.cpp:1334
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:732
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:1374
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:1293
MlirBlock mlirRegionGetFirstBlock(MlirRegion region)
Gets the first block in the region.
Definition: IR.cpp:915
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:1363
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:728
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:1164
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:932
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:1178
void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation)
Takes an operation owned by the caller and appends it to the block.
Definition: IR.cpp:1010
MlirRegion mlirOperationGetFirstRegion(MlirOperation op)
Returns first region attached to the operation.
Definition: IR.cpp:689
MlirAttribute mlirOperationGetInherentAttributeByName(MlirOperation op, MlirStringRef name)
Returns an inherent attribute attached to the operation given its name.
Definition: IR.cpp:750
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:1270
MlirStringRef mlirSymbolTableGetSymbolAttributeName()
Returns the name of the attribute used to store symbol names compatible with symbol tables.
Definition: IR.cpp:1330
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:1014
MlirRegion mlirBlockGetParentRegion(MlirBlock block)
Returns the region that contains this block.
Definition: IR.cpp:985
MlirType mlirValueGetType(MlirValue value)
Returns the type of the value.
Definition: IR.cpp:1141
void mlirOperationMoveAfter(MlirOperation op, MlirOperation other)
Moves the given operation immediately after the other operation in its parent block.
Definition: IR.cpp:861
void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block)
Takes a block owned by the caller and appends it to the given region.
Definition: IR.cpp:922
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:1076
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:782
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:989
void mlirOperationSetSuccessor(MlirOperation op, intptr_t pos, MlirBlock block)
Set pos-th successor of the operation.
Definition: IR.cpp:793
MlirValue mlirOpOperandGetValue(MlirOpOperand opOperand)
Returns the value of an op operand.
Definition: IR.cpp:1210
#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:705
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:873
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:946
MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos)
Returns pos-th argument of the block.
Definition: IR.cpp:1072
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:663
intptr_t mlirBlockArgumentGetArgNumber(MlirValue value)
Returns the position of the value in the argument list of its block.
Definition: IR.cpp:1122
void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback, void *userData, MlirWalkOrder walkOrder)
Walks operation op in walkOrder and calls callback on that operation.
Definition: IR.cpp:887
MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos)
Returns pos-th successor of the operation.
Definition: IR.cpp:740
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:1035
bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2)
Checks if two attributes are equal.
Definition: IR.cpp:1289
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:758
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:1106
MlirContext mlirIdentifierGetContext(MlirIdentifier ident)
Returns the context associated with this identifier.
Definition: IR.cpp:1314
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:1086
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:677
void mlirRegionTakeBody(MlirRegion target, MlirRegion source)
Moves the entire content of the source region to the target region.
Definition: IR.cpp:961
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:1067
void mlirValueSetType(MlirValue value, MlirType type)
Set the type of the value.
Definition: IR.cpp:1145
intptr_t mlirOperationGetNumSuccessors(MlirOperation op)
Returns the number of successor blocks of the operation.
Definition: IR.cpp:736
MlirDialect mlirAttributeGetDialect(MlirAttribute attr)
Gets the dialect of the attribute.
Definition: IR.cpp:1285
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:812
void mlirBlockDestroy(MlirBlock block)
Takes a block owned by the caller and destroys it.
Definition: IR.cpp:1047
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:926
void mlirOperationSetOperand(MlirOperation op, intptr_t pos, MlirValue newValue)
Sets the pos-th operand of the operation.
Definition: IR.cpp:717
intptr_t mlirBlockGetNumArguments(MlirBlock block)
Returns the number of arguments of the block.
Definition: IR.cpp:1054
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:1132
void mlirBlockEraseArgument(MlirBlock block, unsigned index)
Erase the argument at 'index' and remove it from the argument list.
Definition: IR.cpp:1063
bool mlirOpOperandIsNull(MlirOpOperand opOperand)
Returns whether the op operand is null.
Definition: IR.cpp:1204
MlirDialect mlirTypeGetDialect(MlirType type)
Gets the dialect a type belongs to.
Definition: IR.cpp:1247
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:865
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:1157
MlirBlock mlirBlockArgumentGetOwner(MlirValue value)
Returns the block in which this value is defined as an argument.
Definition: IR.cpp:1118
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:713
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:1251
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:807
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:869
MlirTypeID mlirAttributeGetTypeID(MlirAttribute attr)
Gets the type id of the attribute.
Definition: IR.cpp:1281
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:1353
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:765
MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation)
Creates a symbol table for the given operation.
Definition: IR.cpp:1338
void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n, MlirRegion const *regions)
Definition: IR.cpp:513
void mlirOperationSetLocation(MlirOperation op, MlirLocation loc)
Sets the location of the operation.
Definition: IR.cpp:659
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:993
MlirType mlirAttributeGetType(MlirAttribute attribute)
Gets the type of this attribute.
Definition: IR.cpp:1274
bool mlirOperationRemoveDiscardableAttributeByName(MlirOperation op, MlirStringRef name)
Removes a discardable attribute by name.
Definition: IR.cpp:788
void mlirRegionDestroy(MlirRegion region)
Takes a region owned by the caller and destroys it.
Definition: IR.cpp:957
bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name)
Removes an attribute by name.
Definition: IR.cpp:817
bool mlirValueIsAOpResult(MlirValue value)
Returns 1 if the value is an operation result, 0 otherwise.
Definition: IR.cpp:1114
MLIR_CAPI_EXPORTED bool mlirOperationHasInherentAttributeByName(MlirOperation op, MlirStringRef name)
Returns true if this operation defines an inherent attribute with this name.
Definition: IR.cpp:745
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:1095
MlirOperation mlirBlockGetTerminator(MlirBlock block)
Returns the terminator operation in the block or null if no terminator.
Definition: IR.cpp:1000
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:685
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:1266
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:1344
intptr_t mlirBlockGetNumSuccessors(MlirBlock block)
Returns the number of successor blocks of the block.
Definition: IR.cpp:1082
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:833
bool mlirOperationVerify(MlirOperation op)
Verify the operation and return true if it passes, false if it fails.
Definition: IR.cpp:857
void mlirBlockDetach(MlirBlock block)
Detach a block from the owning region and assume ownership.
Definition: IR.cpp:1049
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:802
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:841
void mlirValueDump(MlirValue value)
Prints the value to the standard error stream.
Definition: IR.cpp:1149
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:1020
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:722
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:1239
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:1255
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:911
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:1136
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:977
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:1358
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:770
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:1299
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:1322
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:981
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:1218
intptr_t mlirOperationGetNumOperands(MlirOperation op)
Returns the number of operands of the operation.
Definition: IR.cpp:709
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:1235
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:969
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:1260
intptr_t mlirOperationGetNumAttributes(MlirOperation op)
Returns the number of attributes attached to the operation.
Definition: IR.cpp:798
MlirContext mlirValueGetContext(MlirValue v)
Gets the context that a value was created with.
Definition: IR.cpp:1196
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:67
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:851
MlirWalkOrder
Traversal order for operation walk.
Definition: IR.h:844
@ MlirWalkPreOrder
Definition: IR.h:845
@ MlirWalkPostOrder
Definition: IR.h:846
MlirWalkResult
Operation walk result.
Definition: IR.h:837
@ MlirWalkResultInterrupt
Definition: IR.h:839
@ MlirWalkResultSkip
Definition: IR.h:840
@ MlirWalkResultAdvance
Definition: IR.h:838
static bool mlirBlockIsNull(MlirBlock block)
Checks whether a block is null.
Definition: IR.h:933
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.