| ►Nimpl | |
| CStaticSizeMult | |
| CStaticSizeMult< N, Dims... > | |
| CVectorDataPrinter | |
| CMemRefDataPrinter | |
| CMemRefDataVerifier | Verify the result of two computations are equivalent up to a small numerical error and return the number of errors |
| ►Nllvm | The OpAsmOpInterface, see OpAsmInterface.td for more details |
| ►Ncl | |
| ►Ndetail | |
| CVectorParserBase | |
| Cparser< std::vector< T > > | |
| Cparser< SmallVector< T, N > > | |
| COptionValue< mlir::OpPassManager > | |
| ►Cparser< mlir::OpPassManager > | |
| CParsedPassManager | A utility struct used when parsing a pass manager that prevents the need for a default constructor on OpPassManager |
| COptionValue< PassArgData > | Define a valid OptionValue for the command line pass argument |
| ►Ndetail | |
| CDenseMapPair | |
| ►Nilist_detail | |
| CSpecificNodeAccess< typename compute_node_options<::mlir::Operation >::type > | |
| Norc | |
| ►Nsys | |
| CSmartMutex | |
| ►Nyaml | |
| CMappingTraits< YamlFileInfo > | |
| CGraphTraits< const mlir::CallGraphNode * > | |
| CGraphTraits< const mlir::CallGraph * > | |
| CDenseMapInfo< mlir::ProgramPoint > | Allow hashing of lattice anchors and program points |
| CDenseMapInfo< mlir::LatticeAnchor > | |
| CCastInfo< To, mlir::LatticeAnchor > | |
| CCastInfo< To, const mlir::LatticeAnchor > | |
| CPointerLikeTypeTraits< mlir::async::FuncOp > | Allow stealing the low bits of async::FuncOp |
| CPointerLikeTypeTraits< mlir::func::FuncOp > | Allow stealing the low bits of FuncOp |
| CCastInfo< To, mlir::LLVM::GEPArg > | |
| CCastInfo< To, const mlir::LLVM::GEPArg > | |
| CPointerLikeTypeTraits< mlir::spirv::FuncOp > | Allow stealing the low bits of spirv::Function ops |
| CExpected | |
| CCastInfo< To, mlir::CallInterfaceCallable > | |
| CCastInfo< To, const mlir::CallInterfaceCallable > | |
| CDenseMapInfo< mlir::AffineExpr > | |
| 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 |
| CDenseMapInfo< mlir::AffineMap > | |
| CDenseMapInfo< mlir::Attribute > | |
| CDenseMapInfo< T, std::enable_if_t< std::is_base_of< mlir::Attribute, T >::value &&!mlir::detail::IsInterface< T >::value > > | |
| CPointerLikeTypeTraits< mlir::Attribute > | Allow LLVM to steal the low bits of Attributes |
| CDenseMapInfo< mlir::NamedAttribute > | |
| 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 |
| CDenseMapInfo< mlir::Block::iterator > | |
| CDenseMapInfo< mlir::SuccessorRange > | Provide support for hashing successor ranges |
| Cilist_traits<::mlir::Operation > | |
| Cilist_traits<::mlir::Block > | |
| CDenseMapInfo< mlir::StringAttr > | |
| CPointerLikeTypeTraits< mlir::StringAttr > | |
| CPointerLikeTypeTraits< mlir::IntegerAttr > | |
| CPointerLikeTypeTraits< mlir::SymbolRefAttr > | |
| CPointerLikeTypeTraits< mlir::ModuleOp > | Allow stealing the low bits of ModuleOp |
| 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 > > | |
| Ccast_retty_impl< T, ::mlir::Dialect * > | |
| Ccast_retty_impl< T, ::mlir::Dialect > | |
| Ccast_convert_val< T, ::mlir::Dialect, ::mlir::Dialect > | |
| Ccast_convert_val< T, ::mlir::Dialect *, ::mlir::Dialect * > | |
| CGraphTraits< mlir::DominanceInfoNode * > | DominatorTree GraphTraits specialization so the DominatorTree can be iterated by generic graph iterators |
| CGraphTraits< const mlir::DominanceInfoNode * > | |
| Cisa_impl< mlir::ExtensibleDialect, mlir::Dialect > | Provide isa functionality for ExtensibleDialect |
| Cisa_impl< mlir::DynamicDialect, mlir::Dialect > | Provide isa functionality for DynamicDialect |
| CDenseMapInfo< mlir::IntegerSet > | |
| CDenseMapInfo< mlir::Location > | |
| CPointerLikeTypeTraits< mlir::Location > | We align LocationStorage by 8, so allow LLVM to steal the low bits |
| CValueIsPresent< mlir::Location > | The constructors in mlir::Location ensure that the class is a non-nullable wrapper around mlir::LocationAttr |
| 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, mlir::OpFoldResult > | |
| CCastInfo< To, const mlir::OpFoldResult > | |
| CDenseMapInfo< T, std::enable_if_t< std::is_base_of< mlir::OpState, T >::value &&!mlir::detail::IsInterface< T >::value > > | |
| CCastInfo< T, ::mlir::Operation * > | Cast from an (const) Operation * to a derived operation type |
| CCastInfo< T, const ::mlir::Operation * > | |
| CCastInfo< T, ::mlir::Operation > | Cast from an (const) Operation & to a derived operation type |
| CCastInfo< T, const ::mlir::Operation > | |
| CCastInfo<::mlir::Operation *, ::mlir::Operation * > | Cast (const) Operation * to itself |
| CCastInfo< const ::mlir::Operation *, const ::mlir::Operation * > | |
| CDenseMapInfo< mlir::OperationName > | |
| CDenseMapInfo< mlir::RegisteredOperationName > | |
| CPointerLikeTypeTraits< mlir::OperationName > | |
| CPointerLikeTypeTraits< mlir::RegisteredOperationName > | |
| CDenseMapInfo< mlir::AsmDialectResourceHandle > | |
| CGraphTraits< mlir::Block * > | |
| CGraphTraits< Inverse< mlir::Block * > > | |
| CGraphTraits< const mlir::Block * > | |
| CGraphTraits< Inverse< const mlir::Block * > > | |
| CGraphTraits< mlir::Region * > | |
| CGraphTraits< Inverse< mlir::Region * > > | |
| CDenseMapInfo< mlir::TypeRange > | |
| CDenseMapInfo< mlir::Type > | |
| CDenseMapInfo< T, std::enable_if_t< std::is_base_of< mlir::Type, T >::value &&!mlir::detail::IsInterface< T >::value > > | |
| CPointerLikeTypeTraits< mlir::Type > | We align TypeStorage by 8, so allow LLVM to steal the low bits |
| 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, mlir::IRUnit > | |
| CCastInfo< To, const mlir::IRUnit > | |
| CDenseMapInfo< mlir::Value > | |
| CDenseMapInfo< mlir::BlockArgument > | |
| CDenseMapInfo< mlir::OpResult > | |
| CDenseMapInfo< mlir::detail::TypedValue< T > > | |
| CPointerLikeTypeTraits< mlir::Value > | Allow stealing the low bits of a value |
| CPointerLikeTypeTraits< mlir::BlockArgument > | |
| CPointerLikeTypeTraits< mlir::OpResult > | |
| CPointerLikeTypeTraits< mlir::detail::TypedValue< T > > | |
| 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 |
| CDenseMapInfo< mlir::PassInstrumentation::PipelineParentInfo > | |
| CDenseMapInfo< T, std::enable_if_t< mlir::detail::IsInterface< T >::value > > | |
| CSmallString | |
| CArrayRef | |
| CDenseMap | |
| CDenseMapInfo | |
| CDenseSet | |
| CMutableArrayRef | |
| CPointerUnion | |
| CSetVector | |
| CSmallPtrSet | |
| CSmallPtrSetImpl | |
| CSmallVector | |
| CSmallVectorImpl | |
| CStringSet | |
| CStringSwitch | |
| CTinyPtrVector | |
| CTypeSwitch | |
| Cfunction_ref | |
| Citerator_range | |
| CDenseMapInfo< mlir::TypeID > | |
| CPointerLikeTypeTraits< mlir::TypeID > | We align TypeID::Storage by 8, so allow LLVM to steal the low bits |
| CDenseMapInfo< mlir::tblgen::Constraint > | Unique constraints by their predicate and summary |
| CDenseMapInfo< mlir::tblgen::DagNode > | |
| CDenseMapInfo< mlir::tblgen::DagLeaf > | |
| Cisa_impl< T, ::mlir::LLVM::ModuleTranslation::StackFrame > | |
| Cformat_provider< mlir::lsp::Position > | |
| CDenseMapInfo< mlir::pdll::ast::Type > | |
| 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 |
| CDenseMapInfo< MlirTypeID > | |
| Nlowering_1_d | |
| Nlowering_n_d | |
| Nlowering_n_d_unrolled | |
| ►Nmlir | Include the generated interface declarations |
| ►Nacc | |
| CRuntimeCounters | |
| CConstructResource | |
| CCurrentDeviceIdResource | |
| ►Naffine | |
| Nmatcher | |
| CLoopReduction | A description of a (parallelizable) reduction in an affine loop |
| CMemRefAccess | Encapsulates a memref load or store access information |
| CDependenceComponent | |
| CDependenceResult | Checks whether two accesses to the same memref access the same element |
| CFlatAffineValueConstraints | FlatAffineValueConstraints is an extension of FlatLinearValueConstraints with helper functions for Affine dialect ops |
| CFlatAffineRelation | A FlatAffineRelation represents a set of ordered pairs (domain -> range) where "domain" and "range" are tuples of variables |
| CNestedMatch | An NestedPattern captures nested patterns in the IR |
| CNestedPattern | |
| CNestedPatternContext | RAII structure to transparently manage the bump allocator for NestedPattern and NestedMatch classes |
| CLoopNestStateCollector | |
| ►CMemRefDependenceGraph | |
| CEdge | |
| CNode | |
| CSliceComputationResult | Enumerates different result statuses of slice computation by computeSliceUnion |
| 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) |
| 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 |
| 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]' |
| CAffineBound | AffineBound represents a lower or upper bound in the for operation |
| CAffineValueMap | An AffineValueMap is an affine map plus its ML value operands and results for analysis purposes |
| CFusionResult | |
| CFusionStrategy | Describes the fusion strategy to be used in the Affine loop fusion utilities |
| CLoopNestStats | LoopNestStats aggregates various per-loop statistics (eg |
| CAffineCopyOptions | Explicit copy / DMA generation options for mlir::affineDataCopyGenerate |
| CCopyGenerateResult | Result for calling generateCopyForMemRegion |
| CVectorizationStrategy | Holds parameters to perform n-D vectorization on a single loop nest |
| CDivModValue | Holds the result of (div a, b) and (mod a, b) |
| CAffineValueExpr | |
| CAffineBuilder | Helper struct to build simple AffineValueExprs with minimal type inference support |
| ►Namdgpu | |
| CChipset | Represents the amdgpu gfx chipset version, e.g., gfx90a, gfx942, gfx1103 |
| ►Narith | |
| CAttrConvertFastMathToLLVM | |
| CAttrConvertOverflowToLLVM | |
| CAttrConverterConstrainedFPToLLVM | |
| CConstantIntOp | Specialization of arith.constant op that returns an integer value |
| 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 |
| 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_neon | |
| ►Narm_sme | |
| Ndetail | |
| Narm_sve | |
| Nasync | |
| ►NAttributeTrait | This trait is used to determine if an attribute is a dynamic attribute or not; it should only be implemented by dynamic attributes |
| CIsLocation | This trait is used to determine if an attribute is a location or not |
| CIsDynamicAttr | |
| ►Nbufferization | |
| Ndeallocation_impl | |
| Ndetail | |
| ►Nfunc_ext | |
| CFuncAnalysisState | Extra analysis state that is required for bufferization of function boundaries |
| CCallOpInterface | |
| CReturnOpInterface | |
| CFuncOpInterface | |
| CValueComparator | Compare two SSA values in a deterministic manner |
| COwnership | This class is used to track the ownership of values |
| 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 |
| CAliasingOpOperand | A maybe aliasing OpOperand |
| CAliasingValue | A maybe aliasing Value |
| CAliasList | |
| ►COpFilter | |
| CEntry | An op filter entry |
| CBufferizationOptions | Options for BufferizableOpInterface-based bufferization |
| CTraversalConfig | Traversal parameters for findValueInReverseUseDefChain |
| CAnalysisState | AnalysisState provides a variety of helper functions for dealing with tensor values |
| CDstBufferizableOpInterfaceExternalModel | Bufferizable ops that implement the DestinationStyleOpInterface can use this external model base class |
| COpWithUnstructuredControlFlowBufferizableOpInterfaceExternalModel | A template that provides a default implementation of getAliasingOpOperands for ops that support unstructured control flow within their regions |
| 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 |
| COneShotBufferizationOptions | Options for analysis-enabled bufferization |
| ►COneShotAnalysisState | State for analysis-enabled bufferization |
| CExtension | Base class for OneShotAnalysisState extensions that allow OneShotAnalysisState to contain user-specified information in the state object |
| CBufferResultsToOutParamsOpts | |
| Nbuiltin | |
| Nbuiltin_dialect_detail | |
| ►Nbytecode | |
| ►Ndetail | |
| CAttrTypeNumbering | This class represents a numbering entry for an Attribute or Type |
| CAttributeNumbering | |
| CTypeNumbering | |
| COpNameNumbering | This class represents the numbering entry of an operation name |
| CDialectResourceNumbering | This class represents a numbering entry for a dialect resource |
| CDialectNumbering | This class represents a numbering entry for an Dialect |
| COperationNumbering | This class represents the numbering entry of an operation |
| ►CIRNumberingState | This class manages numbering IR entities in preparation of bytecode emission |
| CNumberingDialectWriter | |
| NOpEncodingMask | This enum represents a mask of all of the potential components of an operation |
| NSection | |
| Ncall_interface_impl | |
| Ncf | |
| ►Ndataflow | |
| CConstantValue | This lattice value represents a known constant value of a lattice |
| CSparseConstantPropagation | This analysis implements sparse constant propagation, which attempts to determine constant-valued results for operations using constant-valued operands, by speculatively folding 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 |
| 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 |
| CCFGEdge | This lattice anchor represents a control-flow edge between a block and one of its successors |
| CDeadCodeAnalysis | Dead code analysis analyzes control-flow, as understood by RegionBranchOpInterface and BranchOpInterface, and the callgraph, as understood by CallableOpInterface and CallOpInterface |
| CAbstractDenseLattice | This class represents a dense lattice |
| CAbstractDenseForwardDataFlowAnalysis | Base class for dense forward data-flow analyses |
| 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 |
| CAbstractDenseBackwardDataFlowAnalysis | Base class for dense backward dataflow analyses |
| 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 |
| CIntegerValueRangeLattice | This lattice element represents the integer value range of an SSA value |
| 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 |
| 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" |
| CRunLivenessAnalysis | Runs liveness analysis on the IR defined by op |
| CAbstractSparseLattice | This class represents an abstract lattice |
| CLattice | This class represents a lattice holding a specific value of type ValueT |
| CAbstractSparseForwardDataFlowAnalysis | Base class for sparse forward data-flow analyses |
| CSparseForwardDataFlowAnalysis | A sparse forward data-flow analysis for propagating SSA value lattices across the IR by implementing transfer functions for operations |
| CAbstractSparseBackwardDataFlowAnalysis | Base class for sparse backward data-flow analyses |
| CSparseBackwardDataFlowAnalysis | A sparse (backward) data-flow analysis for propagating SSA value lattices backwards across the IR by implementing transfer functions for operations |
| ►Ndetail | AttrTypeReplacer |
| Nanalysis_impl | |
| Npass_options | |
| Nstorage_user_base_impl | |
| ►NStorageUserTrait | |
| CIsMutable | This trait is used to determine if a storage user, like Type, is mutable or not |
| ►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 |
| CCallbackOstream | A simple raw ostream subclass that forwards write_impl calls to the user-supplied callback together with opaque user-supplied data |
| 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 |
| CVector1D | |
| CVector1D< T, Dim, true > | |
| CVector1D< T, Dim, false > | |
| CAttributeUniquer | |
| CAttrTypeReplacerBase | This class provides a base utility for replacing attributes/types, and their sub elements |
| Cis_tuple | |
| Cis_tuple< std::tuple< Ts... > > | |
| Cis_pair | |
| Cis_pair< std::pair< Ts... > > | |
| 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 |
| 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 |
| 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 |
| Cis_complex_t | Type trait detector that checks if a given type T is a complex type |
| Cis_complex_t< std::complex< T > > | |
| CDenseArrayAttrImpl | Base class for DenseArrayAttr that is instantiated and specialized for each supported element type below |
| CDenseResourceElementsAttrBase | Base class for DenseResourceElementsAttr that is instantiated and specialized for each supported element type below |
| 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 |
| CDominanceInfoBase | |
| Cattr_value_binder | The matcher that matches a certain kind of Attribute and binds the value inside the Attribute |
| Cconstant_op_matcher | The matcher that matches operations that have the ConstantLike trait |
| CNameOpMatcher | The matcher that matches operations that have the specified op name |
| CAttrOpMatcher | The matcher that matches operations that have the specified attribute name |
| Cconstant_op_binder | The matcher that matches operations that have the ConstantLike trait, and binds the folded attribute value |
| Cinfer_int_range_op_binder | A matcher that matches operations that implement the InferIntRangeInterface interface, and binds the inferred range |
| CAttrOpBinder | The matcher that matches operations that have the specified attribute name, and binds the attribute value |
| 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_float_predicate_matcher | The matcher that matches a given target constant scalar / vector splat / tensor splat float value 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_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 |
| Cop_matcher | The matcher that matches a certain kind of op |
| CAnyValueMatcher | Terminal matcher, always returns true |
| CAnyCapturedValueMatcher | Terminal matcher, always returns true |
| CPatternMatcherValue | Binds to a specific value and matches it |
| CRecursivePatternMatcher | RecursivePatternMatcher that composes |
| 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 |
| CStorageUserTraitBase | Helper class for implementing traits for storage classes |
| CStorageUserBase | Utility class for implementing users of storage classes uniqued by a StorageUniquer |
| CTypeUniquer | A utility class to get, or create, unique instances of types within an MLIRContext |
| CIROperandBase | This class is the base for IROperand, and provides all of the non-templated facilities for operand use management |
| CValueImpl | The base class for all derived Value classes |
| CBlockArgumentImpl | The internal implementation of a BlockArgument |
| COpResultImpl | This class provides the implementation for an operation result |
| CInlineOpResult | This class provides the implementation for an operation result whose index can be represented "inline" in the underlying ValueImpl |
| COutOfLineOpResult | This class provides the implementation for an operation result whose index cannot be represented "inline", and thus requires an additional index field |
| CTypedValue | TypedValue is a Value with a statically know type |
| CPreservedAnalyses | A utility class to represent the analyses that are known to be preserved |
| CAnalysisConcept | The abstract polymorphic base class representing an analysis |
| CAnalysisModel | A derived analysis model used to hold a specific analysis object |
| CAnalysisMap | This class represents a cache of analyses for a single operation |
| CNestedAnalysisMap | An analysis map that contains a map for the current operation, and a set of maps for any child operations |
| CPassExecutionState | The state for a single execution of a pass |
| ►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 |
| ►CInterface | This class represents an abstract interface |
| CTrait | This is a special trait that registers a given interface with an object |
| 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... > | |
| CInterfaceMap | This class provides an efficient mapping between a given Interface type, and a particular implementation of its concept |
| CFallbackTypeIDResolver | This class provides a fallback for resolving TypeIDs |
| CTypeIDResolver | This class provides a resolver for getting the ID for a given class T |
| CInlineTypeIDResolver | This class provides utilities for resolving the TypeID of a class that provides a static TypeID resolveTypeID() method |
| 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 |
| CCreateAlgebraicOpForEndomorphismSimplification | |
| CAsmParserImpl | This class provides the implementation of the generic parser methods within AsmParser |
| CParser | This class implement support for parsing global entities like attributes and types |
| CSymbolState | This class contains record of any parsed top-level symbols |
| CParserState | This class refers to all of the state maintained globally by the parser, such as the current lexer position etc |
| CDataLayoutEntryAttrStorage | |
| CAffineExprStorage | Base storage class appearing in an affine expression |
| CAffineBinaryOpExprStorage | A binary operation appearing in an affine expression |
| CAffineDimExprStorage | A dimensional or symbolic identifier appearing in an affine expression |
| CAffineConstantExprStorage | An integer constant appearing in affine expression |
| CAffineMapStorage | |
| CAsmStateImpl | |
| 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 | |
| ►CDenseStringElementsAttrStorage | An attribute representing a reference to a dense vector or tensor object containing strings |
| CKeyTy | |
| CStringAttrStorage | |
| CDistinctAttrStorage | An attribute to store a distinct reference to another attribute |
| 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 |
| CDistinctAttributeAllocator | An allocator for distinct attribute storage instances |
| CDiagnosticEngineImpl | |
| CSourceMgrDiagnosticHandlerImpl | |
| CExpectedDiag | This class represents an expected output diagnostic |
| CSourceMgrDiagnosticVerifierHandlerImpl | |
| ►CParallelDiagnosticHandlerImpl | |
| CThreadDiagnostic | |
| CDynamicTypeStorage | Storage of DynamicType |
| CDynamicAttrStorage | Storage of DynamicAttr |
| CIntegerSetStorage | |
| CFileLineColRangeAttrStorage | |
| CIntegerTypeStorage | Integer Type Storage and Uniquing |
| CFunctionTypeStorage | Function Type Storage and Uniquing |
| CTupleTypeStorage | A type representing a collection of other types |
| COpPassManagerImpl | |
| CPassInstrumentorImpl | |
| CRecoveryReproducerContext | This class contains all of the context for generating a recovery reproducer |
| COpToOpPassAdaptor | An adaptor pass used to run operation passes over nested operations |
| ►CPassCrashReproducerGenerator | |
| CImpl | |
| CPassPipelineCLParserImpl | |
| CPDLByteCodeMutableState | |
| CPDLByteCodePattern | |
| ►CPDLByteCode | |
| CMatchResult | |
| CStorageUniquerImpl | This is the implementation of the StorageUniquer class |
| CTimingManagerImpl | Private implementation details of the TimingManager |
| CDefaultTimingManagerImpl | Implementation details of the DefaultTimingManager |
| ►CConversionPatternRewriterImpl | |
| CSingleEraseRewriter | A rewriter that keeps track of erased ops and blocks |
| Ndialect_extension_detail | |
| Ndlti | |
| Nemitc | |
| ►Nfunc | |
| Narith | |
| ►Nfunction_interface_impl | |
| CVariadicFlag | A named class for passing around the variadic flag |
| ►Ngpu | |
| Namd | |
| ►Nindex_lowering | |
| COpLowering | |
| COffloadingTranslationAttrTrait | This class indicates that the attribute associated with this trait is a GPU offloading translation attribute |
| CTargetOptions | This class serves as an opaque interface for passing options to the TargetAttrInterface methods |
| CKernelDim3 | Utility class for the GPU dialect to represent triples of Values accessible through .x, .y, and .z similarly to CUDA notation |
| CAsyncTokenType | |
| CMMAMatrixStorageType | MMAMatrixType storage and uniquing |
| CMMAMatrixType | MMAMatrix represents a matrix held by a subgroup for matrix-matrix multiply accumulate operations |
| CSparseDnTensorHandleType | |
| CSparseSpMatHandleType | |
| CSparseSpGEMMOpHandleType | |
| CGPUToNVVMPipelineOptions | Options for the gpu to nvvm pipeline |
| CWarpDistributionPattern | |
| Nimpl | Attribute collections provide a dictionary-like interface |
| Nindex | |
| ►Nintrange | |
| Ndetail | |
| ►Nirdl | |
| CConstraintVerifier | Provides context to the verification of constraints |
| CConstraint | Once turned into IRDL verifiers, all constraints are attribute constraints |
| CIsConstraint | A constraint that checks that an attribute is equal to a given attribute |
| 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 |
| 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 |
| CAnyOfConstraint | A constraint checking that one of the given constraints is satisfied |
| CAllOfConstraint | A constraint checking that all of the given constraints are satisfied |
| CAnyAttributeConstraint | A constraint that is always satisfied |
| CRegionConstraint | A constraint checking that a region satisfies irdl.region requirements |
| Nkhr | |
| ►Nlinalg | |
| ►Ndetail | |
| CPackingResult | Helper struct to hold the results of building a packing loop nest |
| CMultiSizeSpecificationBase | |
| CContinuousTileSizeSpecificationBase | |
| CLinalgOpToLibraryCallRewrite | |
| CContractionDimensions | Positions of a Linalg op loops that correspond to different kinds of a contraction dimension |
| CConvolutionDimensions | Positions of a Linalg op loops that correspond to different kinds of a convolution dimension |
| CBufferizeToAllocationOptions | |
| CLinalgTilingOptions | |
| CLinalgTilingAndFusionOptions | |
| CLinalgPaddingOptions | |
| CLinalgPromotionOptions | |
| CSplitReductionOptions | Split Reduction options |
| CControlDropUnitDims | Transformation to drop unit-extent dimensions from linalg.generic operations |
| CDropUnitDimsResult | |
| CElementwiseOpFusionResult | Fuse two linalg.generic operations that have a producer-consumer relationship captured through fusedOperand |
| CTiledLinalgOp | Perform standalone tiling of a single LinalgOp by tileSizes |
| CPromotionInfo | Create a new buffer using the allocationFn provided |
| 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 |
| CStaticMultiSizeSpecification | |
| CContinuousTileSizeSpecification | |
| CStaticContinuousTileSizeSpecification | |
| CForallReductionTilingResult | Transformation information returned after reduction tiling |
| CSplitReductionResult | Apply transformation to split the single linalg op reduction into a parallel and reduction dimension |
| CCollapseResult | |
| CLowerPackResult | |
| CLowerUnPackOpResult | |
| CPackResult | Struct to hold the result of a pack call |
| CPackTransposeResult | Struct to hold the result of a packTranspose call |
| CBlockPackMatmulOptions | |
| CDownscaleSizeOneWindowed2DConvolution | Rewrites 2-D convolution ops with size-1 window dimensions into 1-D convolution ops |
| CDownscaleDepthwiseConv2DNhwcHwcOp | Rewrites 2-D depthwise convolution ops with size-1 (w, kw) or (h, kh) dimensions into 1-D depthwise convolution ops |
| CDownscaleConv2DOp | |
| CLinalgGeneralizationPattern | Linalg generalization pattern |
| CLinalgSpecializationPattern | |
| CCopyVectorizationPattern | Vectorization pattern for memref::CopyOp |
| CDecomposePadOpPattern | Rewrite a tensor::PadOp into a sequence of EmptyOp, FillOp and InsertSliceOp |
| CDecomposeOuterUnitDimsPackOpPattern | Rewrites a tensor::PackOp into a sequence of: |
| CDecomposeOuterUnitDimsUnPackOpPattern | Rewrites a tensor::UnPackOp into a sequence of rank-reduced |
| CLinalgCopyVTRForwardingPattern | Match and rewrite for the pattern: |
| CLinalgCopyVTWForwardingPattern | Match and rewrite for the pattern: |
| CExtractSliceOfPadTensorSwapPattern | Rewrite extract_slice(tensor.pad(x)) into tensor.pad(extract_slice(x)) |
| CSliceParameters | A struct containg offsets-sizes-strides arguments of the tiled shape |
| CFusionInfo | A struct containing the Linalg producer before and after fusion |
| CProcInfo | Callback function type used to get processor ID, and number of processors used for distribution for all parallel loops generated |
| CLinalgLoopDistributionOptions | Options that allow distribution of loops generated in Linalg transforms to processors while generating the loops |
| CRegionMatcher | A struct containing common matchers over linalg op's region |
| CGenerateLoopNest | Utility class used to generate nested loops with ranges described by loopRanges and loop type described by the iteratorTypes |
| ►NLLVM | |
| ►Ndetail | |
| CNDVectorTypeInfo | |
| ►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 |
| CDataLayoutImporter | Helper class that translates an LLVM data layout to an MLIR data layout specification |
| CDebugImporter | |
| CDebugTranslation | |
| 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 |
| CTypeFromLLVMIRTranslatorImpl | Support for translating LLVM IR types to MLIR LLVM dialect types |
| CTypeToLLVMIRTranslatorImpl | Support for translating MLIR LLVM dialect types to LLVM IR |
| 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 |
| CDILocalScopeAttr | This class represents a LLVM attribute that describes a local debug info scope |
| 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 |
| CTBAANodeAttr | Base class for LLVM attributes participating in the TBAA graph |
| ►CGEPIndicesAdaptor | Class used for convenient access and iteration over GEP indices |
| Citerator | |
| CGEPArg | Class used for building a 'llvm.getelementptr' |
| CAssumeAlignTag | |
| CAssumeSeparateStorageTag | |
| CMergeFragments | Adjacent DW_OP_LLVM_fragment should be merged into one |
| ►CDIExpressionRewriter | Rewriter for DIExpressionAttr |
| CExprRewritePattern | |
| CModuleToObject | Utility base class for transforming operations into binary objects, by default it returns the serialized LLVM bitcode for the module |
| CModuleImport | Module import implementation class that provides methods to import globals and functions from an LLVM module into an MLIR module |
| ►CModuleTranslation | Implementation class for module translation |
| CSaveStack | RAII object calling stackPush/stackPop on construction/destruction |
| CStackFrame | Common CRTP base class for ModuleTranslation stack frames |
| CStackFrameBase | Concrete CRTP base class for ModuleTranslation stack frames |
| 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 |
| CLogger | This class represents the main interface for logging, and allows for filtering logging based on different levels of severity or significance |
| CLSPError | This class models an LSP error as an llvm::Error |
| CURIForFile | URI in "file" scheme for a file |
| CClientCapabilities | |
| CClientInfo | |
| CInitializeParams | |
| CNoParams | |
| CTextDocumentItem | |
| CTextDocumentIdentifier | |
| CVersionedTextDocumentIdentifier | |
| CPosition | |
| CRange | |
| CLocation | |
| CTextDocumentPositionParams | |
| CReferenceContext | |
| CReferenceParams | |
| CDidOpenTextDocumentParams | |
| CDidCloseTextDocumentParams | |
| CTextDocumentContentChangeEvent | |
| CDidChangeTextDocumentParams | |
| CMarkupContent | |
| CHover | |
| CDocumentSymbol | Represents programming constructs like variables, classes, interfaces etc |
| CDocumentSymbolParams | |
| CDiagnosticRelatedInformation | Represents a related message and source code location for a diagnostic |
| CDiagnostic | |
| CPublishDiagnosticsParams | |
| CTextEdit | |
| CCompletionItem | |
| CCompletionList | Represents a collection of completion items to be presented in the editor |
| CCompletionContext | |
| CCompletionParams | |
| CParameterInformation | A single parameter of a particular signature |
| CSignatureInformation | Represents the signature of something callable |
| CSignatureHelp | Represents the signature of a callable |
| CDocumentLinkParams | Parameters for the document link request |
| CDocumentLink | A range in a text document that links to an internal or external resource, like another text document or a web site |
| CInlayHintsParams | A parameter literal used in inlay hint requests |
| CInlayHint | Inlay hint information |
| CCodeActionContext | |
| CCodeActionParams | |
| CWorkspaceEdit | |
| CCodeAction | A code action represents a change that can be performed in code, e.g |
| CSourceMgrInclude | This class represents a single include within a root file |
| CJSONTransport | A transport class that performs the JSON-RPC communication with the LSP client |
| CMessageHandler | A handler used to process the incoming transport messages |
| ►CMLIRServer | This class implements all of the MLIR related functionality necessary for a language server |
| CImpl | |
| 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 |
| ►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 |
| ►CTableGenServer | This class implements all of the TableGen related functionality necessary for a language server |
| CImpl | |
| COptions | |
| Nmatchers | |
| ►Nmath | |
| CErfPolynomialApproximation | |
| ►NMemoryEffects | |
| CEffect | This class represents the base class used for memory effects |
| CAllocate | The following effect indicates that the operation allocates from some resource |
| 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 | |
| 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 |
| ►NMemRefType | |
| CBuilder | This is a builder type that keeps local references to arguments |
| ►Nmesh | |
| Ndetail | |
| CShardingOption | |
| CIndependentParallelIteratorDomainShardingInterface | |
| CElementwiseShardingInterface | |
| CMeshSharding | |
| COpRewritePatternWithSymbolTableCollection | |
| Nml_program | |
| ►Nnvgpu | |
| CWarpMatrixInfo | Collects information about a warp-level matrix operand represented by a VectorType |
| CFragmentElementInfo | Specifies information about the registers which compose a matrix fragment according to the PTX documentation |
| CLdMatrixParams | Encapsulates the parameters needed to lower a nvgpu.ldmatrix operation to nvvm.ldmatrix |
| ►NNVVM | |
| CPtxBuilder | A class to build PTX assembly automatically |
| CSerializeGPUModuleBase | Base class for all NVVM serializations from GPU modules into binary strings |
| ►Nomp | |
| CDeviceTypeClauseOps | |
| COffloadModuleDefaultModel | |
| CDeclareTargetDefaultModel | |
| Nop_definition_impl | |
| ►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 |
| ►Nemitc | |
| CCExpression | |
| Nimpl | |
| ►Nspirv | |
| CUnsignedOp | |
| CSignedOp | |
| 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) |
| Nutil | |
| ►CAtMostOneChildOf | Characterize operations that have at most a single operation of certain types in their region |
| CImpl | |
| 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" |
| CInferTensorType | Tensor type inference trait that constructs a tensor from the inferred shape and elemental types |
| CInferTypeOpAdaptor | |
| CInferShapedTypeOpAdaptor | |
| CHasParallelRegion | |
| CHasRecursiveMemoryEffects | This trait indicates that the memory effects of an operation includes the effects of operations nested within its regions |
| CRecursivelySpeculatableImplTrait | This trait marks an op (which must be tagged as implementing the ConditionallySpeculatable interface) as being recursively speculatable |
| CAlwaysSpeculatableImplTrait | This trait marks an op (which must be tagged as implementing the ConditionallySpeculatable interface) as being always speculatable |
| CTraitBase | Helper class for implementing traits |
| COpInvariants | verifyInvariantsImpl verifies the invariants like the types, attrs, .etc |
| CZeroOperands | This class provides the API for ops that are known to have no SSA operand |
| COneOperand | This class provides the API for ops that are known to have exactly one SSA operand |
| ►CNOperands | This class provides the API for ops that are known to have a specified number of operands |
| CImpl | |
| ►CAtLeastNOperands | This class provides the API for ops that are known to have a at least a specified number of operands |
| CImpl | |
| CVariadicOperands | This class provides the API for ops which have an unknown number of SSA operands |
| CZeroRegions | This class provides verification for ops that are known to have zero regions |
| COneRegion | This class provides APIs for ops that are known to have a single region |
| ►CNRegions | This class provides the API for ops that are known to have a specified number of regions |
| CImpl | |
| ►CAtLeastNRegions | This class provides APIs for ops that are known to have at least a specified number of regions |
| CImpl | |
| CVariadicRegions | This class provides the API for ops which have an unknown number of regions |
| CZeroResults | This class provides return value APIs for ops that are known to have zero results |
| COneResult | This class provides return value APIs for ops that are known to have a single result |
| ►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 |
| ►CNResults | This class provides the API for ops that are known to have a specified number of results |
| CImpl | |
| ►CAtLeastNResults | This class provides the API for ops that are known to have at least a specified number of results |
| CImpl | |
| CVariadicResults | This class provides the API for ops which have an unknown number of results |
| CNoTerminator | This class indicates that the regions associated with this op don't have terminators |
| CIsTerminator | This class provides the API for ops that are known to be terminators |
| CZeroSuccessors | This class provides verification for ops that are known to have zero successors |
| COneSuccessor | This class provides APIs for ops that are known to have a single successor |
| ►CNSuccessors | This class provides the API for ops that are known to have a specified number of successors |
| CImpl | |
| ►CAtLeastNSuccessors | This class provides APIs for ops that are known to have at least a specified number of successors |
| CImpl | |
| CVariadicSuccessors | This class provides the API for ops which have an unknown number of successors |
| 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 | |
| ChasSingleBlockImplicitTerminator | Support to check if an operation has the SingleBlockImplicitTerminator trait |
| ChasSingleBlockImplicitTerminator< Op, false > | |
| 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 |
| 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 |
| 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) |
| 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) |
| CSameOperandsAndResultType | This class provides verification for ops that are known to have the same operand and result type |
| CSameOperandsAndResultRank | This class verifies that op has same ranks for all operands and results types, if known |
| 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 |
| CIsCommutative | This class adds property that the operation is commutative |
| CIsInvolution | This class adds property that the operation is an involution |
| CIsIdempotent | This class adds property that the operation is idempotent |
| 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 |
| CSameTypeOperands | This class verifies that all operands of the specified op have the same type |
| CConstantLike | This class provides the API for a sub-set of ops that are known to be constant-like |
| CIsIsolatedFromAbove | This class provides the API for ops that are known to be isolated from above |
| CAffineScope | A trait of region holding operations that defines a new scope for polyhedral optimization purposes |
| 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 |
| ►CHasParent | This class provides a verifier for ops that are expecting their parent to be one of the given parent ops |
| CImpl | |
| CAttrSizedOperandSegments | A trait for operations that have an attribute specifying operand segments |
| CAttrSizedResultSegments | Similar to AttrSizedOperandSegments but used for results |
| CNoRegionArguments | This trait provides a verifier for ops that are expecting their regions to not have any arguments |
| CMemRefsNormalizable | |
| CElementwise | This trait tags element-wise ops on vectors or tensors |
| CScalarizable | This trait tags Elementwise operatons that can be systematically scalarized |
| CVectorizable | This trait tags Elementwise operatons that can be systematically vectorized |
| CTensorizable | This trait tags Elementwise operatons that can be systematically tensorized |
| CHasOnlyGraphRegion | A trait that specifies that an operation only defines graph regions |
| CSymbolTable | A trait used to provide symbol table functionalities to a region operation |
| ►Npdl | |
| CPDLType | This class represents the base class of all PDL types |
| ►Npdl_to_pdl_interp | |
| NPredicates | |
| CPredicateBase | Base class for all predicates, used to allow efficient pointer comparison |
| CPredicateBase< ConcreteT, BaseT, void, Kind > | Base storage for simple predicates that only unique with the kind |
| CPosition | A position describes a value on the input IR on which a predicate may be applied, such as an operation or attribute |
| CAttributePosition | A position describing an attribute of an operation |
| CAttributeLiteralPosition | A position describing a literal attribute |
| CForEachPosition | A position describing an iterative choice of an operation |
| COperandPosition | A position describing an operand of an operation |
| COperandGroupPosition | A position describing an operand group of an operation |
| COperationPosition | An operation position describes an operation node in the IR |
| CConstraintPosition | A position describing the result of a native constraint |
| CResultPosition | A position describing a result of an operation |
| CResultGroupPosition | A position describing a result group of an operation |
| CTypePosition | A position describing the result type of an entity, i.e |
| CTypeLiteralPosition | A position describing a literal type or type range |
| CUsersPosition | A position describing the users of a value or a range of values |
| CQualifier | An ordinal predicate consists of a "Question" and a set of acceptable "Answers" (later converted to ordinal values) |
| CAttributeAnswer | An Answer representing an Attribute value |
| COperationNameAnswer | An Answer representing an OperationName value |
| CTrueAnswer | An Answer representing a boolean true value |
| CFalseAnswer | An Answer representing a boolean 'false' value |
| CTypeAnswer | An Answer representing a Type value |
| CUnsignedAnswer | An Answer representing an unsigned value |
| CAttributeQuestion | Compare an Attribute to a constant value |
| CConstraintQuestion | Apply a parameterized constraint to multiple position values and possibly produce results |
| CEqualToQuestion | Compare the equality of two values |
| CIsNotNullQuestion | Compare a positional value with null, i.e. check if it exists |
| COperandCountQuestion | Compare the number of operands of an operation with a known value |
| COperandCountAtLeastQuestion | |
| COperationNameQuestion | Compare the name of an operation with a known value |
| CResultCountQuestion | Compare the number of results of an operation with a known value |
| CResultCountAtLeastQuestion | |
| CTypeQuestion | Compare the type of an attribute or value with a known type |
| CPredicateUniquer | This class provides a storage uniquer that is used to allocate predicate instances |
| CPredicateBuilder | This class provides utilities for constructing predicates |
| CPositionalPredicate | A PositionalPredicate is a predicate that is associated with a specific positional value |
| CMatcherNode | This class represents the base of a predicate matcher node |
| CBoolNode | A BoolNode denotes a question with a boolean-like result |
| CExitNode | An ExitNode is a special sentinel node that denotes the end of matcher |
| CSuccessNode | A SuccessNode denotes that a given high level pattern has successfully been matched |
| CSwitchNode | A SwitchNode denotes a question with multiple potential results |
| CRootOrderingEntry | The information associated with an edge in the cost graph |
| COptimalBranching | The optimal branching algorithm solver |
| ►Npdll | |
| ►Nast | |
| ►Ndetail | |
| CTypeStorageBase | A utility CRTP base class that defines many of the necessary utilities for defining a PDLL AST Type |
| CTypeStorageBase< ConcreteT, void > | A specialization of the storage base for singleton types |
| CAttributeTypeStorage | |
| CConstraintTypeStorage | |
| COperationTypeStorage | |
| CRangeTypeStorage | |
| CRewriteTypeStorage | |
| CTupleTypeStorage | |
| CTypeTypeStorage | |
| CValueTypeStorage | |
| CContext | This class represents the main context of the PDLL AST |
| CDiagnostic | This class provides a simple implementation of a PDLL diagnostic |
| CInFlightDiagnostic | This class represents a diagnostic that is inflight and set to be reported |
| CDiagnosticEngine | This class manages the construction and emission of PDLL diagnostics |
| CName | This class provides a convenient API for interacting with source names |
| CDeclScope | This class represents a scope for named AST decls |
| ►CNode | This class represents a base AST node |
| CNodeBase | This CRTP class provides several utilies when defining new AST nodes |
| CStmt | This class represents a base AST Statement node |
| CCompoundStmt | This statement represents a compound statement, which contains a collection of other statements |
| CLetStmt | This statement represents a let statement in PDLL |
| COpRewriteStmt | This class represents a base operation rewrite statement |
| CEraseStmt | This statement represents the erase statement in PDLL |
| CReplaceStmt | This statement represents the replace statement in PDLL |
| CRewriteStmt | This statement represents an operation rewrite that contains a block of nested rewrite commands |
| CReturnStmt | This statement represents a return from a "callable" like decl, e.g |
| CExpr | This class represents a base AST Expression node |
| CAttributeExpr | This expression represents a literal MLIR Attribute, and contains the textual assembly format of that attribute |
| CCallExpr | This expression represents a call to a decl, such as a UserConstraintDecl/UserRewriteDecl |
| CDeclRefExpr | This expression represents a reference to a Decl node |
| CMemberAccessExpr | This expression represents a named member or field access of a given parent expression |
| CAllResultsMemberAccessExpr | This class represents an instance of MemberAccessExpr that references all results of an operation |
| COperationExpr | This expression represents the structural form of an MLIR Operation |
| CRangeExpr | This expression builds a range from a set of element values (which may be ranges themselves) |
| CTupleExpr | This expression builds a tuple from a set of element values |
| CTypeExpr | This expression represents a literal MLIR Type, and contains the textual assembly format of that type |
| CDecl | This class represents the base Decl node |
| 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 |
| CCoreConstraintDecl | This class represents the base of all "core" constraints |
| CAttrConstraintDecl | The class represents an Attribute constraint, and constrains a variable to be an Attribute |
| COpConstraintDecl | The class represents an Operation constraint, and constrains a variable to be an Operation |
| CTypeConstraintDecl | The class represents a Type constraint, and constrains a variable to be a Type |
| CTypeRangeConstraintDecl | The class represents a TypeRange constraint, and constrains a variable to be a TypeRange |
| 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 |
| CUserConstraintDecl | This decl represents a user defined constraint |
| CNamedAttributeDecl | This Decl represents a NamedAttribute, and contains a string name and attribute value |
| COpNameDecl | This Decl represents an OperationName |
| CPatternDecl | This Decl represents a single Pattern |
| CUserRewriteDecl | This decl represents a user defined rewrite |
| CCallableDecl | This decl represents a shared interface for all callable decls |
| CVariableDecl | This Decl represents the definition of a PDLL variable |
| CModule | This class represents a top-level AST module |
| ►CType | |
| CStorage | |
| CTypeBase | This class provides several utilities when defining derived type classes |
| CAttributeType | This class represents a PDLL type that corresponds to an mlir::Attribute |
| CConstraintType | This class represents a PDLL type that corresponds to a constraint |
| COperationType | This class represents a PDLL type that corresponds to an mlir::Operation |
| CRangeType | This class represents a PDLL type that corresponds to a range of elements with a given element type |
| CTypeRangeType | This class represents a PDLL type that corresponds to an mlir::TypeRange |
| CValueRangeType | This class represents a PDLL type that corresponds to an mlir::ValueRange |
| CRewriteType | This class represents a PDLL type that corresponds to a rewrite reference |
| CTupleType | This class represents a PDLL tuple type, i.e |
| CTypeType | This class represents a PDLL type that corresponds to an mlir::Type |
| CValueType | This class represents a PDLL type that corresponds to an mlir::Value |
| ►Nods | |
| CConstraint | This class represents a generic ODS constraint |
| CAttributeConstraint | This class represents a generic ODS Attribute constraint |
| CTypeConstraint | This class represents a generic ODS Type 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 |
| CAttribute | This class provides an ODS representation of a specific operation attribute |
| 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 |
| CCodeCompleteContext | This class provides an abstract interface into the parser for hooking in code completion events |
| CToken | |
| CLexer | |
| ►Npolynomial | |
| CMonomialBase | |
| CIntMonomial | A class representing a monomial of a single-variable polynomial with integer coefficients |
| CFloatMonomial | A class representing a monomial of a single-variable polynomial with integer coefficients |
| CPolynomialBase | |
| CIntPolynomial | A single-variable polynomial with integer coefficients |
| CFloatPolynomial | A single-variable polynomial with double coefficients |
| ►Npresburger | |
| ►Ndetail | |
| CGeneratingFunction | |
| CFraction | A class to represent fractions |
| ►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 |
| CIntegerPolyhedron | An IntegerPolyhedron represents the set of points from a PresburgerSpace that satisfy a list of affine constraints |
| CLinearTransform | |
| CMatrix | This is a class to represent a resizable matrix |
| CIntMatrix | |
| CFracMatrix | |
| 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 | |
| CIdentifier | An Identifier stores a pointer to an object, such as a Value or an Operation |
| CPresburgerSpace | PresburgerSpace is the space of all possible values of a tuple of integer valued variables/variables |
| 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 |
| ►CPWMAFunction | This class represents a piece-wise MultiAffineFunction |
| CPiece | |
| CQuasiPolynomial | |
| ►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 |
| CLexSimplexBase | Simplex class using the lexicographic pivot rule |
| CLexSimplex | A class for lexicographic optimization without any symbols |
| 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 |
| CSimplex | Uses the Normal pivot rule and supports integer emptiness checks as well as detecting redundancies |
| CSimplexRollbackScopeExit | Takes a snapshot of the simplex state on construction and rolls back to the snapshot on destruction |
| CMaybeOptimum | |
| CMaybeLocalRepr | MaybeLocalRepr contains the indices of the constraints that can be expressed as a floordiv of an affine function |
| CDivisionRepr | Class storing division representation of local variables of a constraint system |
| CPrintTableMetrics | Example usage: Print .12, 3.4, 56.7 preAlign = ".", minSpacing = 1, .12 .12 3.4 3.4 56.7 56.7 |
| CSetCoalescer | All functionality concerning the coalesce heuristic |
| 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 |
| ►Npython | |
| ►Nadaptors | |
| 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 |
| 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 |
| ►Nnanobind_adaptors | |
| 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 |
| 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 |
| CCollectDiagnosticsToStringScope | RAII scope intercepting all diagnostics into a string |
| CPyGlobals | Globals that are always accessible once the extension has been initialized |
| CPyConcreteOpInterface | CRTP base class for Python classes representing MLIR Op interfaces |
| ►CPyInferTypeOpInterface | Python wrapper for InferTypeOpInterface |
| CAppendResultsCallbackData | C-style user-data structure for type appending callback |
| CPyShapedTypeComponents | Wrapper around an shaped type components |
| ►CPyInferShapedTypeOpInterface | Python wrapper for InferShapedTypeOpInterface |
| CAppendResultsCallbackData | C-style user-data structure for type appending callback |
| CPyObjectRef | Template for a reference to a concrete type which captures a python reference to its underlying python object |
| CPyThreadContextEntry | Tracks an entry in the thread context stack |
| ►CPyMlirContext | |
| CErrorCapture | RAII object that captures any error diagnostics emitted to the provided context |
| CDefaultingPyMlirContext | Used in function arguments when None should resolve to the current context manager set instance |
| CBaseContextObject | Base class for all objects that directly or indirectly depend on an MlirContext |
| CPyLocation | Wrapper around an MlirLocation |
| ►CPyDiagnostic | Python class mirroring the C MlirDiagnostic struct |
| CDiagnosticInfo | Materialized diagnostic information |
| CPyDiagnosticHandler | Represents a diagnostic handler attached to the context |
| CPyDialectDescriptor | Wrapper around an MlirDialect |
| CPyDialects | User-level object for accessing dialects with dotted syntax such as: ctx.dialect.std |
| CPyDialect | User-level dialect object |
| CPyDialectRegistry | Wrapper around an MlirDialectRegistry |
| CDefaultingPyLocation | Used in function arguments when None should resolve to the current context manager set instance |
| CPyModule | |
| CPyOperationBase | Base class for PyOperation and PyOpView which exposes the primary, user visible methods for manipulating it |
| CPyOperation | |
| 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 |
| CPyAsmState | Wrapper around an MlirAsmState |
| CPyBlock | Wrapper around an MlirBlock |
| CPyInsertionPoint | An insertion point maintains a pointer to a Block and a reference operation |
| CPyType | Wrapper around the generic MlirType |
| CPyTypeID | A TypeID provides an efficient and unique identifier for a specific C++ type |
| CPyConcreteType | CRTP base classes for Python types that subclass Type and should be castable from it (i.e |
| CPyAttribute | Wrapper around the generic MlirAttribute |
| CPyNamedAttribute | Represents a Python MlirNamedAttr, carrying an optional owned name |
| CPyConcreteAttribute | CRTP base classes for Python attributes that subclass Attribute and should be castable from it (i.e |
| CPyValue | Wrapper around the generic MlirValue |
| CPyAffineExpr | Wrapper around MlirAffineExpr. Affine expressions are owned by the context |
| CPyAffineMap | |
| CPyIntegerSet | |
| CPySymbolTable | Bindings for MLIR symbol tables |
| CMLIRError | Custom exception that allows access to error diagnostic information |
| 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 |
| ►Nquant | |
| ►Ndetail | |
| CQuantizedTypeStorage | |
| ►CAnyQuantizedTypeStorage | |
| CKeyTy | |
| ►CUniformQuantizedTypeStorage | |
| CKeyTy | |
| ►CUniformQuantizedPerAxisTypeStorage | |
| CKeyTy | |
| ►CCalibratedQuantizedTypeStorage | |
| CKeyTy | |
| NQuantizationFlags | Enumeration of bit-mapped flags related to quantized types |
| CQuantizedType | Base class for all quantized types known to this dialect |
| CAnyQuantizedType | A quantized type that maps storage to/from expressed types in an unspecified way |
| CUniformQuantizedType | Represents a family of uniform, quantized types |
| CUniformQuantizedPerAxisType | Represents per-axis (also known as per-channel quantization) |
| 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 |
| CUniformQuantizedValueConverter | Reference implementation of converting between real numbers and values represented by a UniformQuantizedType |
| CUniformQuantizedPerAxisValueConverter | An utility class to quantize an attribute by the per-axis quantization parameters |
| ►Nquery | |
| ►Nmatcher | |
| ►Ninternal | |
| CSourceLocation | |
| CSourceRange | |
| CArgTypeTraits | |
| CArgTypeTraits< const T & > | |
| CArgTypeTraits< llvm::StringRef > | |
| CArgTypeTraits< DynMatcher > | |
| CMatcherDescriptor | |
| CFixedArgCountMatcherDescriptor | |
| ►CDiagnostics | |
| CArgStream | |
| ►CParser | |
| CCodeTokenizer | |
| CRegistrySema | |
| CScopedContextEntry | |
| CSema | |
| CTokenInfo | |
| CMatcherInterface | |
| CMatcherFnImpl | |
| CDynMatcher | |
| CMatchFinder | |
| CRegistry | |
| ►CVariantMatcher | |
| CSinglePayload | |
| CVariantValue | |
| CParserValue | |
| CMatcherCompletion | |
| CRegistryManager | |
| CQuery | |
| CInvalidQuery | |
| CNoOpQuery | |
| CHelpQuery | |
| CQuitQuery | |
| CMatchQuery | |
| CQuerySession | |
| ►CQueryParser | |
| CLexOrCompleteWord | |
| ►NRankedTensorType | |
| CBuilder | This is a builder type that keeps local references to arguments |
| ►NROCDL | |
| CSerializeGPUModuleBase | Base class for all ROCDL serializations from GPU modules into binary strings |
| ►Nruntime | |
| CAsyncToken | |
| CAsyncValue | |
| CAsyncGroup | |
| ►Nscf | |
| CLoopNest | |
| CForLoopPipeliningPattern | |
| CSCFTilingOptions | Options to use to control tiling |
| CSCFTilingResult | Transformation information returned after tiling |
| ►CSCFTileAndFuseOptions | Options used to control tile + fuse |
| CControlFnResult | Control function to check if a slice needs to be fused or not, The control function receives 1) the slice along which fusion is to be done, 2) the producer value that is to be fused 3) a boolean value set to true if the fusion is from a destination operand |
| CSCFFuseProducerOfSliceResult | Fuse the producer of the source of candidateSliceOp by computing the required slice of the producer in-place |
| CSCFTileAndFuseResult | Transformation information returned after tile and fuse |
| CSCFFuseConsumerOfSliceResult | Fuse the consumer of the source of candidateSliceOp by computing the required slice of the consumer in-place |
| CPipeliningOption | Options to dictate how loops should be pipelined |
| ►Nshape | |
| 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 |
| CShapeMappingAnalysis | ShapeMappingAnalysis is used together with OutlineShapeComputationPass to preserve Value and corresponding shape function / arguments mapping information |
| ►NSideEffects | |
| ►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 |
| ►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 |
| CDefaultResource | A conservative default resource kind |
| CAutomaticAllocationScopeResource | An automatic allocation-scope resource that is valid in the context of a parent AutomaticAllocationScope trait |
| CEffectInstance | This class represents a specific instance of an effect |
| ►Nsparse_tensor | |
| ►Ndetail | |
| Cis_complex | |
| Cis_complex< std::complex< T > > | |
| ►Nir_detail | |
| CDimLvlExpr | |
| CDimExpr | |
| CLvlExpr | |
| CDimSpec | The full dimVar = dimExpr : dimSlice specification for a given dimension |
| CLvlSpec | The full lvlVar = lvlExpr : lvlType specification for a given level |
| CDimLvlMap | |
| CDimLvlMapParser | Parses the Sparse Tensor Encoding Attribute (STEA) |
| CLvlTypeParser | |
| ►CVar | A concrete variable, to be used in our variant of AffineExpr |
| CImpl | The underlying implementation of Var |
| CSymVar | |
| CDimVar | |
| CLvlVar | |
| CRanks | |
| CVarSet | Efficient representation of a set of Var |
| CVarInfo | A record of metadata for/about a variable, used by VarEnv |
| CVarEnv | |
| CLevelType | This enum defines all the sparse representations supportable by the SparseTensor dialect |
| CCOOSegment | A simple structure that encodes a range of levels in the sparse tensors that forms a COO segment |
| 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 |
| CStorageLayout | Provides methods to access fields of a sparse tensor with the given encoding |
| CSparseTensorType | A wrapper around RankedTensorType, which has three goals: |
| CSparsifierOptions | Options for the "sparsifier" pipeline |
| ►CTensorExp | Tensor expression. Represents an MLIR expression in tensor index notation |
| CChildren | Child subexpressions for non-leaf expressions |
| CLatPoint | Lattice point |
| CMerger | A class to handle all iteration lattice operations |
| 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 |
| CSparseTensorCOO | A memory-resident sparse tensor in coordinate-scheme representation (a collection of Elements) |
| CSparseTensorReader | This class abstracts over the information stored in file headers, as well as providing the buffers and methods for parsing those headers |
| CMapRef | A class for capturing the sparse tensor type map with a compact encoding |
| CSparseTensorStorageBase | Abstract base class for SparseTensorStorage<P,C,V> |
| CSparseTensorStorage | A memory-resident sparse tensor using a storage scheme based on per-level sparse/dense annotations |
| CSparsificationAndBufferizationPass | A pass that lowers tensor ops to memref ops, regardless of whether they are dense or sparse |
| CCodegenEnv | The code generation environment class aggregates a number of data structures that are needed during the code generation phase of sparsification |
| CFuncCallOrInlineGenerator | A helper class to simplify lowering operations with/without function calls |
| CIterationGraphSorter | |
| CLoopEmitter | |
| CSparseTensorSpecifier | |
| CSparseTensorDescriptorImpl | A helper class around an array of values that corresponds to a sparse tensor |
| CSparseTensorDescriptor | Uses ValueRange for immutable descriptors |
| 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 |
| CSparseTensorLevel | The base class for all types of sparse tensor levels |
| 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 |
| NSpeculation | |
| ►Nspirv | |
| NAttrNames | |
| ►Ndetail | |
| CInterfaceVarABIAttributeStorage | |
| CVerCapExtAttributeStorage | |
| CTargetEnvAttributeStorage | |
| CArrayTypeStorage | |
| CCooperativeMatrixTypeStorage | |
| CImageTypeStorage | |
| CPointerTypeStorage | |
| CRuntimeArrayTypeStorage | |
| CSampledImageTypeStorage | |
| CStructTypeStorage | Type storage for SPIR-V structure types: |
| CMatrixTypeStorage | |
| CMemorySpaceToStorageClassConverter | Type converter for converting numeric MemRef memory spaces into SPIR-V symbolic ones |
| CInterfaceVarABIAttr | An attribute that specifies the information regarding the interface variable: descriptor set, binding, storage class |
| ►CVerCapExtAttr | An attribute that specifies the SPIR-V (version, capabilities, extensions) triple |
| Ccap_iterator | |
| Cext_iterator | |
| CTargetEnvAttr | An attribute that specifies the target version, allowed extensions and capabilities, and resource limits |
| CSPIRVType | |
| CScalarType | |
| CCompositeType | |
| CArrayType | |
| CImageType | |
| CPointerType | |
| CRuntimeArrayType | |
| CSampledImageType | |
| ►CStructType | SPIR-V struct type |
| CMemberDecorationInfo | |
| CCooperativeMatrixType | |
| CMatrixType | |
| CTargetEnv | A wrapper class around a spirv::TargetEnvAttr to provide query methods for allowed version/capabilities/extensions |
| CSerializationOptions | |
| CElementwiseOpPattern | Converts elementwise unary, binary and ternary standard operations to SPIR-V operations |
| CBlockMergeInfo | A struct for containing a header block's merge and continue targets |
| 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 |
| CSpecConstOperationMaterializationInfo | A struct that collects the info needed to materialize/emit a SpecConstantOperation op |
| CDeserializer | A SPIR-V module serializer |
| CSerializer | A SPIR-V module serializer |
| ►Ntblgen | |
| ►Ndetail | |
| Cstringifier | |
| Cstringifier< Twine > | |
| Cstringifier< std::optional< OptionalT > > | |
| CNamedAttribute | |
| CNamedTypeConstraint | |
| CAttrConstraint | |
| CAttribute | |
| CConstantAttr | |
| CEnumAttrCase | |
| CEnumAttr | |
| CAttrOrTypeBuilder | Wrapper class that represents a Tablegen AttrOrTypeBuilder |
| CAttrOrTypeParameter | A wrapper class for tblgen AttrOrTypeParameter, arrays of which belong to AttrOrTypeDefs to parameterize them |
| CAttributeSelfTypeParameter | |
| CAttrOrTypeDef | Wrapper class that contains a TableGen AttrOrTypeDef's record and provides helper methods for accessing them |
| CAttrDef | This class represents a wrapper around a tablegen AttrDef record |
| CTypeDef | This class represents a wrapper around a tablegen TypeDef record |
| ►CBuilder | Wrapper class with helper methods for accessing Builders defined in TableGen |
| CParameter | This class represents a single parameter to a builder 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 |
| CMethodBody | This class contains the body of a C++ method |
| CClassDeclaration | A class declaration is a class element that appears as part of its declaration |
| CClassDeclarationBase | Base class for class declarations |
| CMethod | Class for holding an op's method for C++ code emission |
| ►CConstructor | |
| CMemberInitializer | Initialization of a class field in a constructor |
| CParentClass | This class describes a C++ parent class declaration |
| CUsingDeclaration | This class describes a using-declaration for a class |
| CField | This class describes a class field |
| CVisibilityDeclaration | A declaration for the visibility of subsequent declarations |
| CExtraClassDeclaration | Unstructured extra class declarations and definitions, from TableGen definitions |
| CClass | A class used to emit C++ classes from Tablegen |
| CIfDefScope | |
| CNamespaceEmitter | |
| CStaticVerifierFunctionEmitter | This class deduplicates shared operation verification code by emitting static functions alongside the op definitions |
| CConstraint | |
| CAppliedConstraint | |
| CDialect | |
| CFmtContext | Format context containing substitutions for special placeholders |
| CFmtReplacement | Struct representing a replacement segment for the formatted string |
| ►CFmtObjectBase | |
| CCreateAdapters | |
| CFmtObject | |
| CFmtStrVecObject | |
| ►CInterfaceMethod | |
| CArgument | |
| CInterface | |
| CAttrInterface | |
| COpInterface | |
| CTypeInterface | |
| CInferredResultType | This class represents an inferred result type |
| ►COperator | Wrapper class that contains a MLIR op's information (e.g., operands, attributes) defined in TableGen and provides helper methods for accessing them |
| COperandOrAttribute | Pair consisting kind of argument and index into operands or attributes |
| CVariableDecorator | A class used to represent the decorators of an operator variable, i.e |
| CVariableDecoratorIterator | A utility iterator over a list of variable decorators |
| CPassOption | |
| CPassStatistic | |
| CPass | Wrapper class providing helper methods for Passes defined in TableGen |
| CDagLeaf | |
| CDagNode | |
| ►CSymbolInfoMap | |
| CSymbolInfo | |
| CPattern | |
| CPred | |
| CCPred | |
| CCombinedPred | |
| CSubstLeavesPred | |
| CConcatPred | |
| CProperty | |
| CNamedProperty | |
| CRegion | |
| CNamedRegion | |
| CSideEffect | |
| CSideEffectTrait | |
| CSuccessor | |
| CNamedSuccessor | |
| CTrait | |
| CNativeTrait | |
| CPredTrait | |
| CInternalTrait | |
| CInterfaceTrait | |
| CTypeConstraint | |
| CType | |
| ►Ntensor | |
| CExtractSliceFromCollapseHelper | This class assists with generating IR required to materialize an arbitrary-sized slice from the result of a CollapseShapeOp |
| ►Ntosa | |
| CValidationOptions | |
| CValueKnowledge | Statically known information for a particular Value |
| ►Ntracing | |
| 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 |
| 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 |
| CTagBreakpoint | Simple breakpoint matching an action "tag" |
| CTagBreakpointManager | This is a manager to store a collection of breakpoints that trigger on tags |
| CDebugConfig | |
| ►CInstallDebugHandler | This is a RAII class that installs the debug handlers on the context based on the provided configuration |
| CImpl | |
| 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 |
| CActionActiveStack | This class is used to keep track of the active actions in the stack |
| ►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 |
| 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 |
| 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 |
| CActionImpl | CRTP Implementation of an action |
| ►Ntransform | |
| ►Ndetail | |
| CTransformDialectDataBase | Concrete base class for CRTP TransformDialectDataBase |
| ►Ngpu | |
| CIdBuilderResult | Helper type for functions that generate ids for the mapping of a scf.forall |
| CGpuIdBuilder | Helper struct for configuring the rewrite of mapped scf.forall ops to various gpu id configurations |
| CGpuBlockIdBuilder | Builder for gpu::BlockIdOps used to map scf.forall to blocks |
| 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 |
| CGpuThreadIdBuilder | Builder for warp ids used to map scf.forall to reindexed threads |
| CMappingInfo | Base struct to hold GPU mapping information for a given operation |
| CCopyMappingInfo | |
| CStructuredOpPredicateOpTrait | |
| CTileSizesSpec | |
| CNumThreadsSpec | |
| CAtMostOneOpMatcherOpTrait | |
| CSingleOpMatcherOpTrait | |
| CSingleValueMatcherOpTrait | |
| CTransformOptions | Options controlling the application of transform operations by the TransformState |
| ►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 |
| CTransformResults | Local mapping between values defined by a specific op implementing the TransformOpInterface and the payload IR ops they correspond to |
| CTrackingListenerConfig | A configuration object for customizing a TrackingListener |
| CTrackingListener | A listener that updates a TransformState based on IR modifications |
| CErrorCheckingTrackingListener | A specialized listener that keeps track of cases in which no replacement payload could be found |
| CTransformRewriter | This is a special rewriter to be used in transform op implementations, providing additional helper functions to update the transform state, etc |
| CPossibleTopLevelTransformOpTrait | This trait is supposed to be attached to Transform dialect operations that can be standalone top-level transforms |
| 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 |
| CPayloadIRResource | Side effect resource corresponding to the Payload IR itself |
| CFunctionalStyleTransformOpTrait | Trait implementing the MemoryEffectOpInterface for operations that "consume" their operands and produce new results |
| CNavigationTransformOpTrait | Trait implementing the MemoryEffectOpInterface for operations that use their operands without consuming and without modifying the Payload IR to potentially produce new handles |
| CParamProducerTransformOpTrait | Trait implementing the MemoryEffectsOpInterface for operations that produce transform dialect parameters |
| CReportTrackingListenerFailuresOpTrait | TrackingListener failures are reported only for ops that have this trait |
| 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 |
| 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 |
| CBuildOnly | A wrapper for transform dialect extensions that forces them to be constructed in the build-only mode |
| CPDLMatchHooks | PDL constraint callbacks that can be used by the PDL extension of the Transform dialect |
| ►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 | |
| Nub | |
| Nutils | |
| ►Nvector | |
| ►Ndetail | |
| CValueBoundsConstraintSet | Parent class for the value bounds RTTIExtends |
| CBitmaskEnumStorage | |
| ►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 | |
| CVectorDim | |
| CLowerVectorsOptions | Helper structure used to hold the different options of LowerVectorsOp |
| CWarpExecuteOnLane0LoweringOptions | |
| CUnrollVectorOptions | Options that control the vector unrolling |
| CVectorTransformsOptions | Structure to control the behavior of vector transform patterns |
| CVscaleRange | |
| CMaskableOpRewritePattern | A pattern for ops that implement MaskableOpInterface and that might be masked (i.e |
| ►NVectorType | |
| CBuilder | This is a builder type that keeps local references to arguments |
| ►Nx86vector | |
| ►Navx2 | Helpers extracted from: |
| Ninline_asm | |
| Nintrin | |
| CTransposeLoweringOptions | Structure to control the behavior of specialized AVX2 transpose lowering |
| CLoweringOptions | Options for controlling specialized AVX2 lowerings |
| CMaskHelper | Helper class to factor out the creation and extraction of masks from nibs |
| Nxegpu | |
| 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 |
| CAliasResult | The possible results of an alias query |
| CModRefResult | The possible results of whether a memory access modifies or references a memory location |
| CAliasAnalysis | This class represents the main alias analysis interface in MLIR |
| ►CCallGraphNode | This class represents a single callable in the callgraph |
| CEdge | This class represents a directed edge between two nodes in the callgraph |
| CCallGraph | |
| 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 |
| CProgramPoint | Program point represents a specific location in the execution of a program |
| 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 |
| CLatticeAnchor | Fundamental IR components are supported as first-class lattice anchor |
| CDataFlowConfig | Configuration class for data flow solver and child analyses |
| CDataFlowSolver | The general data-flow analysis solver |
| CAnalysisState | Base class for generic analysis states |
| CDataFlowAnalysis | Base class for all data-flow analyses |
| CDataLayoutAnalysis | Stores data layout objects for each operation that specifies the data layout above and below the given operation |
| 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 |
| CLiveness | Represents an analysis for computing liveness information from a given top-level operation |
| CLivenessBlockInfo | This class represents liveness information on block level |
| CSliceOptions | |
| CBackwardSliceOptions | |
| CWalkContinuation | A class to signal how to proceed with the walk of the backward slice: |
| CSymbolTableAnalysis | This is a simple analysis that contains a symbol table collection and, for simplicity, a reference to the top-level symbol table |
| ►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 |
| CAsmParserCodeCompleteContext | This class provides an abstract interface into the parser for hooking in code completion events |
| CPyShapedType | Shaped Type Interface - ShapedType |
| CDialectVersion | This class is used to represent the version of a dialect, for the purpose of polymorphic destruction |
| 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 |
| 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 |
| CAttrTypeBytecodeReader | A class to interact with the attributes and types parser when parsing MLIR bytecode |
| CBytecodeReaderConfig | A class containing bytecode-specific configurations of the ParserConfig |
| CAttrTypeBytecodeWriter | A class to interact with the attributes and types printer when emitting MLIR bytecode |
| ►CBytecodeWriterConfig | This class contains the configuration used for the bytecode writer |
| CImpl | |
| COperationPass | Pass to transform an operation of a specific type |
| CComplexStructBuilder | |
| CControlFlowToSCFTransformation | Implementation of CFGToSCFInterface used to lift Control Flow Dialect operations to SCF Dialect operations |
| CConvertToLLVMPatternInterface | Base class for dialect interfaces providing translation to LLVM IR |
| CFunctionCallBuilder | |
| CLLVMConversionTarget | Derived class that automatically populates legalization information for different LLVM ops |
| CLowerToLLVMOptions | Options to control the LLVM lowering |
| 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 |
| CUnrankedMemRefDescriptor | |
| CConvertToLLVMPattern | Base class for operation conversions targeting the LLVM IR dialect |
| CConvertOpToLLVMPattern | Utility class for operation conversions targeting the LLVM dialect that match exactly one source operation |
| COneToOneConvertToLLVMPattern | Generic implementation of one-to-one conversion from "SourceOp" to "TargetOp" where the latter belongs to the LLVM dialect or an equivalent |
| CStructBuilder | Helper class to produce LLVM dialect operations extracting or inserting values to a struct |
| CLLVMTypeConverter | Conversion from types to the LLVM IR dialect |
| CAttrConvertPassThrough | |
| CVectorConvertToLLVMPattern | Basic lowering implementation to rewrite Ops with just one result to the LLVM Dialect |
| CAllocationOpLLVMLowering | Lowering for memory allocation ops |
| CAllocLikeOpLLVMLowering | Lowering for AllocOp and AllocaOp |
| CInterfacePass | Pass to transform an operation that implements the given interface |
| CScfToSPIRVContext | |
| CSPIRVToLLVMConversion | |
| 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 |
| CArithBuilder | Helper struct to build simple arithmetic quantities with minimal type inference support |
| CBufferViewFlowAnalysis | A straight-forward alias analysis which ensures that all dependencies of all values will be determined |
| CBufferOriginAnalysis | An is-same-buffer analysis that checks if two SSA values belong to the same buffer allocation or not |
| CHasDefaultDLTIDataLayout | Trait to be used by operations willing to use the implementation of the data layout interfaces provided by the Target dialect |
| CMathPolynomialApproximationOptions | |
| CUnrolledLoopInfo | |
| CSparsificationOptions | Options for the Sparsification pass |
| CSparseIterationTypeConverter | Type converter for iter_space and iterator |
| CSparseTensorTypeToPtrConverter | Sparse tensor type converter into an opaque pointer |
| CSparseTensorTypeToBufferConverter | Sparse tensor type converter into an actual buffer |
| CStorageSpecifierToLLVMTypeConverter | |
| CSPIRVConversionOptions | |
| CSPIRVTypeConverter | Type conversion from builtin types to SPIR-V types for shader interface |
| CSPIRVConversionTarget | |
| 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 |
| 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 |
| CDiagnosedSilenceableFailure | The result of a transform IR operation application |
| CDiagnosedDefiniteFailure | A compatibility class connecting InFlightDiagnostic to DiagnosedSilenceableFailure while providing an interface similar to the former |
| ►CRaggedArray | A 2D array where each row may have different length |
| Cconst_iterator | Constant iterator over the rows |
| Citerator | Iterator over the rows |
| 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 |
| CComposeReassociativeReshapeOps | Pattern to collapse producer/consumer reshape ops that are both collapsing dimensions or are both expanding dimensions |
| CComposeCollapseOfExpandOp | Pattern to compose collapse_shape(expand_shape(src, reassociation_1), reassociation_2) |
| CComposeExpandOfCollapseOp | |
| CRange | Represents a range (offset, size, and stride) where each element of the triple may be dynamic or static |
| CSaturatedInteger | Idiomatic saturated operations on values like offsets, sizes, and strides |
| ►CStructuredGenerator | Helper StructuredGenerator class to manipulate and rewrite ops with StructuredOpInterface |
| CIteratorType | |
| CPar | |
| CRed | |
| CSimpleObjectCache | A simple object cache following Lang's LLJITWithObjectCache example |
| CExecutionEngineOptions | |
| ►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 |
| CJitRunnerOptions | JitRunner command line options used by JitRunnerConfig methods |
| CJitRunnerConfig | Configuration to override functionality of the JitRunner |
| COwningMemRef | Owning MemRef type that abstracts over the runtime type for ranked strided memref |
| CCallInterfaceCallable | A callable is either a symbol, or an SSA value, that is referenced by a call-like operation |
| CSuccessorOperands | This class models how operands are forwarded to block arguments in control flow |
| CRegionSuccessor | This class represents a successor of a region |
| CRegionBranchPoint | This class represents a point being branched from in the methods of the RegionBranchOpInterface |
| CInvocationBounds | This class represents upper and lower bounds on the number of times a region of a RegionBranchOpInterface can be invoked |
| CDataLayoutDialectInterface | An interface to be implemented by dialects that can have identifiers in the data layout specification entries |
| CDataLayout | The main mechanism for performing data layout queries |
| CDialectFoldInterface | Define a fold interface to allow for dialects to control specific aspects of the folding behavior for operations they define |
| CConstantIntRanges | A set of arbitrary-precision integers representing bounds on a given integer value |
| CIntegerValueRange | This lattice value represents the integer range of an SSA value |
| 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 |
| CValueShapeRange | Range of values and shapes (corresponding effectively to Shapes dialect's ValueShape type concept) |
| CJamBlockGatherer | |
| CMemorySlot | Represents a slot in memory |
| CDestructurableMemorySlot | Memory slot attached with information about its destructuring procedure |
| CTilingResult | Container for result values of tiling |
| CMergeResult | Container for the result of merge operation of tiling |
| CHyperrectangularSlice | A hyperrectangular slice, represented as a list of offsets, sizes and strides |
| ►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" |
| COpWithOffsetSizesAndStridesConstantArgumentFolder | Pattern to rewrite dynamic offsets/sizes/strides of view/slice-like ops as constant arguments |
| CAffineExpr | Base type for affine expression |
| CAffineBinaryOpExpr | Affine binary operation expression |
| CAffineDimExpr | A dimensional identifier appearing in an affine expression |
| CAffineSymbolExpr | A symbolic identifier appearing in an affine expression |
| CAffineConstantExpr | An integer constant appearing in affine expression |
| CAffineExprVisitorBase | Base class for AffineExpr visitors/walkers |
| CAffineExprVisitor | See documentation for AffineExprVisitorBase |
| CAffineExprVisitor< SubClass, LogicalResult > | |
| CSimpleAffineExprFlattener | |
| CAffineMap | A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued |
| CMutableAffineMap | A mutable affine map. Its affine expressions are however unique |
| CAsmResourceBlob | This class represents a processed binary blob of data |
| CHeapAsmResourceBlob | This class provides a simple utility wrapper for creating heap allocated AsmResourceBlobs |
| CUnmanagedAsmResourceBlob | This class provides a simple utility wrapper for creating "unmanaged" AsmResourceBlobs |
| CAsmResourceBuilder | This class is used to build resource entries for use by the printer |
| CAsmParsedResourceEntry | This class represents a single parsed resource entry |
| CAsmResourceParser | This class represents an instance of a resource parser |
| CAsmResourcePrinter | This class represents an instance of a resource printer |
| ►CFallbackAsmResourceMap | A fallback map containing external resources not explicitly handled by another parser/printer |
| COpaqueAsmResource | This class represents an opaque resource |
| CParserConfig | This class represents a configuration for the MLIR assembly parser |
| CAsmState | This class provides management for the lifetime of the state used when printing the IR |
| CAttribute | Attributes are known-constant values of operations |
| CNamedAttribute | NamedAttribute represents a combination of a name and an Attribute value |
| CAttrTypeSubElementHandler< NamedAttribute > | Allow walking and replacing the subelements of a NamedAttribute |
| CAttributeInterface | This class represents the base of an attribute interface |
| CAbstractAttribute | This class contains all of the static information common to all instances of a registered Attribute |
| CAttributeStorage | Base storage class appearing in an attribute |
| CAttrTypeWalker | AttrTypeWalker |
| CAttrTypeReplacer | This is an attribute/type replacer that is naively cached |
| CCyclicAttrTypeReplacer | This is an attribute/type replacer that supports custom handling of cycles in the replacer logic |
| CAttrTypeImmediateSubElementWalker | AttrTypeSubElementHandler |
| CAttrTypeSubElementReplacements | This class is used by AttrTypeSubElementHandler instances to process sub element replacements |
| CAttrTypeSubElementHandler | This class provides support for interacting with the SubElementInterfaces for different types of parameters |
| 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< ArrayRef< T >, std::enable_if_t< has_sub_attr_or_type_v< T > > > | Implementation for derived ArrayRef |
| CAttrTypeSubElementHandler< std::tuple< Ts... >, std::enable_if_t< has_sub_attr_or_type_v< Ts... > > > | Implementation for Tuple |
| CValueTypeRange | This class implements iteration on the types of a given range of values |
| CBlock | Block represents an ordered list of Operations |
| CBlockOperand | A block operand represents an operand that holds a reference to a Block, e.g |
| CPredecessorIterator | Implement a predecessor iterator for blocks |
| CSuccessorRange | This class implements the successor iterators for Block |
| CBlockRange | This class provides an abstraction over the different types of ranges over Blocks |
| CBuilder | This class is a general helper class for creating context-global objects like types, attributes, and affine expressions |
| ►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 |
| CDialectResourceBlobHandle | This class defines a dialect specific handle to a resource blob |
| ►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 |
| CSplatElementsAttr | An attribute that represents a reference to a splat vector or tensor constant, meaning all of the elements have the same value |
| CBoolAttr | Special case of IntegerAttr to represent boolean integers, i.e., signless i1 integers |
| CFlatSymbolRefAttr | A symbol reference with a reference path containing a single element |
| 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 |
| CDistinctAttr | An attribute that associates a referenced attribute with a unique identifier |
| CValueSemantics | Type trait indicating that the type has value semantics |
| CFloatType | |
| CTensorType | Tensor types represent multi-dimensional arrays, and have two variants: RankedTensorType and UnrankedTensorType |
| CBaseMemRefType | This class provides a shared interface for ranked and unranked memref types |
| CScalableVectorType | A vector type containing at least one scalable dimension |
| CFixedVectorType | A vector type with no scalable dimensions |
| CDiagnosticArgument | A variant type that holds a single argument for a diagnostic |
| CDiagnostic | This class contains all of the information necessary to report a diagnostic to the DiagnosticEngine |
| CInFlightDiagnostic | This class represents a diagnostic that is inflight and set to be reported |
| CDiagnosticEngine | This class is the main interface for diagnostics |
| CScopedDiagnosticHandler | This diagnostic handler is a simple RAII class that registers and erases a diagnostic handler on a given context |
| 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 |
| CParallelDiagnosticHandler | This class is a utility diagnostic handler for use when multi-threading some part of the compiler where diagnostics may be emitted |
| CDialect | Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the entire group |
| CDialectAsmPrinter | This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom printAttribute/printType() method on a dialect |
| CDialectAsmParser | The DialectAsmParser has methods for interacting with the asm parser when parsing attributes and types |
| CFieldParser | Provide a template class that can be specialized by users to dispatch to parsers |
| CFieldParser< AttributeT, std::enable_if_t< std::is_base_of< Attribute, AttributeT >::value, AttributeT > > | Parse an attribute |
| CFieldParser< TypeT, std::enable_if_t< std::is_base_of< Type, TypeT >::value, TypeT > > | Parse a type |
| CFieldParser< IntT, std::enable_if_t< std::is_integral< IntT >::value, IntT > > | Parse any integer |
| CFieldParser< std::string > | Parse a string |
| 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< 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< AffineMap > | Parse an affine map |
| 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 |
| CDialectExtensionBase | This class represents an opaque dialect extension |
| CDialectExtension | This class represents a dialect extension anchored on the given set of dialects |
| CDialectRegistry | The DialectRegistry maps a dialect namespace to a constructor for the matching dialect |
| ►CDialectResourceBlobManager | This class defines a manager for dialect resource blobs |
| CBlobEntry | The class represents an individual entry of a blob |
| 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 |
| CDominanceInfo | A class for computing basic dominance information |
| CPostDominanceInfo | A class for computing basic postdominance information |
| CDynamicAttrDefinition | The definition of a dynamic attribute |
| CDynamicAttr | A dynamic attribute instance |
| CDynamicTypeDefinition | The definition of a dynamic type |
| CDynamicType | A dynamic type instance |
| CDynamicOpDefinition | The definition of a dynamic op |
| CExtensibleDialect | A dialect that can be extended with new operations/types/attributes at runtime |
| CDynamicDialect | A dialect that can be defined at runtime |
| CImplicitLocOpBuilder | ImplicitLocOpBuilder maintains a 'current location', allowing use of the create<> method without specifying the location |
| CIntegerSet | An integer set representing a conjunction of one or more affine equalities and inequalities |
| CIRMapping | This is a utility class for mapping one set of IR entities to another |
| CReverseIterator | This iterator enumerates elements in "reverse" order |
| CForwardDominanceIterator | This iterator enumerates elements according to their dominance relationship |
| CReverseDominanceIterator | This iterator enumerates elements according to their reverse dominance relationship |
| CLocationAttr | Location objects represent source locations information in MLIR |
| CLocation | This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around a LocationAttr |
| CFusedLocWith | This class represents a fused location whose metadata is known to be an instance of the given type |
| CFileLineColLoc | An instance of this location represents a tuple of file, line number, and column number |
| CAttrTypeSubElementHandler< Location > | Enable locations to be introspected as sub-elements |
| CMLIRContext | MLIRContext is the top-level object for a collection of MLIR operations |
| COptionalParseResult | This class implements Optional functionality for ParseResult |
| CEmptyProperties | Structure used by default as a "marker" when no "Properties" are set on an Operation |
| 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 > > | |
| 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 |
| COpFoldResult | This class represents a single result from folding an operation |
| COp | This provides public APIs that all operations should have |
| COpInterface | This class represents the base of an operation interface |
| ►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 |
| COpaqueProperties | Simple wrapper around a void* in order to express generically how to pass in op properties through APIs |
| ►COperationName | |
| CImpl | |
| CInterfaceConcept | This class represents a type erased version of an operation |
| CUnregisteredOpModel | Default implementation for unregistered operations |
| ►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 |
| CNamedAttrList | NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work to remain sorted |
| COperationState | This represents an operation in an abstracted form, suitable for use with the builder APIs |
| COpPrintingFlags | Set of flags used to control the behavior of the various IR print methods (e.g |
| 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) |
| CAsmDialectResourceHandle | This class represents an opaque handle to a dialect resource entry |
| CAsmDialectResourceHandleBase | This class represents a CRTP base class for dialect resource handles |
| ►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 | |
| COpAsmPrinter | This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom print() method |
| ►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 |
| ►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 |
| COpAsmDialectInterface | |
| CPatternBenefit | This class represents the benefit of a pattern match in a unitless scheme that ranges from 0 (very little benefit) to 65K |
| ►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 |
| CRewritePattern | RewritePattern is the common base class for all DAG to DAG replacements |
| 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 |
| 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 |
| COpTraitRewritePattern | OpTraitRewritePattern is a wrapper around RewritePattern that allows for matching and rewriting against instances of an operation that possess a given trait |
| ►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 | |
| 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 |
| 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 |
| CRewritePatternSet | |
| ►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 |
| CRegionRange | This class provides an abstraction over the different types of ranges over Regions |
| ►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 |
| CSymbolTableCollection | This class represents a collection of SymbolTables |
| CLockedSymbolTableCollection | This class implements a lock-based shared wrapper around a symbol table collection that allows shared access to the collection of symbol tables |
| 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 |
| 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 |
| CValueTypeIterator | This class implements iteration on the types of a given range of values |
| CAttrTypeSubElementHandler< TypeRange > | Enable TypeRange to be introspected for sub-elements |
| CType | Instances of the Type class are uniqued, have an immutable identifier and an optional mutable component |
| CTypeInterface | This class represents the base of a type interface |
| CAbstractType | This class contains all of the static information common to all instances of a registered Type |
| CTypeStorage | Base storage class appearing in a Type |
| COperandElementTypeIterator | |
| CResultElementTypeIterator | |
| CIRUnit | IRUnit is a union of the different types of IR objects that consistute the IR structure (other than Type and Attribute), that is Operation, Region, and Block |
| 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 |
| CIROperand | A reference to a value, suitable for use as an operand of an operation |
| CIRObjectWithUseList | This class represents a single IR object that contains a use list |
| 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 |
| COpOperand | This class represents an operand of an operation |
| CBlockArgument | This class represents an argument of a Block |
| COpResult | This is a value defined by a result of an operation |
| COperandRange | This class implements the operand iterators for the Operation class |
| COperandRangeRange | This class represents a contiguous range of operand ranges, e.g |
| 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 |
| ►CResultRange | This class implements the result iterators for the Operation class |
| CUseIterator | This class implements a use iterator for a range of operation results |
| CValueRange | This class provides an abstraction over the different types of ranges over Values |
| CWalkResult | A utility result that is used to signal how to proceed with an ongoing walk: |
| CForwardIterator | This iterator enumerates the elements in "forward" order |
| CWalkStage | A utility class to encode the current walk stage for "generic" walkers |
| CAnalysisManager | This class represents an analysis manager for a particular operation instance |
| CModuleAnalysisManager | An analysis manager class specifically for the top-level operation |
| ►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 |
| COperationPass< void > | Pass to transform an operation |
| CPassWrapper | This class provides a CRTP wrapper around a base pass class to define several necessary utility methods |
| CPassExecutionAction | This class encapsulates the "action" of executing a single pass |
| ►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 |
| COpPassManager | This class represents a pass manager that runs passes on either a specific operation type, or any isolated operation |
| CReproducerStream | Streams on which to output crash reproducer |
| ►CPassManager | The main pass manager and pipeline builder |
| CIRPrinterConfig | A configuration struct provided to the IR printer instrumentation |
| CPassPipelineOptions | Subclasses of PassPipelineOptions provide a set of options that can be used to initialize a pass pipeline |
| CEmptyPipelineOptions | A default empty option struct to be used for passes that do not need to take any options |
| CPassRegistryEntry | Structure to group information about a passes and pass pipelines (argument to invoke via mlir-opt, description, pass pipeline builder) |
| CPassPipelineInfo | A structure to represent the information of a registered pass pipeline |
| CPassInfo | A structure to represent the information for a derived pass class |
| CPassRegistration | PassRegistration provides a global initializer that registers a Pass allocation routine for a concrete pass instance |
| 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 |
| CPassPipelineCLParser | This class implements a command-line parser for MLIR passes |
| CPassNameCLParser | This class implements a command-line parser specifically for MLIR pass names |
| CPassReproducerOptions | |
| ►CReductionNode | ReductionTreePass will build a reduction tree during module reduction and the ReductionNode represents the vertex of the tree |
| Citerator | |
| Citerator< SinglePath > | |
| CDialectReductionPatternInterface | This is used to report the reduction patterns for a Dialect |
| CTester | This class is used to keep track of the testing environment of the tool |
| CFrozenRewritePatternSet | This class represents a frozen set of patterns that can be processed by a pattern applicator |
| CApplyPatternAction | This is the type of Action that is dispatched when a pattern is applied |
| CPatternApplicator | This class manages the application of a group of rewrite patterns, with a user-provided cost model |
| CCopyOnWriteArrayRef | |
| ►CCyclicReplacerCache | A cache for replacer-like functions that map values between two domains |
| CCacheEntry | A possibly unresolved cache entry |
| CCachedCyclicReplacer | A helper class for cases where the input/output types of the replacer function is identical to the types stored in the cache |
| ►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 |
| ►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 |
| CThreadLocalCache | This class provides support for defining a thread local object with non static storage duration |
| CTimingIdentifier | This class represesents a uniqued string owned by a TimingManager |
| CTimingManager | This class represents facilities to measure execution time |
| CTimer | A handle for a timer in a TimingManager |
| CTimingScope | An RAII-style wrapper around a timer that ensures the timer is properly started and stopped |
| CTimeRecord | Simple record class to record timing information |
| COutputStrategy | Facilities for printing timing reports to various output formats |
| CDefaultTimingManager | Facilities for time measurement and report printing to an output stream |
| 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 |
| CSelfOwningTypeID | Defines a TypeID for each instance of this class by using a pointer to the instance |
| CGenInfo | Structure to group information about a generator (argument to invoke via mlir-tblgen, description, and generator function) |
| CGenRegistration | GenRegistration provides a global initializer that registers a generator function |
| CGenNameParser | Adds command line option for each registered generator |
| 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 |
| CMlirOptMainConfig | Configuration options for the mlir-opt tool |
| CTranslation | This class contains all of the components necessary for performing a translation |
| CTranslateToMLIRRegistration | Use Translate[ToMLIR|FromMLIR]Registration as an initializer that registers a function and associates it with name |
| CTranslateFromMLIRRegistration | |
| CTranslateRegistration | |
| CTranslationParser | A command line parser for translation functions |
| CDialectPluginLibraryInfo | Information about the plugin required to load its dialects & passes |
| CDialectPlugin | A loaded dialect plugin |
| CPassPluginLibraryInfo | Information about the plugin required to load its passes |
| CPassPlugin | A loaded pass plugin |
| CCFGToSCFInterface | Interface that should be implemented by any caller of transformCFGToSCF |
| ►CTypeConverter | Type conversion class |
| CAttributeConversionResult | The general result of a type attribute conversion callback, allowing for early termination |
| ►CSignatureConversion | This class provides all of the information necessary to convert a type signature |
| CInputMapping | This struct represents a range of new types or a single value that remaps an existing signature input |
| CConversionPattern | Base class for the conversion patterns |
| COpConversionPattern | OpConversionPattern is a wrapper around ConversionPattern that allows for matching and rewriting against an instance of a derived operation class as opposed to a raw Operation |
| COpInterfaceConversionPattern | OpInterfaceConversionPattern is a wrapper around ConversionPattern that allows for matching and rewriting against an instance of an OpInterface class as opposed to a raw Operation |
| COpTraitConversionPattern | OpTraitConversionPattern is a wrapper around ConversionPattern that allows for matching and rewriting against instances of an operation that possess a given trait |
| CConversionPatternRewriter | This class implements a pattern rewriter for use with ConversionPatterns |
| ►CConversionTarget | This class describes a specific conversion target |
| CLegalOpDetails | A structure containing additional information describing a specific legal operation instance |
| CPDLConversionConfig | A PDL configuration that is used to supported dialect conversion functionality |
| CConversionConfig | Dialect conversion configuration |
| CEndomorphismSimplification | |
| COperationFolder | A utility class for folding operations, and unifying duplicated constants generated along the way |
| CGreedyRewriteConfig | This class allows control over how the GreedyPatternRewriteDriver works |
| CHomomorphismSimplification | |
| CInlinerConfig | |
| ►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 |
| CDialectInlinerInterface | This is the interface that must be implemented by the dialects of operations to be inlined |
| CInlinerInterface | This interface provides the hooks into the inlining interface |
| CMem2RegStatistics | Statistics collected while applying mem2reg |
| COneToNTypeMapping | Stores a 1:N mapping of types and provides several useful accessors |
| CRewritePatternWithConverter | Extends the basic RewritePattern class with a type converter member and some accessors to it |
| COneToNPatternRewriter | Specialization of PatternRewriter that OneToNConversionPatterns use |
| COneToNConversionPattern | Base class for patterns with 1:N type conversions |
| ►COneToNOpConversionPattern | This class is a wrapper around OneToNConversionPattern for matching against instances of a particular op class |
| COpAdaptor | Generic adaptor around the root op of this pattern using the converted operands |
| CSROAStatistics | Statistics collected while applying SROA |
| CLexer | This class breaks up the current file into a token stream |
| CToken | This represents a token in the MLIR syntax |
| CPyPrintAccumulator | Accumulates into a python string from a method that accepts an MlirStringCallback |
| CPyFileAccumulator | Accumulates int a python file-like object, either writing text (default) or binary |
| 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) |
| CSliceable | A CRTP base class for pseudo-containers willing to support Python-type slicing access on top of indexed access |
| CExternalPass | This pass class wraps external passes defined in other languages using the MLIR C-interface |
| CGPUDynamicSharedMemoryOpLowering | Lowering for gpu.dynamic.shared.memory to LLVM dialect |
| CGPUFuncOpLoweringOptions | |
| CGPUFuncOpLowering | |
| 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 | |
| CScalarizeVectorOpLowering | Rewriting that unrolls SourceOp to scalars if it's operating on vectors |
| COpToFuncCallLowering | Rewriting that replace SourceOp with a CallOp to f32Func or f64Func or f32ApproxFunc or f16Func depending on the element type and the fastMathFlag of that Op |
| CScfToSPIRVContextImpl | |
| CAttrTypeSubElementHandler< LLVM::detail::LLVMStructTypeStorage::Key > | Allow walking and replacing the subelements of a LLVMStructTypeStorage key |
| CMLIRContextImpl | This is the implementation of the MLIRContext class, using the pImpl idiom |
| COperationConverter | |
| ►Nnanobind | |
| ►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< MlirLocation > | Casts object <-> MlirLocation |
| Ctype_caster< MlirModule > | Casts object <-> MlirModule |
| Ctype_caster< MlirFrozenRewritePatternSet > | Casts object <-> MlirFrozenRewritePatternSet |
| Ctype_caster< MlirOperation > | Casts object <-> MlirOperation |
| Ctype_caster< MlirValue > | Casts object <-> MlirValue |
| Ctype_caster< MlirPassManager > | Casts object -> MlirPassManager |
| Ctype_caster< MlirTypeID > | Casts object <-> MlirTypeID |
| Ctype_caster< MlirType > | Casts object <-> MlirType |
| Ctype_caster< mlir::python::DefaultingPyMlirContext > | |
| Ctype_caster< mlir::python::DefaultingPyLocation > | |
| CMlirDefaultingCaster | |
| ►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< MlirLocation > | Casts object <-> MlirLocation |
| Ctype_caster< MlirModule > | Casts object <-> MlirModule |
| Ctype_caster< MlirFrozenRewritePatternSet > | Casts object <-> MlirFrozenRewritePatternSet |
| Ctype_caster< MlirOperation > | Casts object <-> MlirOperation |
| Ctype_caster< MlirValue > | Casts object <-> MlirValue |
| Ctype_caster< MlirPassManager > | Casts object -> MlirPassManager |
| Ctype_caster< MlirTypeID > | Casts object <-> MlirTypeID |
| Ctype_caster< MlirType > | Casts object <-> MlirType |
| ►Nstd | |
| Citerator_traits< nanobind::detail::fast_iterator > | |
