| Nimpl | |
| CMemRefDataPrinter | |
| CMemRefDataVerifier | Verify the result of two computations are equivalent up to a small numerical error and return the number of errors |
| CStaticSizeMult | |
| CStaticSizeMult< N, Dims... > | |
| CVectorDataPrinter | |
| Nllvm | The OpAsmOpInterface, see OpAsmInterface.td for more details |
| Ncl | |
| COptionValue< PassArgData > | Define a valid OptionValue for the command line pass argument |
| Ndetail | |
| CDenseMapPair | |
| Nilist_detail | |
| CSpecificNodeAccess< compute_node_options<::mlir::Operation >::type > | |
| Nlsp | |
| CMLIRConvertBytecodeParams | This class represents the parameters used when converting between MLIR's bytecode and textual format |
| CMLIRConvertBytecodeResult | This class represents the result of converting between MLIR's bytecode and textual format |
| Nsys | |
| CSmartMutex | |
| Nyaml | |
| CMappingTraits< YamlFileInfo > | |
| CArrayRef | |
| Ccast_convert_val< T, ::mlir::Dialect *, ::mlir::Dialect * > | |
| Ccast_convert_val< T, ::mlir::Dialect, ::mlir::Dialect > | |
| Ccast_retty_impl< T, ::mlir::Dialect * > | |
| Ccast_retty_impl< T, ::mlir::Dialect > | |
| CCastInfo< const ::mlir::Operation *, const ::mlir::Operation * > | |
| CCastInfo< T, ::mlir::Operation * > | Cast from an (const) Operation * to a derived operation type |
| CCastInfo< T, ::mlir::Operation > | Cast from an (const) Operation & to a derived operation type |
| CCastInfo< T, const ::mlir::Operation * > | |
| CCastInfo< T, const ::mlir::Operation > | |
| CCastInfo< To, const mlir::CallInterfaceCallable > | |
| CCastInfo< To, const mlir::IRUnit > | |
| CCastInfo< To, const mlir::LatticeAnchor > | |
| CCastInfo< To, const mlir::LLVM::GEPArg > | |
| CCastInfo< To, const mlir::OpFoldResult > | |
| CCastInfo< To, From, std::enable_if_t< std::is_same_v< mlir::AffineExpr, std::remove_const_t< From > >||std::is_base_of_v< mlir::AffineExpr, From > > > | Add support for llvm style casts |
| CCastInfo< To, From, std::enable_if_t< std::is_same_v< mlir::Attribute, std::remove_const_t< From > >||std::is_base_of_v< mlir::Attribute, From > > > | Add support for llvm style casts |
| CCastInfo< To, From, std::enable_if_t< std::is_same_v< mlir::Location, std::remove_const_t< From > >||std::is_base_of_v< mlir::Location, From > > > | Add support for llvm style casts |
| CCastInfo< To, From, std::enable_if_t< std::is_same_v< mlir::pdll::ast::Type, std::remove_const_t< From > >||std::is_base_of_v< mlir::pdll::ast::Type, From > > > | Add support for llvm style casts |
| CCastInfo< To, From, std::enable_if_t< std::is_same_v< mlir::Type, std::remove_const_t< From > >||std::is_base_of_v< mlir::Type, From > > > | Add support for llvm style casts |
| CCastInfo< To, From, std::enable_if_t< std::is_same_v< mlir::Value, std::remove_const_t< From > >||std::is_base_of_v< mlir::Value, From > > > | Add support for llvm style casts |
| CCastInfo< To, mlir::CallInterfaceCallable > | |
| CCastInfo< To, mlir::IRUnit > | |
| CCastInfo< To, mlir::LatticeAnchor > | |
| CCastInfo< To, mlir::LLVM::GEPArg > | |
| CCastInfo< To, mlir::OpFoldResult > | |
| CCastInfo<::mlir::Operation *, ::mlir::Operation * > | Cast (const) Operation * to itself |
| CDenseMap | |
| CDenseMapInfo | |
| CDenseMapInfo< mlir::AffineExpr > | |
| CDenseMapInfo< mlir::AffineMap > | |
| CDenseMapInfo< mlir::AsmDialectResourceHandle > | |
| CDenseMapInfo< mlir::Attribute > | |
| CDenseMapInfo< mlir::Block::iterator > | |
| CDenseMapInfo< mlir::BlockArgument > | |
| CDenseMapInfo< mlir::detail::TypedValue< T > > | |
| CDenseMapInfo< mlir::IntegerSet > | |
| CDenseMapInfo< mlir::LatticeAnchor > | |
| CDenseMapInfo< mlir::Location > | |
| CDenseMapInfo< mlir::NamedAttribute > | |
| CDenseMapInfo< mlir::OperationName > | |
| CDenseMapInfo< mlir::OpResult > | |
| CDenseMapInfo< mlir::PassInstrumentation::PipelineParentInfo > | |
| CDenseMapInfo< mlir::pdll::ast::Type > | |
| CDenseMapInfo< mlir::ProgramPoint > | Allow hashing of lattice anchors and program points |
| CDenseMapInfo< mlir::RegisteredOperationName > | |
| CDenseMapInfo< mlir::remark::detail::Remark > | |
| CDenseMapInfo< mlir::StringAttr > | |
| CDenseMapInfo< mlir::SuccessorRange > | Provide support for hashing successor ranges |
| CDenseMapInfo< mlir::tblgen::Constraint > | Unique constraints by their predicate and summary |
| CDenseMapInfo< mlir::tblgen::DagLeaf > | |
| CDenseMapInfo< mlir::tblgen::DagNode > | |
| CDenseMapInfo< mlir::Type > | |
| CDenseMapInfo< mlir::TypeID > | |
| CDenseMapInfo< mlir::TypeRange > | |
| CDenseMapInfo< mlir::Value > | |
| CDenseMapInfo< MlirTypeID > | |
| CDenseMapInfo< T, std::enable_if_t< mlir::detail::IsInterface< T >::value > > | |
| CDenseMapInfo< T, std::enable_if_t< std::is_base_of< mlir::Attribute, T >::value &&!mlir::detail::IsInterface< T >::value > > | |
| CDenseMapInfo< T, std::enable_if_t< std::is_base_of< mlir::OpState, T >::value &&!mlir::detail::IsInterface< T >::value > > | |
| CDenseMapInfo< T, std::enable_if_t< std::is_base_of< mlir::Type, T >::value &&!mlir::detail::IsInterface< T >::value > > | |
| CDenseSet | |
| CExpected | |
| Cfunction_ref | |
| CGraphTraits< const mlir::Block * > | |
| CGraphTraits< const mlir::CallGraph * > | |
| CGraphTraits< const mlir::CallGraphNode * > | |
| CGraphTraits< const mlir::DominanceInfoNode * > | |
| CGraphTraits< Inverse< const mlir::Block * > > | |
| CGraphTraits< Inverse< mlir::Block * > > | |
| CGraphTraits< Inverse< mlir::Region * > > | |
| CGraphTraits< mlir::Block * > | |
| CGraphTraits< mlir::DominanceInfoNode * > | DominatorTree GraphTraits specialization so the DominatorTree can be iterated by generic graph iterators |
| CGraphTraits< mlir::Region * > | |
| Cilist_traits<::mlir::Block > | |
| Cilist_traits<::mlir::Operation > | |
| Cisa_impl< mlir::DynamicDialect, mlir::Dialect > | Provide isa functionality for DynamicDialect |
| Cisa_impl< mlir::ExtensibleDialect, mlir::Dialect > | Provide isa functionality for ExtensibleDialect |
| Cisa_impl< T, ::mlir::Dialect, std::enable_if_t< std::is_base_of<::mlir::Dialect, T >::value > > | Provide isa functionality for Dialects |
| Cisa_impl< T, ::mlir::Dialect, std::enable_if_t< std::is_base_of<::mlir::DialectInterface, T >::value > > | |
| Cisa_impl< T, ::mlir::StateStackFrame > | |
| Citerator_range | |
| CMutableArrayRef | |
| CPointerLikeTypeTraits< mlir::async::FuncOp > | Allow stealing the low bits of async::FuncOp |
| CPointerLikeTypeTraits< mlir::Attribute > | Allow LLVM to steal the low bits of Attributes |
| CPointerLikeTypeTraits< mlir::BlockArgument > | |
| CPointerLikeTypeTraits< mlir::detail::TypedValue< T > > | |
| CPointerLikeTypeTraits< mlir::func::FuncOp > | Allow stealing the low bits of FuncOp |
| CPointerLikeTypeTraits< mlir::IntegerAttr > | |
| CPointerLikeTypeTraits< mlir::Location > | We align LocationStorage by 8, so allow LLVM to steal the low bits |
| CPointerLikeTypeTraits< mlir::ModuleOp > | Allow stealing the low bits of ModuleOp |
| CPointerLikeTypeTraits< mlir::OperationName > | |
| CPointerLikeTypeTraits< mlir::OpResult > | |
| CPointerLikeTypeTraits< mlir::RegisteredOperationName > | |
| CPointerLikeTypeTraits< mlir::spirv::FuncOp > | Allow stealing the low bits of spirv::Function ops |
| CPointerLikeTypeTraits< mlir::StringAttr > | |
| CPointerLikeTypeTraits< mlir::SymbolRefAttr > | |
| CPointerLikeTypeTraits< mlir::Type > | We align TypeStorage by 8, so allow LLVM to steal the low bits |
| CPointerLikeTypeTraits< mlir::TypeID > | We align TypeID::Storage by 8, so allow LLVM to steal the low bits |
| CPointerLikeTypeTraits< mlir::Value > | Allow stealing the low bits of a value |
| CPointerUnion | |
| CSetVector | |
| CSmallPtrSet | |
| CSmallPtrSetImpl | |
| CSmallString | |
| CSmallVector | |
| CSmallVectorImpl | |
| CStringSet | |
| CStringSwitch | |
| CTinyPtrVector | |
| CTypeSwitch | |
| CValueIsPresent< mlir::Location > | The constructors in mlir::Location ensure that the class is a non-nullable wrapper around mlir::LocationAttr |
| Nmlir | Include the generated interface declarations |
| Nacc | |
| Ndetail | |
| COpenACCSupportTraits | This class contains internal trait classes used by OpenACCSupport |
| CConcept | |
| CModel | This class wraps a concrete OpenACCSupport implementation and forwards interface calls to it |
| Nimpl | |
| CACCImplicitDataBase | |
| CACCImplicitDeclareBase | |
| CACCImplicitRoutineBase | |
| CACCLegalizeSerialBase | |
| CACCLoopTilingBase | |
| CLegalizeDataValuesInRegionBase | |
| CACCImplicitDataOptions | |
| CACCImplicitRoutineOptions | |
| CACCLoopTilingOptions | |
| CConstructResource | |
| CCurrentDeviceIdResource | |
| CLegalizeDataValuesInRegionOptions | |
| COpenACCSupport | |
| CRuntimeCounters | |
| Naffine | |
| Nimpl | |
| CAffineDataCopyGenerationBase | |
| CAffineExpandIndexOpsAsAffineBase | |
| CAffineExpandIndexOpsBase | |
| CAffineLoopFusionBase | |
| CAffineLoopInvariantCodeMotionBase | |
| CAffineLoopNormalizeBase | |
| CAffineLoopTilingBase | |
| CAffineLoopUnrollAndJamBase | |
| CAffineLoopUnrollBase | |
| CAffineParallelizeBase | |
| CAffinePipelineDataTransferBase | |
| CAffineScalarReplacementBase | |
| CAffineVectorizeBase | |
| CLoopCoalescingBase | |
| CRaiseMemrefDialectBase | |
| CSimplifyAffineMinMaxPassBase | |
| CSimplifyAffineStructuresBase | |
| CAffineBound | AffineBound represents a lower or upper bound in the for operation |
| CAffineBuilder | Helper struct to build simple AffineValueExprs with minimal type inference support |
| CAffineCopyOptions | Explicit copy / DMA generation options for mlir::affineDataCopyGenerate |
| CAffineDataCopyGenerationOptions | |
| CAffineDmaStartOp | AffineDmaStartOp starts a non-blocking DMA operation that transfers data from a source memref to a destination memref |
| CAffineDmaWaitOp | AffineDmaWaitOp blocks until the completion of a DMA operation associated with the tag element 'tag[index]' |
| CAffineLoopFusionOptions | |
| CAffineLoopNormalizeOptions | |
| CAffineLoopTilingOptions | |
| CAffineLoopUnrollAndJamOptions | |
| CAffineLoopUnrollOptions | |
| CAffineParallelizeOptions | |
| CAffineValueExpr | |
| CAffineValueMap | An AffineValueMap is an affine map plus its ML value operands and results for analysis purposes |
| CAffineVectorizeOptions | |
| CComputationSliceState | ComputationSliceState aggregates loop IVs, loop bound AffineMaps and their associated operands for a set of loops within a loop nest (typically the set of loops surrounding a store operation) |
| CDependenceComponent | |
| CDependenceResult | Checks whether two accesses to the same memref access the same element |
| CFlatAffineRelation | A FlatAffineRelation represents a set of ordered pairs (domain -> range) where "domain" and "range" are tuples of variables |
| CFlatAffineValueConstraints | FlatAffineValueConstraints is an extension of FlatLinearValueConstraints with helper functions for Affine dialect ops |
| CFusionResult | |
| CFusionStrategy | Describes the fusion strategy to be used in the Affine loop fusion utilities |
| CLoopNestStateCollector | |
| CLoopNestStats | LoopNestStats aggregates various per-loop statistics (eg |
| CLoopReduction | A description of a (parallelizable) reduction in an affine loop |
| CMemRefAccess | Encapsulates a memref load or store access information |
| CMemRefDependenceGraph | |
| CEdge | |
| CNode | |
| CMemRefRegion | A region of a memref's data space; this is typically constructed by analyzing load/store op's on this memref and the index space of loops surrounding such op's |
| CNestedMatch | An NestedPattern captures nested patterns in the IR |
| CNestedPattern | |
| CNestedPatternContext | RAII structure to transparently manage the bump allocator for NestedPattern and NestedMatch classes |
| CSliceComputationResult | Enumerates different result statuses of slice computation by computeSliceUnion |
| Namdgpu | |
| Nimpl | |
| CAmdgpuEmulateAtomicsPassBase | |
| CAmdgpuFoldMemRefOpsPassBase | |
| CAmdgpuMaskedloadToLoadPassBase | |
| CAmdgpuResolveStridedMetadataPassBase | |
| CAmdgpuEmulateAtomicsPassOptions | |
| CAmdgpuFoldMemRefOpsPass | |
| CChipset | Represents the amdgpu gfx chipset version, e.g., gfx90a, gfx942, gfx1103 |
| CFoldMemRefOpsIntoGatherToLDSOp | |
| Narith | |
| Nimpl | |
| CArithEmulateUnsupportedFloatsBase | |
| CArithEmulateWideIntBase | |
| CArithExpandOpsPassBase | |
| CArithIntRangeNarrowingBase | |
| CArithIntRangeOptsBase | |
| CArithUnsignedWhenEquivalentPassBase | |
| CArithEmulateUnsupportedFloatsOptions | |
| CArithEmulateWideIntOptions | |
| CArithExpandOpsPassOptions | |
| CArithIntRangeNarrowingOptions | |
| CAttrConverterConstrainedFPToLLVM | |
| CAttrConvertFastMathToLLVM | |
| CAttrConvertOverflowToLLVM | |
| CConstantFloatOp | Specialization of arith.constant op that returns a floating point value |
| CConstantIndexOp | Specialization of arith.constant op that returns an integer of index type |
| CConstantIntOp | Specialization of arith.constant op that returns an integer value |
| CNarrowTypeEmulationConverter | Converts narrow integer or float types that are not supported by the target hardware to wider types |
| CWideIntEmulationConverter | Converts integer types that are too wide for the target by splitting them in two halves and thus turning into supported ones, i.e., i2*N --> iN, where N is the widest integer bitwidth supported by the target |
| Narm_sme | |
| Ndetail | An interface for operations that use Arm SME tiles |
| CArmSMETileOpInterfaceInterfaceTraits | |
| CConcept | |
| CExternalModel | |
| CFallbackModel | |
| CModel | |
| CArmSMETileOpInterfaceTrait | |
| Nimpl | |
| CEnableArmStreamingBase | |
| COuterProductFusionBase | |
| CTestTileAllocationBase | |
| CVectorLegalizationBase | |
| CArmSMETileOpInterface | |
| CTrait | |
| CEnableArmStreamingOptions | |
| CTestTileAllocationOptions | |
| Narm_sve | |
| Nimpl | |
| CLegalizeVectorStorageBase | |
| NAttributeTrait | This trait is used to determine if an attribute is a dynamic attribute or not; it should only be implemented by dynamic attributes |
| CIsDynamicAttr | |
| CIsLocation | This trait is used to determine if an attribute is a location or not |
| Nbufferization | |
| Nfunc_ext | |
| CCallOpInterface | |
| CFuncAnalysisState | Extra analysis state that is required for bufferization of function boundaries |
| CFuncOpInterface | |
| CReturnOpInterface | |
| Nimpl | |
| CBufferDeallocationSimplificationPassBase | |
| CBufferHoistingPassBase | |
| CBufferLoopHoistingPassBase | |
| CBufferResultsToOutParamsPassBase | |
| CDropEquivalentBufferResultsPassBase | |
| CEmptyTensorEliminationPassBase | |
| CEmptyTensorToAllocTensorPassBase | |
| CLowerDeallocationsPassBase | |
| COneShotBufferizePassBase | |
| COptimizeAllocationLivenessPassBase | |
| COwnershipBasedBufferDeallocationPassBase | |
| CPromoteBuffersToStackPassBase | |
| CBranchOpBufferizableOpInterfaceExternalModel | A template that provides a default implementation of getAliasingValues for ops that implement the BranchOpInterface |
| CBufferDeallocationPipelineOptions | Options for the buffer deallocation pipeline |
| CBufferizationStatistics | Bufferization statistics for debugging |
| CBufferPlacementAllocs | A simple analysis that detects allocation operations |
| CBufferPlacementTransformationBase | The base class for all BufferPlacement transformations |
| CBufferResultsToOutParamsOpts | |
| CBufferResultsToOutParamsPassOptions | |
| CDeallocationOptions | Options for BufferDeallocationOpInterface-based buffer deallocation |
| CDeallocationState | This class collects all the state that we need to perform the buffer deallocation pass with associated helper functions such that we have easy access to it in the BufferDeallocationOpInterface implementations and the BufferDeallocation pass |
| CDstBufferizableOpInterfaceExternalModel | Bufferizable ops that implement the DestinationStyleOpInterface can use this external model base class |
| COneShotAnalysisState | State for analysis-enabled bufferization |
| CExtension | Base class for OneShotAnalysisState extensions that allow OneShotAnalysisState to contain user-specified information in the state object |
| COneShotBufferizationOptions | Options for analysis-enabled bufferization |
| COneShotBufferizePassOptions | |
| COpWithUnstructuredControlFlowBufferizableOpInterfaceExternalModel | A template that provides a default implementation of getAliasingOpOperands for ops that support unstructured control flow within their regions |
| COwnership | This class is used to track the ownership of values |
| COwnershipBasedBufferDeallocationPassOptions | |
| CPromoteBuffersToStackPassOptions | |
| CValueComparator | Compare two SSA values in a deterministic manner |
| Nbytecode | |
| Ndetail | |
| CAttributeNumbering | |
| CAttrTypeNumbering | This class represents a numbering entry for an Attribute or Type |
| CDialectNumbering | This class represents a numbering entry for an Dialect |
| CDialectResourceNumbering | This class represents a numbering entry for a dialect resource |
| CIRNumberingState | This class manages numbering IR entities in preparation of bytecode emission |
| CNumberingDialectWriter | |
| COperationNumbering | This class represents the numbering entry of an operation |
| COpNameNumbering | This class represents the numbering entry of an operation name |
| CTypeNumbering | |
| Ndataflow | |
| CAbstractDenseBackwardDataFlowAnalysis | Base class for dense backward dataflow analyses |
| CAbstractDenseForwardDataFlowAnalysis | Base class for dense forward data-flow analyses |
| CAbstractDenseLattice | This class represents a dense lattice |
| CAbstractSparseBackwardDataFlowAnalysis | Base class for sparse backward data-flow analyses |
| CAbstractSparseForwardDataFlowAnalysis | Base class for sparse forward data-flow analyses |
| CAbstractSparseLattice | This class represents an abstract lattice |
| CCFGEdge | This lattice anchor represents a control-flow edge between a block and one of its successors |
| CConstantValue | This lattice value represents a known constant value of a lattice |
| CDeadCodeAnalysis | Dead code analysis analyzes control-flow, as understood by RegionBranchOpInterface and BranchOpInterface, and the callgraph, as understood by CallableOpInterface and CallOpInterface |
| CDenseBackwardDataFlowAnalysis | A dense backward dataflow analysis propagating lattices after and before the execution of every operation across the IR by implementing transfer functions for opreations |
| CDenseForwardDataFlowAnalysis | A dense forward data-flow analysis for propagating lattices before and after the execution of every operation across the IR by implementing transfer functions for operations |
| CExecutable | This is a simple analysis state that represents whether the associated lattice anchor (either a block or a control-flow edge) is live |
| CIntegerRangeAnalysis | Integer range analysis determines the integer value range of SSA values using operations that define InferIntRangeInterface and also sets the range of iteration indices of loops with known bounds |
| CIntegerValueRangeLattice | This lattice element represents the integer value range of an SSA value |
| CLattice | This class represents a lattice holding a specific value of type ValueT |
| CLiveness | This lattice represents, for a given value, whether or not it is "live" |
| CLivenessAnalysis | An analysis that, by going backwards along the dataflow graph, annotates each value with a boolean storing true iff it is "live" |
| CPredecessorState | This analysis state represents a set of live control-flow "predecessors" of a program point (either an operation or a block), which are the last operations along all execution paths that pass through this point |
| CRunLivenessAnalysis | Runs liveness analysis on the IR defined by op |
| CSparseBackwardDataFlowAnalysis | A sparse (backward) data-flow analysis for propagating SSA value lattices backwards across the IR by implementing transfer functions for operations |
| CSparseConstantPropagation | This analysis implements sparse constant propagation, which attempts to determine constant-valued results for operations using constant-valued operands, by speculatively folding operations |
| CSparseForwardDataFlowAnalysis | A sparse forward data-flow analysis for propagating SSA value lattices across the IR by implementing transfer functions for operations |
| CStridedMetadataRangeAnalysis | Strided metadata range analysis determines the strided metadata ranges of SSA values using operations that define InferStridedMetadataInterface |
| CStridedMetadataRangeLattice | This lattice element represents the strided metadata of an SSA value |
| Ndetail | AttrTypeReplacer |
| NStorageUserTrait | |
| CIsMutable | This trait is used to determine if a storage user, like Type, is mutable or not |
| CAffineBinaryOpExprStorage | A binary operation appearing in an affine expression |
| CAffineConstantExprStorage | An integer constant appearing in affine expression |
| CAffineDimExprStorage | A dimensional or symbolic identifier appearing in an affine expression |
| CAffineExprStorage | Base storage class appearing in an affine expression |
| CAffineMapStorage | |
| CAliasAnalysisTraits | This class contains various internal trait classes used by the main AliasAnalysis class below |
| CConcept | This class represents the Concept of an alias analysis implementation |
| CModel | This class represents the Model of an alias analysis implementation ImplT |
| CAnalysisConcept | The abstract polymorphic base class representing an analysis |
| CAnalysisMap | This class represents a cache of analyses for a single operation |
| CAnalysisModel | A derived analysis model used to hold a specific analysis object |
| CAnyCapturedValueMatcher | Terminal matcher, always returns true |
| CAnyValueMatcher | Terminal matcher, always returns true |
| CAsmParserImpl | This class provides the implementation of the generic parser methods within AsmParser |
| CAsmStateImpl | |
| Cattr_value_binder | The matcher that matches a certain kind of Attribute and binds the value inside the Attribute |
| CAttributeUniquer | |
| CAttrOpBinder | The matcher that matches operations that have the specified attribute name, and binds the attribute value |
| CAttrOpMatcher | The matcher that matches operations that have the specified attribute name |
| CAttrTypeReplacerBase | This class provides a base utility for replacing attributes/types, and their sub elements |
| CBlockArgumentImpl | The internal implementation of a BlockArgument |
| CCallbackOstream | A simple raw ostream subclass that forwards write_impl calls to the user-supplied callback together with opaque user-supplied data |
| Cconstant_float_predicate_matcher | The matcher that matches a given target constant scalar / vector splat / tensor splat float value that fulfills a predicate |
| Cconstant_float_value_binder | The matcher that matches a constant scalar / vector splat / tensor splat float Attribute or Operation and binds the constant float value |
| Cconstant_int_predicate_matcher | The matcher that matches a given target constant scalar / vector splat / tensor splat integer value that fulfills a predicate |
| Cconstant_int_range_predicate_matcher | A matcher that matches a given a constant scalar / vector splat / tensor splat integer value or a constant integer range that fulfills a predicate |
| Cconstant_int_value_binder | The matcher that matches a constant scalar / vector splat / tensor splat integer Attribute or Operation and binds the constant integer value |
| Cconstant_op_binder | The matcher that matches operations that have the ConstantLike trait, and binds the folded attribute value |
| Cconstant_op_matcher | The matcher that matches operations that have the ConstantLike trait |
| CConversionPatternRewriterImpl | |
| CSingleEraseRewriter | A rewriter that keeps track of erased ops and blocks |
| Ccount_if_t_impl | Template utility that computes the number of elements within T that satisfy the given predicate |
| Ccount_if_t_impl< Pred, N, T, Us... > | |
| CCreateAlgebraicOpForEndomorphismSimplification | |
| CDataLayoutEntryAttrStorage | |
| CDefaultTimingManagerImpl | Implementation details of the DefaultTimingManager |
| CDenseArrayAttrImpl | Base class for DenseArrayAttr that is instantiated and specialized for each supported element type below |
| CDenseElementIndexedIteratorImpl | Impl iterator for indexed DenseElementsAttr iterators that records a data pointer and data index that is adjusted for the case of a splat attribute |
| CDenseElementsAttributeStorage | An attribute representing a reference to a dense vector or tensor object |
| CDenseIntOrFPElementsAttrStorage | An attribute representing a reference to a dense vector or tensor object |
| CKeyTy | |
| CDenseResourceElementsAttrBase | Base class for DenseResourceElementsAttr that is instantiated and specialized for each supported element type below |
| CDenseStringElementsAttrStorage | An attribute representing a reference to a dense vector or tensor object containing strings |
| CKeyTy | |
| CDiagnosticEngineImpl | |
| CDialectInterfaceBase | The base class used for all derived interface types |
| CDialectInterfaceCollectionBase | This class is the base class for a collection of instances for a specific interface kind |
| Citerator | An iterator class that iterates the held interface objects of the given derived interface type |
| CDistinctAttributeAllocator | An allocator for distinct attribute storage instances |
| CDistinctAttributeUniquer | A specialized attribute uniquer for distinct attributes that always allocates since the distinct attribute instances use the address of their storage as unique identifier |
| CDistinctAttrStorage | An attribute to store a distinct reference to another attribute |
| CDominanceInfoBase | |
| CDynamicAttrStorage | Storage of DynamicAttr |
| CDynamicTypeStorage | Storage of DynamicType |
| CElementsAttrIndexer | This class provides support for indexing into the element range of an ElementsAttr |
| CElementsAttrIterator | This class implements a generic iterator for ElementsAttr |
| CElementsAttrRange | This class provides iterator utilities for an ElementsAttr range |
| CExpectedDiag | This class represents an expected output diagnostic |
| CFallbackTypeIDResolver | This class provides a fallback for resolving TypeIDs |
| CFileLineColRangeAttrStorage | |
| CFunctionTypeStorage | Function Type Storage and Uniquing |
| Cinfer_int_range_op_binder | A matcher that matches operations that implement the InferIntRangeInterface interface, and binds the inferred range |
| CInlineOpResult | This class provides the implementation for an operation result whose index can be represented "inline" in the underlying ValueImpl |
| CInlineTypeIDResolver | This class provides utilities for resolving the TypeID of a class that provides a static TypeID resolveTypeID() method |
| CIntegerSetStorage | |
| CIntegerTypeStorage | Integer Type Storage and Uniquing |
| CInterface | This class represents an abstract interface |
| CTrait | This is a special trait that registers a given interface with an object |
| CInterfaceMap | This class provides an efficient mapping between a given Interface type, and a particular implementation of its concept |
| CIROperandBase | This class is the base for IROperand, and provides all of the non-templated facilities for operand use management |
| Cis_complex_t | Type trait detector that checks if a given type T is a complex type |
| Cis_complex_t< std::complex< T > > | |
| Cis_fully_resolved_t | |
| Cis_pair | |
| Cis_pair< std::pair< Ts... > > | |
| Cis_tuple | |
| Cis_tuple< std::tuple< Ts... > > | |
| CNameOpMatcher | The matcher that matches operations that have the specified op name |
| CNestedAnalysisMap | An analysis map that contains a map for the current operation, and a set of maps for any child operations |
| Cop_filter_iterator | A utility iterator that filters out operations that are not 'OpT' |
| Cop_iterator | This class provides iteration over the held operations of a block for a specific operation type |
| Cop_matcher | The matcher that matches a certain kind of op |
| COperandStorage | This class handles the management of operation operands |
| COpOrInterfaceRewritePatternBase | OpOrInterfaceRewritePatternBase is a wrapper around RewritePattern that allows for matching and rewriting against an instance of a derived operation class or Interface |
| COpPassManagerImpl | |
| COpResultImpl | This class provides the implementation for an operation result |
| COpToOpPassAdaptor | An adaptor pass used to run operation passes over nested operations |
| COutOfLineOpResult | This class provides the implementation for an operation result whose index cannot be represented "inline", and thus requires an additional index field |
| CParallelDiagnosticHandlerImpl | |
| CThreadDiagnostic | |
| CParser | This class implement support for parsing global entities like attributes and types |
| CParserState | This class refers to all of the state maintained globally by the parser, such as the current lexer position etc |
| CPassCrashReproducerGenerator | |
| CImpl | |
| CPassExecutionState | The state for a single execution of a pass |
| CPassInstrumentorImpl | |
| CPassOptions | Base container class and manager for all pass options |
| CListOption | This class represents a specific pass option that contains a list of values of the provided data type |
| COption | This class represents a specific pass option, with a provided data type |
| CPassPipelineCLParserImpl | |
| CPatternMatcherValue | Binds to a specific value and matches it |
| CPDLByteCode | |
| CMatchResult | |
| CPDLByteCodeMutableState | |
| CPDLByteCodePattern | |
| CPreservedAnalyses | A utility class to represent the analyses that are known to be preserved |
| CRecoveryReproducerContext | This class contains all of the context for generating a recovery reproducer |
| CRecursivePatternMatcher | RecursivePatternMatcher that composes |
| CSourceMgrDiagnosticHandlerImpl | |
| CSourceMgrDiagnosticVerifierHandlerImpl | |
| CStorageUniquerImpl | This is the implementation of the StorageUniquer class |
| CStorageUserBase | Utility class for implementing users of storage classes uniqued by a StorageUniquer |
| CStorageUserTraitBase | Helper class for implementing traits for storage classes |
| CStringAttrStorage | |
| CSymbolState | This class contains record of any parsed top-level symbols |
| CTileOffsetRangeImpl | Encapsulates the set of parameters that are used to make tile offset calculations in the TileOffsetRangeIterator |
| CTileOffsetRangeIterator | The STL-style iterator implementation for StaticTileOffsetRange |
| CTimingManagerImpl | Private implementation details of the TimingManager |
| CTupleTypeStorage | A type representing a collection of other types |
| CTypedValue | TypedValue is a Value with a statically know type |
| CTypeIDResolver | This class provides a resolver for getting the ID for a given class T |
| CTypeIDResolver< T, std::enable_if_t< InlineTypeIDResolver::has_resolve_typeid< T >::value > > | This class provides a resolver for getting the ID for a given class T, when the class provides a static TypeID resolveTypeID() method |
| CTypeUniquer | A utility class to get, or create, unique instances of types within an MLIRContext |
| CValueImpl | The base class for all derived Value classes |
| CVector1D | |
| CVector1D< T, Dim, false > | |
| CVector1D< T, Dim, true > | |
| Nemitc | |
| Nimpl | |
| CFormExpressionsPassBase | |
| CWrapFuncInClassPassBase | |
| CPlaceholder | |
| Nfunc | |
| Nimpl | |
| CDuplicateFunctionEliminationPassBase | |
| Nfunction_interface_impl | |
| CVariadicFlag | A named class for passing around the variadic flag |
| Ngpu | |
| Nindex_lowering | |
| COpLowering | |
| CAsyncTokenType | |
| CGPUToNVVMPipelineOptions | Options for the gpu to nvvm pipeline |
| CGPUToXeVMPipelineOptions | |
| CKernelDim3 | Utility class for the GPU dialect to represent triples of Values accessible through .x, .y, and .z similarly to CUDA notation |
| CMMAMatrixStorageType | MMAMatrixType storage and uniquing |
| CMMAMatrixType | MMAMatrix represents a matrix held by a subgroup for matrix-matrix multiply accumulate operations |
| COffloadingTranslationAttrTrait | This class indicates that the attribute associated with this trait is a GPU offloading translation attribute |
| CSparseDnTensorHandleType | |
| CSparseSpGEMMOpHandleType | |
| CSparseSpMatHandleType | |
| CTargetOptions | This class serves as an opaque interface for passing options to the TargetAttrInterface methods |
| CWarpDistributionPattern | |
| Nimpl | Attribute collections provide a dictionary-like interface |
| CArithToAMDGPUConversionPassBase | |
| CArithToAPFloatConversionPassBase | |
| CArithToArmSMEConversionPassBase | |
| CArithToLLVMConversionPassBase | |
| CAsyncFuncToAsyncRuntimePassBase | |
| CAsyncParallelForPassBase | |
| CAsyncRuntimePolicyBasedRefCountingPassBase | |
| CAsyncRuntimeRefCountingOptPassBase | |
| CAsyncRuntimeRefCountingPassBase | |
| CAsyncToAsyncRuntimePassBase | |
| CBubbleDownMemorySpaceCastsBase | |
| CCanonicalizerBase | |
| CCompositeFixedPointPassBase | |
| CControlFlowSinkBase | |
| CConvertAffineForToGPUPassBase | |
| CConvertAMDGPUToROCDLPassBase | |
| CConvertArithToEmitCBase | |
| CConvertArithToSPIRVPassBase | |
| CConvertArmNeon2dToIntrPassBase | |
| CConvertArmSMEToLLVMBase | |
| CConvertArmSMEToSCFPassBase | |
| CConvertAsyncToLLVMPassBase | |
| CConvertBufferizationToMemRefPassBase | |
| CConvertComplexToLibmBase | |
| CConvertComplexToLLVMPassBase | |
| CConvertComplexToROCDLLibraryCallsBase | |
| CConvertComplexToSPIRVPassBase | |
| CConvertComplexToStandardPassBase | |
| CConvertControlFlowToLLVMPassBase | |
| CConvertControlFlowToSPIRVPassBase | |
| CConvertElementwiseToLinalgPassBase | |
| CConvertFuncToEmitCBase | |
| CConvertFuncToLLVMPassBase | |
| CConvertFuncToSPIRVPassBase | |
| CConvertGpuOpsToLLVMSPVOpsBase | |
| CConvertGpuOpsToNVVMOpsBase | |
| CConvertGpuOpsToROCDLOpsBase | |
| CConvertGPUToSPIRVBase | |
| CConvertIndexToLLVMPassBase | |
| CConvertIndexToSPIRVPassBase | |
| CConvertLinalgToAffineLoopsPassBase | |
| CConvertLinalgToLoopsPassBase | |
| CConvertLinalgToParallelLoopsPassBase | |
| CConvertLinalgToStandardPassBase | |
| CConvertMathToEmitCBase | |
| CConvertMathToFuncsBase | |
| CConvertMathToLibmPassBase | |
| CConvertMathToLLVMPassBase | |
| CConvertMathToROCDLBase | |
| CConvertMathToSPIRVPassBase | |
| CConvertMathToXeVMBase | |
| CConvertMemRefToEmitCBase | |
| CConvertMemRefToSPIRVPassBase | |
| CConvertNVGPUToNVVMPassBase | |
| CConvertNVVMToLLVMPassBase | |
| CConvertOpenACCToSCFPassBase | |
| CConvertOpenMPToLLVMPassBase | |
| CConvertParallelLoopToGpuPassBase | |
| CConvertPDLToPDLInterpPassBase | |
| CConvertSCFToOpenMPPassBase | |
| CConvertShapeConstraintsPassBase | |
| CConvertShapeToStandardPassBase | |
| CConvertShardToMPIPassBase | |
| CConvertSPIRVToLLVMPassBase | |
| CConvertTensorToLinalgPassBase | |
| CConvertTensorToSPIRVPassBase | |
| CConvertToEmitCBase | |
| CConvertToLLVMPassBase | |
| CConvertVectorToAMXBase | |
| CConvertVectorToArmSMEPassBase | |
| CConvertVectorToGPUBase | |
| CConvertVectorToLLVMPassBase | |
| CConvertVectorToSCFBase | |
| CConvertVectorToSPIRVPassBase | |
| CConvertVectorToXeGPUBase | |
| CConvertXeGPUToXeVMPassBase | |
| CConvertXeVMToLLVMPassBase | |
| CCSEBase | |
| CFinalizeMemRefToLLVMConversionPassBase | |
| CGenerateRuntimeVerificationBase | |
| CGpuAsyncRegionPassBase | |
| CGpuDecomposeMemrefsPassBase | |
| CGpuEliminateBarriersBase | |
| CGpuKernelOutliningPassBase | |
| CGpuLaunchSinkIndexComputationsPassBase | |
| CGpuMapParallelLoopsPassBase | |
| CGpuModuleToBinaryPassBase | |
| CGpuNVVMAttachTargetBase | |
| CGpuROCDLAttachTargetBase | |
| CGpuSPIRVAttachTargetBase | |
| CGpuToLLVMConversionPassBase | |
| CGpuXeVMAttachTargetBase | |
| CInlinerBase | |
| CLiftControlFlowToSCFPassBase | |
| CLinalgBlockPackMatmulBase | |
| CLinalgDetensorizePassBase | |
| CLinalgElementwiseOpFusionPassBase | |
| CLinalgFoldIntoElementwisePassBase | |
| CLinalgFoldUnitExtentDimsPassBase | |
| CLinalgGeneralizeNamedOpsPassBase | |
| CLinalgInlineScalarOperandsPassBase | |
| CLinalgMorphOpsPassBase | |
| CLinalgSpecializeGenericOpsPassBase | |
| CLocationSnapshotBase | |
| CLoopInvariantCodeMotionBase | |
| CLoopInvariantSubsetHoistingBase | |
| CLowerAffinePassBase | |
| CLowerForeachToSCFBase | |
| CLowerHostCodeToLLVMPassBase | |
| CLowerSparseIterationToSCFBase | |
| CLowerSparseOpsToForeachBase | |
| CMapMemRefStorageClassBase | |
| CMem2RegBase | |
| COptReductionPassBase | |
| COutlineShapeComputationPassBase | |
| CPreSparsificationRewriteBase | |
| CPrintOpStatsBase | |
| CReconcileUnrealizedCastsPassBase | |
| CReductionTreePassBase | |
| CRemoveDeadValuesBase | |
| CRemoveShapeConstraintsPassBase | |
| CSCCPBase | |
| CSCFForallToForLoopBase | |
| CSCFForallToParallelLoopBase | |
| CSCFForLoopCanonicalizationBase | |
| CSCFForLoopPeelingBase | |
| CSCFForLoopRangeFoldingBase | |
| CSCFForLoopSpecializationBase | |
| CSCFForToWhileLoopBase | |
| CSCFParallelForToNestedForsBase | |
| CSCFParallelLoopFusionBase | |
| CSCFParallelLoopSpecializationBase | |
| CSCFParallelLoopTilingBase | |
| CSCFToControlFlowPassBase | |
| CSCFToEmitCBase | |
| CSCFToSPIRVBase | |
| CSetLLVMModuleDataLayoutPassBase | |
| CShapeToShapeLoweringPassBase | |
| CSimplifyDepthwiseConvPassBase | |
| CSparseAssemblerBase | |
| CSparseBufferRewriteBase | |
| CSparseGPUCodegenBase | |
| CSparseReinterpretMapBase | |
| CSparseSpaceCollapseBase | |
| CSparseTensorCodegenBase | |
| CSparseTensorConversionPassBase | |
| CSparseVectorizationBase | |
| CSparsificationAndBufferizationBase | |
| CSparsificationPassBase | |
| CSROABase | |
| CStageSparseOperationsBase | |
| CStorageSpecifierToLLVMBase | |
| CStripDebugInfoBase | |
| CSymbolDCEBase | |
| CSymbolPrivatizeBase | |
| CTestSCFParallelLoopCollapsingBase | |
| CTopologicalSortBase | |
| CTosaToArithPassBase | |
| CTosaToLinalgBase | |
| CTosaToLinalgNamedBase | |
| CTosaToMLProgramBase | |
| CTosaToSCFPassBase | |
| CTosaToTensorPassBase | |
| CUBToLLVMConversionPassBase | |
| CUBToSPIRVConversionPassBase | |
| CViewOpGraphBase | |
| Nirdl | |
| Ndetail | |
| CTemplate | Template Code as used by IRDL-to-Cpp |
| CAllOfConstraint | A constraint checking that all of the given constraints are satisfied |
| CAnyAttributeConstraint | A constraint that is always satisfied |
| CAnyOfConstraint | A constraint checking that one of the given constraints is satisfied |
| CBaseAttrConstraint | A constraint that checks that an attribute is of a given attribute base (e.g |
| CBaseTypeConstraint | A constraint that checks that a type is of a given type base (e.g |
| CConstraint | Once turned into IRDL verifiers, all constraints are attribute constraints |
| CConstraintVerifier | Provides context to the verification of constraints |
| CDynParametricAttrConstraint | A constraint that checks that an attribute is of a specific dynamic attribute definition, and that all of its parameters satisfy the given constraints |
| CDynParametricTypeConstraint | A constraint that checks that a type is of a specific dynamic type definition, and that all of its parameters satisfy the given constraints |
| CIsConstraint | A constraint that checks that an attribute is equal to a given attribute |
| CRegionConstraint | A constraint checking that a region satisfies irdl.region requirements |
| Nlinalg | |
| Ndetail | |
| CContinuousTileSizeSpecificationBase | |
| CMultiSizeSpecificationBase | |
| CPackingResult | Helper struct to hold the results of building a packing loop nest |
| CBatchMatmulTransposeAOp | Specialization of linalg.batch_matmul op that has a transpose map on A |
| CBatchMatmulTransposeBOp | Specialization of linalg.batch_matmul op that has a transpose map on B |
| CBlockPackMatmulOptions | |
| CBufferizeToAllocationOptions | |
| CCollapseResult | |
| CContinuousTileSizeSpecification | |
| CContractionDimensions | Positions of a Linalg op loops that correspond to different kinds of a contraction dimension |
| CControlDropUnitDims | Transformation to drop unit-extent dimensions from linalg.generic operations |
| CConvMatcherBuilder | Helper class for building convolution op matchers with minimal boilerplate |
| CConvolutionDimensions | Positions of a Linalg op loops that correspond to different kinds of a convolution dimension |
| CCopyVectorizationPattern | Vectorization pattern for memref::CopyOp |
| CDecomposeOuterUnitDimsPackOpPattern | Rewrites a linalg::PackOp into a sequence of: |
| CDecomposeOuterUnitDimsUnPackOpPattern | Rewrites a linalg::UnPackOp into a sequence of: |
| CDecomposePadOpPattern | Rewrite a tensor::PadOp into a sequence of EmptyOp, FillOp and InsertSliceOp |
| CDownscaleConv2DOp | |
| CDownscaleDepthwiseConv2DNhwcHwcOp | Rewrites 2-D depthwise convolution ops with size-1 (w, kw) or (h, kh) dimensions into 1-D depthwise convolution ops |
| CDownscaleSizeOneWindowed2DConvolution | Rewrites 2-D convolution ops with size-1 window dimensions into 1-D convolution ops |
| CDropUnitDimsResult | |
| CElementwiseOpFusionResult | Fuse two linalg.generic operations that have a producer-consumer relationship captured through fusedOperand |
| CExtractSliceOfPadTensorSwapPattern | Rewrite extract_slice(tensor.pad(x)) into tensor.pad(extract_slice(x)) |
| CFoldTensorCastPackOp | Folds a tensor.cast op into a consuming PackOp op if the tensor.cast has source that is more static than the consuming op |
| CFoldTensorCastUnPackOp | Folds a tensor.cast op into a consuming UnPackOp op if the tensor.cast has source that is more static than the consuming op |
| CForallReductionTilingResult | Transformation information returned after reduction tiling |
| CFusionInfo | A struct containing the Linalg producer before and after fusion |
| CGenerateLoopNest | Utility class used to generate nested loops with ranges described by loopRanges and loop type described by the iteratorTypes |
| CIm2ColToInputDimsExprs | |
| CIm2ColToOperandsExprs | |
| CLinalgCopyVTRForwardingPattern | Match and rewrite for the pattern: |
| CLinalgCopyVTWForwardingPattern | Match and rewrite for the pattern: |
| CLinalgGeneralizationPattern | Linalg generalization pattern |
| CLinalgLoopDistributionOptions | Options that allow distribution of loops generated in Linalg transforms to processors while generating the loops |
| CLinalgOpToLibraryCallRewrite | |
| CLinalgPaddingOptions | |
| CLinalgPromotionOptions | |
| CLinalgSpecializationPattern | |
| CLinalgTilingAndFusionOptions | |
| CLinalgTilingOptions | |
| CLowerPackResult | |
| CLowerUnPackOpResult | |
| CMatmulTransposeAOp | Specialization of linalg.matmul op that has a transpose map on A |
| CMatmulTransposeBOp | Specialization of linalg.matmul op that has a transpose map on B |
| CMultiSizeSpecification | A description of a multi-size tiling comprising tile sizes and numbers of tiles, expressed as Values which may or may not be constant |
| CPackResult | Struct to hold the result of a pack call |
| CPackTransposeResult | Struct to hold the result of a packTranspose call |
| CPadTilingInterfaceOptions | |
| CPadTilingInterfaceResult | Operations and values created in the process of padding a TilingInterface operation |
| CProcInfo | Callback function type used to get processor ID, and number of processors used for distribution for all parallel loops generated |
| CPromotionInfo | Create a new buffer using the allocationFn provided |
| CRegionMatcher | A struct containing common matchers over linalg op's region |
| CSliceParameters | A struct containg offsets-sizes-strides arguments of the tiled shape |
| CSplitReductionOptions | Split Reduction options |
| CSplitReductionResult | Apply transformation to split the single linalg op reduction into a parallel and reduction dimension |
| CStaticContinuousTileSizeSpecification | |
| CStaticMultiSizeSpecification | |
| CTiledLinalgOp | Perform standalone tiling of a single LinalgOp by tileSizes |
| CVectorizationResult | Transformation information returned after vectorizing |
| NLLVM | |
| Ndetail | |
| CDataLayoutImporter | Helper class that translates an LLVM data layout string to an MLIR data layout specification |
| CDebugImporter | |
| CDebugTranslation | |
| CLLVMStructTypeStorage | Type storage for LLVM structure types |
| CKey | Construction/uniquing key class for LLVM dialect structure storage |
| CLLVMTypeAndSizeStorage | Common storage used for LLVM dialect types that need an element type and a number: arrays, fixed and scalable vectors |
| CLoopAnnotationImporter | A helper class that converts llvm.loop metadata nodes into corresponding LoopAnnotationAttrs and llvm.access.group nodes into AccessGroupAttrs |
| CLoopAnnotationTranslation | A helper class that converts LoopAnnotationAttrs and AccessGroupAttrs into corresponding llvm::MDNodes |
| CNDVectorTypeInfo | |
| CTypeFromLLVMIRTranslatorImpl | Support for translating LLVM IR types to MLIR LLVM dialect types |
| CTypeToLLVMIRTranslatorImpl | Support for translating MLIR LLVM dialect types to LLVM IR |
| Nimpl | |
| CDIScopeForLLVMFuncOpPassBase | |
| CLLVMAddComdatsBase | |
| CLLVMLegalizeForExportPassBase | |
| CLLVMRequestCWrappersPassBase | |
| CLLVMTargetToDataLayoutBase | |
| CLLVMTargetToTargetFeaturesBase | |
| CNVVMOptimizeForTargetPassBase | |
| CAssumeAlignTag | |
| CAssumeSeparateStorageTag | |
| CDIExpressionRewriter | Rewriter for DIExpressionAttr |
| CExprRewritePattern | |
| CDILocalScopeAttr | This class represents a LLVM attribute that describes a local debug info scope |
| CDINodeAttr | This class represents the base attribute for all debug info attributes |
| CDIScopeAttr | This class represents a LLVM attribute that describes a debug info scope |
| CDIScopeForLLVMFuncOpPassOptions | |
| CDITypeAttr | This class represents a LLVM attribute that describes a debug info type |
| CDIVariableAttr | This class represents a LLVM attribute that describes a debug info variable |
| CGEPArg | Class used for building a 'llvm.getelementptr' |
| CGEPIndicesAdaptor | Class used for convenient access and iteration over GEP indices |
| Citerator | |
| CLLVMTargetToDataLayoutOptions | |
| CLLVMTargetToTargetFeaturesOptions | |
| CMergeFragments | Adjacent DW_OP_LLVM_fragment should be merged into one |
| CModuleImport | Module import implementation class that provides methods to import globals and functions from an LLVM module into an MLIR module |
| CModuleToObject | Utility base class for transforming operations into binary objects, by default it returns the serialized LLVM bitcode for the module |
| CModuleTranslation | Implementation class for module translation |
| CTBAANodeAttr | Base class for LLVM attributes participating in the TBAA graph |
| CTypeFromLLVMIRTranslator | Utility class to translate LLVM IR types to the MLIR LLVM dialect |
| CTypeToLLVMIRTranslator | Utility class to translate MLIR LLVM dialect types to LLVM IR |
| Nlsp | |
| CCompilationDatabase | This class contains a collection of compilation information for files provided to the language server, such as the available include directories |
| CFileInfo | Compilation information for a specific file within the database |
| CMLIRConvertBytecodeResult | This class represents the result of converting between MLIR's bytecode and textual format |
| CMLIRServer | This class implements all of the MLIR related functionality necessary for a language server |
| CImpl | |
| CPDLLServer | This class implements all of the PDLL related functionality necessary for a language server |
| CImpl | |
| COptions | |
| CPDLLViewOutputParams | Represents the parameters used when viewing the output of a PDLL file |
| CPDLLViewOutputResult | Represents the result of viewing the output of a PDLL file |
| CSourceMgrInclude | This class represents a single include within a root file |
| CTableGenServer | This class implements all of the TableGen related functionality necessary for a language server |
| CImpl | |
| COptions | |
| Nmath | |
| Nimpl | |
| CMathExpandOpsPassBase | |
| CMathExtendToSupportedTypesBase | |
| CMathSincosFusionPassBase | |
| CMathUpliftToFMABase | |
| CErfcPolynomialApproximation | |
| CErfPolynomialApproximation | |
| CMathExpandOpsPassOptions | |
| CMathExtendToSupportedTypesOptions | |
| NMemoryEffects | |
| CAllocate | The following effect indicates that the operation allocates from some resource |
| CEffect | This class represents the base class used for memory effects |
| CFree | The following effect indicates that the operation frees some resource that has been allocated |
| CRead | The following effect indicates that the operation reads from some resource |
| CWrite | The following effect indicates that the operation writes to some resource |
| Nmemref | |
| Nimpl | |
| CExpandOpsPassBase | |
| CExpandReallocPassBase | |
| CExpandStridedMetadataPassBase | |
| CFlattenMemrefsPassBase | |
| CFoldMemRefAliasOpsPassBase | |
| CMemRefEmulateWideIntBase | |
| CNormalizeMemRefsPassBase | |
| CReifyResultShapesPassBase | |
| CResolveRankedShapeTypeResultDimsPassBase | |
| CResolveShapedTypeResultDimsPassBase | |
| CExpandReallocPassOptions | |
| CLinearizedMemRefInfo | For a memref with offset, sizes and strides, returns the offset, size, and potentially the size padded at the front to use for the linearized memref |
| CMemRefEmulateWideIntOptions | |
| CResolveRankedShapeTypeResultDimsPassOptions | |
| CResolveShapedTypeResultDimsPassOptions | |
| NMemRefType | |
| CBuilder | This is a builder type that keeps local references to arguments |
| Nml_program | |
| Nimpl | |
| CMLProgramPipelineGlobalsPassBase | |
| Nnvgpu | |
| Nimpl | |
| COptimizeSharedMemoryBase | |
| CWarpMatrixInfo | Collects information about a warp-level matrix operand represented by a VectorType |
| NNVVM | |
| CNVVMCheckSMVersion | |
| CPtxBuilder | A class to build PTX assembly automatically |
| CSerializeGPUModuleBase | Base class for all NVVM serializations from GPU modules into binary strings |
| Nomp | |
| Nimpl | |
| CPrepareForOMPOffloadPrivatizationPassBase | |
| CDeclareTargetDefaultModel | |
| CDeviceTypeClauseOps | |
| COffloadModuleDefaultModel | |
| NOpTrait | |
| Ndetail | |
| CMultiOperandTraitBase | Utility trait base that provides accessors for derived traits that have multiple operands |
| CMultiRegionTraitBase | Utility trait base that provides accessors for derived traits that have multiple regions |
| CMultiResultTraitBase | Utility trait base that provides accessors for derived traits that have multiple results |
| CMultiSuccessorTraitBase | Utility trait base that provides accessors for derived traits that have multiple successors |
| Nspirv | |
| CSignedOp | |
| CUnsignedOp | |
| CUsableInSpecConstantOp | A trait to mark ops that can be enclosed/wrapped in a SpecConstantOperation op |
| Ntosa | |
| CMulOperandsAndResultElementType | |
| CTosaElementwiseOperator | This class indicates that an op is tosa-elementwise (permits broadcasting, unlike Elementwise trait) |
| CTosaResolvableShapeOperands | This class verifies that tosa shape operands are compile time resolvable |
| CTosaShapeOperator | This class indicates that op operates on tosa shape types |
| CTosaShapeOperatorWithSameRanks | This class indicates that op operates on tosa shape types |
| CAffineScope | A trait of region holding operations that defines a new scope for polyhedral optimization purposes |
| CAlwaysSpeculatableImplTrait | This trait marks an op (which must be tagged as implementing the ConditionallySpeculatable interface) as being always speculatable |
| CAtLeastNOperands | This class provides the API for ops that are known to have a at least a specified number of operands |
| CImpl | |
| CAtLeastNRegions | This class provides APIs for ops that are known to have at least a specified number of regions |
| CImpl | |
| CAtLeastNResults | This class provides the API for ops that are known to have at least a specified number of results |
| CImpl | |
| CAtLeastNSuccessors | This class provides APIs for ops that are known to have at least a specified number of successors |
| CImpl | |
| CAtMostOneChildOf | Characterize operations that have at most a single operation of certain types in their region |
| CImpl | |
| CAttrSizedOperandSegments | A trait for operations that have an attribute specifying operand segments |
| CAttrSizedResultSegments | Similar to AttrSizedOperandSegments but used for results |
| CAutomaticAllocationScope | A trait of region holding operations that define a new scope for automatic allocations, i.e., allocations that are freed when control is transferred back from the operation's region |
| CConstantLike | This class provides the API for a sub-set of ops that are known to be constant-like |
| CDistinctObjectsTrait | This trai indicates that pointer-like objects (such as memrefs) returned from this operation will never alias with each other |
| CElementwise | This trait tags element-wise ops on vectors or tensors |
| CHasOnlyGraphRegion | A trait that specifies that an operation only defines graph regions |
| CHasParallelRegion | |
| CHasParent | This class provides a verifier for ops that are expecting their parent to be one of the given parent ops |
| CImpl | |
| CHasRecursiveMemoryEffects | This trait indicates that the memory effects of an operation includes the effects of operations nested within its regions |
| ChasSingleBlockImplicitTerminator | Support to check if an operation has the SingleBlockImplicitTerminator trait |
| ChasSingleBlockImplicitTerminator< Op, false > | |
| CInferShapedTypeOpAdaptor | |
| CInferTensorType | Tensor type inference trait that constructs a tensor from the inferred shape and elemental types |
| CInferTypeOpAdaptor | |
| CIsCommutative | This class adds property that the operation is commutative |
| CIsIdempotent | This class adds property that the operation is idempotent |
| CIsInvolution | This class adds property that the operation is an involution |
| CIsIsolatedFromAbove | This class provides the API for ops that are known to be isolated from above |
| CIsTerminator | This class provides the API for ops that are known to be terminators |
| CMemRefsNormalizable | |
| CNOperands | This class provides the API for ops that are known to have a specified number of operands |
| CImpl | |
| CNoRegionArguments | This trait provides a verifier for ops that are expecting their regions to not have any arguments |
| CNoTerminator | This class indicates that the regions associated with this op don't have terminators |
| CNRegions | This class provides the API for ops that are known to have a specified number of regions |
| CImpl | |
| CNResults | This class provides the API for ops that are known to have a specified number of results |
| CImpl | |
| CNSuccessors | This class provides the API for ops that are known to have a specified number of successors |
| CImpl | |
| CNVVMRequiresSM | |
| CImpl | |
| CNVVMRequiresSMa | |
| CImpl | |
| COneOperand | This class provides the API for ops that are known to have exactly one SSA operand |
| COneRegion | This class provides APIs for ops that are known to have a single region |
| COneResult | This class provides return value APIs for ops that are known to have a single result |
| COneSuccessor | This class provides APIs for ops that are known to have a single successor |
| COneTypedResult | This trait is used for return value APIs for ops that are known to have a specific type other than Type |
| CImpl | This class provides return value APIs for ops that are known to have a single result |
| COperandsAreFloatLike | This class verifies that all operands of the specified op have a float type, a vector thereof, or a tensor thereof |
| COperandsAreSignlessIntegerLike | This class verifies that all operands of the specified op have a signless integer or index type, a vector thereof, or a tensor thereof |
| COpInvariants | verifyInvariantsImpl verifies the invariants like the types, attrs, .etc |
| CRecursivelySpeculatableImplTrait | This trait marks an op (which must be tagged as implementing the ConditionallySpeculatable interface) as being recursively speculatable |
| CResultsAreBoolLike | This class verifies that any results of the specified op have a boolean type, a vector thereof, or a tensor thereof |
| CResultsAreFloatLike | This class verifies that any results of the specified op have a floating point type, a vector thereof, or a tensor thereof |
| CResultsAreSignlessIntegerLike | This class verifies that any results of the specified op have a signless integer or index type, a vector thereof, or a tensor thereof |
| CResultsBroadcastableShape | Trait for ops that are known to have broadcast compatible operands and result types |
| CReturnLike | This trait indicates that a terminator operation is "return-like" |
| CSameOperandsAndResultElementType | This class provides verification for ops that are known to have the same operand and result element type (or the type itself if it is scalar) |
| CSameOperandsAndResultRank | This class verifies that op has same ranks for all operands and results types, if known |
| CSameOperandsAndResultShape | This class provides verification for ops that are known to have the same operand and result shape: both are scalars, vectors/tensors of the same shape |
| CSameOperandsAndResultType | This class provides verification for ops that are known to have the same operand and result type |
| CSameOperandsElementType | This class provides verification for ops that are known to have the same operand element type (or the type itself if it is scalar) |
| CSameOperandsShape | This class provides verification for ops that are known to have the same operand shape: all operands are scalars, vectors/tensors of the same shape |
| CSameTypeOperands | This class verifies that all operands of the specified op have the same type |
| CScalarizable | This trait tags Elementwise operatons that can be systematically scalarized |
| CSingleBlock | This class provides APIs and verifiers for ops with regions having a single block |
| CSingleBlockImplicitTerminator | This class provides APIs and verifiers for ops with regions having a single block that must terminate with TerminatorOpType |
| CImpl | |
| CSymbolTable | A trait used to provide symbol table functionalities to a region operation |
| CTensorizable | This trait tags Elementwise operatons that can be systematically tensorized |
| CTraitBase | Helper class for implementing traits |
| CVariadicOperands | This class provides the API for ops which have an unknown number of SSA operands |
| CVariadicRegions | This class provides the API for ops which have an unknown number of regions |
| CVariadicResults | This class provides the API for ops which have an unknown number of results |
| CVariadicSuccessors | This class provides the API for ops which have an unknown number of successors |
| CVectorizable | This trait tags Elementwise operatons that can be systematically vectorized |
| CZeroOperands | This class provides the API for ops that are known to have no SSA operand |
| CZeroRegions | This class provides verification for ops that are known to have zero regions |
| CZeroResults | This class provides return value APIs for ops that are known to have zero results |
| CZeroSuccessors | This class provides verification for ops that are known to have zero successors |
| Npdl | |
| CPDLType | This class represents the base class of all PDL types |
| Npdl_to_pdl_interp | |
| CAttributeAnswer | An Answer representing an Attribute value |
| CAttributeLiteralPosition | A position describing a literal attribute |
| CAttributePosition | A position describing an attribute of an operation |
| CAttributeQuestion | Compare an Attribute to a constant value |
| CBoolNode | A BoolNode denotes a question with a boolean-like result |
| CConstraintPosition | A position describing the result of a native constraint |
| CConstraintQuestion | Apply a parameterized constraint to multiple position values and possibly produce results |
| CEqualToQuestion | Compare the equality of two values |
| CExitNode | An ExitNode is a special sentinel node that denotes the end of matcher |
| CFalseAnswer | An Answer representing a boolean 'false' value |
| CForEachPosition | A position describing an iterative choice of an operation |
| CIsNotNullQuestion | Compare a positional value with null, i.e. check if it exists |
| CMatcherNode | This class represents the base of a predicate matcher node |
| COperandCountAtLeastQuestion | |
| COperandCountQuestion | Compare the number of operands of an operation with a known value |
| COperandGroupPosition | A position describing an operand group of an operation |
| COperandPosition | A position describing an operand of an operation |
| COperationNameAnswer | An Answer representing an OperationName value |
| COperationNameQuestion | Compare the name of an operation with a known value |
| COperationPosition | An operation position describes an operation node in the IR |
| COptimalBranching | The optimal branching algorithm solver |
| CPosition | A position describes a value on the input IR on which a predicate may be applied, such as an operation or attribute |
| CPositionalPredicate | A PositionalPredicate is a predicate that is associated with a specific positional value |
| CPredicateBase | Base class for all predicates, used to allow efficient pointer comparison |
| CPredicateBuilder | This class provides utilities for constructing predicates |
| CPredicateUniquer | This class provides a storage uniquer that is used to allocate predicate instances |
| CQualifier | An ordinal predicate consists of a "Question" and a set of acceptable "Answers" (later converted to ordinal values) |
| CResultCountAtLeastQuestion | |
| CResultCountQuestion | Compare the number of results of an operation with a known value |
| CResultGroupPosition | A position describing a result group of an operation |
| CResultPosition | A position describing a result of an operation |
| CRootOrderingEntry | The information associated with an edge in the cost graph |
| CSuccessNode | A SuccessNode denotes that a given high level pattern has successfully been matched |
| CSwitchNode | A SwitchNode denotes a question with multiple potential results |
| CTrueAnswer | An Answer representing a boolean true value |
| CTypeAnswer | An Answer representing a Type value |
| CTypeLiteralPosition | A position describing a literal type or type range |
| CTypePosition | A position describing the result type of an entity, i.e |
| CTypeQuestion | Compare the type of an attribute or value with a known type |
| CUnsignedAnswer | An Answer representing an unsigned value |
| CUsersPosition | A position describing the users of a value or a range of values |
| Npdll | |
| Nast | |
| Ndetail | |
| CAttributeTypeStorage | |
| CConstraintTypeStorage | |
| COperationTypeStorage | |
| CRangeTypeStorage | |
| CRewriteTypeStorage | |
| CTupleTypeStorage | |
| CTypeStorageBase | A utility CRTP base class that defines many of the necessary utilities for defining a PDLL AST Type |
| CTypeTypeStorage | |
| CValueTypeStorage | |
| CAllResultsMemberAccessExpr | This class represents an instance of MemberAccessExpr that references all results of an operation |
| CAttrConstraintDecl | The class represents an Attribute constraint, and constrains a variable to be an Attribute |
| CAttributeExpr | This expression represents a literal MLIR Attribute, and contains the textual assembly format of that attribute |
| CAttributeType | This class represents a PDLL type that corresponds to an mlir::Attribute |
| CCallableDecl | This decl represents a shared interface for all callable decls |
| CCallExpr | This expression represents a call to a decl, such as a UserConstraintDecl/UserRewriteDecl |
| CCompoundStmt | This statement represents a compound statement, which contains a collection of other statements |
| CConstraintDecl | This class represents the base of all AST Constraint decls |
| CConstraintRef | This class represents a reference to a constraint, and contains a constraint and the location of the reference |
| CConstraintType | This class represents a PDLL type that corresponds to a constraint |
| CContext | This class represents the main context of the PDLL AST |
| CCoreConstraintDecl | This class represents the base of all "core" constraints |
| CDecl | This class represents the base Decl node |
| CDeclRefExpr | This expression represents a reference to a Decl node |
| CDeclScope | This class represents a scope for named AST decls |
| CDiagnostic | This class provides a simple implementation of a PDLL diagnostic |
| CDiagnosticEngine | This class manages the construction and emission of PDLL diagnostics |
| CEraseStmt | This statement represents the erase statement in PDLL |
| CExpr | This class represents a base AST Expression node |
| CInFlightDiagnostic | This class represents a diagnostic that is inflight and set to be reported |
| CLetStmt | This statement represents a let statement in PDLL |
| CMemberAccessExpr | This expression represents a named member or field access of a given parent expression |
| CModule | This class represents a top-level AST module |
| CName | This class provides a convenient API for interacting with source names |
| CNamedAttributeDecl | This Decl represents a NamedAttribute, and contains a string name and attribute value |
| CNode | This class represents a base AST node |
| CNodeBase | This CRTP class provides several utilies when defining new AST nodes |
| COpConstraintDecl | The class represents an Operation constraint, and constrains a variable to be an Operation |
| COperationExpr | This expression represents the structural form of an MLIR Operation |
| COperationType | This class represents a PDLL type that corresponds to an mlir::Operation |
| COpNameDecl | This Decl represents an OperationName |
| COpRewriteStmt | This class represents a base operation rewrite statement |
| CPatternDecl | This Decl represents a single Pattern |
| CRangeExpr | This expression builds a range from a set of element values (which may be ranges themselves) |
| CRangeType | This class represents a PDLL type that corresponds to a range of elements with a given element type |
| CReplaceStmt | This statement represents the replace statement in PDLL |
| CReturnStmt | This statement represents a return from a "callable" like decl, e.g |
| CRewriteStmt | This statement represents an operation rewrite that contains a block of nested rewrite commands |
| CRewriteType | This class represents a PDLL type that corresponds to a rewrite reference |
| CStmt | This class represents a base AST Statement node |
| CTupleExpr | This expression builds a tuple from a set of element values |
| CTupleType | This class represents a PDLL tuple type, i.e |
| CType | |
| CStorage | |
| CTypeBase | This class provides several utilities when defining derived type classes |
| CTypeConstraintDecl | The class represents a Type constraint, and constrains a variable to be a Type |
| CTypeExpr | This expression represents a literal MLIR Type, and contains the textual assembly format of that type |
| CTypeRangeConstraintDecl | The class represents a TypeRange constraint, and constrains a variable to be a TypeRange |
| CTypeRangeType | This class represents a PDLL type that corresponds to an mlir::TypeRange |
| CTypeType | This class represents a PDLL type that corresponds to an mlir::Type |
| CUserConstraintDecl | This decl represents a user defined constraint |
| CUserRewriteDecl | This decl represents a user defined rewrite |
| CValueConstraintDecl | The class represents a Value constraint, and constrains a variable to be a Value |
| CValueRangeConstraintDecl | The class represents a ValueRange constraint, and constrains a variable to be a ValueRange |
| CValueRangeType | This class represents a PDLL type that corresponds to an mlir::ValueRange |
| CValueType | This class represents a PDLL type that corresponds to an mlir::Value |
| CVariableDecl | This Decl represents the definition of a PDLL variable |
| Nods | |
| CAttribute | This class provides an ODS representation of a specific operation attribute |
| CAttributeConstraint | This class represents a generic ODS Attribute constraint |
| CConstraint | This class represents a generic ODS constraint |
| CContext | This class contains all of the registered ODS operation classes |
| CDialect | This class represents an ODS dialect, and contains information on the constructs held within the dialect |
| COperandOrResult | This class provides an ODS representation of a specific operation operand or result |
| COperation | This class provides an ODS representation of a specific operation |
| CTypeConstraint | This class represents a generic ODS Type constraint |
| CCodeCompleteContext | This class provides an abstract interface into the parser for hooking in code completion events |
| CLexer | |
| CToken | |
| Npresburger | |
| Ndetail | |
| CGeneratingFunction | |
| CArrayRef | |
| CDivisionRepr | Class storing division representation of local variables of a constraint system |
| CFracMatrix | |
| CFraction | A class to represent fractions |
| CGBRSimplex | Given a simplex for a polytope, construct a new simplex whose variables are identified with a pair of points (x, y) in the original polytope |
| CIdentifier | An Identifier stores a pointer to an object, such as a Value or an Operation |
| CIntegerPolyhedron | An IntegerPolyhedron represents the set of points from a PresburgerSpace that satisfy a list of affine constraints |
| CIntegerRelation | An IntegerRelation represents the set of points from a PresburgerSpace that satisfy a list of affine constraints |
| CCountsSnapshot | The struct CountsSnapshot stores the count of each VarKind, and also of each constraint type |
| CIntMatrix | |
| CLexSimplex | A class for lexicographic optimization without any symbols |
| CLexSimplexBase | Simplex class using the lexicographic pivot rule |
| CLinearTransform | |
| CMatrix | This is a class to represent a resizable matrix |
| CMaybeLocalRepr | MaybeLocalRepr contains the indices of the constraints that can be expressed as a floordiv of an affine function |
| CMaybeOptimum | |
| CMultiAffineFunction | This class represents a multi-affine function with the domain as Z^d, where d is the number of domain variables of the function |
| CMutableArrayRef | |
| CPresburgerRelation | A PresburgerRelation represents a union of IntegerRelations that live in the same PresburgerSpace with support for union, intersection, subtraction, and complement operations, as well as sampling |
| CPresburgerSet | |
| CPresburgerSpace | PresburgerSpace is the space of all possible values of a tuple of integer valued variables/variables |
| CPrintTableMetrics | Example usage: Print .12, 3.4, 56.7 preAlign = ".", minSpacing = 1, .12 .12 3.4 3.4 56.7 56.7 |
| CPWMAFunction | This class represents a piece-wise MultiAffineFunction |
| CPiece | |
| CQuasiPolynomial | |
| Craw_ostream | |
| CSetCoalescer | All functionality concerning the coalesce heuristic |
| CSimplex | Uses the Normal pivot rule and supports integer emptiness checks as well as detecting redundancies |
| CSimplexBase | The Simplex class implements a version of the Simplex and Generalized Basis Reduction algorithms, which can perform analysis of integer sets with affine inequalities and equalities |
| CPivot | |
| CUnknown | An Unknown is either a variable or a constraint |
| CSimplexRollbackScopeExit | Takes a snapshot of the simplex state on construction and rolls back to the snapshot on destruction |
| CSmallVector | |
| CSmallVectorImpl | |
| CSymbolicLexOpt | Represents the result of a symbolic lexicographic optimization computation |
| CSymbolicLexSimplex | A class to perform symbolic lexicographic optimization, i.e., to find, for every assignment to the symbols the specified symbolDomain, the lexicographically minimum value integer value attained by the non-symbol variables |
| Npython | |
| Nadaptors | |
| Cmlir_attribute_subclass | Creates a custom subclass of mlir.ir.Attribute, implementing a casting constructor and type checking methods |
| Cmlir_type_subclass | Creates a custom subclass of mlir.ir.Type, implementing a casting constructor and type checking methods |
| Cmlir_value_subclass | Creates a custom subclass of mlir.ir.Value, implementing a casting constructor and type checking methods |
| Cpure_subclass | Provides a facility like py::class_ for defining a new class in a scope, but this allows extension of an arbitrary Python class, defining methods on it is a similar way |
| Nnanobind_adaptors | |
| Cmlir_attribute_subclass | Creates a custom subclass of mlir.ir.Attribute, implementing a casting constructor and type checking methods |
| Cmlir_type_subclass | Creates a custom subclass of mlir.ir.Type, implementing a casting constructor and type checking methods |
| Cmlir_value_subclass | Creates a custom subclass of mlir.ir.Value, implementing a casting constructor and type checking methods |
| Cpure_subclass | Provides a facility like nanobind::class_ for defining a new class in a scope, but this allows extension of an arbitrary Python class, defining methods on it is a similar way |
| CBaseContextObject | Base class for all objects that directly or indirectly depend on an MlirContext |
| CCollectDiagnosticsToStringScope | RAII scope intercepting all diagnostics into a string |
| CDefaulting | CRTP template for special wrapper types that are allowed to be passed in as 'None' function arguments and can be resolved by some global mechanic if so |
| CDefaultingPyLocation | Used in function arguments when None should resolve to the current context manager set instance |
| CDefaultingPyMlirContext | Used in function arguments when None should resolve to the current context manager set instance |
| CMLIRError | Custom exception that allows access to error diagnostic information |
| CPyAffineExpr | Wrapper around MlirAffineExpr. Affine expressions are owned by the context |
| CPyAffineMap | |
| CPyAsmState | Wrapper around an MlirAsmState |
| CPyAttribute | Wrapper around the generic MlirAttribute |
| CPyBlock | Wrapper around an MlirBlock |
| CPyConcreteAttribute | CRTP base classes for Python attributes that subclass Attribute and should be castable from it (i.e |
| CPyConcreteOpInterface | CRTP base class for Python classes representing MLIR Op interfaces |
| CPyConcreteType | CRTP base classes for Python types that subclass Type and should be castable from it (i.e |
| CPyDiagnostic | Python class mirroring the C MlirDiagnostic struct |
| CDiagnosticInfo | Materialized diagnostic information |
| CPyDiagnosticHandler | Represents a diagnostic handler attached to the context |
| CPyDialect | User-level dialect object |
| CPyDialectDescriptor | Wrapper around an MlirDialect |
| CPyDialectRegistry | Wrapper around an MlirDialectRegistry |
| CPyDialects | User-level object for accessing dialects with dotted syntax such as: ctx.dialect.std |
| CPyGlobals | Globals that are always accessible once the extension has been initialized |
| CTracebackLoc | |
| CTypeIDAllocator | |
| CPyInferShapedTypeOpInterface | Python wrapper for InferShapedTypeOpInterface |
| CAppendResultsCallbackData | C-style user-data structure for type appending callback |
| CPyInferTypeOpInterface | Python wrapper for InferTypeOpInterface |
| CAppendResultsCallbackData | C-style user-data structure for type appending callback |
| CPyInsertionPoint | An insertion point maintains a pointer to a Block and a reference operation |
| CPyIntegerSet | |
| CPyLocation | Wrapper around an MlirLocation |
| CPyMlirContext | |
| CErrorCapture | RAII object that captures any error diagnostics emitted to the provided context |
| CPyModule | |
| CPyNamedAttribute | Represents a Python MlirNamedAttr, carrying an optional owned name |
| CPyObjectRef | Template for a reference to a concrete type which captures a python reference to its underlying python object |
| CPyOperation | |
| CPyOperationBase | Base class for PyOperation and PyOpView which exposes the primary, user visible methods for manipulating it |
| CPyOpView | A PyOpView is equivalent to the C++ "Op" wrappers: these are the basis for providing more instance-specific accessors and serve as the base class for custom ODS-style operation classes |
| CPyRegion | Wrapper around an MlirRegion |
| CPyShapedTypeComponents | Wrapper around an shaped type components |
| CPyStringAttribute | |
| CPySymbolTable | Bindings for MLIR symbol tables |
| CPyThreadContextEntry | Tracks an entry in the thread context stack |
| CPyThreadPool | Wrapper around MlirLlvmThreadPool Python object owns the C++ thread pool |
| CPyType | Wrapper around the generic MlirType |
| CPyTypeID | A TypeID provides an efficient and unique identifier for a specific C++ type |
| CPyValue | Wrapper around the generic MlirValue |
| Nquant | |
| Ndetail | |
| CAnyQuantizedTypeStorage | |
| CKeyTy | |
| CCalibratedQuantizedTypeStorage | |
| CKeyTy | |
| CQuantizedTypeStorage | |
| CUniformQuantizedPerAxisTypeStorage | |
| CKeyTy | |
| CUniformQuantizedSubChannelTypeStorage | |
| CKeyTy | |
| CUniformQuantizedTypeStorage | |
| CKeyTy | |
| Nimpl | |
| CLowerQuantOpsBase | |
| CNormalizeQuantTypesBase | |
| CStripFuncQuantTypesBase | |
| CAnyQuantizedType | A quantized type that maps storage to/from expressed types in an unspecified way |
| CCalibratedQuantizedType | A quantized type that infers its range from given min/max values |
| CExpressedToQuantizedConverter | Performs type conversion from an arbitrary input type to a type that is expressed by a QuantizedType |
| CQuantizedType | Base class for all quantized types known to this dialect |
| CUniformQuantizedPerAxisType | Represents per-axis (also known as per-channel quantization) |
| CUniformQuantizedPerAxisValueConverter | An utility class to quantize an attribute by the per-axis quantization parameters |
| CUniformQuantizedSubChannelType | Represents sub-channel (also known as blockwise quantization) |
| CUniformQuantizedType | Represents a family of uniform, quantized types |
| CUniformQuantizedValueConverter | Reference implementation of converting between real numbers and values represented by a UniformQuantizedType |
| Nquery | |
| Nmatcher | Computes the backward-slice of all transitive defs reachable from rootOp, if innerMatcher matches |
| Ninternal | |
| CArgTypeTraits | |
| CArgTypeTraits< bool > | |
| CArgTypeTraits< const T & > | |
| CArgTypeTraits< DynMatcher > | |
| CArgTypeTraits< int64_t > | |
| CArgTypeTraits< llvm::StringRef > | |
| CDiagnostics | |
| CArgStream | |
| CFixedArgCountMatcherDescriptor | |
| CMatcherDescriptor | |
| CParser | |
| CCodeTokenizer | |
| CRegistrySema | |
| CScopedContextEntry | |
| CSema | |
| CTokenInfo | |
| CSourceLocation | |
| CSourceRange | |
| CVariadicOperatorMatcherDescriptor | |
| CBackwardSliceMatcher | |
| CDynMatcher | |
| Chas_bound_match | |
| Chas_bound_match< T, std::void_t< decltype(std::declval< T >().match(std::declval< Operation * >(), std::declval< SetVector< Operation * > & >()))> > | |
| Chas_simple_match | |
| Chas_simple_match< T, std::void_t< decltype(std::declval< T >().match(std::declval< Operation * >()))> > | |
| CMatcherCompletion | |
| CMatcherFnImpl | |
| CMatcherInterface | |
| CMatchFinder | Finds and collects matches from the IR |
| CMatchResult | A subclass which preserves the matching information |
| CParserValue | |
| CPredicateBackwardSliceMatcher | Computes the backward-slice of all transitive defs reachable from rootOp, if innerMatcher matches |
| CPredicateForwardSliceMatcher | Computes the forward-slice of all users reachable from rootOp, if innerMatcher matches |
| CRegistry | |
| CRegistryManager | |
| CVariadicMatcher | |
| CVariadicOperatorMatcher | |
| CVariadicOperatorMatcherFunc | |
| CVariantMatcher | |
| CSinglePayload | |
| CVariadicOpPayload | |
| CVariantValue | |
| CHelpQuery | |
| CInvalidQuery | |
| CMatchQuery | |
| CNoOpQuery | |
| CQuery | |
| CQueryParser | |
| CLexOrCompleteWord | |
| CQuerySession | |
| CQuitQuery | |
| NRankedTensorType | |
| CBuilder | This is a builder type that keeps local references to arguments |
| Nremark | |
| Ndetail | |
| CInFlightRemark | InFlightRemark is a RAII class that holds a reference to a Remark instance and allows to build the remark using the << operator |
| CLazyTextBuild | Lazy text building for zero cost string formatting |
| CLLVMRemarkStreamer | Concrete streamer that writes LLVM optimization remarks to a file (YAML or Bitstream) |
| CMLIRRemarkStreamerBase | Base class for MLIR remark streamers that is used to stream optimization remarks to the underlying remark streamer |
| COptRemarkBase | |
| CRemark | |
| CArg | |
| CRemarkEmittingPolicyBase | Base class for MLIR remark emitting policies that is used to emit optimization remarks to the underlying remark streamer |
| CRemarkEngine | |
| CRemarkCategories | Define an the set of categories to accept |
| CRemarkEmittingPolicyAll | Policy that emits all remarks |
| CRemarkEmittingPolicyFinal | Policy that emits final remarks |
| CRemarkOpts | Options to create a Remark |
| NROCDL | |
| CSerializeGPUModuleBase | Base class for all ROCDL serializations from GPU modules into binary strings |
| Nruntime | |
| CAsyncGroup | |
| CAsyncToken | |
| CAsyncValue | |
| Nscf | |
| CForLoopPipeliningPattern | |
| CLoopNest | |
| CPipeliningOption | Options to dictate how loops should be pipelined |
| Nshape | |
| CShapeMappingAnalysis | ShapeMappingAnalysis is used together with OutlineShapeComputationPass to preserve Value and corresponding shape function / arguments mapping information |
| CShapeMappingValue | ShapeMappingValue works as the value of ShapeMappingAnalysis table, where funcSymbol is the symbol of mapping function, and inputs are the actual parameters for the function |
| Nshard | |
| Nimpl | |
| CPartitionBase | |
| CShardingPropagationBase | |
| CElementwiseShardingInterface | |
| CIndependentParallelIteratorDomainShardingInterface | |
| COpRewritePatternWithSymbolTableCollection | |
| CSharding | |
| CShardingOption | |
| CShardingPropagationOptions | |
| NSideEffects | |
| CAutomaticAllocationScopeResource | An automatic allocation-scope resource that is valid in the context of a parent AutomaticAllocationScope trait |
| CDefaultResource | A conservative default resource kind |
| CEffect | This class represents a base class for a specific effect type |
| CBase | This base class is used for derived effects that are non-parametric |
| CEffectInstance | This class represents a specific instance of an effect |
| CResource | This class represents a specific resource that an effect applies to |
| CBase | This base class is used for derived effects that are non-parametric |
| Nsmt | |
| CSMTEmissionOptions | Emission options for the ExportSMTLIB pass |
| CSMTOpVisitor | This helps visit SMT nodes |
| CSMTTypeVisitor | This helps visit SMT types |
| Nsparse_tensor | |
| Ndetail | |
| Cis_complex | |
| Cis_complex< std::complex< T > > | |
| Nir_detail | |
| CDimExpr | |
| CDimLvlExpr | |
| CDimLvlMap | |
| CDimLvlMapParser | Parses the Sparse Tensor Encoding Attribute (STEA) |
| CDimSpec | The full dimVar = dimExpr : dimSlice specification for a given dimension |
| CDimVar | |
| CLvlExpr | |
| CLvlSpec | The full lvlVar = lvlExpr : lvlType specification for a given level |
| CLvlTypeParser | |
| CLvlVar | |
| CRanks | |
| CSymVar | |
| CVar | A concrete variable, to be used in our variant of AffineExpr |
| CImpl | The underlying implementation of Var |
| CVarEnv | |
| CVarInfo | A record of metadata for/about a variable, used by VarEnv |
| CVarSet | Efficient representation of a set of Var |
| CCodegenEnv | The code generation environment class aggregates a number of data structures that are needed during the code generation phase of sparsification |
| CCOOSegment | A simple structure that encodes a range of levels in the sparse tensors that forms a COO segment |
| CElement | An element of a sparse tensor in coordinate-scheme representation (i.e., a pair of coordinates and value) |
| CElementLT | Closure object for operator< on Element with a given rank |
| CFuncCallOrInlineGenerator | A helper class to simplify lowering operations with/without function calls |
| CI64BitSet | A simple wrapper to encode a bitset of (at most 64) levels, currently used by sparse_tensor.iterate operation for the set of levels on which the coordinates should be loaded |
| CIterationGraphSorter | |
| CLatPoint | Lattice point |
| CLevelType | This enum defines all the sparse representations supportable by the SparseTensor dialect |
| CLoopEmitter | |
| CMapRef | A class for capturing the sparse tensor type map with a compact encoding |
| CMerger | A class to handle all iteration lattice operations |
| CMutSparseTensorDescriptor | Using SmallVector for mutable descriptor allows users to reuse it as a tmp buffers to append value for some special cases, though users should be responsible to restore the buffer to legal states after their use |
| CSparseIterationSpace | A SparseIterationSpace represents a sparse set of coordinates defined by (possibly multiple) levels of a specific sparse tensor |
| CSparseIterator | Helper class that generates loop conditions, etc, to traverse a sparse tensor level |
| CSparseTensorCOO | A memory-resident sparse tensor in coordinate-scheme representation (a collection of Elements) |
| CSparseTensorDescriptor | Uses ValueRange for immutable descriptors |
| CSparseTensorDescriptorImpl | A helper class around an array of values that corresponds to a sparse tensor |
| CSparseTensorLevel | The base class for all types of sparse tensor levels |
| CSparseTensorReader | This class abstracts over the information stored in file headers, as well as providing the buffers and methods for parsing those headers |
| CSparseTensorSpecifier | |
| CSparseTensorStorage | A memory-resident sparse tensor using a storage scheme based on per-level sparse/dense annotations |
| CSparseTensorStorageBase | Abstract base class for SparseTensorStorage<P,C,V> |
| CSparseTensorType | A wrapper around RankedTensorType, which has three goals: |
| CSparsificationAndBufferizationPass | A pass that lowers tensor ops to memref ops, regardless of whether they are dense or sparse |
| CSparsifierOptions | Options for the "sparsifier" pipeline |
| CStorageLayout | Provides methods to access fields of a sparse tensor with the given encoding |
| CTensorExp | Tensor expression. Represents an MLIR expression in tensor index notation |
| CChildren | Child subexpressions for non-leaf expressions |
| Nspirv | |
| Ndetail | |
| CArrayTypeStorage | |
| CCooperativeMatrixTypeStorage | |
| CImageTypeStorage | |
| CInterfaceVarABIAttributeStorage | |
| CMatrixTypeStorage | |
| CPointerTypeStorage | |
| CRuntimeArrayTypeStorage | |
| CSampledImageTypeStorage | |
| CStructTypeStorage | Type storage for SPIR-V structure types: |
| CTargetEnvAttributeStorage | |
| CTensorArmTypeStorage | |
| CVerCapExtAttributeStorage | |
| Nimpl | |
| CSPIRVCanonicalizeGLPassBase | |
| CSPIRVCompositeTypeLayoutPassBase | |
| CSPIRVLowerABIAttributesPassBase | |
| CSPIRVReplicatedConstantCompositePassBase | |
| CSPIRVRewriteInsertsPassBase | |
| CSPIRVUnifyAliasedResourcePassBase | |
| CSPIRVUpdateVCEPassBase | |
| CSPIRVWebGPUPreparePassBase | |
| CArrayType | |
| CBlockMergeInfo | A struct for containing a header block's merge and continue targets |
| CCompositeType | |
| CCooperativeMatrixType | |
| CDebugLine | A struct for containing OpLine instruction information |
| CDeferredStructTypeInfo | A "deferred struct type" is a struct type with one or more member types not known when the Deserializer first encounters the struct |
| CDeserializationOptions | |
| CDeserializer | A SPIR-V module serializer |
| CElementwiseOpPattern | Converts elementwise unary, binary and ternary standard operations to SPIR-V operations |
| CGraphConstantARMOpMaterializationInfo | A struct that collects the info needed to materialize/emit a GraphConstantARMOp |
| CImageType | |
| CInterfaceVarABIAttr | An attribute that specifies the information regarding the interface variable: descriptor set, binding, storage class |
| CMatrixType | |
| CMemorySpaceToStorageClassConverter | Type converter for converting numeric MemRef memory spaces into SPIR-V symbolic ones |
| CPointerType | |
| CRuntimeArrayType | |
| CSampledImageType | |
| CScalarType | |
| CSerializationOptions | |
| CSerializer | A SPIR-V module serializer |
| CSpecConstOperationMaterializationInfo | A struct that collects the info needed to materialize/emit a SpecConstantOperation op |
| CSPIRVType | |
| CStructType | SPIR-V struct type |
| CMemberDecorationInfo | |
| CStructDecorationInfo | |
| CTargetEnv | A wrapper class around a spirv::TargetEnvAttr to provide query methods for allowed version/capabilities/extensions |
| CTargetEnvAttr | An attribute that specifies the target version, allowed extensions and capabilities, and resource limits |
| CTensorArmType | SPIR-V TensorARM Type |
| CVerCapExtAttr | An attribute that specifies the SPIR-V (version, capabilities, extensions) triple |
| Ccap_iterator | |
| Cext_iterator | |
| Ntblgen | |
| Ndetail | |
| Cstringifier | |
| Cstringifier< std::optional< OptionalT > > | |
| Cstringifier< Twine > | |
| CAppliedConstraint | |
| CAttrConstraint | |
| CAttrDef | This class represents a wrapper around a tablegen AttrDef record |
| CAttribute | |
| CAttributeSelfTypeParameter | |
| CAttrInterface | |
| CAttrOrTypeBuilder | Wrapper class that represents a Tablegen AttrOrTypeBuilder |
| CAttrOrTypeDef | Wrapper class that contains a TableGen AttrOrTypeDef's record and provides helper methods for accessing them |
| CAttrOrTypeParameter | A wrapper class for tblgen AttrOrTypeParameter, arrays of which belong to AttrOrTypeDefs to parameterize them |
| CBuilder | Wrapper class with helper methods for accessing Builders defined in TableGen |
| CParameter | This class represents a single parameter to a builder method |
| CClassDeclaration | A class declaration is a class element that appears as part of its declaration |
| CClassDeclarationBase | Base class for class declarations |
| CCombinedPred | |
| CConcatPred | |
| CConstantAttr | |
| CConstantProp | |
| CConstraint | |
| CConstructor | |
| CMemberInitializer | Initialization of a class field in a constructor |
| CCPred | |
| CDagLeaf | |
| CDagNode | |
| CDialect | |
| CDialectInterface | |
| CDialectNamespaceEmitter | |
| CEnumCase | |
| CEnumInfo | |
| CFmtContext | Format context containing substitutions for special placeholders |
| CFmtObject | |
| CFmtObjectBase | |
| CCreateAdapters | |
| CFmtReplacement | Struct representing a replacement segment for the formatted string |
| CFmtStrVecObject | |
| CInferredResultType | This class represents an inferred result type |
| CInterface | |
| CInterfaceMethod | |
| CArgument | |
| CInterfaceTrait | |
| CInternalTrait | |
| CMethod | Class for holding an op's method for C++ code emission |
| CMethodBody | This class contains the body of a C++ method |
| CMethodParameter | This class contains a single method parameter for a C++ function |
| CMethodParameters | This class contains a list of method parameters for constructor, class methods, and method signatures |
| CMethodSignature | This class contains the signature of a C++ method, including the return type |
| CNamedAttribute | |
| CNamedProperty | |
| CNamedRegion | |
| CNamedSuccessor | |
| CNamedTypeConstraint | |
| CNativeTrait | |
| COperator | Wrapper class that contains a MLIR op's information (e.g., operands, attributes) defined in TableGen and provides helper methods for accessing them |
| COperandAttrOrProp | Pair consisting kind of argument and index into operands, attributes, or properties |
| CVariableDecorator | A class used to represent the decorators of an operator variable, i.e |
| CVariableDecoratorIterator | A utility iterator over a list of variable decorators |
| COpInterface | |
| CParentClass | This class describes a C++ parent class declaration |
| CPass | Wrapper class providing helper methods for Passes defined in TableGen |
| CPassOption | |
| CPassStatistic | |
| CPattern | |
| CPred | |
| CPredTrait | |
| CPropConstraint | |
| CProperty | |
| CRegion | |
| CSideEffect | |
| CSideEffectTrait | |
| CStaticVerifierFunctionEmitter | This class deduplicates shared operation verification code by emitting static functions alongside the op definitions |
| CSubstLeavesPred | |
| CSuccessor | |
| CSymbolInfoMap | |
| CSymbolInfo | |
| CTrait | |
| CType | |
| CTypeConstraint | |
| CTypeDef | This class represents a wrapper around a tablegen TypeDef record |
| CTypeInterface | |
| CUsingDeclaration | This class describes a using-declaration for a class |
| Ntensor | |
| Nimpl | |
| CFoldTensorSubsetOpsPassBase | |
| CExtractSliceFromCollapseHelper | This class assists with generating IR required to materialize an arbitrary-sized slice from the result of a CollapseShapeOp |
| Ntosa | |
| Ndetail | Implemented by ops that correspond to the Tosa specification |
| CTosaOpInterfaceTraits | |
| CConcept | |
| CExternalModel | |
| CFallbackModel | |
| CModel | |
| CTosaOpTrait | |
| Nimpl | |
| CTosaArithConstantToTosaConstPassBase | |
| CTosaAttachTargetBase | |
| CTosaConvertIntegerTypeToSignlessBase | |
| CTosaInferShapesPassBase | |
| CTosaLayerwiseConstantFoldPassBase | |
| CTosaMakeBroadcastablePassBase | |
| CTosaNarrowI64ToI32PassBase | |
| CTosaOptionalDecompositionsPassBase | |
| CTosaReduceTransposesBase | |
| CTosaValidationBase | |
| CTargetEnv | This class represents the capability enabled in the target implementation such as profile, extension, and level |
| CTosaAttachTargetOptions | |
| CTosaLayerwiseConstantFoldPassOptions | |
| CTosaLevel | |
| CTosaNarrowI64ToI32PassOptions | |
| CTosaOp | |
| CTrait | |
| CTosaSpecificationVersion | A thin wrapper around the SpecificationVersion enum to represent and provide utilities around the TOSA specification version |
| CTosaValidationOptions | |
| CValueKnowledge | Statically known information for a particular Value |
| Ntracing | |
| CAction | An action is a specific action that is to be taken by the compiler, that can be toggled and controlled by an external user |
| CActionActiveStack | This class is used to keep track of the active actions in the stack |
| CActionImpl | CRTP Implementation of an action |
| CActionLogger | This class defines an observer that print Actions before and after execution on the provided stream |
| CActionProfiler | This class defines an observer that profiles events before and after execution on the provided stream |
| CBreakpoint | This abstract class represents a breakpoint |
| CBreakpointBase | This class provides a CRTP wrapper around a base breakpoint class to define a few necessary utility methods |
| CBreakpointManager | A breakpoint manager is responsible for managing a set of breakpoints and matching them to a given action |
| CBreakpointManagerBase | CRTP base class for BreakpointManager implementations |
| CDebugConfig | |
| CDebugCounter | This class implements an action handler that attaches a counter value to debug actions and enables/disables execution of these action based on the value of the counter |
| CExecutionContext | The ExecutionContext is the main orchestration of the infrastructure, it acts as a handler in the MLIRContext for executing an Action |
| CObserver | This abstract class defines the interface used to observe an Action execution |
| CFileLineColLocBreakpoint | This breakpoing intends to match a FileLineColLocation, that is a tuple of file name, line number, and column number |
| CFileLineColLocBreakpointManager | This breakpoint manager is responsible for matching FileLineColLocBreakpoint |
| CInstallDebugHandler | This is a RAII class that installs the debug handlers on the context based on the provided configuration |
| CImpl | |
| CTagBreakpoint | Simple breakpoint matching an action "tag" |
| CTagBreakpointManager | This is a manager to store a collection of breakpoints that trigger on tags |
| Ntransform | |
| Ndetail | |
| CTransformDialectDataBase | Concrete base class for CRTP TransformDialectDataBase |
| Ngpu | |
| CCopyMappingInfo | |
| CGpuBlockIdBuilder | Builder for gpu::BlockIdOps used to map scf.forall to blocks |
| CGpuIdBuilder | Helper struct for configuring the rewrite of mapped scf.forall ops to various gpu id configurations |
| CGpuLaneIdBuilder | Builder for lane id |
| CGpuThreadIdBuilder | Builder for warp ids used to map scf.forall to reindexed threads |
| CGpuWarpgroupIdBuilder | Builder for warpgroup ids used to map scf.forall to reindexed warpgroups |
| CGpuWarpIdBuilder | Builder for warp ids used to map scf.forall to reindexed warps |
| CIdBuilderResult | Helper type for functions that generate ids for the mapping of a scf.forall |
| CMappingInfo | Base struct to hold GPU mapping information for a given operation |
| Nimpl | |
| CCheckUsesPassBase | |
| CInferEffectsPassBase | |
| CInterpreterPassBase | |
| CPreloadLibraryPassBase | |
| CApplyToEachResultList | A list of results of applying a transform op with ApplyEachOpTrait to a single payload operation, co-indexed with the results of the transform op |
| CAtMostOneOpMatcherOpTrait | |
| CBuildOnly | A wrapper for transform dialect extensions that forces them to be constructed in the build-only mode |
| CErrorCheckingTrackingListener | A specialized listener that keeps track of cases in which no replacement payload could be found |
| CFunctionalStyleTransformOpTrait | Trait implementing the MemoryEffectOpInterface for operations that "consume" their operands and produce new results |
| CInterpreterPassOptions | |
| CNavigationTransformOpTrait | Trait implementing the MemoryEffectOpInterface for operations that use their operands without consuming and without modifying the Payload IR to potentially produce new handles |
| CNumThreadsSpec | |
| CParamProducerTransformOpTrait | Trait implementing the MemoryEffectsOpInterface for operations that produce transform dialect parameters |
| CPayloadIRResource | Side effect resource corresponding to the Payload IR itself |
| CPDLMatchHooks | PDL constraint callbacks that can be used by the PDL extension of the Transform dialect |
| CPossibleTopLevelTransformOpTrait | This trait is supposed to be attached to Transform dialect operations that can be standalone top-level transforms |
| CPreloadLibraryPassOptions | |
| CReportTrackingListenerFailuresOpTrait | TrackingListener failures are reported only for ops that have this trait |
| CSingleOpMatcherOpTrait | |
| CSingleValueMatcherOpTrait | |
| CStructuredOpPredicateOpTrait | |
| CTileSizesSpec | |
| CTrackingListener | A listener that updates a TransformState based on IR modifications |
| CTrackingListenerConfig | A configuration object for customizing a TrackingListener |
| CTransformDialectData | Base class for additional data owned by the Transform dialect |
| CTransformDialectExtension | Base class for extensions of the Transform dialect that supports injecting operations into the Transform dialect at load time |
| CTransformEachOpTrait | Trait implementing the TransformOpInterface for operations applying a transformation to a single operation handle and producing an arbitrary number of handles and parameter values |
| CTransformMappingResource | Side effect resource corresponding to the mapping between Transform IR values and Payload IR operations |
| CTransformOptions | Options controlling the application of transform operations by the TransformState |
| CTransformResults | Local mapping between values defined by a specific op implementing the TransformOpInterface and the payload IR ops they correspond to |
| CTransformRewriter | This is a special rewriter to be used in transform op implementations, providing additional helper functions to update the transform state, etc |
| CTransformState | The state maintained across applications of various ops implementing the TransformOpInterface |
| CExtension | Base class for TransformState extensions that allow TransformState to contain user-specified information in the state object |
| CRegionScope | A RAII object maintaining a "stack frame" for a transform IR region |
| NTypeTrait | This trait is used to determine if a type is a dynamic type or not; it should only be implemented by dynamic types |
| CIsDynamicType | |
| Nvector | |
| Ndetail | |
| CBitmaskEnumStorage | |
| CValueBoundsConstraintSet | Parent class for the value bounds RTTIExtends |
| Nimpl | |
| CLowerVectorMaskPassBase | |
| CLowerVectorMultiReductionBase | |
| CLowerVectorToFromElementsToShuffleTreeBase | |
| CLowerVectorMultiReductionOptions | |
| CLowerVectorsOptions | Helper structure used to hold the different options of LowerVectorsOp |
| CMaskableOpRewritePattern | A pattern for ops that implement MaskableOpInterface and that might be masked (i.e |
| CScalableValueBoundsConstraintSet | A version of ValueBoundsConstraintSet that can solve for scalable bounds |
| CConstantOrScalableBound | A thin wrapper over an AffineMap which can represent a constant bound, or a scalable bound (in terms of vscale) |
| CBoundSize | |
| CUnrollVectorOptions | Options that control the vector unrolling |
| CVectorDim | |
| CVectorTransformsOptions | Structure to control the behavior of vector transform patterns |
| CWarpExecuteOnLane0LoweringOptions | |
| NVectorType | |
| CBuilder | This is a builder type that keeps local references to arguments |
| Nwasmssa | |
| CConstantExpressionInitializerOpTrait | Trait used to verify operations that need a constant expression initializer |
| CConstantExprOpTrait | Operations implementing this trait are considered as valid constant expressions in any context (In contrast of ConstantExprCheckOpInterface which are sometimes considered valid constant expressions |
| Nx86vector | |
| Navx2 | Helpers extracted from: |
| CLoweringOptions | Options for controlling specialized AVX2 lowerings |
| CTransposeLoweringOptions | Structure to control the behavior of specialized AVX2 transpose lowering |
| CMaskHelper | Helper class to factor out the creation and extraction of masks from nibs |
| Nxegpu | |
| Nimpl | |
| CXeGPUBlockingBase | |
| CXeGPUFoldAliasOpsBase | |
| CXeGPUOptimizeBlockLoadsBase | |
| CXeGPUPropagateLayoutBase | |
| CXeGPUSubgroupDistributeBase | |
| CXeGPUVectorLinearizeBase | |
| CXeGPUWgToSgDistributeBase | |
| NuArch | |
| CBMGuArch | |
| CCacheInfo | |
| CInstruction | |
| CMMAInstructionInterface | |
| CPVCuArch | |
| CRegisterFileInfo | |
| CSharedMemory | |
| CSubgroup2DBlockLoadInstruction | |
| CSubgroup2DBlockPrefetchInstruction | |
| CSubgroup2DBlockStoreInstruction | |
| CSubgroupMatrixMultiplyAcc | |
| CuArch | |
| CXe2Plus | |
| CXeCoreInfo | |
| CUnrollOptions | Options to control the XeGPU unrolling |
| CXeGPUPropagateLayoutOptions | |
| Nxevm | |
| CSerializeGPUModuleBase | Base class for all XeVM serializations from GPU modules into binary strings |
| CAbstractAttribute | This class contains all of the static information common to all instances of a registered Attribute |
| CAbstractType | This class contains all of the static information common to all instances of a registered Type |
| CAffineBinaryOpExpr | Affine binary operation expression |
| CAffineConstantExpr | An integer constant appearing in affine expression |
| CAffineDimExpr | A dimensional identifier appearing in an affine expression |
| CAffineExpr | Base type for affine expression |
| CAffineExprVisitor | See documentation for AffineExprVisitorBase |
| CAffineExprVisitor< SubClass, LogicalResult > | |
| CAffineExprVisitorBase | Base class for AffineExpr visitors/walkers |
| CAffineMap | A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued |
| CAffineSymbolExpr | A symbolic identifier appearing in an affine expression |
| CAliasAnalysis | This class represents the main alias analysis interface in MLIR |
| CAliasResult | The possible results of an alias query |
| CAnalysisManager | This class represents an analysis manager for a particular operation instance |
| CAnalysisState | Base class for generic analysis states |
| CApplyPatternAction | This is the type of Action that is dispatched when a pattern is applied |
| CArithBuilder | Helper struct to build simple arithmetic quantities with minimal type inference support |
| CArithIndexingBuilder | ArithBuilder specialized specifically for tensor/memref indexing calculations |
| CArithToAMDGPUConversionPassOptions | |
| CArithToLLVMConversionPassOptions | |
| CArrayRef | |
| CAsmDialectResourceHandle | This class represents an opaque handle to a dialect resource entry |
| CAsmDialectResourceHandleBase | This class represents a CRTP base class for dialect resource handles |
| CAsmParsedResourceEntry | This class represents a single parsed resource entry |
| CAsmParser | This base class exposes generic asm parser hooks, usable across the various derived parsers |
| CCyclicParseReset | Class used to automatically end a cyclic region on destruction |
| CKeywordSwitch | This class represents a StringSwitch like class that is useful for parsing expected keywords |
| CAsmParserCodeCompleteContext | This class provides an abstract interface into the parser for hooking in code completion events |
| CAsmParserState | This class represents state from a parsed MLIR textual format string |
| CAttributeAliasDefinition | This class represents the information for an attribute alias definition within the input file |
| CBlockDefinition | This class represents the information for a block definition within the input file |
| CImpl | |
| CPartialOpDef | |
| COperationDefinition | This class represents the information for an operation definition within an input file |
| CResultGroupDefinition | |
| CSMDefinition | This class represents a definition within the source manager, containing it's defining location and locations of any uses |
| CTypeAliasDefinition | This class represents the information for type definition within the input file |
| CAsmPrinter | This base class exposes generic asm printer hooks, usable across the various derived printers |
| CCyclicPrintReset | Class used to automatically end a cyclic region on destruction |
| CImpl | |
| CAsmResourceBlob | This class represents a processed binary blob of data |
| CAsmResourceBuilder | This class is used to build resource entries for use by the printer |
| CAsmResourceParser | This class represents an instance of a resource parser |
| CAsmResourcePrinter | This class represents an instance of a resource printer |
| CAsmState | This class provides management for the lifetime of the state used when printing the IR |
| CAsyncParallelForPassOptions | |
| CAttrConvertPassThrough | |
| CAttribute | Attributes are known-constant values of operations |
| CAttributeInterface | This class represents the base of an attribute interface |
| CAttributeStorage | Base storage class appearing in an attribute |
| CAttrTypeBytecodeReader | A class to interact with the attributes and types parser when parsing MLIR bytecode |
| CAttrTypeBytecodeWriter | A class to interact with the attributes and types printer when emitting MLIR bytecode |
| CAttrTypeImmediateSubElementWalker | AttrTypeSubElementHandler |
| CAttrTypeReplacer | This is an attribute/type replacer that is naively cached |
| CAttrTypeSubElementHandler | This class provides support for interacting with the SubElementInterfaces for different types of parameters |
| CAttrTypeSubElementHandler< ArrayRef< T >, std::enable_if_t< has_sub_attr_or_type_v< T > > > | Implementation for derived ArrayRef |
| CAttrTypeSubElementHandler< LLVM::detail::LLVMStructTypeStorage::Key > | Allow walking and replacing the subelements of a LLVMStructTypeStorage key |
| CAttrTypeSubElementHandler< Location > | Enable locations to be introspected as sub-elements |
| CAttrTypeSubElementHandler< NamedAttribute > | Allow walking and replacing the subelements of a NamedAttribute |
| CAttrTypeSubElementHandler< std::tuple< Ts... >, std::enable_if_t< has_sub_attr_or_type_v< Ts... > > > | Implementation for Tuple |
| CAttrTypeSubElementHandler< T, std::enable_if_t< std::is_base_of_v< Attribute, T >||std::is_base_of_v< Type, T > > > | Implementation for derived Attributes and Types |
| CAttrTypeSubElementHandler< TypeRange > | Enable TypeRange to be introspected for sub-elements |
| CAttrTypeSubElementReplacements | This class is used by AttrTypeSubElementHandler instances to process sub element replacements |
| CAttrTypeWalker | AttrTypeWalker |
| CBackwardSliceOptions | |
| CBaseMemRefType | This class provides a shared interface for ranked and unranked memref types |
| CBlock | Block represents an ordered list of Operations |
| CBlockArgument | This class represents an argument of a Block |
| CBlockOperand | A block operand represents an operand that holds a reference to a Block, e.g |
| CBlockRange | This class provides an abstraction over the different types of ranges over Blocks |
| CBoolAttr | Special case of IntegerAttr to represent boolean integers, i.e., signless i1 integers |
| CBufferOriginAnalysis | An is-same-buffer analysis that checks if two SSA values belong to the same buffer allocation or not |
| CBufferViewFlowAnalysis | A straight-forward alias analysis which ensures that all dependencies of all values will be determined |
| CBuilder | This class is a general helper class for creating context-global objects like types, attributes, and affine expressions |
| CBytecodeDialectInterface | |
| CBytecodeReader | The BytecodeReader allows to load MLIR bytecode files, while keeping the state explicitly available in order to support lazy loading |
| CImpl | This class is used to read a bytecode buffer and translate it into MLIR |
| CBytecodeReaderConfig | A class containing bytecode-specific configurations of the ParserConfig |
| CBytecodeWriterConfig | This class contains the configuration used for the bytecode writer |
| CImpl | |
| CCachedCyclicReplacer | A helper class for cases where the input/output types of the replacer function is identical to the types stored in the cache |
| CCallGraph | |
| CCallGraphNode | This class represents a single callable in the callgraph |
| CEdge | This class represents a directed edge between two nodes in the callgraph |
| CCallInterfaceCallable | A callable is either a symbol, or an SSA value, that is referenced by a call-like operation |
| CCanonicalizerOptions | |
| CCFGLoop | Representation of a single loop formed by blocks |
| CCFGLoopInfo | An LLVM LoopInfo instantiation for MLIR that provides access to CFG loops found in the dominator tree |
| CCFGToSCFInterface | Interface that should be implemented by any caller of transformCFGToSCF |
| CComplexStructBuilder | |
| CComposeCollapseOfExpandOp | Common verifier for reshape-like types |
| CComposeExpandOfCollapseOp | |
| CCompositeFixedPointPassOptions | |
| CConstantIntRanges | A set of arbitrary-precision integers representing bounds on a given integer value |
| CControlFlowToSCFTransformation | Implementation of CFGToSCFInterface used to lift Control Flow Dialect operations to SCF Dialect operations |
| CConvertAffineForToGPUPassOptions | |
| CConvertAMDGPUToROCDLPassOptions | |
| CConvertArithToSPIRVPassOptions | |
| CConvertArmSMEToLLVMOptions | |
| CConvertComplexToLLVMPassOptions | |
| CConvertComplexToStandardPassOptions | |
| CConvertControlFlowToLLVMPassOptions | |
| CConvertControlFlowToSPIRVPassOptions | |
| CConvertFuncToLLVMPassOptions | |
| CConvertFuncToSPIRVPassOptions | |
| CConvertGpuOpsToLLVMSPVOpsOptions | |
| CConvertGpuOpsToNVVMOpsOptions | |
| CConvertGpuOpsToROCDLOpsOptions | |
| CConvertGPUToSPIRVOptions | |
| CConvertIndexToLLVMPassOptions | |
| CConvertIndexToSPIRVPassOptions | |
| CConvertMathToEmitCOptions | |
| CConvertMathToFuncsOptions | |
| CConvertMathToLLVMPassOptions | |
| CConvertMathToROCDLOptions | |
| CConvertMathToXeVMOptions | |
| CConvertMemRefToEmitCOptions | |
| CConvertMemRefToSPIRVPassOptions | |
| CConvertOpInterfaceToLLVMPattern | Utility class for operation conversions targeting the LLVM dialect that allows for matching and rewriting against an instance of an OpInterface class |
| CConvertOpToLLVMPattern | Utility class for operation conversions targeting the LLVM dialect that match exactly one source operation |
| CConvertSCFToOpenMPPassOptions | |
| CConvertSPIRVToLLVMPassOptions | |
| CConvertTensorToSPIRVPassOptions | |
| CConvertToEmitCOptions | |
| CConvertToEmitCPatternInterface | |
| CConvertToLLVMPassOptions | |
| CConvertToLLVMPattern | Base class for operation conversions targeting the LLVM IR dialect |
| CConvertToLLVMPatternInterface | Base class for dialect interfaces providing translation to LLVM IR |
| CConvertVectorToGPUOptions | |
| CConvertVectorToLLVMPassOptions | |
| CConvertVectorToSCFOptions | |
| CCopyOnWriteArrayRef | |
| CCyclicAttrTypeReplacer | This is an attribute/type replacer that supports custom handling of cycles in the replacer logic |
| CCyclicReplacerCache | A cache for replacer-like functions that map values between two domains |
| CCacheEntry | A possibly unresolved cache entry |
| CDataFlowAnalysis | Base class for all data-flow analyses |
| CDataFlowConfig | Configuration class for data flow solver and child analyses |
| CDataFlowSolver | The general data-flow analysis solver |
| CDataLayout | The main mechanism for performing data layout queries |
| CDataLayoutAnalysis | Stores data layout objects for each operation that specifies the data layout above and below the given operation |
| CDataLayoutDialectInterface | An interface to be implemented by dialects that can have identifiers in the data layout specification entries |
| CDefaultTimingManager | Facilities for time measurement and report printing to an output stream |
| CDenseElementsAttr | An attribute that represents a reference to a dense vector or tensor object |
| CAttributeElementIterator | A utility iterator that allows walking over the internal Attribute values of a DenseElementsAttr |
| CBoolElementIterator | A utility iterator that allows walking over the internal bool values |
| CComplexFloatElementIterator | Iterator for walking over complex APFloat values |
| CComplexIntElementIterator | A utility iterator that allows walking over the internal raw complex APInt values |
| CDerivedAttributeElementIterator | |
| CElementIterator | Iterator for walking raw element values of the specified type 'T', which may be any c++ data type matching the stored representation: int32_t, float, etc |
| CFloatElementIterator | Iterator for walking over APFloat values |
| CIntElementIterator | A utility iterator that allows walking over the internal raw APInt values |
| Cis_valid_cpp_fp_type | Type trait used to check if the given type T is a potentially valid C++ floating point type that can be used to access the underlying element types of a DenseElementsAttr |
| CDenseFPElementsAttr | An attribute that represents a reference to a dense float vector or tensor object |
| CDenseIntElementsAttr | An attribute that represents a reference to a dense integer vector or tensor object |
| CDestructurableMemorySlot | Memory slot attached with information about its destructuring procedure |
| CDiagnosedDefiniteFailure | A compatibility class connecting InFlightDiagnostic to DiagnosedSilenceableFailure while providing an interface similar to the former |
| CDiagnosedSilenceableFailure | The result of a transform IR operation application |
| CDiagnostic | This class contains all of the information necessary to report a diagnostic to the DiagnosticEngine |
| CDiagnosticArgument | A variant type that holds a single argument for a diagnostic |
| CDiagnosticEngine | This class is the main interface for diagnostics |
| CDialect | Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the entire group |
| CDialectAsmParser | The DialectAsmParser has methods for interacting with the asm parser when parsing attributes and types |
| CDialectAsmPrinter | This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom printAttribute/printType() method on a dialect |
| CDialectBytecodeReader | This class defines a virtual interface for reading a bytecode stream, providing hooks into the bytecode reader |
| CDialectBytecodeWriter | This class defines a virtual interface for writing to a bytecode stream, providing hooks into the bytecode writer |
| CDialectExtension | This class represents a dialect extension anchored on the given set of dialects |
| CDialectExtensionBase | This class represents an opaque dialect extension |
| CDialectFoldInterface | Define a fold interface to allow for dialects to control specific aspects of the folding behavior for operations they define |
| CDialectInterface | This class represents an interface overridden for a single dialect |
| CDialectInterfaceCollection | A collection of dialect interfaces within a context, for a given concrete interface type |
| CDialectPlugin | A loaded dialect plugin |
| CDialectPluginLibraryInfo | Information about the plugin required to load its dialects & passes |
| CDialectReductionPatternInterface | This is used to report the reduction patterns for a Dialect |
| CDialectRegistry | The DialectRegistry maps a dialect namespace to a constructor for the matching dialect |
| CDialectResourceBlobHandle | This class defines a dialect specific handle to a resource blob |
| CDialectResourceBlobManager | This class defines a manager for dialect resource blobs |
| CBlobEntry | The class represents an individual entry of a blob |
| CDialectVersion | This class is used to represent the version of a dialect, for the purpose of polymorphic destruction |
| CDistinctAttr | An attribute that associates a referenced attribute with a unique identifier |
| CDominanceInfo | A class for computing basic dominance information |
| CDynamicAttr | A dynamic attribute instance |
| CDynamicAttrDefinition | The definition of a dynamic attribute |
| CDynamicDialect | A dialect that can be defined at runtime |
| CDynamicOpDefinition | The definition of a dynamic op |
| CDynamicType | A dynamic type instance |
| CDynamicTypeDefinition | The definition of a dynamic type |
| CEmptyProperties | Structure used by default as a "marker" when no "Properties" are set on an Operation |
| CEndomorphismSimplification | |
| CExecutionEngine | JIT-backed execution engine for MLIR |
| CArgument | Trait that defines how a given type is passed to the JIT code |
| CArgument< Result< T > > | |
| CResult | Tag to wrap an output parameter when invoking a jitted function |
| CExecutionEngineOptions | |
| CExtensibleDialect | A dialect that can be extended with new operations/types/attributes at runtime |
| CExternalPass | This pass class wraps external passes defined in other languages using the MLIR C-interface |
| CExternalRewritePattern | |
| CFallbackAsmResourceMap | A fallback map containing external resources not explicitly handled by another parser/printer |
| COpaqueAsmResource | This class represents an opaque resource |
| CFieldParser | Provide a template class that can be specialized by users to dispatch to parsers |
| CFieldParser< AffineMap > | Parse an affine map |
| CFieldParser< AttributeT, std::enable_if_t< std::is_base_of< Attribute, AttributeT >::value, AttributeT > > | Parse an attribute |
| CFieldParser< ContainerT, std::enable_if_t< llvm::is_detected< detail::has_push_back_t, ContainerT >::value, ContainerT > > | Parse any container that supports back insertion as a list |
| CFieldParser< IntT, std::enable_if_t<(std::is_integral< IntT >::value||std::is_same_v< IntT, llvm::APInt >), IntT > > | Parse any integer |
| CFieldParser< std::optional< AttributeT >, std::enable_if_t< std::is_base_of< Attribute, AttributeT >::value, std::optional< AttributeT > > > | Parse an Optional attribute |
| CFieldParser< std::optional< IntT >, std::enable_if_t< std::is_integral< IntT >::value, std::optional< IntT > > > | Parse an Optional integer |
| CFieldParser< std::string > | Parse a string |
| CFieldParser< TypeT, std::enable_if_t< std::is_base_of< Type, TypeT >::value, TypeT > > | Parse a type |
| CFileLineColLoc | An instance of this location represents a tuple of file, line number, and column number |
| CFinalizeMemRefToLLVMConversionPassOptions | |
| CFixedVectorType | A vector type with no scalable dimensions |
| CFlatLinearConstraints | FlatLinearConstraints is an extension of IntegerPolyhedron |
| CFlatLinearValueConstraints | FlatLinearValueConstraints represents an extension of FlatLinearConstraints where each non-local variable can have an SSA Value attached to it |
| CFlatSymbolRefAttr | A symbol reference with a reference path containing a single element |
| CForwardDominanceIterator | This iterator enumerates elements according to their dominance relationship |
| CForwardIterator | This iterator enumerates the elements in "forward" order |
| CFrozenRewritePatternSet | This class represents a frozen set of patterns that can be processed by a pattern applicator |
| CFunctionCallBuilder | |
| CFusedLocWith | This class represents a fused location whose metadata is known to be an instance of the given type |
| CGenerateRuntimeVerificationOptions | |
| CGenericLatticeAnchor | Abstract class for generic lattice anchor |
| CGenericLatticeAnchorBase | Base class for generic lattice anchor based on a concrete lattice anchor type and a content key |
| CGenInfo | Structure to group information about a generator (argument to invoke via mlir-tblgen, description, and generator function) |
| CGenNameParser | Adds command line option for each registered generator |
| CGenRegistration | GenRegistration provides a global initializer that registers a generator function |
| CGPUDynamicSharedMemoryOpLowering | Lowering for gpu.dynamic.shared.memory to LLVM dialect |
| CGPUFuncOpLowering | |
| CGPUFuncOpLoweringOptions | |
| CGpuKernelOutliningPassOptions | |
| CGpuMapParallelLoopsPassOptions | |
| CGpuModuleToBinaryPassOptions | |
| CGpuNVVMAttachTargetOptions | |
| CGPUPrintfOpToHIPLowering | The lowering of gpu.printf to a call to HIP hostcalls |
| CGPUPrintfOpToLLVMCallLowering | The lowering of gpu.printf to a call to an external printf() function |
| CGPUPrintfOpToVPrintfLowering | Lowering of gpu.printf to a vprintf standard library |
| CGPUReturnOpLowering | |
| CGpuROCDLAttachTargetOptions | |
| CGpuSPIRVAttachTargetOptions | |
| CGpuToLLVMConversionPassOptions | |
| CGpuXeVMAttachTargetOptions | |
| CGreedyRewriteConfig | This class allows control over how the GreedyPatternRewriteDriver works |
| CHasDefaultDLTIDataLayout | Trait to be used by operations willing to use the implementation of the data layout interfaces provided by the Target dialect |
| CHeapAsmResourceBlob | This class provides a simple utility wrapper for creating heap allocated AsmResourceBlobs |
| CHomomorphismSimplification | |
| CHyperrectangularSlice | A hyperrectangular slice, represented as a list of offsets, sizes and strides |
| CImplicitLocOpBuilder | ImplicitLocOpBuilder maintains a 'current location', allowing use of the create<> method without specifying the location |
| CInFlightDiagnostic | This class represents a diagnostic that is inflight and set to be reported |
| CInliner | This is an implementation of the inliner that operates bottom up over the Strongly Connected Components(SCCs) of the CallGraph |
| CImpl | |
| CResolvedCall | This struct represents a resolved call to a given callgraph node |
| CInlinerConfig | |
| CInlinerInterface | This interface provides the hooks into the inlining interface |
| CInlinerOptions | |
| CIntegerSet | An integer set representing a conjunction of one or more affine equalities and inequalities |
| CIntegerValueRange | This lattice value represents the integer range of an SSA value |
| CInterfacePass | Pass to transform an operation that implements the given interface |
| CInvocationBounds | This class represents upper and lower bounds on the number of times a region of a RegionBranchOpInterface can be invoked |
| CIRMapping | This is a utility class for mapping one set of IR entities to another |
| CIRObjectWithUseList | This class represents a single IR object that contains a use list |
| CIROperand | A reference to a value, suitable for use as an operand of an operation |
| CIRRewriter | This class coordinates rewriting a piece of IR outside of a pattern rewrite, providing a way to keep track of the mutations made to the IR |
| CIRUnit | IRUnit is a union of the different types of IR objects that constitute the IR structure (other than Type and Attribute), that is Operation, Region, and Block |
| Citerator_range | |
| CJamBlockGatherer | |
| CJitRunnerConfig | Configuration to override functionality of the JitRunner |
| CJitRunnerOptions | JitRunner command line options used by JitRunnerConfig methods |
| CLatticeAnchor | Fundamental IR components are supported as first-class lattice anchor |
| CLexer | This class breaks up the current file into a token stream |
| CLinalgBlockPackMatmulOptions | |
| CLinalgDetensorizePassOptions | |
| CLinalgFoldUnitExtentDimsPassOptions | |
| CLinalgMorphOpsPassOptions | |
| CLiveness | Represents an analysis for computing liveness information from a given top-level operation |
| CLivenessBlockInfo | This class represents liveness information on block level |
| CLLVMConversionTarget | Derived class that automatically populates legalization information for different LLVM ops |
| CLLVMImportDialectInterface | Base class for dialect interfaces used to import LLVM IR |
| CLLVMImportInterface | Interface collection for the import of LLVM IR that dispatches to a concrete dialect interface implementation |
| CLLVMTranslationDialectInterface | Base class for dialect interfaces providing translation to LLVM IR |
| CLLVMTranslationInterface | Interface collection for translation to LLVM IR, dispatches to a concrete interface implementation based on the dialect to which the given op belongs |
| CLLVMTypeConverter | Conversion from types to the LLVM IR dialect |
| CLocalAliasAnalysis | This class implements a local form of alias analysis that tries to identify the underlying values addressed by each value and performs a few basic checks to see if they alias |
| CLocation | This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around a LocationAttr |
| CLocationAttr | Location objects represent source locations information in MLIR |
| CLocationSnapshotOptions | |
| CLockedSymbolTableCollection | This class implements a lock-based shared wrapper around a symbol table collection that allows shared access to the collection of symbol tables |
| CLowerSparseOpsToForeachOptions | |
| CLowerToLLVMOptions | Options to control the LLVM lowering |
| CMapMemRefStorageClassOptions | |
| CMathPolynomialApproximationOptions | |
| CMem2RegOptions | |
| CMem2RegStatistics | Statistics collected while applying mem2reg |
| CMemorySlot | Represents a slot in memory |
| CMemRefDescriptor | Helper class to produce LLVM dialect operations extracting or inserting elements of a MemRef descriptor |
| CMemRefDescriptorView | Helper class allowing the user to access a range of Values that correspond to an unpacked memref descriptor using named accessors |
| CMergeResult | Container for the result of merge operation of tiling |
| CMLIRContext | MLIRContext is the top-level object for a collection of MLIR operations |
| CMLIRContextImpl | This is the implementation of the MLIRContext class, using the pImpl idiom |
| CMlirOptMainConfig | Configuration options for the mlir-opt tool |
| CModRefResult | The possible results of whether a memory access modifies or references a memory location |
| CModuleAnalysisManager | An analysis manager class specifically for the top-level operation |
| CMutableAffineMap | A mutable affine map. Its affine expressions are however unique |
| CMutableArrayRef | |
| CMutableOperandRange | This class provides a mutable adaptor for a range of operands |
| CMutableOperandRangeRange | This class represents a contiguous range of mutable operand ranges, e.g |
| CNamedAttribute | NamedAttribute represents a combination of a name and an Attribute value |
| CNamedAttrList | NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work to remain sorted |
| CNamespace | A namespace that is used to store existing names and generate new names in some scope within the IR |
| COneToOneConvertToLLVMPattern | Generic implementation of one-to-one conversion from "SourceOp" to "TargetOp" where the latter belongs to the LLVM dialect or an equivalent |
| COp | This provides public APIs that all operations should have |
| COpaqueProperties | Simple wrapper around a void* in order to express generically how to pass in op properties through APIs |
| COpAsmDialectInterface | |
| COpAsmParser | The OpAsmParser has methods for interacting with the asm parser: parsing things from it, emitting errors etc |
| CArgument | |
| CUnresolvedOperand | This is the representation of an operand reference |
| COpAsmPrinter | This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom print() method |
| COpBuilder | This class helps build Operations |
| CInsertionGuard | RAII guard to reset the insertion point of the builder when destroyed |
| CInsertPoint | This class represents a saved insertion point |
| CListener | This class represents a listener that may be used to hook into various actions within an OpBuilder |
| CListenerBase | Base class for listeners |
| COperandElementTypeIterator | |
| COperandRange | This class implements the operand iterators for the Operation class |
| COperandRangeRange | This class represents a contiguous range of operand ranges, e.g |
| COperation | Operation is the basic unit of execution within MLIR |
| CCloneOptions | Class encompassing various options related to cloning an operation |
| Cdialect_attr_iterator | A utility iterator that filters out non-dialect attributes |
| COperationConverter | |
| COperationEquivalence | This class provides utilities for computing if two operations are equivalent |
| COperationFingerPrint | A unique fingerprint for a specific operation, and all of it's internal operations (if includeNested is set) |
| COperationFolder | A utility class for folding operations, and unifying duplicated constants generated along the way |
| COperationName | |
| CImpl | |
| CInterfaceConcept | This class represents a type erased version of an operation |
| CUnregisteredOpModel | Default implementation for unregistered operations |
| COperationPass | Pass to transform an operation of a specific type |
| COperationPass< void > | Pass to transform an operation |
| COperationState | This represents an operation in an abstracted form, suitable for use with the builder APIs |
| COpFoldResult | This class represents a single result from folding an operation |
| COpInterface | This class represents the base of an operation interface |
| COpInterfaceRewritePattern | OpInterfaceRewritePattern is a wrapper around RewritePattern that allows for matching and rewriting against an instance of an operation interface instead of a raw Operation |
| COpOperand | This class represents an operand of an operation |
| COpPassManager | This class represents a pass manager that runs passes on either a specific operation type, or any isolated operation |
| COpPrintingFlags | Set of flags used to control the behavior of the various IR print methods (e.g |
| COpResult | This is a value defined by a result of an operation |
| COpRewritePattern | OpRewritePattern is a wrapper around RewritePattern that allows for matching and rewriting against an instance of a derived operation class as opposed to a raw Operation |
| COpState | This is the concrete base class that holds the operation pointer and has non-generic methods that only depend on State (to avoid having them instantiated on template types that don't affect them |
| COptionalParseResult | This class implements Optional functionality for ParseResult |
| COptionValue< mlir::OpPassManager > | |
| COpToFuncCallLowering | Rewriting that replaces SourceOp with a CallOp to f32Func or f64Func or f32ApproxFunc or f16Func or i32Type depending on the element type and the fastMathFlag of that Op, if present |
| COpTraitRewritePattern | OpTraitRewritePattern is a wrapper around RewritePattern that allows for matching and rewriting against instances of an operation that possess a given trait |
| COptReductionPassOptions | |
| COpWithFlags | A wrapper class that allows for printing an operation with a set of flags, useful to act as a "stream modifier" to customize printing an operation with a stream using the operator<< overload, e.g.: llvm::dbgs() << OpWithFlags(op, OpPrintingFlags().skipRegions()); This always prints the operation with the local scope, to avoid introducing spurious newlines in the stream |
| COpWithOffsetSizesAndStridesConstantArgumentFolder | Pattern to rewrite dynamic offsets/sizes/strides of view/slice-like ops as constant arguments |
| COpWithState | A wrapper class that allows for printing an operation with a custom AsmState, useful to act as a "stream modifier" to customize printing an operation with a stream using the operator<< overload, e.g.: llvm::dbgs() << OpWithState(op, OpPrintingFlags().skipRegions()); |
| COutputStrategy | Facilities for printing timing reports to various output formats |
| COwningMemRef | Owning MemRef type that abstracts over the runtime type for ranked strided memref |
| COwningOpRef | This class acts as an owning reference to an op, and will automatically destroy the held op on destruction if the held op is valid |
| CParallelDiagnosticHandler | This class is a utility diagnostic handler for use when multi-threading some part of the compiler where diagnostics may be emitted |
| Cparser< mlir::OpPassManager > | |
| CParsedPassManager | A utility struct used when parsing a pass manager that prevents the need for a default constructor on OpPassManager |
| Cparser< SmallVector< T, N > > | |
| Cparser< std::vector< T > > | |
| CParserConfig | This class represents a configuration for the MLIR assembly parser |
| CPass | The abstract base pass class |
| CListOption | This class represents a specific pass option that contains a list of values of the provided data type |
| COption | This class represents a specific pass option, with a provided data type |
| CStatistic | This class represents a single pass statistic |
| CPassExecutionAction | This class encapsulates the "action" of executing a single pass |
| CPassInfo | A structure to represent the information for a derived pass class |
| CPassInstrumentation | PassInstrumentation provides several entry points into the pass manager infrastructure |
| CPipelineParentInfo | This struct represents information related to the parent pass of pipeline |
| CPassInstrumentor | This class holds a collection of PassInstrumentation objects, and invokes their respective call backs |
| CPassManager | The main pass manager and pipeline builder |
| CIRPrinterConfig | A configuration struct provided to the IR printer instrumentation |
| CPassNameCLParser | This class implements a command-line parser specifically for MLIR pass names |
| CPassPipelineCLParser | This class implements a command-line parser for MLIR passes |
| CPassPipelineInfo | A structure to represent the information of a registered pass pipeline |
| CPassPipelineRegistration | PassPipelineRegistration provides a global initializer that registers a Pass pipeline builder routine |
| CPassPipelineRegistration< EmptyPipelineOptions > | Convenience specialization of PassPipelineRegistration for EmptyPassOptions that does not pass an empty options struct to the pass builder function |
| CPassPlugin | A loaded pass plugin |
| CPassPluginLibraryInfo | Information about the plugin required to load its passes |
| CPassRegistration | PassRegistration provides a global initializer that registers a Pass allocation routine for a concrete pass instance |
| CPassRegistryEntry | Structure to group information about a passes and pass pipelines (argument to invoke via mlir-opt, description, pass pipeline builder) |
| CPassReproducerOptions | |
| CPassWrapper | This class provides a CRTP wrapper around a base pass class to define several necessary utility methods |
| CPattern | This class contains all of the data related to a pattern, but does not contain any methods or logic for the actual matching |
| CMatchAnyOpTypeTag | This class acts as a special tag that makes the desire to match "any" operation type explicit |
| CMatchInterfaceOpTypeTag | This class acts as a special tag that makes the desire to match any operation that implements a given interface explicit |
| CMatchTraitOpTypeTag | This class acts as a special tag that makes the desire to match any operation that implements a given trait explicit |
| CPatternApplicator | This class manages the application of a group of rewrite patterns, with a user-provided cost model |
| CPatternBenefit | This class represents the benefit of a pattern match in a unitless scheme that ranges from 0 (very little benefit) to 65K |
| CPatternRewriter | A special type of RewriterBase that coordinates the application of a rewrite pattern on the current IR being matched, providing a way to keep track of any mutations made |
| CPointerUnion | |
| CPostDominanceInfo | A class for computing basic postdominance information |
| CPredecessorIterator | Implement a predecessor iterator for blocks |
| CPrintIRPassOptions | |
| CPrintOpStatsOptions | |
| CProgramPoint | Program point represents a specific location in the execution of a program |
| CPropertiesSelector | Traits to detect whether an Operation defined a Properties type, otherwise it'll default to EmptyProperties |
| CPropertiesSelector< Op, std::void_t< typename Op::Properties > > | |
| CPyFileAccumulator | Accumulates into a file, either writing text (default) or binary |
| CPyPrintAccumulator | Accumulates into a python string from a method that accepts an MlirStringCallback |
| CPyShapedType | Shaped Type Interface - ShapedType |
| CPySinglePartStringAccumulator | Accumulates into a python string from a method that is expected to make one (no more, no less) call to the callback (asserts internally on violation) |
| CRaggedArray | A 2D array where each row may have different length |
| Cconst_iterator | Constant iterator over the rows |
| Citerator | Iterator over the rows |
| CRange | Represents a range (offset, size, and stride) where each element of the triple may be dynamic or static |
| Craw_indented_ostream | Raw_ostream subclass that simplifies indention a sequence of code |
| CDelimitedScope | Simple RAII struct to use to indentation around entering/exiting region |
| Craw_ostream | |
| CReductionNode | ReductionTreePass will build a reduction tree during module reduction and the ReductionNode represents the vertex of the tree |
| Citerator | |
| Citerator< SinglePath > | |
| CReductionTreePassOptions | |
| CRegion | This class contains a list of basic blocks and a link to the parent operation it is attached to |
| COpIterator | This class provides iteration over the held operations of blocks directly within a region |
| CRegionBranchPoint | This class represents a point being branched from in the methods of the RegionBranchOpInterface |
| CRegionRange | This class provides an abstraction over the different types of ranges over Regions |
| CRegionSuccessor | This class represents a successor of a region |
| CRegisteredOperationName | This is a "type erased" representation of a registered operation |
| CModel | Implementation of the InterfaceConcept for operation APIs that forwarded to a concrete op implementation |
| CReproducerStream | Streams on which to output crash reproducer |
| CResourceBlobManagerDialectInterface | This class implements a dialect interface that provides common functionality for interacting with a resource blob manager |
| CResourceBlobManagerDialectInterfaceBase | This class provides a base class for dialects implementing the resource blob interface |
| CResultElementTypeIterator | |
| CResultRange | This class implements the result iterators for the Operation class |
| CUseIterator | This class implements a use iterator for a range of operation results |
| CReverseDominanceIterator | This iterator enumerates elements according to their reverse dominance relationship |
| CReverseIterator | This iterator enumerates elements in "reverse" order |
| CRewritePattern | RewritePattern is the common base class for all DAG to DAG replacements |
| CRewritePatternSet | |
| CRewriterBase | This class coordinates the application of a rewrite on a set of IR, providing a way for clients to track mutations and create new operations |
| CForwardingListener | A listener that forwards all notifications to another listener |
| CListener | |
| CPatternLoggingListener | A listener that logs notification events to llvm::dbgs() before forwarding to the base listener |
| CSaturatedInteger | Idiomatic saturated operations on values like offsets, sizes, and strides |
| CSaveStateStack | RAII object calling stackPush/stackPop on construction/destruction |
| CScalableVectorType | A vector type containing at least one scalable dimension |
| CScalarizeVectorOpLowering | Unrolls SourceOp to array/vector elements |
| CSCFForLoopPeelingOptions | |
| CSCFParallelLoopTilingOptions | |
| CSCFToControlFlowPassOptions | |
| CScfToSPIRVContext | |
| CScfToSPIRVContextImpl | |
| CScopedDiagnosticHandler | This diagnostic handler is a simple RAII class that registers and erases a diagnostic handler on a given context |
| CSelfOwningTypeID | Defines a TypeID for each instance of this class by using a pointer to the instance |
| CSetLLVMModuleDataLayoutPassOptions | |
| CShapeAdaptor | Adaptor class to abstract the differences between whether value is from a ShapedType or ShapedTypeComponents or DenseIntElementsAttribute |
| CShapedTypeComponents | ShapedTypeComponents that represents the components of a ShapedType |
| CSimpleAffineExprFlattener | |
| CSimpleObjectCache | A simple object cache following Lang's LLJITWithObjectCache example |
| CSliceable | A CRTP base class for pseudo-containers willing to support Python-type slicing access on top of indexed access |
| CSliceBoundsVerificationResult | Result for slice bounds verification; |
| CSliceOptions | |
| CSmallPtrSet | |
| CSmallPtrSetImpl | |
| CSmallString | |
| CSmallVector | |
| CSmallVectorImpl | |
| CSourceMgrDiagnosticHandler | This class is a utility diagnostic handler for use with llvm::SourceMgr |
| CSourceMgrDiagnosticVerifierHandler | This class is a utility diagnostic handler for use with llvm::SourceMgr that verifies that emitted diagnostics match 'expected-*' lines on the corresponding line of the source file |
| CSparseAssemblerOptions | |
| CSparseBufferRewriteOptions | |
| CSparseGPUCodegenOptions | |
| CSparseIterationTypeConverter | Type converter for iter_space and iterator |
| CSparseReinterpretMapOptions | |
| CSparseTensorCodegenOptions | |
| CSparseTensorTypeToBufferConverter | Sparse tensor type converter into an actual buffer |
| CSparseTensorTypeToPtrConverter | Sparse tensor type converter into an opaque pointer |
| CSparseVectorizationOptions | |
| CSparsificationAndBufferizationOptions | |
| CSparsificationOptions | Options for the Sparsification pass |
| CSparsificationPassOptions | |
| CSPIRVConversionOptions | |
| CSPIRVConversionTarget | |
| CSPIRVToLLVMConversion | |
| CSPIRVTypeConverter | Type conversion from builtin types to SPIR-V types for shader interface |
| CSplatElementsAttr | An attribute that represents a reference to a splat vector or tensor constant, meaning all of the elements have the same value |
| CSROAStatistics | Statistics collected while applying SROA |
| CStateStack | |
| CStateStackFrame | Common CRTP base class for StateStack frames |
| CStateStackFrameBase | Concrete CRTP base class for StateStack frames |
| CStaticTileOffsetRange | A range-style iterator that allows for iterating over the offsets of all potential tiles of size tileShape within the larger shape shape, using an ordering specified by loopOrder |
| CStorageSpecifierToLLVMTypeConverter | |
| CStorageUniquer | A utility class to get or create instances of "storage classes" |
| CBaseStorage | This class acts as the base storage that all storage classes must derived from |
| CStorageAllocator | This is a utility allocator used to allocate memory for instances of derived types |
| CStridedMetadataRange | A class that represents the strided metadata range information, including offsets, sizes, and strides as integer ranges |
| CStructBuilder | Helper class to produce LLVM dialect operations extracting or inserting values to a struct |
| CStructuredGenerator | Helper StructuredGenerator class to manipulate and rewrite ops with StructuredOpInterface |
| CIteratorType | |
| CPar | |
| CRed | |
| CSuccessorOperands | This class models how operands are forwarded to block arguments in control flow |
| CSuccessorRange | This class implements the successor iterators for Block |
| CSymbolCache | Default symbol cache implementation; stores associations between names (StringAttr's) to mlir::Operation's |
| CSymbolCacheBase | Base symbol cache class to allow for cache lookup through a pointer to some abstract cache |
| CCacheIteratorImpl | |
| CIterator | |
| CSymbolPrivatizeOptions | |
| CSymbolTable | This class allows for representing and managing the symbol table used by operations with the 'SymbolTable' trait |
| CSymbolUse | This class represents a specific symbol use |
| CUseRange | This class implements a range of SymbolRef uses |
| CSymbolTableAnalysis | This is a simple analysis that contains a symbol table collection and, for simplicity, a reference to the top-level symbol table |
| CSymbolTableCollection | This class represents a collection of SymbolTables |
| CSymbolUserMap | This class represents a map of symbols to users, and provides efficient implementations of symbol queries related to users; such as collecting the users of a symbol, replacing all uses, etc |
| CTensorType | Tensor types represent multi-dimensional arrays, and have two variants: RankedTensorType and UnrankedTensorType |
| CTester | This class is used to keep track of the testing environment of the tool |
| CTestSCFParallelLoopCollapsingOptions | |
| CThreadLocalCache | This class provides support for defining a thread local object with non static storage duration |
| CTilingResult | Container for result values of tiling |
| CTimer | A handle for a timer in a TimingManager |
| CTimeRecord | Simple record class to record timing information |
| CTimingIdentifier | This class represesents a uniqued string owned by a TimingManager |
| CTimingManager | This class represents facilities to measure execution time |
| CTimingScope | An RAII-style wrapper around a timer that ensures the timer is properly started and stopped |
| CTinyPtrVector | |
| CToken | This represents a token in the MLIR syntax |
| CTosaToArithPassOptions | |
| CTosaToLinalgNamedOptions | |
| CTosaToLinalgOptions | |
| CTranslateFromMLIRRegistration | |
| CTranslateRegistration | |
| CTranslateToMLIRRegistration | Use Translate[ToMLIR|FromMLIR]Registration as an initializer that registers a function and associates it with name |
| CTranslation | This class contains all of the components necessary for performing a translation |
| CTranslationParser | A command line parser for translation functions |
| CType | Instances of the Type class are uniqued, have an immutable identifier and an optional mutable component |
| CTypeID | This class provides an efficient unique identifier for a specific C++ type |
| CTypeIDAllocator | This class provides a way to define new TypeIDs at runtime |
| CTypeInterface | This class represents the base of a type interface |
| CTypeRange | This class provides an abstraction over the various different ranges of value types |
| CTypeRangeRange | This class provides an abstraction for a range of TypeRange |
| CTypeStorage | Base storage class appearing in a Type |
| CUBToLLVMConversionPassOptions | |
| CUnmanagedAsmResourceBlob | This class provides a simple utility wrapper for creating "unmanaged" AsmResourceBlobs |
| CUnrankedMemRefDescriptor | |
| CUnrolledLoopInfo | |
| CValue | This class represents an instance of an SSA value in the MLIR system, representing a computable value that has a type and a set of users |
| CValueBoundsConstraintSet | A helper class to be used with ValueBoundsOpInterface |
| CBoundBuilder | Helper class that builds a bound for a shaped value dimension or index-typed value |
| CVariable | A variable that can be added to the constraint set as a "column" |
| CValueRange | This class provides an abstraction over the different types of ranges over Values |
| CValueSemantics | Type trait indicating that the type has value semantics |
| CValueShapeRange | Range of values and shapes (corresponding effectively to Shapes dialect's ValueShape type concept) |
| CValueTypeIterator | This class implements iteration on the types of a given range of values |
| CValueTypeRange | This class implements iteration on the types of a given range of values |
| CValueUseIterator | An iterator class that allows for iterating over the uses of an IR operand type |
| CValueUserIterator | An iterator over the users of an IRObject |
| CVectorConvertToLLVMPattern | Basic lowering implementation to rewrite Ops with just one result to the LLVM Dialect |
| CVectorTransferToSCFOptions | When lowering an N-d vector transfer op to an (N-1)-d vector transfer op, a temporary buffer is created through which individual (N-1)-d vector are staged |
| CViewOpGraphOptions | |
| CVulkanLayoutUtils | According to the Vulkan spec "15.6.4. Offset and Stride Assignment": "There are different alignment requirements depending on the specific resources and on the features enabled on the device |
| CWalkContinuation | A class to signal how to proceed with the walk of the backward slice: |
| CWalkResult | A utility result that is used to signal how to proceed with an ongoing walk: |
| CWalkStage | A utility class to encode the current walk stage for "generic" walkers |
| CWasmBinaryEncoding | |
| CExport | Byte encodings describing Wasm exports |
| CGlobalMutability | Byte encodings describing the mutability of globals |
| CImport | Byte encodings of Wasm imports |
| CLimitHeader | Byte encodings for Wasm limits |
| COpCode | Byte encodings for Wasm instructions |
| CType | Byte encodings of types in Wasm binaries |
| Nnanobind | |
| Ndetail | |
| CMlirDefaultingCaster | |
| Ctype_caster< mlir::python::DefaultingPyLocation > | |
| Ctype_caster< mlir::python::DefaultingPyMlirContext > | |
| Ctype_caster< MlirAffineMap > | Casts object <-> MlirAffineMap |
| Ctype_caster< MlirAttribute > | Casts object <-> MlirAttribute |
| Ctype_caster< MlirBlock > | Casts object -> MlirBlock |
| Ctype_caster< MlirContext > | Casts object -> MlirContext |
| Ctype_caster< MlirDialectRegistry > | Casts object <-> MlirDialectRegistry |
| Ctype_caster< MlirFrozenRewritePatternSet > | Casts object <-> MlirFrozenRewritePatternSet |
| Ctype_caster< MlirLocation > | Casts object <-> MlirLocation |
| Ctype_caster< MlirModule > | Casts object <-> MlirModule |
| Ctype_caster< MlirOperation > | Casts object <-> MlirOperation |
| Ctype_caster< MlirPassManager > | Casts object -> MlirPassManager |
| Ctype_caster< MlirStringRef > | Casts MlirStringRef -> object |
| Ctype_caster< MlirType > | Casts object <-> MlirType |
| Ctype_caster< MlirTypeID > | Casts object <-> MlirTypeID |
| Ctype_caster< MlirValue > | Casts object <-> MlirValue |
| Npybind11 | |
| Ndetail | |
| Ctype_caster< MlirAffineMap > | Casts object <-> MlirAffineMap |
| Ctype_caster< MlirAttribute > | Casts object <-> MlirAttribute |
| Ctype_caster< MlirBlock > | Casts object -> MlirBlock |
| Ctype_caster< MlirContext > | Casts object -> MlirContext |
| Ctype_caster< MlirDialectRegistry > | Casts object <-> MlirDialectRegistry |
| Ctype_caster< MlirFrozenRewritePatternSet > | Casts object <-> MlirFrozenRewritePatternSet |
| Ctype_caster< MlirLocation > | Casts object <-> MlirLocation |
| Ctype_caster< MlirModule > | Casts object <-> MlirModule |
| Ctype_caster< MlirOperation > | Casts object <-> MlirOperation |
| Ctype_caster< MlirPassManager > | Casts object -> MlirPassManager |
| Ctype_caster< MlirType > | Casts object <-> MlirType |
| Ctype_caster< MlirTypeID > | Casts object <-> MlirTypeID |
| Ctype_caster< MlirValue > | Casts object <-> MlirValue |
| Nstd | |
| Citerator_traits< nanobind::detail::fast_iterator > | |
| CAllocaScopeHoister | Move allocations into an allocation scope, if it is legal to move them (e.g |
| CAllocaScopeInliner | Inline an AllocaScopeOp if either the direct parent is an allocation scope or it contains no allocation |
| CAmdgpuMaskedloadToLoadPass | |
| CAncestorKey | Stores the "key" associated with an ancestor |
| CApplyConversionAction | This is the type of Action that is dispatched when a conversion is applied |
| CAssertOpLowering | |
| CBaseTrait | |
| Cbasic_parser | |
| CBatchMatmulOp | |
| Cbf16 | |
| CBinaryArithOpToAPFloatConversion | Rewrite a binary arithmetic operation to an APFloat function call |
| CBreakDownVectorReduction | Example: |
| CBufferizationOptions | |
| CCanonicalizeAffineMinMaxOpExprAndTermOrder | Canonicalize the affine map result expression order of an affine min/max operation |
| CCanonicalizeContractAdd | Return a fused vector::ContractionOp which represents a patterns such as: |
| CCanonicalizeContractMatmulToMMT | Canonicalization of a vector.contraction a, b, c with row-major matmul semantics to a contraction suitable for MMT (matrix matrix multiplication with the RHS transposed) lowering |
| CCanonicalizeSingleResultAffineMinMaxOp | |
| CCastInfo | |
| CChainedReduction | Pattern to fold chained reduction to a series of vector additions and a final reduction. This form should require fewer subgroup operations |
| CClampClampOptimization | |
| CClampRange | |
| CClampFOpConversion | |
| CClampIsNoOp | |
| CCmpFIntToFPConst | |
| CCmpFOpToAPFloatConversion | |
| CCollapseShapeOpMemRefCastFolder | |
| CCommutativeOperand | Stores a commutative operand along with its BFS traversal information |
| CConcatOptimization | |
| CConcatSliceOptimization | |
| CConsolidateTransposeOptimization | |
| CConstStrippingForwardingCast | |
| CContractOpToElementwise | Lower vector.contract with all size one reduction dimensions to elementwise ops when possible |
| CConversionPattern | |
| CConversionTarget | |
| CConvert1DExtractStridedSliceIntoExtractInsertChain | For a 1-D ExtractStridedSlice, breaks it down into a chain of Extract ops to extract each element from the source, and then a chain of Insert ops to insert to the target vector |
| CConvert1DExtractStridedSliceIntoShuffle | RewritePattern for ExtractStridedSliceOp where source and destination vectors are 1-D |
| CConvertAccessChain | |
| CConvertAddressOf | |
| CConvertAliasResource | |
| CConvertLoad | |
| CConvertMathToROCDLPass | |
| CConvertNativeFuncPattern | Convert math ops marked with fast (afn) to native OpenCL intrinsics |
| CConvertSameRankInsertStridedSliceIntoShuffle | RewritePattern for InsertStridedSliceOp where source and destination vectors have the same rank |
| CConvertStore | |
| CConvertVariable | |
| CCopyBuilder | Helper to create the tma operations corresponding to linalg::CopyOp |
| CDecomposeDifferentRankInsertStridedSlice | RewritePattern for InsertStridedSliceOp where source and destination vectors have different ranks |
| CDecomposeNDExtractStridedSlice | RewritePattern for ExtractStridedSliceOp where the source vector is n-D |
| CDeduplicateAffineMinMaxExpressions | Remove duplicated expressions in affine min/max ops |
| CDefaultDoCastIfPossible | |
| CDenseIntOrFPElementsAttr | |
| CDerivedTy | |
| CDescriptorSetInfo | Struct containing information regarding a descriptor set |
| CDropInnerMostUnitDimsTransferRead | Drop inner most contiguous unit dimensions from transfer_read operand |
| CDropInnerMostUnitDimsTransferWrite | Drop inner most contiguous unit dimensions from transfer_write operand. E.g., vector.transfer_write arg1, arg0[c0, arg2, c0, c0, c0] {in_bounds = [true, true, true, true, true]} : vector<1x16x16x1x1xf32>, memref<1x512x16x1x1xf32> |
| CDropUnitDimFromElementwiseOps | For vectors with at least one unit dim, replaces: elementwise(a, b) with: sc_a = shape_cast(a) sc_b = shape_cast(b) res = elementwise(sc_a, sc_b) return shape_cast(res) The newly inserted shape_cast Ops fold (before elementwise Op) and then restore (after elementwise Op) the unit dim. Vectors a and b are required to be rank > 1 |
| CDropUnitDimsFromScfForOp | A pattern to drop unit dims from the iter_args of an scf.for |
| CDropUnitDimsFromTransposeOp | A pattern to drop unit dims from vector.transpose |
| CDynamicEventPool | |
| CDynamicMemRefIterator | Iterate over all elements in a dynamic memref |
| CDynamicMemRefType | |
| CExecuteRegionForwardingEliminator | |
| CExpected | |
| Cf16 | |
| CFileLineColRange | |
| CFoldAddIntoDest | Replace a linalg.add with one operand the single user of a contraction, which has a zero-filled, "identity-mapped" destination and is dominated by the other operand, by the contraction with other as its dest |
| CFoldArithExtIntoContractionOp | Pattern to fold arithmetic extensions on floating point data types into vector contraction operations. linalg.matmul introduces arithmetic extensions on its operands. Please mlir snippets below for more details |
| CFoldBroadcasts | Fold back-to-back broadcasts together |
| CFoldConstantCase | |
| CFoldConvertLayoutOp | |
| CFoldLaunchArguments | Simplify the gpu.launch when the range of a thread or block ID is trivially known to be one |
| CFoldTensorCastProducerOp | Folds a tensor.cast op into a consuming DestinationStyleOpInterface op if the tensor.cast has source that is more static than the consuming op |
| CFoldTransposeWithTranspose | Fold transpose with transpose |
| CForallRewriteResult | Struct to return the result of the rewrite of a forall operation |
| CFpToFpConversion | |
| CFpToIntConversion | |
| CFromElementsToShapeCast | Rewrite from_elements on multiple scalar extracts as a shape_cast on a single extract |
| CFusedLoc | |
| CGenericOptionValue | |
| CGPUAllReduceConversion | Pattern to convert a gpu.all_reduce op into a SPIR-V group op |
| CGPUSubgroupReduceConversion | Pattern to convert a gpu.subgroup_reduce op into a SPIR-V group op |
| CHasAffineDimExprVisitor | Visitor to check if any of the given set of positions from AffineDimExprs are used within an AffineExpr |
| CHopperBuilder | Helper to create the base Hopper-specific operations that are reused in various other places |
| CIAddCarryFold | |
| Cilist_alloc_traits | |
| CIndexSwitchOpLowering | |
| CInputAndOutputIndices | |
| CInsertSliceOfInsertSliceFolder | |
| CIntToFpConversion | |
| Cj | Eliminates variable at the specified position using Fourier-Motzkin variable elimination |
| CL0RTContextWrapper | |
| CMatmulOp | |
| CMaxPool2dIsNoOp | |
| CMemoryRequirements | |
| CMemRefDescriptor | |
| CMergeAffineMinMaxOp | Merge an affine min/max op to its consumers if its consumer is also an affine min/max op |
| CMergeArithBitcast | |
| CMergeComplexBitcast | |
| CMLIRConvertBytecodeParams | This class represents the parameters used when converting between MLIR's bytecode and textual format |
| CMLIRConvertBytecodeResult | This class represents the result of converting between MLIR's bytecode and textual format |
| CMlirDiagnostic | An opaque reference to a diagnostic, always owned by the diagnostics engine (context) |
| CMlirDialectHandle | |
| CMlirDialectRegistrationHooks | Structure of dialect registration hooks |
| CMlirLinalgContractionDimensions | |
| CMlirLinalgConvolutionDimensions | |
| CMlirLogicalResult | A logical result value, essentially a boolean with named states |
| CMlirNamedAttribute | Named MLIR attribute |
| CMlirRewritePatternCallbacks | RewritePattern API |
| CMlirStringRef | A pointer to a sized fragment of a string, not necessarily null-terminated |
| CMlirTypeFromLLVMIRTranslator | |
| CMlirTypeToLLVMIRTranslator | |
| CMmaSyncBuilder | Helper struct to provide a simple mapping from matmul operations to the corresponding mma.sync operation |
| CMulExtendedFold | |
| CMultiBlockExecuteInliner | |
| CNegFOpToAPFloatConversion | |
| CNodeAccess | |
| CNullableValueCastFailed | |
| CNumWorkGroups | Struct containing the number of local workgroups to dispatch for each dimension |
| COpComplianceInfo | |
| COptionValueBase | |
| COuterProductOpLowering | Progressive lowering of OuterProductOp |
| CPadSliceOptimization | |
| CPassPipelineOptions | |
| CPrivateVarsInfo | A util to collect info needed to convert delayed privatizers from MLIR to LLVM |
| CProfileInfoDepot | |
| CPyAttrBuilderMap | |
| CPyGlobalDebugFlag | Wrapper for the global LLVM debugging flag |
| CPyOpResult | Python wrapper for MlirOpResult |
| CPyOpResultList | A list of operation results |
| Craw_ostream | |
| CReduceRedundantZero | Pattern to eliminate redundant zero-constants added to reduction operands. It's enough for there to be one initial zero value, so we can eliminate the extra ones that feed into vector.reduction <add>. These get created by the ChainedReduction pattern |
| CReifyCollapseShapeOp | |
| CRemoveUnusedLvlCrds | |
| CRowColIndexing | Helper struct to encode a pair of row/column indexings in the form of affine expressions |
| CScopedContext | |
| CSelectToExtUI | |
| CShapeDimension | Implements a simple high-level fusion pass on linalg structured operations |
| CShardingPropagation | |
| CSimplifyAffineMinMaxPass | Creates a simplification pass for affine min/max/apply |
| CSincosOpLowering | |
| CSingleBlockExecuteInliner | |
| CSinkVectorProducerOps | Sink vector producers forward to reduce live ranges |
| CSliceCanonicalizer | A canonicalizer wrapper to replace ExtractSliceOps |
| CSliceDynamicSizeCanonicalization | |
| CSliceReturnTypeCanonicalizer | Return the canonical type of the result of an extract_slice op |
| CSmallDenseMap | |
| CSmallPtrSetImpl | |
| CSmallVector | |
| Csme_state | |
| CSortCommutativeOperands | Sorts the operands of op in ascending order of the "key" associated with each operand iff op is commutative |
| CSpecifierGetterSetterOpConverter | |
| CStorageSpecifierGetOpConverter | |
| CStorageSpecifierInitOpConverter | |
| CStorageSpecifierSetOpConverter | |
| CStreamWrapper | |
| CStridedMemrefIterator | Iterate over all elements in a strided memref |
| CStridedMemrefIterator< T, 0 > | Iterate over all elements in a 0-ranked strided memref |
| CStridedMemRefType | StridedMemRef descriptor type with static rank |
| CStridedMemRefType< T, 0 > | StridedMemRef descriptor type specialized for rank 0 |
| CStridedMemRefType< T, 1 > | StridedMemRef descriptor type specialized for rank 1 |
| CStrideInfo | |
| CSubViewCanonicalizer | A canonicalizer wrapper to replace SubViewOps |
| CSubViewReturnTypeCanonicalizer | Return the canonical type of the result of a subview |
| CSwapExtractSliceOfFill | Swaps: tensor.extract_slice(linalg.fill(cst, init)) with: linalg.fill(cst, tensor.extract_slice(init)) |
| CSwapTransposeWithBroadcast | This pattern canonicalize transpose by swapping the order of broadcast and transpose: transpose(broadcast(input)) -> broadcast(transpose(input)) |
| CTargetToDataLayoutPass | |
| CTargetToTargetFeaturesPass | |
| CToElementsOfBroadcast | Canonicalize vector.to_elements(vector.broadcast(v)) where v is a vector |
| CTosaProfileCompliance | |
| CTranslationOptions | |
| CTransposeIsReshape | |
| CTransposeOpLowering | Rewrite AVX2-specific vector.transpose, for the supported cases and depending on the TransposeLoweringOptions |
| CTuneExtension | |
| CTypeConverter | |
| CTypeInfo | |
| CUModSimplification | |
| CUMulExtendedOpXOne | |
| CUnitExtentReplacementInfo | Compute the modified metadata for an operands of operation whose unit dims are being dropped |
| CUnrankedMemRefType | |
| CValueEquivalenceCache | |
| CValueFromPointerCast | |
| CVector | |
| CVector< T, Dim > | |
| CVectorizationHookResult | VectorizationHookResult contains the vectorized op returned from a CustomVectorizationHook |
| CVectorizationState | Contains the vectorization state and related methods used across the vectorization process of a given operation |
| CVectorShape | |
| CVulkanDeviceMemoryBuffer | Struct containing information regarding to a device memory buffer |
| CVulkanHostMemoryBuffer | Struct containing information regarding to a host memory buffer |
| CVulkanRuntime | Vulkan runtime |
| CWhileLowering | |
| CWrapFuncInClass | |
| CYieldOpLowering | |
| CZeCommandListDeleter | |
| CZeContextDeleter | |
| CZeEventDeleter | |
| CZeEventPoolDeleter | |