Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

Nautomaton
CAutomatonBase
CDFANode
CLt
CDFA
CNFANode
CLt
CNFA
CRangeCompare
Nmim
Nast
CAnnexInfo
CAST
CNode
CExpr
CDecl
CValDecl
CPtrn
CErrorPtrn
CIdPtrn	dbg: type
CGrpPtrn	If you have x1 x2 x3 x4: T it consists of 3 GrpPtrns and 1 IdPtrn while each GrpPtrn references the last IdPtrn
CAliasPtrn	ptrn as id
CTuplePtrn	(ptrn_0, ..., ptrn_n-1), [ptrn_0, ..., ptrn_n-1], or {ptrn_0, ..., ptrn_n-1}
CErrorExpr
CHoleExpr
CIdExpr	sym
CPrimaryExpr	tag
CLitExpr	tok:type
CDeclExpr	decls e or e where decls if where is true
CTypeExpr	Type level
CRuleExpr	Reform (type of a rule) Rule type
CUnionExpr	t1 ∪ t2
CInjExpr	value inj t1 ∪ t2
CMatchExpr
CArm
CArrowExpr	dom -> codom
CPiExpr	One of:
CDom
CLamExpr	Wraps a LamDecl as Expr
CAppExpr	callee arg
CRetExpr	ret ptrn = callee $ arg; body
CSigmaExpr	Just wraps TuplePtrn as Expr
CTupleExpr	(elem_0, ..., elem_n-1)
CSeqExpr	«dbg: arity; body» or ‹dbg: arity; body›
CExtractExpr	tuple#index
CInsertExpr	ins(tuple, index, value)
CUniqExpr	⦃ expr ⦄
CLetDecl	let ptrn: type = value;
CAxmDecl	axm ptrn: type = value;
CAlias
CRecDecl	.rec dbg: type = body
CLamDecl	One of:
CDom
CCDecl	cfun dbg dom -> codom
CRuleDecl	Rewrite rules rule (x:T, y:T) : x+y => y+x (when ); all meta variables have to be introduced
CImport
CModule
CLexer
CParser	Parses Mim code as AST
CTok
CDummyDecl
CScopes
CEmitter
CS
CR
CAnnexInfo.sym
CAnnexInfo.id
Nplug
Naffine	The affine Plugin
Nphase
CLowerFor	Lowers the for axm to actual control flow in CPS
CLowerIndex	Lowers the affine index algebra to core arithmetic
Nautodiff	The automatic differentiation Plugin
Nphase
CEval	This phase is the heart of AD
Nbuffer	The buffer Plugin
CLowerPtr	Lowers the buffer abstraction to the low-level pointer representation
Nclos	The clos Plugin
Nphase
CBranchClosElim	Flattens branches over closure literals back into a direct branch over Lams
CClos2SJLJ	Lowers basicblock closures that are passed as arguments (i.e
CFreeDefAna	Computes, on demand and with memoization, the free Defs that a Lam must capture in its closure environment
CClosConv	Performs typed closure conversion, rebuilding the old world into a new one
CClosConvPrep	Wraps operands with clos.attr markers (returning, free_bb, fstclass_bb, ...) and eta-expands branches and continuations so that ClosConv sees a canonical program
CLowerTypedClos	This pass lowers typed closures to untyped closures
CLowerTypedClosPrep	Escape analysis for closures: closure literals get their function wrapped in clos.attr.esc or clos.attr.bottom, depending on whether their environment escapes
CClosLit	Lightweight, non-owning view onto a closure literal (env_type, fn, env); see isa_clos_lit
Ncps	The CPS Plugin
CConv	Full CPS conversion in one recursive rewrite
Ngpu	The gpu Plugin
Nphase
CMemChecks
CRemoveDoubleSyncs
CSplitApply
CSplitOffKernels
Nll	The ll Plugin
CBB
CEmitter
CEmit	Pipeline phase for ll.emit
Nll_nvptx	The ll_nvptx Plugin
CDeviceEmitFlags
CEmit
CHostEmitter
CDeviceEmitter
Nmatrix	The matrix Plugin
Nphase
CLowerAff	Lowers the buffer-world operations (matrix.map_reduce_aff, matrix.broadcast, matrix.pad, matrix.concat) into affine.For loop nests over buffer.read / buffer.write / buffer.alloc, threading mem.M
CLowerMatrixHighLevelMapRed	Resolves lowering of high level operations into medium/other high-level operations
CLowerMatrixMediumLevel	In this step, we lower map_reduce operations into affine for loops making the iteration scheme explicit
Nmem	The mem Plugin
Nphase
CAddMem	Threads the mem.M memory monad through the world: mem-extends continuations and rewires every memory operand to the current memory at that program point
CSEO	Symbolic Expression Optimization
Nregex	The regex Plugin
CLowerRegex	Lowers a regex axm application to a DFA matcher function
Capp_range
Ntensor	The tensor Plugin
Nphase
CFuse
CLower	Lowers the high-level tensor axioms into the low-level tensor axioms (map_reduce, …)
CLowerGetSet	Lowers the tensor axioms (get, set) to their underlying primitives (extract, insert)
CLowerMapReduce	Lowers the low-level tensor axioms (map_reduce, pad, concat, broadcast) directly to their underlying primitives (loops, extract, insert, pack, …)
CLowerToMem	Bufferizes the low-level tensor axioms onto the shared buffer layer
Nsexpr
CBB
CEmitter
Nlct
CNode	This is an intrusive Link-Cut-Tree
Nsys
CCmdNotFound	Thrown by sys::require_cmd when a command cannot be located on the system
CAxm
CIsANode
CIsA
CEmitter
CHole	This node is a hole in the IR that is inferred by its context later on
CChecker
CSetters	CRTP-based mixin to declare setters for Def::loc & Def::name using a covariant return type
CDotConfig	Options for Def::dot and World::dot
CDef	Base class for all Defs
CVar	A variable introduced by a binder (mutable)
CUniv
CUMax
CUInc
CType
CLit
CNat
CIdx	A built-in constant of type Nat -> *
CProxy
CGlobal
CDriver	Some "global" variables needed all over the place
CImports
CEntry
CFlags	Compiler switches that must be saved and looked up in later phases of compilation
CPi	A dependent function type
CLam	A function
CApp
CBound	Common base for TBound
CTBound	Specific Bound depending on Up
CMerge	Constructs a Meet value
CInj	Constructs a Join value
CSplit	Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type)
CMatch	Scrutinize Match::scrutinee() and dispatch to Match::arms
CExt	Common base for TExtremum
CTExt	Extremum. Either Top (Up) or Bottom
CUniq	A singleton wraps a type into a higher order type
CNest	Builds a nesting tree for all mutables/binders
CNode
CChildren
CSiblDeps
CPhase	A Phase performs one self-contained task over the whole World
CAnalysis	Traverses the current World using Rewriter infrastructure while staying in the same world
CRWPhase	Rebuilds old_world() into new_world() and then swaps them
CRepl	An RWPhase that searches for a pattern and replaces it
CCleanup	Removes unreachable and dead code by rebuilding the whole World into a new one and swapping them afterwards
CPhaseMan	Organizes several Phases into a pipeline
CClosedMutPhase	Transitively visits all reachable, closed mutables in the World
CNestPhase	Like ClosedMutPhase but computes a Nest for each NestPhase::visit
CBetaRed	Inlines in post-order all Lams that occur exactly once in the program
CBranchNormalize	Normalizes branches: η-expands non-Lam branch targets so that both sides of a (f, t)#cond branch are Lams, as later phases and the backends expect
CEtaConv	Combined η-normalization: folds η-reduction and η-expansion into a single, idempotent phase
CLamSpec	Specializes a Lam at its call site by inlining all Pi-typed (i.e. higher-order) arguments
CPrefixCleanup
CRetWrap
CScalarize	Perform Scalarization (= Argument simplification)
CTailRecElim	Eliminates tail recursion: A returning Lam f that calls itself with its own ret var as continuation is split into a wrapper rec (same signature) and a loop basic block (signature without the ret var); the recursive call becomes a jump to loop
CVersion
CPlugin	Basic info and registration function pointer to be returned from a specific plugin
CAnnex	Holds info about an entity defined within a Plugin (called Annex)
CRewriter	Recurseivly rebuilds part of a program into the provided World w.r.t. Rewriter::map
CVarRewriter	Extends Rewriter for variable substitution
CZonker
CReform	Type formation of a rewrite Rule
CRule	A rewrite rule
CUse	Const Def*erences a user
CUseHash
CUseEq
CScheduler
CProd	Base class for Sigma and Tuple
CSigma	A dependent tuple type
CTuple	Data constructor for a Sigma
CSeq	Base class for Arr and Pack
CArr	A (possibly paramterized) Array
CPack	A (possibly paramterized) Tuple
CExtract	Extracts from a Sigma or Array-typed Extract::tuple the element at position Extract::index
CInsert	Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple
CSelect	Matches (ff, tt)#cond - where cond is not a Literal
CBranch	Matches (ff, tt)#cond arg where cond is not a Literal
CDispatch	Matches a dispatch through a jump table of the form: (target_0, target_1, ...)#index arg where index is not a Literal
CError
CMsg
CDbg
CFNV1
CFNV1< 4 >
CFNV1< 8 >
CLog	Facility to log what you are doing
CProfiler	Records wall-clock timings for (possibly nested) Phase runs and reports them in various formats
CSpan	A single Phase run
CSets
CSet
Citerator
CSpan	This is a thin wrapper for std::span<T, N> with the following additional features:
Cunique_queue
CGIDHash
CGIDLt
CRestore	RAII guard that restores ref to its current value at the end of the scope
CVector	This is a thin wrapper for absl::InlinedVector<T, N, A> which is a drop-in replacement for std::vector<T, A>
CWorld	The World represents the whole program and manages creation of MimIR nodes (Defs)
CState
CPOD	Plain Old Data
CScopedLoc
CExternals
CAnnexes
CEntry
CMove.arena
Nstd
Ctuple_size< mim::Span< T, N > >
Ctuple_element< I, mim::Span< T, N > >
Cformatter< mim::ast::S >
Cformatter< mim::ast::R< T > >
Cformatter< mim::Op >
Cformatter< mim::Dump >
Cformatter< automaton::DFA >
Cformatter< automaton::NFA >
CNamed	Phase hook for compile.named