14 #include "TypeDetail.h"
29 #include "llvm/ADT/DenseMap.h"
30 #include "llvm/ADT/Twine.h"
31 #include "llvm/Support/Allocator.h"
32 #include "llvm/Support/CommandLine.h"
33 #include "llvm/Support/Compiler.h"
34 #include "llvm/Support/DebugLog.h"
35 #include "llvm/Support/ManagedStatic.h"
36 #include "llvm/Support/Mutex.h"
37 #include "llvm/Support/RWMutex.h"
38 #include "llvm/Support/ThreadPool.h"
39 #include "llvm/Support/raw_ostream.h"
43 #define DEBUG_TYPE "mlircontext"
56 struct MLIRContextOptions {
57 llvm::cl::opt<bool> disableThreading{
58 "mlir-disable-threading",
59 llvm::cl::desc(
"Disable multi-threading within MLIR, overrides any "
60 "further call to MLIRContext::enableMultiThreading()")};
62 llvm::cl::opt<bool> printOpOnDiagnostic{
63 "mlir-print-op-on-diagnostic",
64 llvm::cl::desc(
"When a diagnostic is emitted on an operation, also print "
65 "the operation as an attached note"),
66 llvm::cl::init(
true)};
68 llvm::cl::opt<bool> printStackTraceOnDiagnostic{
69 "mlir-print-stacktrace-on-diagnostic",
70 llvm::cl::desc(
"When a diagnostic is emitted, also print the stack trace "
71 "as an attached note")};
75 static llvm::ManagedStatic<MLIRContextOptions>
clOptions;
78 #if LLVM_ENABLE_THREADS != 0
100 struct ScopedWriterLock {
101 ScopedWriterLock(llvm::sys::SmartRWMutex<true> &mutexParam,
bool shouldLock)
102 : mutex(shouldLock ? &mutexParam : nullptr) {
106 ~ScopedWriterLock() {
110 llvm::sys::SmartRWMutex<true> *mutex;
149 bool allowUnregisteredDialects =
false;
152 bool threadingIsEnabled =
true;
158 std::atomic<int> multiThreadedExecutionContext{0};
163 bool printOpOnDiagnostic =
true;
166 bool printStackTraceOnDiagnostic =
false;
176 llvm::ThreadPoolInterface *threadPool =
nullptr;
186 llvm::StringMap<std::unique_ptr<OperationName::Impl>>
operations;
235 IntegerType int1Ty, int8Ty, int16Ty, int32Ty, int64Ty,
int128Ty;
274 : threadingIsEnabled(threadingIsEnabled) {
275 if (threadingIsEnabled) {
276 ownedThreadPool = std::make_unique<llvm::DefaultThreadPool>();
277 threadPool = ownedThreadPool.get();
281 for (
auto typeMapping : registeredTypes)
282 typeMapping.second->~AbstractType();
283 for (
auto attrMapping : registeredAttributes)
284 attrMapping.second->~AbstractAttribute();
305 getOrLoadDialect<BuiltinDialect>();
312 impl->bf16Ty = TypeUniquer::get<BFloat16Type>(
this);
313 impl->f16Ty = TypeUniquer::get<Float16Type>(
this);
314 impl->tf32Ty = TypeUniquer::get<FloatTF32Type>(
this);
315 impl->f32Ty = TypeUniquer::get<Float32Type>(
this);
316 impl->f64Ty = TypeUniquer::get<Float64Type>(
this);
317 impl->f80Ty = TypeUniquer::get<Float80Type>(
this);
318 impl->f128Ty = TypeUniquer::get<Float128Type>(
this);
320 impl->indexTy = TypeUniquer::get<IndexType>(
this);
322 impl->int1Ty = TypeUniquer::get<IntegerType>(
this, 1, IntegerType::Signless);
323 impl->int8Ty = TypeUniquer::get<IntegerType>(
this, 8, IntegerType::Signless);
325 TypeUniquer::get<IntegerType>(
this, 16, IntegerType::Signless);
327 TypeUniquer::get<IntegerType>(
this, 32, IntegerType::Signless);
329 TypeUniquer::get<IntegerType>(
this, 64, IntegerType::Signless);
331 TypeUniquer::get<IntegerType>(
this, 128, IntegerType::Signless);
333 impl->noneType = TypeUniquer::get<NoneType>(
this);
339 impl->unknownLocAttr = AttributeUniquer::get<UnknownLoc>(
this);
341 impl->falseAttr = IntegerAttr::getBoolAttrUnchecked(
impl->int1Ty,
false);
342 impl->trueAttr = IntegerAttr::getBoolAttrUnchecked(
impl->int1Ty,
true);
344 impl->unitAttr = AttributeUniquer::get<UnitAttr>(
this);
346 impl->emptyDictionaryAttr = DictionaryAttr::getEmptyUnchecked(
this);
348 impl->emptyStringAttr = StringAttr::getEmptyStringAttrUnchecked(
this);
364 template <
typename T>
367 auto result = allocator.Allocate<T>(elements.size());
368 llvm::uninitialized_copy(elements, result);
381 void MLIRContext::executeActionInternal(
function_ref<
void()> actionFn,
383 assert(
getImpl().actionHandler);
401 std::unique_ptr<remark::detail::RemarkEngine> engine) {
417 assert(
impl->multiThreadedExecutionContext == 0 &&
418 "appending to the MLIRContext dialect registry while in a "
419 "multi-threaded execution context");
427 return impl->dialectsRegistry;
432 std::vector<Dialect *> result;
433 result.reserve(
impl->loadedDialects.size());
434 for (
auto &dialect :
impl->loadedDialects)
435 result.push_back(dialect.second.get());
436 llvm::array_pod_sort(result.begin(), result.end(),
438 return (*lhs)->getNamespace() < (*rhs)->getNamespace();
443 std::vector<StringRef> result;
444 for (
auto dialect :
impl->dialectsRegistry.getDialectNames())
445 result.push_back(dialect);
453 auto it =
impl->loadedDialects.find(name);
454 return (it !=
impl->loadedDialects.end()) ? it->second.get() :
nullptr;
462 impl->dialectsRegistry.getDialectAllocator(name);
463 return allocator ? allocator(
this) :
nullptr;
474 auto dialectIt =
impl.loadedDialects.try_emplace(dialectNamespace,
nullptr);
476 if (dialectIt.second) {
477 LDBG() <<
"Load new dialect in Context " << dialectNamespace;
479 if (
impl.multiThreadedExecutionContext != 0)
480 llvm::report_fatal_error(
481 "Loading a dialect (" + dialectNamespace +
482 ") while in a multi-threaded execution context (maybe "
483 "the PassManager): this can indicate a "
484 "missing `dependentDialects` in a pass for example.");
490 std::unique_ptr<Dialect> &dialectOwned =
491 impl.loadedDialects[dialectNamespace] = ctor();
492 Dialect *dialect = dialectOwned.get();
493 assert(dialect &&
"dialect ctor failed");
498 auto stringAttrsIt =
impl.dialectReferencingStrAttrs.find(dialectNamespace);
499 if (stringAttrsIt !=
impl.dialectReferencingStrAttrs.end()) {
502 impl.dialectReferencingStrAttrs.erase(stringAttrsIt);
506 impl.dialectsRegistry.applyExtensions(dialect);
511 if (dialectIt.first->second ==
nullptr)
512 llvm::report_fatal_error(
513 "Loading (and getting) a dialect (" + dialectNamespace +
514 ") while the same dialect is still loading: use loadDialect instead "
515 "of getOrLoadDialect.");
519 std::unique_ptr<Dialect> &dialect = dialectIt.first->second;
520 if (dialect->getTypeID() != dialectID)
521 llvm::report_fatal_error(
"a dialect with namespace '" + dialectNamespace +
522 "' has already been registered");
524 return dialect.get();
527 bool MLIRContext::isDialectLoading(StringRef dialectNamespace) {
537 auto dialectIt =
impl.loadedDialects.find(dialectNamespace);
539 if (dialectIt !=
impl.loadedDialects.end()) {
540 if (
auto *dynDialect = dyn_cast<DynamicDialect>(dialectIt->second.get()))
542 llvm::report_fatal_error(
"a dialect with namespace '" + dialectNamespace +
543 "' has already been registered");
546 LDBG() <<
"Load new dynamic dialect in Context " << dialectNamespace;
548 if (
impl.multiThreadedExecutionContext != 0)
549 llvm::report_fatal_error(
550 "Loading a dynamic dialect (" + dialectNamespace +
551 ") while in a multi-threaded execution context (maybe "
552 "the PassManager): this can indicate a "
553 "missing `dependentDialects` in a pass for example.");
560 return std::unique_ptr<DynamicDialect>(dialect);
573 llvm::hash_code hash(0);
575 hash = llvm::hash_combine(hash,
impl->loadedDialects.size());
576 hash = llvm::hash_combine(hash,
impl->registeredAttributes.size());
577 hash = llvm::hash_combine(hash,
impl->registeredOperations.size());
578 hash = llvm::hash_combine(hash,
impl->registeredTypes.size());
583 return impl->allowUnregisteredDialects;
587 assert(
impl->multiThreadedExecutionContext == 0 &&
588 "changing MLIRContext `allow-unregistered-dialects` configuration "
589 "while in a multi-threaded execution context");
590 impl->allowUnregisteredDialects = allowing;
595 return impl->threadingIsEnabled && llvm::llvm_is_multithreaded();
604 assert(
impl->multiThreadedExecutionContext == 0 &&
605 "changing MLIRContext `disable-threading` configuration while "
606 "in a multi-threaded execution context");
608 impl->threadingIsEnabled = !disable;
611 impl->affineUniquer.disableMultithreading(disable);
612 impl->attributeUniquer.disableMultithreading(disable);
613 impl->typeUniquer.disableMultithreading(disable);
621 if (
impl->ownedThreadPool) {
622 assert(
impl->threadPool);
623 impl->threadPool =
nullptr;
624 impl->ownedThreadPool.reset();
626 }
else if (!
impl->threadPool) {
628 assert(!
impl->ownedThreadPool);
629 impl->ownedThreadPool = std::make_unique<llvm::DefaultThreadPool>();
630 impl->threadPool =
impl->ownedThreadPool.get();
636 "expected multi-threading to be disabled when setting a ThreadPool");
637 impl->threadPool = &pool;
638 impl->ownedThreadPool.reset();
644 assert(
impl->threadPool &&
645 "multi-threading is enabled but threadpool not set");
646 return impl->threadPool->getMaxConcurrency();
654 "expected multi-threading to be enabled within the context");
655 assert(
impl->threadPool &&
656 "multi-threading is enabled but threadpool not set");
657 return *
impl->threadPool;
662 ++
impl->multiThreadedExecutionContext;
667 --
impl->multiThreadedExecutionContext;
674 return impl->printOpOnDiagnostic;
680 assert(
impl->multiThreadedExecutionContext == 0 &&
681 "changing MLIRContext `print-op-on-diagnostic` configuration while in "
682 "a multi-threaded execution context");
683 impl->printOpOnDiagnostic = enable;
689 return impl->printStackTraceOnDiagnostic;
695 assert(
impl->multiThreadedExecutionContext == 0 &&
696 "changing MLIRContext `print-stacktrace-on-diagnostic` configuration "
697 "while in a multi-threaded execution context");
698 impl->printStackTraceOnDiagnostic = enable;
703 return impl->sortedRegisteredOperations;
709 auto lowerBound = llvm::lower_bound(
710 impl->sortedRegisteredOperations, dialectName, [](
auto &lhs,
auto &rhs) {
711 return lhs.getDialect().getNamespace().compare(rhs);
714 if (lowerBound ==
impl->sortedRegisteredOperations.end() ||
715 lowerBound->getDialect().getNamespace() != dialectName)
719 std::upper_bound(lowerBound,
impl->sortedRegisteredOperations.end(),
720 dialectName, [](
auto &lhs,
auto &rhs) {
721 return lhs.compare(rhs.getDialect().getNamespace());
724 size_t count = std::distance(lowerBound, upperBound);
725 return ArrayRef(&*lowerBound, count);
734 assert(
impl.multiThreadedExecutionContext == 0 &&
735 "Registering a new type kind while in a multi-threaded execution "
740 if (!
impl.registeredTypes.insert({typeID, newInfo}).second)
741 llvm::report_fatal_error(
"Dialect Type already registered.");
742 if (!
impl.nameToType.insert({newInfo->getName(), newInfo}).second)
743 llvm::report_fatal_error(
"Dialect Type with name " + newInfo->getName() +
744 " is already registered.");
749 assert(
impl.multiThreadedExecutionContext == 0 &&
750 "Registering a new attribute kind while in a multi-threaded execution "
755 if (!
impl.registeredAttributes.insert({typeID, newInfo}).second)
756 llvm::report_fatal_error(
"Dialect Attribute already registered.");
757 if (!
impl.nameToAttribute.insert({newInfo->getName(), newInfo}).second)
758 llvm::report_fatal_error(
"Dialect Attribute with name " +
759 newInfo->getName() +
" is already registered.");
771 llvm::report_fatal_error(
"Trying to create an Attribute that was not "
772 "registered in this MLIRContext.");
779 return impl.registeredAttributes.lookup(typeID);
782 std::optional<std::reference_wrapper<const AbstractAttribute>>
799 std::move(interfaceMap)) {}
806 if (isMultithreadingEnabled) {
812 impl = registeredIt->second.impl;
819 impl = it->second.get();
827 auto it = ctxImpl.
operations.try_emplace(name);
830 it.first->second = std::make_unique<UnregisteredOpModel>(
831 nameAttr, nameAttr.getReferencedDialect(), TypeID::get<void>(),
834 impl = it.first->second.get();
839 return dialect->getNamespace();
854 llvm::report_fatal_error(
"getParseAssemblyFn hook called on unregistered op");
871 std::optional<Attribute>
874 auto dict = dyn_cast_or_null<DictionaryAttr>(getPropertiesAsAttr(op));
884 auto dict = dyn_cast_or_null<DictionaryAttr>(getPropertiesAsAttr(op));
887 attrs.
set(name, value);
933 return llvm::hash_combine(*prop.
as<
Attribute *>());
940 std::optional<RegisteredOperationName>
943 auto it =
impl.registeredOperations.find(typeID);
944 if (it !=
impl.registeredOperations.end())
949 std::optional<RegisteredOperationName>
952 auto it =
impl.registeredOperationsByName.find(name);
953 if (it !=
impl.registeredOperationsByName.end())
954 return it->getValue();
959 std::unique_ptr<RegisteredOperationName::Impl> ownedImpl,
963 auto &ctxImpl = ctx->
getImpl();
964 assert(ctxImpl.multiThreadedExecutionContext == 0 &&
965 "registering a new operation kind while in a multi-threaded execution "
970 if (!attrNames.empty()) {
972 ctxImpl.abstractDialectSymbolAllocator.Allocate<StringAttr>(
975 for (
unsigned i : llvm::seq<unsigned>(0, attrNames.size()))
976 new (&cachedAttrNames[i]) StringAttr(
StringAttr::get(ctx, attrNames[i]));
977 impl->attributeNames = cachedAttrNames;
979 StringRef name =
impl->getName().strref();
981 ctxImpl.operations[name] = std::move(ownedImpl);
984 auto emplaced = ctxImpl.registeredOperations.try_emplace(
986 assert(emplaced.second &&
"operation name registration must be successful");
987 auto emplacedByName = ctxImpl.registeredOperationsByName.try_emplace(
989 (void)emplacedByName;
990 assert(emplacedByName.second &&
991 "operation name registration must be successful");
995 ctxImpl.sortedRegisteredOperations.
insert(
996 llvm::upper_bound(ctxImpl.sortedRegisteredOperations, value,
997 [](
auto &lhs,
auto &rhs) {
998 return lhs.getIdentifier().compare(
999 rhs.getIdentifier());
1009 const AbstractType *type = lookupMutable(typeID, context);
1011 llvm::report_fatal_error(
1012 "Trying to create a Type that was not registered in this MLIRContext.");
1018 return impl.registeredTypes.lookup(typeID);
1021 std::optional<std::reference_wrapper<const AbstractType>>
1027 return std::nullopt;
1070 IntegerType::SignednessSemantics signedness,
1072 if (signedness != IntegerType::Signless)
1073 return IntegerType();
1089 return IntegerType();
1094 IntegerType::SignednessSemantics signedness) {
1097 return Base::get(context, width, signedness);
1103 SignednessSemantics signedness) {
1106 return Base::getChecked(
emitError, context, width, signedness);
1125 return getImpl().attributeUniquer;
1129 void AttributeUniquer::initializeAttributeStorage(
AttributeStorage *storage,
1148 detail::DistinctAttributeUniquer::allocateStorage(
MLIRContext *context,
1154 DictionaryAttr DictionaryAttr::getEmpty(
MLIRContext *context) {
1161 auto dialectNamePair = value.split(
'.');
1162 if (dialectNamePair.first.empty() || dialectNamePair.second.empty())
1168 if ((referencedDialect = context->
getLoadedDialect(dialectNamePair.first)))
1172 llvm::sys::SmartScopedLock<true> lock(
impl.dialectRefStrAttrMutex);
1173 impl.dialectReferencingStrAttrs[dialectNamePair.first].push_back(
this);
1186 return getImpl().affineUniquer;
1189 AffineMap AffineMap::getImpl(
unsigned dimCount,
unsigned symbolCount,
1195 symbolCount, results);
1204 LLVM_ATTRIBUTE_UNUSED
static bool
1207 int64_t maxDimPosition = -1;
1208 int64_t maxSymbolPosition = -1;
1211 if ((maxDimPosition >= dimCount) || (maxSymbolPosition >= symbolCount)) {
1213 <<
"maximum dimensional identifier position in result expression must "
1214 "be less than `dimCount` and maximum symbolic identifier position "
1215 "in result expression must be less than `symbolCount`";
1222 return getImpl(0, 0, {}, context);
1227 return getImpl(dimCount, symbolCount, {}, context);
1239 return getImpl(dimCount, symbolCount, results, context);
1251 assert(!constraints.empty());
1252 assert(constraints.size() == eqFlags.size());
1254 auto &
impl = constraints[0].getContext()->getImpl();
static MLIRContext * getContext(OpFoldResult val)
static LLVM_ATTRIBUTE_UNUSED bool willBeValidAffineMap(unsigned dimCount, unsigned symbolCount, ArrayRef< AffineExpr > results)
Check whether the arguments passed to the AffineMap::get() are consistent.
static bool isThreadingGloballyDisabled()
static ArrayRef< T > copyArrayRefInto(llvm::BumpPtrAllocator &allocator, ArrayRef< T > elements)
Copy the specified array of elements into memory managed by the provided bump pointer allocator.
static llvm::ManagedStatic< MLIRContextOptions > clOptions
static IntegerType getCachedIntegerType(unsigned width, IntegerType::SignednessSemantics signedness, MLIRContext *context)
Return an existing integer type instance if one is cached within the context.
This class contains all of the static information common to all instances of a registered Attribute.
static const AbstractAttribute & lookup(TypeID typeID, MLIRContext *context)
Look up the specified abstract attribute in the MLIRContext and return a reference to it.
This class contains all of the static information common to all instances of a registered Type.
static const AbstractType & lookup(TypeID typeID, MLIRContext *context)
Look up the specified abstract type in the MLIRContext and return a reference to it.
Base type for affine expression.
MLIRContext * getContext() const
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
static AffineMap get(MLIRContext *context)
Returns a zero result affine map with no dimensions or symbols: () -> ().
Base storage class appearing in an attribute.
void initializeAbstractAttribute(const AbstractAttribute &abstractAttr)
Set the abstract attribute for this storage instance.
Attributes are known-constant values of operations.
Special case of IntegerAttr to represent boolean integers, i.e., signless i1 integers.
static BoolAttr get(MLIRContext *context, bool value)
This class is the main interface for diagnostics.
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
bool isSubsetOf(const DialectRegistry &rhs) const
Returns true if the current registry is a subset of 'rhs', i.e.
void appendTo(DialectRegistry &destination) const
void applyExtensions(Dialect *dialect) const
Apply any held extensions that require the given dialect.
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
A dialect that can be defined at runtime.
This class represents a diagnostic that is inflight and set to be reported.
An integer set representing a conjunction of one or more affine equalities and inequalities.
static IntegerSet get(unsigned dimCount, unsigned symbolCount, ArrayRef< AffineExpr > constraints, ArrayRef< bool > eqFlags)
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
This is the implementation of the MLIRContext class, using the pImpl idiom.
DictionaryAttr emptyDictionaryAttr
llvm::DenseMap< StringRef, AbstractAttribute * > nameToAttribute
This is a mapping from attribute name to the abstract attribute describing it.
DenseMap< StringRef, std::unique_ptr< Dialect > > loadedDialects
This is a list of dialects that are created referring to this context.
llvm::DenseMap< TypeID, RegisteredOperationName > registeredOperations
A vector of operation info specifically for registered operations.
BoolAttr falseAttr
Cached Attribute Instances.
llvm::sys::SmartRWMutex< true > operationInfoMutex
A mutex used when accessing operation information.
BFloat16Type bf16Ty
Cached Type Instances.
DenseMap< StringRef, SmallVector< StringAttrStorage * > > dialectReferencingStrAttrs
llvm::StringMap< RegisteredOperationName > registeredOperationsByName
StringAttr emptyStringAttr
std::function< void(function_ref< void()>, const tracing::Action &)> actionHandler
An action handler for handling actions that are dispatched through this context.
llvm::sys::SmartMutex< true > dialectRefStrAttrMutex
Map of string attributes that may reference a dialect, that are awaiting that dialect to be loaded.
llvm::DenseMap< StringRef, AbstractType * > nameToType
This is a mapping from type name to the abstract type describing it.
StorageUniquer typeUniquer
llvm::BumpPtrAllocator abstractDialectSymbolAllocator
An allocator used for AbstractAttribute and AbstractType objects.
DenseMap< TypeID, AbstractType * > registeredTypes
StorageUniquer affineUniquer
DiagnosticEngine diagEngine
std::unique_ptr< remark::detail::RemarkEngine > remarkEngine
UnknownLoc unknownLocAttr
DenseMap< TypeID, AbstractAttribute * > registeredAttributes
llvm::StringMap< std::unique_ptr< OperationName::Impl > > operations
This is a mapping from operation name to the operation info describing it.
std::unique_ptr< llvm::ThreadPoolInterface > ownedThreadPool
In case where the thread pool is owned by the context, this ensures destruction with the context.
SmallVector< RegisteredOperationName, 0 > sortedRegisteredOperations
This is a sorted container of registered operations for a deterministic and efficient getRegisteredOp...
DistinctAttributeAllocator distinctAttributeAllocator
A distinct attribute allocator that allocates every time since the address of the distinct attribute ...
MLIRContextImpl(bool threadingIsEnabled)
StorageUniquer attributeUniquer
DialectRegistry dialectsRegistry
MLIRContext is the top-level object for a collection of MLIR operations.
void appendDialectRegistry(const DialectRegistry ®istry)
Append the contents of the given dialect registry to the registry associated with this context.
bool shouldPrintStackTraceOnDiagnostic()
Return true if we should attach the current stacktrace to diagnostics when emitted.
unsigned getNumThreads()
Return the number of threads used by the thread pool in this context.
bool isOperationRegistered(StringRef name)
Return true if this operation name is registered in this context.
MLIRContext(Threading multithreading=Threading::ENABLED)
Create a new Context.
void disableMultithreading(bool disable=true)
Set the flag specifying if multi-threading is disabled by the context.
void printStackTraceOnDiagnostic(bool enable)
Set the flag specifying if we should attach the current stacktrace when emitting diagnostics.
Dialect * getLoadedDialect(StringRef name)
Get a registered IR dialect with the given namespace.
bool hasActionHandler()
Return true if a valid ActionHandler is set.
void setRemarkEngine(std::unique_ptr< remark::detail::RemarkEngine > engine)
Set the remark engine for this context.
void setThreadPool(llvm::ThreadPoolInterface &pool)
Set a new thread pool to be used in this context.
void enableMultithreading(bool enable=true)
remark::detail::RemarkEngine * getRemarkEngine()
Returns the remark engine for this context, or nullptr if none has been set.
std::vector< Dialect * > getLoadedDialects()
Return information about all IR dialects loaded in the context.
ArrayRef< RegisteredOperationName > getRegisteredOperationsByDialect(StringRef dialectName)
Return a sorted array containing the information for registered operations filtered by dialect name.
void printOpOnDiagnostic(bool enable)
Set the flag specifying if we should attach the operation to diagnostics emitted via Operation::emit.
void registerActionHandler(HandlerTy handler)
Register a handler for handling actions that are dispatched through this context.
ArrayRef< RegisteredOperationName > getRegisteredOperations()
Return a sorted array containing the information about all registered operations.
llvm::hash_code getRegistryHash()
Returns a hash of the registry of the context that may be used to give a rough indicator of if the st...
void enterMultiThreadedExecution()
These APIs are tracking whether the context will be used in a multithreading environment: this has no...
const DialectRegistry & getDialectRegistry()
Return the dialect registry associated with this context.
DynamicDialect * getOrLoadDynamicDialect(StringRef dialectNamespace, function_ref< void(DynamicDialect *)> ctor)
Get (or create) a dynamic dialect for the given name.
StorageUniquer & getAttributeUniquer()
Returns the storage uniquer used for constructing attribute storage instances.
StorageUniquer & getAffineUniquer()
Returns the storage uniquer used for creating affine constructs.
StorageUniquer & getTypeUniquer()
Returns the storage uniquer used for constructing type storage instances.
llvm::ThreadPoolInterface & getThreadPool()
Return the thread pool used by this context.
std::vector< StringRef > getAvailableDialects()
Return information about all available dialects in the registry in this context.
bool isMultithreadingEnabled()
Return true if multi-threading is enabled by the context.
void allowUnregisteredDialects(bool allow=true)
Enables creating operations in unregistered dialects.
bool allowsUnregisteredDialects()
Return true if we allow to create operation for unregistered dialects.
T * getLoadedDialect()
Get a registered IR dialect for the given derived dialect type.
DiagnosticEngine & getDiagEngine()
Returns the diagnostic engine for this context.
std::function< void(function_ref< void()>, const tracing::Action &)> HandlerTy
Signatures for the action handler that can be registered with the context.
MLIRContextImpl & getImpl()
T * getOrLoadDialect()
Get (or create) a dialect for the given derived dialect type.
void exitMultiThreadedExecution()
bool shouldPrintOpOnDiagnostic()
Return true if we should attach the operation to diagnostics emitted via Operation::emit.
void loadAllAvailableDialects()
Load all dialects available in the registry in this context.
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
DictionaryAttr getDictionary(MLIRContext *context) const
Return a dictionary attribute for the underlying dictionary.
Attribute set(StringAttr name, Attribute value)
If the an attribute exists with the specified name, change it to the new value.
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
virtual void printGenericOp(Operation *op, bool printOpName=true)=0
Print the entire operation with the default generic assembly form.
Simple wrapper around a void* in order to express generically how to pass in op properties through AP...
Impl(StringRef, Dialect *dialect, TypeID typeID, detail::InterfaceMap interfaceMap)
StringRef getStringRef() const
Return the name of this operation. This always succeeds.
llvm::unique_function< ParseResult(OpAsmParser &, OperationState &)> ParseAssemblyFn
Dialect * getDialect() const
Return the dialect this operation is registered to if the dialect is loaded in the context,...
OperationName(StringRef name, MLIRContext *context)
StringRef getDialectNamespace() const
Return the name of the dialect this operation is registered to.
Operation is the basic unit of execution within MLIR.
MLIRContext * getContext()
Return the context this operation is associated with.
OpaqueProperties getPropertiesStorage()
Returns the properties storage.
This is a "type erased" representation of a registered operation.
static void insert(Dialect &dialect)
Register a new operation in a Dialect object.
static std::optional< RegisteredOperationName > lookup(StringRef name, MLIRContext *ctx)
Lookup the registered operation information for the given operation.
A utility class to get or create instances of "storage classes".
This class provides an efficient unique identifier for a specific C++ type.
An allocator for distinct attribute storage instances.
DistinctAttrStorage * allocate(Attribute referencedAttr)
This class provides an efficient mapping between a given Interface type, and a particular implementat...
An action is a specific action that is to be taken by the compiler, that can be toggled and controlle...
llvm::unique_function< InFlightDiagnostic()> getDefaultDiagnosticEmitFn(MLIRContext *ctx)
Utility method to generate a callback that can be used to generate a diagnostic when checking the con...
Include the generated interface declarations.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
void registerMLIRContextCLOptions()
Register a set of useful command-line options that can be used to configure various flags within the ...
static void getMaxDimAndSymbol(ArrayRef< AffineExprContainer > exprsList, int64_t &maxDim, int64_t &maxSym)
Calculates maximum dimension and symbol positions from the expressions in exprsLists and stores them ...
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
LogicalResult foldHook(Operation *, ArrayRef< Attribute >, SmallVectorImpl< OpFoldResult > &) final
llvm::hash_code hashProperties(OpaqueProperties) final
void populateInherentAttrs(Operation *op, NamedAttrList &attrs) final
void deleteProperties(OpaqueProperties) final
LogicalResult setPropertiesFromAttr(OperationName, OpaqueProperties, Attribute, function_ref< InFlightDiagnostic()> emitError) final
int getOpPropertyByteSize() final
void setInherentAttr(Operation *op, StringAttr name, Attribute value) final
void populateDefaultProperties(OperationName opName, OpaqueProperties properties) final
OperationName::ParseAssemblyFn getParseAssemblyFn() final
bool hasTrait(TypeID) final
LogicalResult verifyRegionInvariants(Operation *) final
std::optional< Attribute > getInherentAttr(Operation *op, StringRef name) final
Implementation for properties.
void getCanonicalizationPatterns(RewritePatternSet &, MLIRContext *) final
void initProperties(OperationName opName, OpaqueProperties storage, OpaqueProperties init) final
void populateDefaultAttrs(const OperationName &, NamedAttrList &) final
void printAssembly(Operation *, OpAsmPrinter &, StringRef) final
LogicalResult verifyInvariants(Operation *) final
void copyProperties(OpaqueProperties, OpaqueProperties) final
LogicalResult verifyInherentAttrs(OperationName opName, NamedAttrList &attributes, function_ref< InFlightDiagnostic()> emitError) final
Attribute getPropertiesAsAttr(Operation *) final
bool compareProperties(OpaqueProperties, OpaqueProperties) final
A binary operation appearing in an affine expression.
An integer constant appearing in affine expression.
A dimensional or symbolic identifier appearing in an affine expression.
An attribute to store a distinct reference to another attribute.
Dialect * referencedDialect
If the string value contains a dialect namespace prefix (e.g.