| ►NAppIDIndex | |
| CModuleAppIDs | Helper class constructed on a per-HWModuleLike basis |
| ►Ncirct | The InstanceGraph op interface, see InstanceGraphInterface.td for more details |
| ►Naiger | |
| CExportAIGERHandler | Handler for AIGER export |
| CExportAIGEROptions | Options for AIGER export |
| CImportAIGEROptions | Options for AIGER import |
| ►Nanalysis | |
| CCyclicSchedulingAnalysis | CyclicSchedulingAnalysis constructs a CyclicProblem for each AffineForOp by performing a memory dependence analysis and inserting dependences into the problem |
| CMemoryDependence | MemoryDependence captures a dependence from one memory operation to another |
| CMemoryDependenceAnalysis | MemoryDependenceAnalysis traverses any AffineForOps in the FuncOp body and checks for affine memory access dependences |
| COpCountAnalysis | |
| ►Narc | |
| CArcCostModel | |
| CArcReducePatternDialectInterface | A dialect interface to provide reduction patterns to a reducer tool |
| CModelInfo | Gathers information about a given Arc model |
| COperationCosts | |
| CRuntimeCostEstimateDialectInterface | A dialect interface to get runtime cost estimates of MLIR operations |
| CStateInfo | Gathers information about a given Arc state |
| ►Ncalyx | |
| CBasicLoopInterface | |
| CBuildBasicBlockRegs | Builds registers for each block argument in the program |
| CBuildCallInstance | Builds instance for the calyx.invoke and calyx.group in order to initialize the instance |
| CBuildReturnRegs | Builds registers for the return statement of the program and constant assignments to the component return value |
| CCalyxLoweringState | An interface for conversion passes that lower Calyx programs |
| CCombinational | Signals that the following operation is combinational |
| ►CComponentLoweringStateInterface | |
| CIsFloatingPoint | |
| CIsFloatingPoint< T, std::void_t< decltype(std::declval< T >().getFloatingPointStandard())> > | |
| CControlLike | Signals that the following operation is "control-like." |
| CConvertIndexTypes | Converts all index-typed operations and values to i32 values |
| CDeduplicateParallelOp | Removes duplicate EnableOps in parallel operations |
| CDeduplicateStaticParallelOp | Removes duplicate EnableOps in static parallel operations |
| CEliminateUnusedCombGroups | Removes calyx::CombGroupOps which are unused |
| CFuncOpPartialLoweringPattern | FuncOpPartialLoweringPatterns are patterns which intend to match on FuncOps and then perform their own walking of the IR |
| CInlineCombGroups | This pass recursively inlines use-def chains of combinational logic (from non-stateful groups) into groups referenced in the control schedule |
| CLoopInterface | |
| CLoopLoweringStateInterface | |
| CMemoryInterface | |
| CMemoryPortsImpl | |
| CMultipleGroupDonePattern | When building groups which contain accesses to multiple sequential components, a group_done op is created for each of these |
| CNonTerminatingGroupDonePattern | GroupDoneOp's are terminator operations and should therefore be the last operator in a group |
| CPartialLoweringPattern | Base class for partial lowering passes |
| CPortInfo | This holds information about the port for either a Component or Cell |
| ►CPredicateInfo | Predicate information for the floating point comparisons |
| CInputPorts | |
| CRepeatOpInterface | |
| CRewriteMemoryAccesses | This pass rewrites memory accesses that have a width mismatch |
| CSchedulerInterface | Holds common utilities used for scheduling when lowering to Calyx |
| CWhileOpInterface | |
| ►Nchirrtl | |
| CCHIRRTLVisitor | CHIRRTLVisitor is a visitor for CHIRRTL operations |
| ►Ncomb | |
| CCombinationalVisitor | This helps visit Combinational nodes |
| ►Ndatapath | |
| CCompressorBit | |
| CCompressorTree | |
| ►Ndc | |
| CEliminateBranchToSelectPattern | |
| CEliminateForkOfSourcePattern | |
| CEliminateForkToForkPattern | |
| CEliminateRedundantUnpackPattern | |
| CEliminateUnusedForkResultsPattern | |
| CJoinOnBranchPattern | |
| CRemoveDuplicateJoinOperandsPattern | |
| CRemoveJoinOnSourcePattern | |
| CStaggeredJoinCanonicalization | |
| ►Ndebug | |
| CEmitHGLDDOptions | Options for HGLDD emission |
| ►Ndetail | |
| CDebugInfoBuilder | Helper to populate a DebugInfo with nodes |
| ►Nesi | |
| ►Ndetail | |
| CESIHWBuilder | Assist the lowering steps for conversions which need to create auxiliary IR |
| CRemoveOpLowering | Generic pattern for removing an op during pattern conversion |
| CAppIDIndex | An index for resolving AppIDPaths to dynamic instances |
| CBundledChannel | |
| CPlatform | This should eventually become a set of functions to define the various platform-specific lowerings |
| CServiceGeneratorDispatcher | Class which "dispatches" a service implementation request to its specified generator |
| CServicePortInfo | Describes a service port |
| ►NExportSystemC | |
| CAttrEmissionPattern | This is a convenience class providing default implementations for attribute emission patterns |
| CAttrEmissionPatternBase | This is intended to be the base class for all emission patterns matching on attributes |
| CEmissionPatternSet | This class collects a set of emission patterns with base type 'PatternTy' |
| CEmissionPrinter | This is intended to be the driving class for all pattern-based IR emission |
| ►CFrozenEmissionPatternSet | This class intends to collect a set of emission patterns in a way to provide fast lookups, but does not allow to add more patterns after construction |
| CImpl | The internal implementation of the frozen pattern set |
| CInlineEmitter | This class is returned to a pattern that requested inlined emission of a value |
| CMatchResult | This class allows a pattern's match function for inlining to pass its result's precedence to the pattern that requested the expression |
| COpEmissionPattern | This is a convenience class providing default implementations for operation emission patterns |
| COpEmissionPatternBase | This is intended to be the base class for all emission patterns matching on operations |
| CPatternBase | This is indented to be the base class for all emission patterns |
| CTypeEmissionPattern | This is a convenience class providing default implementations for type emission patterns |
| CTypeEmissionPatternBase | This is intended to be the base class for all emission patterns matching on types |
| ►NExportVerilog | |
| CFieldNameResolver | |
| CFileInfo | Information to control the emission of a list of operations into a file |
| CGlobalNameResolver | This class keeps track of modules and interfaces that need to be renamed, as well as module ports, parameters, declarations and verif labels that need to be renamed |
| CGlobalNameTable | This class keeps track of global names at the module/interface level |
| CNameCollisionResolver | |
| COpFileInfo | Information to control the emission of a single operation into a file |
| ►COpLocMap | Track the output verilog line,column number information for every op |
| CLineColPair | |
| CLocationRange | |
| CSharedEmitterState | This class tracks the top-level state for the emitters, which is built and then shared across all per-file emissions that happen in parallel |
| CStringOrOpToEmit | This class wraps an operation or a fixed string that should be emitted |
| ►Nfirrtl | |
| ►Ndetail | |
| CAnnoTargetImpl | |
| CBaseTypeAliasStorage | |
| CBundleTypeStorage | |
| CClassTypeStorage | |
| CFEnumTypeStorage | |
| CFIRRTLBaseTypeStorage | |
| CFVectorTypeStorage | |
| COpenBundleTypeStorage | |
| COpenVectorTypeStorage | |
| CWidthTypeStorage | |
| CAnnoPathValue | |
| CAnnoRecord | ===-------------------------------------------------------------------—===// LowerAnnotations ===-------------------------------------------------------------------—===// |
| CAnnoTarget | An annotation target is used to keep track of something that is targeted by an Annotation |
| CAnnoTargetCache | Cache AnnoTargets for a module's named things |
| ►CAnnotation | This class provides a read-only projection of an annotation |
| CClassIsa | Helper struct to perform variadic class equality check |
| CAnnotationSet | This class provides a read-only projection over the MLIR attributes that represent a set of annotations |
| CAnnotationSetIterator | |
| CApplyState | State threaded through functions for resolving and applying annotations |
| CBaseTypeAliasOr | |
| CCircuitNamespace | The namespace of a CircuitOp, generally inhabited by modules |
| CCircuitTargetCache | Cache AnnoTargets for a circuit's modules, walked as needed |
| CClassElement | |
| CContainAliasableTypes | A struct to check if there is a type derived from FIRRTLBaseType |
| CContainAliasableTypes< BaseTy > | |
| CDeclVisitor | ExprVisitor is a visitor for FIRRTL declaration nodes |
| CExprVisitor | ExprVisitor is a visitor for FIRRTL expression nodes |
| CFieldRefCache | Caching version of getFieldRefFromValue |
| ►CFieldSource | To use this class, retrieve a cached copy from the analysis manager: auto &fieldsource = getAnalysis<FieldSource>(getOperation()); |
| CPathNode | |
| CFIRLexer | This implements a lexer for .fir files |
| CFIRLexerCursor | This is the state captured for a lexer cursor |
| CFirMemory | |
| CFIRParserOptions | |
| CFIRRTLBaseType | |
| CFIRRTLIntrinsicLoweringDialectInterface | |
| CFIRRTLReducePatternDialectInterface | A dialect interface to provide reduction patterns to a reducer tool |
| CFIRRTLType | |
| CFIRRTLTypeSwitch | This class implements the same functionality as TypeSwitch except that it uses firrtl::type_dyn_cast for dynamic cast |
| CFIRRTLTypeSwitch< T, void > | Specialization of FIRRTLTypeSwitch for void returning callables |
| CFIRRTLVisitor | FIRRTLVisitor allows you to visit all of the expr/stmt/decls with one class declaration |
| CFIRToken | This represents a specific token for .fir files |
| CFIRVersion | The FIRRTL specification version |
| CGenericIntrinsic | Helper class for checking and extracting information from the generic instrinsic op |
| CHierPathCache | A cache of existing HierPathOps, mostly used to facilitate HierPathOp reuse |
| CInstanceGraph | This graph tracks modules and where they are instantiated |
| ►CInstanceInfo | |
| CCircuitAttributes | Information about a circuit |
| CLatticeValue | A lattice value to record the value of a property |
| CModuleAttributes | Information about a module |
| CIntrinsicConverter | Base class for Intrinsic Converters |
| CIntrinsicLoweringDialectInterface | A dialect interface to provide lowering conversions |
| CIntrinsicLoweringInterfaceCollection | |
| CIntrinsicLowerings | Lowering helper which collects all intrinsic converters |
| CIntrinsicOpConverter | |
| CIntType | This is the common base class between SIntType and UIntType |
| CLayerSetCompare | Compares two SymbolRefAttr lexicographically, returning true if LHS should be ordered before RHS |
| CLegacyWiringProblem | A representation of a legacy Wiring problem consisting of a signal source that should be connected to one or many sinks |
| CModuleModifications | A store of pending modifications to a FIRRTL module associated with solving one or more WiringProblems |
| CNLATable | This table tracks nlas and what modules participate in them |
| COpAnnoTarget | This represents an annotation targeting a specific operation |
| COwningModuleCache | This implements an analysis to determine which module owns a given path operation |
| CPortAnnoTarget | This represents an annotation targeting a specific port of a module, memory, or instance |
| CPortInfo | This holds the name and type that describes the module's ports |
| CPropertyType | |
| CRecursiveTypeProperties | A collection of bits indicating the recursive properties of a type |
| CSameOperandsIntTypeKind | A binary operation where the operands have the same integer kind |
| CStmtExprVisitor | StmtExprVisitor is a visitor for FIRRTL operation that has an optional result |
| CStmtVisitor | ExprVisitor is a visitor for FIRRTL statement nodes |
| CTargetToken | Stores an index into an aggregate |
| CTokenAnnoTarget | The parsed annotation path |
| CWidthQualifiedTypeTrait | Trait for types which have a width |
| CWiringProblem | A representation of a deferred Wiring problem consisting of a source that should be connected to a sink |
| ►Nfirtool | |
| CFirtoolOptions | Set of options used to control the behavior of the firtool pipeline |
| ►Nhandshake | |
| ►CHandshakeLowering | |
| CMergeOpInfo | |
| CHandshakeVisitor | HandshakeVisitor is a visitor for handshake nodes |
| CMemLoadInterface | |
| CMemStoreInterface | |
| ►Nhw | |
| ►Ndetail | |
| CFieldInfo | Struct defining a field. Used in structs |
| CModuleTypeStorage | |
| COffsetFieldInfo | Struct defining a field with an offset. Used in unions |
| ►Nmodule_like_impl | |
| CPortParse | |
| CHierPathCache | |
| CHWModulePortAccessor | |
| CHWReducePatternDialectInterface | A dialect interface to provide reduction patterns to a reducer tool |
| ►CHWSymbolCache | This stores lookup tables to make manipulating and working with the IR more efficient |
| CHwSymbolCacheIteratorImpl | |
| CItem | |
| CInnerRefNamespace | This class represents the namespace in which InnerRef's can be resolved |
| CInnerRefNamespaceLike | Classify operations that are InnerRefNamespace-like, until structure is in place to do this via Traits |
| CInnerSymbolNamespace | |
| CInnerSymbolNamespaceCollection | |
| CInnerSymbolTable | A table of inner symbols and their resolutions |
| CInnerSymbolTableCollection | This class represents a collection of InnerSymbolTable's |
| CInnerSymTarget | The target of an inner symbol, the entity the symbol is a handle for |
| CInstanceGraph | HW-specific instance graph with a virtual entry node linking to all publicly visible modules |
| CModulePort | |
| CModulePortInfo | This holds a decoded list of input/inout and output ports for a module or instance |
| CModulePortLookupInfo | |
| CPortConversion | Base class for the port conversion of a particular port |
| CPortConversionBuilder | |
| CPortConverter | |
| CPortConverterImpl | |
| CPortInfo | This holds the name, type, direction of a module's ports |
| CStmtVisitor | This helps visit TypeOp nodes |
| CTypeAliasOr | |
| CTypeOpVisitor | This helps visit TypeOp nodes |
| CTypeVariant | Utility type that wraps a type that may be one of several possible Types |
| ►Nigraph | |
| ►Ndetail | |
| CAddressIterator | This just maps a iterator of references to an iterator of addresses |
| CInstanceGraph | This graph tracks modules and where they are instantiated |
| ►CInstanceGraphNode | This is a Node in the InstanceGraph |
| CUseIterator | Iterator for module uses |
| CInstancePath | An instance path composed of a series of instances |
| CInstancePathCache | A data structure that caches and provides paths to module instances in the IR |
| CInstanceRecord | This is an edge in the InstanceGraph |
| ►Nimpl | |
| CConvertToLLVMPass | |
| ►NImportVerilog | |
| CClassLowering | |
| CContext | A helper class to facilitate the conversion from a Slang AST to MLIR operations |
| CFunctionLowering | Function lowering information |
| CHierPathInfo | Hierarchical path information |
| CLoopFrame | Information about a loops continuation and exit blocks relevant while lowering the loop's body statements |
| CModuleLowering | Module lowering information |
| CPortLowering | Port lowering information |
| ►Nllhd | |
| ►Ndeseq | |
| CClockInfo | A single clock extracted from a process during trigger analysis |
| CDNF | A boolean function expressed in canonical disjunctive normal form |
| CDNFTerm | A single AND operation within a DNF |
| CDriveInfo | A drive op and the clock and reset that resulted from trigger analysis |
| CFixedValue | A single i1 value that is fixed to a given value in the past and the present |
| CResetInfo | A single reset extracted from a process during trigger analysis |
| CTruthTable | A boolean function expressed as a truth table |
| CValueEntry | A single entry in a value table |
| CValueTable | A table of SSA values and the conditions under which they appear |
| CProceduralRegion | Signals that an operations regions are procedural |
| ►Nlsp | |
| CDebounceOptions | Debounce tuning for document-change bursts |
| CLSPDiagnosticClient | |
| CLSPServerOptions | |
| CPendingChanges | Accumulated edits + timing for a single document key |
| CPendingChangesMap | Thread-safe accumulator + debouncer for text document changes |
| CVerilogDocument | |
| CVerilogIndex | |
| ►CVerilogServer | This class implements all of the Verilog related functionality necessary for a language server |
| CImpl | |
| CVerilogServerContext | |
| CVerilogServerOptions | |
| CVerilogTextFile | This class represents a text file containing one or more Verilog documents |
| ►Nltl | |
| CVisitor | |
| ►Nmoore | |
| CPackedType | A packed SystemVerilog type |
| CStructLikeMember | A member of a struct |
| CUnpackedType | An unpacked SystemVerilog type |
| ►Nmsft | |
| ►CPlacementDB | A data structure to contain both the locations of the primitives on the device and instance assignments to said primitives locations, aka placements |
| CPlacementCell | A memory slot |
| CWalkOrder | |
| CPrimitiveDB | A data structure to contain locations of the primitives on the device |
| CRemoveOpLowering | Generic pattern for removing an op during pattern conversion |
| CTclEmitter | Instantiate for all Tcl emissions |
| ►Nom | |
| ►Nevaluator | |
| ►CAttributeValue | Values which can be directly representable by MLIR attributes |
| CPrivateTag | |
| CBasePathValue | A Basepath value |
| CEvaluatorValue | Base class for evaluator runtime values |
| CListValue | A List which contains variadic length of elements with the same type |
| CObjectValue | A composite Object, which has a type and fields |
| CPathValue | A Path value |
| CReferenceValue | Values which can be used as pointers to different values |
| CUnknownValue | An unknown value |
| CEvaluator | An Evaluator, which is constructed with an IR module and can instantiate Objects |
| CPathElement | A module name, and the name of an instance inside that module |
| ►Npipelinetocalyx | |
| CBuildControl | Builds a control schedule by traversing the CFG of the function and associating this with the previously created groups |
| CBuildOpGroups | Iterate through the operations of a source function and instantiate components or primitives based on the type of the operations |
| CBuildPipelineGroups | Builds groups for assigning registers for pipeline stages |
| CBuildPipelineRegs | Builds registers for each pipeline stage in the program |
| CBuildWhileGroups | In BuildWhileGroups, a register is created for each iteration argumenet of the while op |
| CCleanupFuncOps | Erases FuncOp operations |
| CComponentLoweringState | Handles the current state of lowering of a Calyx component |
| CFuncOpConversion | Creates a new Calyx component for each FuncOp in the program |
| CLateSSAReplacement | LateSSAReplacement contains various functions for replacing SSA values that were not replaced during op construction |
| ►CLoopScheduleToCalyxPass | |
| CLoweringPattern | |
| CPipelineScheduleable | |
| CPipelineScheduler | Holds additional information required for scheduling Pipeline pipelines |
| CPipelineWhileOp | |
| ►Npretty | |
| CBeginToken | |
| CBreakToken | |
| CBufferingPP | Buffer tokens for clients that need to adjust things |
| CCallbackToken | |
| CEndToken | |
| CPPExtString | String wrapper to indicate string has external storage |
| CPPSaveString | String wrapper to indicate string needs to be saved |
| ►CPrettyPrinter | |
| CFormattedToken | Format token with tracked size |
| CListener | Listener to Token storage events |
| CPrintEntry | Printing information for active scope, stored in printStack |
| CPrintEventAndStorageListener | Note: Callable class must implement a callable with signature: void (Data) |
| CStringToken | Token types |
| ►CToken | |
| CBeginInfo | |
| CBreakInfo | |
| CCallbackInfo | |
| CEndInfo | |
| CStringInfo | |
| CTokenInfo | |
| CTokenBase | Helper class to CRTP-derive common functions |
| CTokenBuilder | Add convenience methods for generating pretty-printing tokens |
| CTokenStream | Wrap a PrettyPrinter with TokenBuilder features as well as operator<<'s |
| CTokenStreamWithCallback | Wrap the TokenStream with a helper for CallbackTokens, to record the print events on the stream |
| CTokenStringSaver | PrettyPrinter::Listener that saves strings while live |
| ►Npython | |
| CPyFileAccumulator | Taken from NanobindUtils.h in MLIR |
| ►Nreduce | |
| CInnerSymbolUses | A helper struct that scans a root operation and all its nested operations for InnerRefAttrs |
| ►Nrtg | |
| ►Ndetail | |
| CImmediateAttrStorage | |
| CDictEntry | Defines an entry in an !rtg.dict |
| CInstructionOpAdaptorTrait | |
| CRandomizationPipelineOptions | Options for the RTG randomization pipeline |
| CRTGOpVisitor | This helps visit TypeOp nodes |
| CRTGReducePatternDialectInterface | A dialect interface to provide reduction patterns to a reducer tool |
| CRTGTypeVisitor | This helps visit TypeOp nodes |
| ►Nscftocalyx | |
| CBuildControl | Builds a control schedule by traversing the CFG of the function and associating this with the previously created groups |
| CBuildForGroups | In BuildForGroups, a register is created for the iteration argument of the for op |
| CBuildIfGroups | |
| CBuildOpGroups | Iterate through the operations of a source function and instantiate components or primitives based on the type of the operations |
| CBuildWhileGroups | In BuildWhileGroups, a register is created for each iteration argumenet of the while op |
| CCallScheduleable | |
| CCleanupFuncOps | Erases FuncOp operations |
| CComponentLoweringState | Handles the current state of lowering of a Calyx component |
| CForLoopLoweringStateInterface | |
| CForScheduleable | |
| CFuncOpConversion | Creates a new Calyx component for each FuncOp in the program |
| CIfLoweringStateInterface | |
| CIfScheduleable | |
| CInlineExecuteRegionOpPattern | Inlines Calyx ExecuteRegionOp operations within their parent blocks |
| CLateSSAReplacement | LateSSAReplacement contains various functions for replacing SSA values that were not replaced during op construction |
| CParScheduleable | |
| CScfForOp | |
| CScfWhileOp | |
| CSeqOpLoweringStateInterface | Stores the state information for condition checks involving sequential computation |
| CWhileLoopLoweringStateInterface | |
| CWhileScheduleable | |
| ►Nscheduling | |
| ►Ndetail | |
| CDependence | A wrapper class to uniformly handle def-use and auxiliary dependence edges |
| CDependenceIterator | An iterator to transparently surface an operation's def-use dependences from the SSA subgraph (induced by the registered operations), as well as auxiliary, operation-to-operation dependences explicitly provided by the client |
| CChainingCyclicProblem | This class models the accumulation of physical propagation delays on combinational paths along SSA dependences on a cyclic scheduling problem |
| CChainingProblem | This class models the accumulation of physical propagation delays on combinational paths along SSA dependences |
| CCyclicProblem | This class models a cyclic scheduling problem |
| CModuloProblem | This class models the modulo scheduling problem as the composition of the cyclic problem and the resource-constrained problem with fully-pipelined shared operators |
| ►CProblem | This class models the most basic scheduling problem |
| COperatorType | Operator types are distinguished by name (chosen by the client) |
| CResourceType | Resource types are distinguished by name (chosen by the client) |
| CSharedOperatorsProblem | This class models a resource-constrained scheduling problem |
| ►Nseq | |
| CFirMemory | Helper structure carrying information about FIR memory generated ops |
| ►Nssp | |
| CDefault | Dummy struct to query a problem's default properties (i.e |
| CDefault< scheduling::ChainingCyclicProblem > | |
| CDefault< scheduling::ChainingProblem > | |
| CDefault< scheduling::CyclicProblem > | |
| CDefault< scheduling::ModuloProblem > | |
| CDefault< scheduling::Problem > | |
| CDefault< scheduling::SharedOperatorsProblem > | |
| ►Nsv | |
| CCaseBitPattern | |
| CCaseDefaultPattern | |
| CCaseEnumPattern | |
| CCaseExprPattern | |
| CCaseInfo | |
| CCasePattern | |
| CNonProceduralOp | This class verifies that the specified op is not located in a procedural region |
| CProceduralOp | This class verifies that the specified op is located in a procedural region |
| CProceduralRegion | Signals that an operations regions are procedural |
| CVendorExtension | This class provides a verifier for ops that are expecting their parent to be one of the given parent ops |
| CVisitor | |
| ►Nsynth | |
| CAndInverterVariadicOpConversion | |
| CCombLoweringPipelineOptions | Options for the aig lowering pipeline |
| CCut | Represents a cut in the combinational logic network |
| CCutEnumerator | Cut enumeration engine for combinational logic networks |
| CCutRewritePattern | Base class for cut rewriting patterns used in combinational logic optimization |
| CCutRewritePatternSet | Manages a collection of rewriting patterns for combinational logic optimization |
| CCutRewriter | Main cut-based rewriting algorithm for combinational logic optimization |
| CCutRewriterOptions | Configuration options for the cut-based rewriting algorithm |
| CCutSet | Manages a collection of cuts for a single logic node using priority cuts algorithm |
| CDataflowPath | |
| CDebugPoint | |
| CIncrementalLongestPathAnalysis | |
| CLongestPathAnalysis | |
| CLongestPathAnalysisOptions | Configuration options for the longest path analysis |
| CLongestPathCollection | |
| CMatchedPattern | Represents a cut that has been successfully matched to a rewriting pattern |
| CObject | |
| COpenPath | |
| CSynthOptimizationPipelineOptions | Options for the synth optimization pipeline |
| ►Nsystemc | |
| ►Ndetail | |
| CIntegerWidthStorage | Integer Type Storage and Uniquing |
| CPortInfo | A struct containing minimal information for a systemc module port |
| CBigIntType | Represents a finite word-length signed integer in SystemC as described in IEEE 1666-2011 §7.6.5 |
| CBigUIntType | Represents a finite word-length unsigned integer in SystemC as described in IEEE 1666-2011 §7.6.6 |
| CBitVectorBaseType | Represents a finite word-length bit vector in SystemC as described in IEEE 1666-2011 §7.9.3 |
| CBitVectorType | Represents a finite word-length bit vector in SystemC as described in IEEE 1666-2011 §7.9.5 |
| CIntBaseType | Represents a limited word-length signed integer in SystemC as described in IEEE 1666-2011 §7.5.2 |
| CIntType | Represents a limited word-length signed integer in SystemC as described in IEEE 1666-2011 §7.5.4 |
| CLogicVectorBaseType | Represents a finite word-length bit vector in SystemC as described in IEEE 1666-2011 §7.9.4 |
| CLogicVectorType | Represents a finite word-length bit vector (of four-state values) in SystemC as described in IEEE 1666-2011 §7.9.6 |
| CSignedType | Represents a finite word-length signed integer in SystemC as described in IEEE 1666-2011 §7.6.3 |
| CUIntBaseType | Represents a limited word-length unsigned integer in SystemC as described in IEEE 1666-2011 §7.5.3 |
| CUIntType | Represents a limited word-length unsigned integer in SystemC as described in IEEE 1666-2011 §7.5.5 |
| CUnsignedType | Represents a finite word-length unsigned integer in SystemC as described in IEEE 1666-2011 §7.6.4 |
| CValueBaseType | This provides a common base class for all SystemC integers |
| ►Nverif | |
| CVisitor | |
| CArcConversionOptions | |
| CArcOptimizationOptions | |
| CArcPreprocessingOptions | |
| CArcStateAllocationOptions | |
| CArcStateLoweringOptions | |
| CBackedge | Backedge is a wrapper class around a Value |
| CBackedgeBuilder | Instantiate one of these and use it to build typed backedges |
| CBinaryTruthTable | Represents a boolean function as a truth table |
| CConversionPatternSet | Extension of RewritePatternSet that allows adding matchAndRewrite functions with op adaptors and ConversionPatternRewriter as patterns |
| CDebugAnalysis | Identify operations and values that are only used for debug info |
| CDebugInfo | Debug information attached to an operation and the operations nested within |
| CDIInstance | |
| CDIModule | |
| CDIVariable | |
| CFieldRef | This class represents a reference to a specific field or element of an aggregate value |
| CFirMemConfig | The configuration of a FIR memory |
| CFirMemLowering | FIR memory lowering helper |
| ►CFirRegLowering | Lower FirRegOp to sv.reg and sv.always |
| CRegCondition | The conditions under which a register is defined |
| CRegLowerInfo | |
| CFVInt | Four-valued arbitrary precision integers |
| ►CHWArithToHWTypeConverter | A helper type converter class that automatically populates the relevant materializations and type conversions for converting HWArith to HW |
| CConvertedType | |
| CHWToLLVMArraySpillCache | Helper class mapping array values (HW or LLVM Dialect) to pointers to buffers containing the array value |
| CHWToLLVMEndianessConverter | |
| CImportVerilogOptions | Options that control how Verilog input files are parsed and processed |
| CLlhdToCorePipelineOptions | Convert LLHD dialect IR into core dialect IR |
| CLoweringOptions | Options which control the emission from CIRCT to Verilog |
| CLoweringOptionsOption | |
| CLoweringOptionsParser | Commandline parser for LoweringOptions |
| CNamespace | A namespace that is used to store existing names and generate new names in some scope within the IR |
| CNPNClass | Represents the canonical form of a boolean function under NPN equivalence |
| COpReduction | A reduction pattern for a specific operation |
| COpUserInfo | |
| CPassReduction | A reduction pattern that applies an mlir::Pass |
| CReachableMuxes | |
| CReducePatternDialectInterface | A dialect interface to provide reduction patterns to a reducer tool |
| CReducePatternInterfaceCollection | |
| CReducePatternSet | |
| CReduction | An abstract reduction pattern |
| CScopedDebugPassLogger | RAII helper for creating a pass header and footer automatically |
| CSeqToSVPass | |
| CSMTGlobalsHandler | A symbol cache for LLVM globals and functions relevant to SMT lowering patterns |
| CSSAMaximizationStrategy | Strategy class to control the behavior of SSA maximization |
| CStringAttrOrRef | A helper union that can represent a StringAttr, StringRef, or Twine |
| ►CSymbolCache | Default symbol cache implementation; stores associations between names (StringAttr's) to mlir::Operation's |
| CSymbolCacheIteratorImpl | |
| ►CSymbolCacheBase | Base symbol cache class to allow for cache lookup through a pointer to some abstract cache |
| CCacheIteratorImpl | |
| CIterator | |
| CTestCase | A single test case to be run by a tester |
| CTester | A testing environment for reduction attempts |
| CTypeConversionPattern | Generic pattern which replaces an operation by one of the same operation name, but with converted attributes, operands, and result types to eliminate illegal types |
| CTypeOpConversionPattern | |
| CUnusedOpPruner | Utility that tracks operations that have potentially become unused and allows them to be cleaned up at a later point |
| CValueMapper | Facilitates the definition and connection of SSA def-use chains between two location - a 'from' location (defining use-def chains) and a 'to' location (where new operations are created based on the 'from' location) |
| CVerbosePassInstrumentation | |
| ►Ncomb | |
| CAddOp | |
| CAndOp | |
| CBinaryOpBuilder | |
| CConcatOp | |
| CDivSOp | |
| CDivUOp | |
| CEqOp | |
| CExtractOp | |
| CExtractOpBuilder | |
| CGeSOp | |
| CGeUOp | |
| CGtSOp | |
| CGtUOp | |
| CICmpOpBuilder | |
| CLeSOp | |
| CLeUOp | |
| CLtSOp | |
| CLtUOp | |
| CModSOp | |
| CModUOp | |
| CMulOp | |
| CMuxOp | |
| CNeOp | |
| COrOp | |
| CParityOp | |
| CShlOp | |
| CShrSOp | |
| CShrUOp | |
| CSubOp | |
| CUnaryOpBuilder | |
| CXorOp | |
| ►Ndetail | |
| CSymbolCache | A utility doing lazy construction of SymbolTables and SymbolUserMaps, which is handy for reductions that need to look up a lot of symbols |
| ►Nesi | |
| ►Nbackends | |
| ►Ncosim | |
| CCosimAccelerator | Connect to an ESI simulation |
| CCosimEngine | Implement the magic cosim channel communication |
| ►CRpcClient | A gRPC client for communicating with the cosimulation server |
| CChannelDesc | Description of a channel from the server |
| CImpl | |
| CReadChannelConnection | Abstract handle for a read channel connection |
| ►Ntrace | |
| ►CTraceAccelerator | Connect to an ESI simulation |
| CImpl | |
| ►Nxrt | |
| ►CXrtAccelerator | Connect to an ESI simulation |
| CImpl | |
| ►Ncosim | |
| ►CRpcServer | TODO: make this a proper backend (as much as possible) |
| CImpl | |
| ►Nregistry | |
| ►Ninternal | |
| CBackendRegistry | |
| CRegisterAccelerator | |
| CRegisterEngine | Helper struct to register engines |
| ►Nservices | |
| ►CCallService | Service for servicing function calls from the accelerator |
| CCallback | A function call which gets attached to a service port |
| CCustomService | A service for which there are no standard services registered |
| ►CFuncService | Service for calling functions |
| CFunction | A function call which gets attached to a service port |
| ►CHostMem | |
| CHostMemRegion | RAII memory region for host memory |
| COptions | Options for allocating host memory |
| ►CMMIO | |
| CMMIORegion | A "slice" of some parent MMIO space |
| CRegionDescriptor | Describe a region (slice) of MMIO space |
| CMMIOSysInfo | Implement the SysInfo API for a standard MMIO protocol |
| CService | Parent class of all APIs modeled as 'services' |
| CServicePort | Add a custom interface to a service client at a particular point in the design hierarchy |
| CServiceRegistry | Registry of services which can be instantiated directly by the Accelerator class if the backend doesn't do anything special with a service |
| CSysInfo | Information about the Accelerator system |
| ►CTelemetryService | Service for retrieving telemetry data from the accelerator |
| CMetric | A telemetry port which gets attached to a service port |
| ►Nutils | |
| CTSQueue | Thread safe queue |
| CAccelerator | Top level accelerator class |
| CAcceleratorConnection | Abstract class representing a connection to an accelerator |
| ►CAcceleratorServiceThread | Background thread which services various requests |
| CImpl | |
| CAnyType | The "any" type is a special type which can be used to represent any type, as identified by the type id |
| CAppID | |
| CAppIDPath | |
| CArrayType | Arrays have a compile time specified (static) size and an element type |
| CBitsType | Bits are just an array of bits |
| ►CBitVector | A lightweight, non-owning bit vector view backed by a byte array span |
| Cbit_iterator | Forward iterator for iterating over bits from LSB (index 0) to MSB |
| CBitVectorType | Bit vectors include signed, unsigned, and signless integers |
| CBundleEngineMap | Since engines can support multiple channels BUT not necessarily all of the channels in a bundle, a mapping from bundle channels to engines is needed |
| CBundlePort | Services provide connections to 'bundles' – collections of named, unidirectional communication channels |
| CBundleType | Bundles represent a collection of channels |
| CChannelAssignment | Details about how to connect to a particular channel |
| ►CChannelPort | Unidirectional channels are the basic communication primitive between the host and accelerator |
| CConnectOptions | |
| ►CTranslationInfo | Instructions for translating windowed types |
| CCopyOp | A copy operation for translating between frame data and the translation |
| CFrameInfo | Information about each frame in the windowed type |
| CListFieldInfo | Information about a list field within a frame (for parallel encoding) |
| CChannelSignaling | |
| CChannelType | Channels are the basic communication primitives |
| CCliParser | Common options and code for ESI runtime tools |
| CConsoleLogger | A logger that writes to the console. Includes color support |
| CConstant | |
| CContext | AcceleratorConnections, Accelerators, and Manifests must all share a context |
| CEngine | Engines implement the actual channel communication between the host and the accelerator |
| CESIPureModuleOp | |
| CHWClientDetail | A description of a hardware client |
| CHWModule | Represents either the top level or an instance of a hardware module |
| CInstance | Subclass of HWModule which represents a submodule instance |
| CInt | |
| CIntegerType | Integers are bit vectors which may be signed or unsigned and are interpreted as numbers |
| CListType | Lists represent variable-length sequences of elements of a single type |
| CLogger | |
| CManifest | Class to parse a manifest |
| CMessageData | A logical chunk of data representing serialized data |
| CModuleInfo | |
| CMutableBitVector | A mutable bit vector that owns its underlying storage |
| CNullLogger | A logger that does nothing |
| CRandomAccessMemoryDeclOp | |
| CReadChannelPort | A ChannelPort which reads data from the accelerator |
| CRequestConnectionOp | |
| CServicePortDesc | A description of a service port |
| CSIntType | Signed integer |
| CStreamLogger | A logger that writes to a C++ std::ostream |
| CStructType | Structs are an ordered collection of fields, each with a name and a type |
| CTSLogger | A thread-safe logger which calls functions implemented by subclasses |
| CType | Root class of the ESI type system |
| CUInt | |
| CUIntType | Unsigned integer |
| CUnknownReadChannelPort | Instantiated when a backend does not know how to create a read channel |
| CUnknownWriteChannelPort | Instantiated when a backend does not know how to create a write channel |
| CVoidType | The "void" type is a special type which can be used to represent no type |
| ►CWindowType | Windows represent a fixed-size sliding window over a stream of data |
| CField | Field information describing a field within a frame |
| CFrame | Frame information describing which fields are included in a particular frame |
| CWriteChannelPort | A ChannelPort which sends data to the accelerator |
| ►Nesiaccel | |
| ►Naccelerator | |
| CAccelerator | |
| CAcceleratorConnection | |
| CContext | |
| CHWModule | |
| CInstance | |
| ►Ncodegen | |
| CCppGenerator | |
| CGenerator | |
| ►Ntypes | |
| CArrayType | |
| CBitsType | |
| CBundlePort | |
| CCallbackPort | |
| CESIType | |
| CFunctionPort | |
| CIntType | |
| CMessageFuture | |
| CMetricPort | |
| CMMIORegion | |
| CPort | |
| CReadPort | |
| CSIntType | |
| CStructType | |
| CUIntType | |
| CVoidType | |
| CWritePort | |
| ►Nfsm | |
| CMachineOp | |
| COutputOp | |
| CStateOp | |
| CTransitionOp | |
| ►Nhandshake | |
| CFuncOp | |
| ►Nhw | |
| CArrayConcatOp | |
| CArrayCreateOp | |
| CArrayGetOp | |
| CArraySliceOp | |
| CBitcastOp | |
| CConstantOp | |
| CHWModuleExternOp | |
| CHWModuleOp | |
| CInstanceBuilder | |
| CModuleLike | |
| CStructCreateOp | |
| CStructExtractOp | |
| CTypedeclOp | |
| CTypeScopeOp | |
| ►Nhwarith | |
| CAddOp | |
| CBinaryOpBuilder | |
| CCastOp | |
| CConstantOp | |
| CDivOp | |
| CICmpOp | |
| CMulOp | |
| CSubOp | |
| ►Nllvm | |
| ►Nyaml | |
| ►CMappingContextTraits< DescribedInstance, Context > | Conversion from a DescribedInstance to YAML |
| CInstance | A YAML-serializable representation of an interface instantiation |
| ►CMappingContextTraits< DescribedSignal, Context > | Conversion from a DescribedSignal to YAML |
| CField | A one-to-one representation with a YAML representation of a signal/field |
| ►CMappingContextTraits< sv::InterfaceOp, Context > | Conversion from an sv::InterfaceOp to YAML |
| CInterface | A YAML-serializable representation of an interface |
| CCastInfo< To, From, std::enable_if_t< std::is_base_of_v<::circt::firrtl::AnnoTarget, From > > > | Add support for llvm style casts to AnnoTarget |
| CDenseMapInfo | |
| CDenseMapInfo< AffineAccessExpr > | |
| CDenseMapInfo< bool > | |
| CDenseMapInfo< circt::FieldRef > | Allow using FieldRef with DenseMaps |
| CDenseMapInfo< circt::FirMemConfig > | |
| CDenseMapInfo< circt::firrtl::AnnoTarget > | Make AnnoTarget hash |
| CDenseMapInfo< circt::firrtl::Annotation > | Make Annotation hash just like Attribute |
| CDenseMapInfo< circt::firrtl::FIRRTLType > | |
| CDenseMapInfo< circt::firrtl::FModuleOp > | |
| CDenseMapInfo< circt::FVInt, void > | Provide DenseMapInfo for FVInt |
| CDenseMapInfo< circt::igraph::InstancePath > | DenseMap traits for InstancePath |
| CDenseMapInfo< circt::llhd::deseq::FixedValue > | |
| CDenseMapInfo< circt::llhd::deseq::FixedValues > | |
| CDenseMapInfo< circt::scheduling::Problem::OperatorType > | |
| CDenseMapInfo< circt::scheduling::Problem::ResourceType > | |
| CDenseMapInfo< circt::synth::Object > | |
| CDenseMapInfo< Dependence > | |
| CDenseMapInfo< DriveCondition > | |
| CDenseMapInfo< JValue > | |
| CDenseMapInfo< Key > | |
| CDenseMapInfo< LabelValue > | |
| CDenseMapInfo< ModuleInfoRef > | Allow ModuleInfoRef to be used as dense map keys |
| CDenseMapInfo< ModuleSummaryPass::KeyTy > | |
| CDenseMapInfo< ResetSignal > | |
| CDenseMapInfo< slang::BufferID > | |
| CDenseMapInfo< SmallVector< Value > > | |
| CDenseMapInfo< StructuralHashKey > | |
| CDOTGraphTraits< circt::firrtl::InstanceGraph * > | |
| CDOTGraphTraits< circt::hw::HWModuleOp > | |
| CDOTGraphTraits< circt::hw::InstanceGraph * > | |
| CDOTGraphTraits< circt::igraph::InstanceGraph * > | |
| CGraphTraits< circt::firrtl::InstanceGraph * > | |
| CGraphTraits< circt::hw::detail::HWOperation * > | |
| CGraphTraits< circt::hw::HWModuleOp > | |
| CGraphTraits< circt::hw::InstanceGraph * > | |
| CGraphTraits< circt::igraph::InstanceGraph * > | Graph traits for the instance graph |
| CGraphTraits< circt::igraph::InstanceGraphNode * > | Graph traits for modules |
| CGraphTraits< llvm::Inverse< circt::igraph::InstanceGraphNode * > > | Graph traits for iterating modules in inverse order |
| CPointerLikeTypeTraits< circt::firrtl::Annotation > | Make Annotation behave like a Attribute in terms of pointer-likeness |
| CPointerLikeTypeTraits< circt::llhd::TimeAttr > | |
| CPointerLikeTypeTraits< mlir::ArrayAttr > | |
| CSmallDenseMap | |
| CSmallSet | |
| ►NManifest | |
| CImpl | |
| ►Nmlir | |
| ►NOpTrait | |
| CHasClock | |
| ►CHasParentInterface | |
| CImpl | |
| CInnerRefNamespace | This trait is for operations that define a scope for resolving InnerRef's, and provides verification for InnerRef users (via InnerRefUserOpInterface) |
| CInnerSymbolTable | A trait for inner symbol table functionality on an operation |
| CAttrTypeSubElementHandler< circt::firrtl::BundleType::BundleElement > | Allow walking and replacing the subelements of a BundleElement |
| CAttrTypeSubElementHandler< circt::firrtl::ClassElement > | Allow walking and replacing the subelements of a ClassElement |
| CAttrTypeSubElementHandler< circt::firrtl::FEnumType::EnumElement > | Allow walking and replacing the subelements of an EnumElement |
| CAttrTypeSubElementHandler< circt::firrtl::OpenBundleType::BundleElement > | Allow walking and replacing the subelements of an OpenBundleElement |
| CFieldParser<::BundledChannel, ::BundledChannel > | |
| COpConversionPattern | |
| COperationPass | |
| COpRewritePattern | |
| COwningOpRef | |
| CStdExprVisitor | StdExprVisitor is a visitor for standard expression nodes |
| ►Nmsft | |
| CDeclPhysicalRegionOp | |
| CDynamicInstanceOp | |
| CInstanceHierarchyOp | |
| CPDPhysLocationOp | |
| ►Nnanobind | |
| ►Ndetail | |
| Ctype_caster< std::any > | Nanobind doesn't have a built-in type caster for std::any |
| Ctype_hook< ChannelPort > | |
| Ctype_hook< Service > | |
| ►Nom | |
| CBasePath | |
| CEvaluator | |
| CList | |
| CObject | |
| ►NPython | |
| ►Nsetup | |
| CCMakeBuild | |
| CCMakeExtension | |
| CCustomBuild | |
| CNoopBuildExtension | |
| ►Nsupport | |
| ►CBackedgeBuilder | |
| CEdge | |
| CConnectionError | |
| CNamedValueOpView | |
| COpOperand | |
| CUnconnectedSignalError | |
| ►Nquesta | |
| CQuesta | |
| ►Nseq | |
| CCompRegBuilder | |
| CCompRegClockEnabledBuilder | |
| CCompRegClockEnabledOp | |
| CCompRegLike | |
| CCompRegLikeBuilder | |
| CCompRegOp | |
| ►Nsetup | |
| CCMakeBuild | |
| CCMakeExtension | |
| CCustomBuild | |
| CNoopBuildExtension | |
| ►Nsimulator | |
| CSimProcess | |
| CSimulator | |
| CSourceFiles | |
| ►Nsv | |
| CAssignOp | |
| CIfDefOp | |
| CReadInOutOp | |
| CRegOp | |
| CSVVerbatimModuleOp | |
| CSVVerbatimSourceOp | |
| CWireOp | |
| ►Nsynth | |
| CDataflowPath | |
| CDebugPoint | |
| CInstance | |
| ►CLongestPathAnalysis | |
| CImpl | Internal implementation for LongestPathAnalysis |
| CLongestPathCollection | |
| CLongestPathHistory | |
| CObject | |
| ►Nverilator | |
| CVerilator | |
| C_build | |
| CAffineAccessExpr | |
| CAffineLoadLowering | Apply the affine map from an 'affine.load' operation to its operands, and feed the results to a newly created 'memref.load' operation (which replaces the original 'affine.load') |
| CAffineParallelOpLowering | |
| CAffinePloopUnparallelize | |
| CAffineStoreLowering | Apply the affine map from an 'affine.store' operation to its operands, and feed the results to a newly created 'memref.store' operation (which replaces the original 'affine.store') |
| CAndRCat | |
| CAssignEmitter | Emit a systemc.cpp.assign operation |
| CBalanceMuxPass | Pass that performs enhanced mux chain optimizations |
| CBankAffineLoadPattern | |
| CBankAffineStorePattern | |
| CBankReturnPattern | |
| CBaseBasePath | |
| CBaseEvaluator | |
| CBaseList | |
| CBaseObject | |
| CBindPortEmitter | Emit a systemc.instance.bind_port operation using the operator() rather than .bind() variant |
| CBitsOfCat | |
| CBlockControlTerm | Holds information about an handshake "basic block terminator" control operation |
| CCallEmitter | Emit a systemc.cpp.call operation |
| CCallIndirectEmitter | Emit a systemc.cpp.call_indirect operation |
| CCallPrepPrecomputed | Build indexes to make lookups faster. Create the new argument types as well |
| CCheckCombLoopsPass | This pass constructs a local graph for each module to detect combinational cycles |
| CCheckLayersPass | |
| CCirctESIAppIDIndex | |
| CCirctESIBundleTypeBundleChannel | |
| CCirctMSFTPlacementDB | |
| CCirctMSFTPrimitiveDB | |
| CCirctMSFTWalkOrder | |
| CCollapseUnaryControl | This pattern collapses a calyx.seq or calyx.par operation when it contains exactly one calyx.enable operation |
| CCompileControlVisitor | |
| CConstantFoldCompress | |
| CContext | This class provides a thread-safe interface to access the analysis results |
| CConvertAssignOp | |
| CConvertCellOp | |
| CConvertComponentOp | ConversionPatterns |
| CConvertControlOp | |
| CConvertToLLVMBase | |
| CConvertWiresOp | |
| CCoord | Test the CoordTranslator module using message translation |
| CCoordTranslateArg | Translated argument struct for CoordTranslator |
| CCoordTranslateResult | Translated result struct for CoordTranslator |
| CDeduper | |
| CDefaultDoCastIfPossible | |
| CDiscoverLoops | |
| CDPICallLowering | |
| CEmittedExpressionState | |
| CEmittedExpressionStateManager | This class handles information about AST structures of each expressions |
| CEmptyIfBody | This pattern checks for one of two cases that will lead to IfOp deletion: (1) Then and Else bodies are both empty |
| CEmptyStaticIfBody | This pattern checks for one of two cases that will lead to StaticIfOp deletion: (1) Then and Else bodies are both empty |
| ►CEquivalence | This class is for reporting differences between two modules which should have been deduplicated |
| CModuleData | |
| CFileEmitter | |
| CFIRRTLBundleField | Describes a field in a bundle type |
| CFIRRTLClassElement | Describes an element in a class type |
| CFoldAddIntoCompress | |
| CFoldCompressIntoCompress | |
| CFuncEmitter | Emit a systemc.cpp.func function |
| CFunctionRewrite | A struct for maintaining function declarations which needs to be rewritten, if they contain memref arguments that was flattened |
| CGenericLUT | A generic K-input LUT pattern that can implement any boolean function with up to K inputs using a lookup table |
| CGenericLUTMapperPass | |
| ►CHashTableStack | This is a stack of hashtables, if lookup fails in the top-most hashtable, it will attempt to lookup in lower hashtables |
| CIterator | |
| CHasParameters | |
| CHasParameters< Properties, std::void_t< decltype(std::declval< Properties >().parameters)> > | |
| CHWConstantifier | A sample reduction pattern that replaces integer operations with a constant zero of their type |
| CHWExportModuleHierarchyPass | |
| CHWModulePort | |
| CHWOperandForwarder | A sample reduction pattern that replaces all uses of an operation with one of its operands |
| CHWStructFieldInfo | |
| CHWUnionFieldInfo | |
| CIfOpHoisting | Helper to hoist computation out of scf::IfOp branches, turning it into a mux-like operation, and exposing potentially concurrent execution of its branches |
| CIgraphInstancePath | |
| CInnerSymbolDCEPass | |
| CLocalVisitor | |
| ►CLocationEmitter | |
| CImpl | |
| CLongestPathAnalysisWrapper | |
| CLowerDomainsPass | |
| CLowerDPIFunc | |
| CLowerLayersPass | |
| CLowerRegionTarget | |
| CLowerXMRPass | |
| CMemberAccessEmitter | Emit a systemc.cpp.member_access operation |
| CModuleExternalizer | A sample reduction pattern that maps hw.module to hw.module.extern |
| CModuleInfo | |
| CModuleInfoRef | A reference to a ModuleInfo that compares and hashes like it |
| CModuleInputPruner | Remove unused module input ports |
| CModuleOutputPruner | Remove unused module output ports |
| CModuleSizeCache | Utility to track the transitive size of modules |
| CNLARemover | A tracker for track NLAs affected by a reduction |
| CNullableValueCastFailed | |
| COMEvaluator | A value type for use in C APIs that just wraps a pointer to an Evaluator |
| COMEvaluatorValue | A value type for use in C APIs that just wraps a pointer to an Object |
| COperationAnalyzer | |
| COpInterfaceConversionPattern | |
| COrRCat | |
| CPartialLowerRegion | Allows to partially lower a region by matching on the parent operation to then call the provided partial lowering function with the region and the rewriter |
| CPlacementDB | |
| CPlusArgsTestLowering | |
| CPlusArgsValueLowering | |
| CPointerLikeTypeTraits | |
| CPosPartialProducts | |
| CPrimitiveDB | |
| CPyAppIDIndex | |
| CPyLocationVecIterator | |
| CReduceNumPartialProducts | |
| CReduceNumPosPartialProducts | |
| CReductionCat | |
| CReservedWordsCreator | Return a StringSet that contains all of the reserved names (e.g |
| CResolveTracesPass | |
| CReturnEmitter | Emit a systemc.cpp.return operation |
| CRuntimeError | |
| CServiceGenFunc | Container for a Python function that will be called to generate a service |
| CSFCCompatPass | |
| CStateElimination | A sample reduction pattern that converts arc.state operations to the simpler arc.call operation and removes clock, latency, name attributes, enables, and resets in the process |
| CStreamingAddArg | Packed struct representing a parallel window argument for StreamingAdder |
| CStreamingAddResult | Packed struct representing a parallel window result for StreamingAdder |
| CStreamingAddTranslatedArg | Test the StreamingAdder module using message translation |
| CStreamingAddTranslatedResult | Translated result struct for StreamingAdder |
| CStructuralHasher | |
| CStructuralHasherSharedConstants | This struct contains constant string attributes shared across different threads |
| CStructuralHashKey | A struct that represents the key used for structural hashing |
| CSwitchToIfConversion | |
| CTechLibraryPattern | Simple technology library encoded as a HWModuleOp |
| ►CTraceHostMem | |
| CTraceHostMemRegion | |
| CTraceMMIO | |
| CTVpiVecval | |
| CVariableEmitter | Emit a systemc.cpp.variable operation |
| CWireLowering | |
| CXorRCat | |
