Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234567]

Cmim::Annex	Holds info about an entity defined within a Plugin (called Annex)
Cmim::World::Annexes
Cmim::ast::AnnexInfo
Cmim::ast::AnnexInfo.id
Cmim::ast::AnnexInfo.sym
Cmim::plug::regex::app_range
Cmim::ast::AST
Cautomaton::AutomatonBase< NodeType >
Cautomaton::AutomatonBase< DFANode >
Cautomaton::DFA
Cautomaton::AutomatonBase< NFANode >
Cautomaton::NFA
Cmim::plug::ll::BB
Cmim::sexpr::BB
Cmim::Checker
Cmim::Nest::Node::Children
Cmim::plug::clos::ClosLit	Lightweight, non-owning view onto a closure literal (env_type, fn, env); see isa_clos_lit
Cmim::Dbg
Cmim::plug::ll_nvptx::DeviceEmitFlags
Cautomaton::DFANode
Cmim::Dispatch	Matches a dispatch through a jump table of the form: (target_0, target_1, ...)#index arg where index is not a Literal
Cmim::DotConfig	Options for Def::dot and World::dot
Cmim::ast::Emitter
Cmim::Driver::Imports::Entry
Cmim::World::Annexes::Entry
Cmim::Sets< D, N >::Data::Equal
Cstd::exception
Cmim::Error
Cmim::World::Externals
Cmim::Flags	Compiler switches that must be saved and looked up in later phases of compilation
Cmim::FNV1< size_t >
Cmim::FNV1< 4 >
Cmim::FNV1< 8 >
Cmim::plug::clos::phase::FreeDefAna	Computes, on demand and with memoization, the free Defs that a Lam must capture in its closure environment
Cmim::GIDHash< T >
Cmim::GIDLt< T >
Cmim::Driver::Imports
Cabsl::InlinedVector
Cmim::Vector< const Def * >
Cmim::Vector< Def * >
Cmim::Vector< Range >
Cmim::Vector< size_t >
Cmim::Vector< mim::Profiler::Span >
Cmim::Vector< mim::Sets::Set >
Cmim::Vector< Node * >
Cmim::Vector< Pending >
Cmim::Vector< T, N, A >	This is a thin wrapper for absl::InlinedVector<T, N, A> which is a drop-in replacement for std::vector<T, A>
Cabsl::InlinedVector< std::pair< std::string, uint64_t >, Default_Inlined_Size< std::pair< std::string, uint64_t > >, std::allocator< std::pair< std::string, uint64_t > > >
Cmim::Vector< std::pair< std::string, uint64_t > >
Cstd::integral_constant
Cstd::tuple_size< mim::Span< T, N > >
Cmim::Axm::IsA< Id, D >
Cmim::Axm::IsANode< T >
Cmim::Sets< D, N >::Set::iterator
Cfe::Lexer
Cmim::ast::Lexer
Cmim::Log	Facility to log what you are doing
Cstd::logic_error
Cmim::sys::CmdNotFound	Thrown by sys::require_cmd when a command cannot be located on the system
Cautomaton::DFANode::Lt
Cautomaton::NFANode::Lt
Cmim::World::Move.arena
Cmim::Error::Msg
Cmim::Nest	Builds a nesting tree for all mutables/binders
Cautomaton::NFANode
Cmim::lct::Node< P, K >	This is an intrusive Link-Cut-Tree
Cmim::Nest::Node
Cmim::detail::NullSafeDefGIDLt	Like GIDLt, but the nesting virtual root is represented as a nullptr Def%, which must sort first
Cfe::ostream_formatter
Cstd::formatter< automaton::DFA >
Cstd::formatter< automaton::DFA >
Cstd::formatter< automaton::NFA >
Cstd::formatter< mim::Dump >
Cstd::formatter< mim::Op >
Cstd::formatter< mim::ast::R< T > >
Cstd::formatter< mim::ast::S >
Cfe::Parser
Cmim::ast::Parser	Parses Mim code as AST
Cmim::Plugin	Basic info and registration function pointer to be returned from a specific plugin
Cmim::World::State::POD	Plain Old Data
Cmim::Profiler	Records wall-clock timings for (possibly nested) Phase runs and reports them in various formats
Cmim::ast::R< T >
Cautomaton::RangeCompare
Cmim::Restore< T >	RAII guard that restores ref to its current value at the end of the scope
Cmim::Rewriter	Recurseivly rebuilds part of a program into the provided World w.r.t. Rewriter::map
Cmim::Analysis	Traverses the current World using Rewriter infrastructure while staying in the same world
Cmim::plug::gpu::phase::MemChecks
Cmim::RWPhase	Rebuilds old_world() into new_world() and then swaps them
Cmim::BetaRed	Inlines in post-order all Lams that occur exactly once in the program
Cmim::BranchNormalize	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
Cmim::Cleanup	Removes unreachable and dead code by rebuilding the whole World into a new one and swapping them afterwards
Cmim::EtaConv	Combined η-normalization: folds η-reduction and η-expansion into a single, idempotent phase
Cmim::LamSpec	Specializes a Lam at its call site by inlining all Pi-typed (i.e. higher-order) arguments
Cmim::PrefixCleanup
Cmim::Repl	An RWPhase that searches for a pattern and replaces it
Cmim::RetWrap
Cmim::Scalarize	Perform Scalarization (= Argument simplification)
Cmim::TailRecElim	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
Cmim::plug::affine::phase::LowerFor	Lowers the for axm to actual control flow in CPS
Cmim::plug::affine::phase::LowerIndex	Lowers the affine index algebra to core arithmetic
Cmim::plug::autodiff::phase::Eval	This phase is the heart of AD
Cmim::plug::buffer::LowerPtr	Lowers the buffer abstraction to the low-level pointer representation
Cmim::plug::clos::phase::BranchClosElim	Flattens branches over closure literals back into a direct branch over Lams
Cmim::plug::clos::phase::Clos2SJLJ	Lowers basicblock closures that are passed as arguments (i.e
Cmim::plug::clos::phase::ClosConv	Performs typed closure conversion, rebuilding the old world into a new one
Cmim::plug::clos::phase::ClosConvPrep	Wraps operands with clos.attr markers (returning, free_bb, fstclass_bb, ...) and eta-expands branches and continuations so that ClosConv sees a canonical program
Cmim::plug::clos::phase::LowerTypedClos	This pass lowers typed closures to untyped closures
Cmim::plug::clos::phase::LowerTypedClosPrep	Escape analysis for closures: closure literals get their function wrapped in clos.attr.esc or clos.attr.bottom, depending on whether their environment escapes
Cmim::plug::cps::Conv	Full CPS conversion in one recursive rewrite
Cmim::plug::gpu::phase::RemoveDoubleSyncs
Cmim::plug::gpu::phase::SplitApply
Cmim::plug::gpu::phase::SplitOffKernels
Cmim::plug::matrix::phase::LowerAff	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
Cmim::plug::matrix::phase::LowerMatrixHighLevelMapRed	Resolves lowering of high level operations into medium/other high-level operations
Cmim::plug::matrix::phase::LowerMatrixMediumLevel	In this step, we lower map_reduce operations into affine for loops making the iteration scheme explicit
Cmim::plug::mem::phase::AddMem	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
Cmim::plug::mem::phase::SEO	Symbolic Expression Optimization
Cmim::plug::regex::LowerRegex	Lowers a regex axm application to a DFA matcher function
Cmim::plug::tensor::phase::Fuse
Cmim::plug::tensor::phase::Lower	Lowers the high-level tensor axioms into the low-level tensor axioms (map_reduce, …)
Cmim::plug::tensor::phase::LowerGetSet	Lowers the tensor axioms (get, set) to their underlying primitives (extract, insert)
Cmim::plug::tensor::phase::LowerMapReduce	Lowers the low-level tensor axioms (map_reduce, pad, concat, broadcast) directly to their underlying primitives (loops, extract, insert, pack, …)
Cmim::plug::tensor::phase::LowerToMem	Bufferizes the low-level tensor axioms onto the shared buffer layer
Cmim::VarRewriter	Extends Rewriter for variable substitution
Cmim::Zonker
Cfe::RuntimeCast
Cmim::Def	Base class for all Defs
Cmim::App
Cmim::Axm
Cmim::Bound	Common base for TBound
Cmim::TBound< false >
Cmim::TBound< true >
Cmim::TBound< Up >	Specific Bound depending on Up
Cmim::Ext	Common base for TExtremum
Cmim::TExt< false >
Cmim::TExt< true >
Cmim::TExt< Up >	Extremum. Either Top (Up) or Bottom
Cmim::Extract	Extracts from a Sigma or Array-typed Extract::tuple the element at position Extract::index
Cmim::Global
Cmim::Hole	This node is a hole in the IR that is inferred by its context later on
Cmim::Idx	A built-in constant of type Nat -> *
Cmim::Inj	Constructs a Join value
Cmim::Insert	Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple
Cmim::Lam	A function
Cmim::Lit
Cmim::Match	Scrutinize Match::scrutinee() and dispatch to Match::arms
Cmim::Merge	Constructs a Meet value
Cmim::Nat
Cmim::Pi	A dependent function type
Cmim::Prod	Base class for Sigma and Tuple
Cmim::Sigma	A dependent tuple type
Cmim::Tuple	Data constructor for a Sigma
Cmim::Proxy
Cmim::Reform	Type formation of a rewrite Rule
Cmim::Rule	A rewrite rule
Cmim::Seq	Base class for Arr and Pack
Cmim::Arr	A (possibly paramterized) Array
Cmim::Pack	A (possibly paramterized) Tuple
Cmim::Split	Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type)
Cmim::Type
Cmim::UInc
Cmim::UMax
Cmim::Uniq	A singleton wraps a type into a higher order type
Cmim::Univ
Cmim::Var	A variable introduced by a binder (mutable)
Cmim::Phase	A Phase performs one self-contained task over the whole World
Cmim::ClosedMutPhase< Lam >
Cmim::NestPhase< Lam >
Cmim::Emitter< std::string, std::string, BB, Emitter >
Cmim::plug::ll::Emitter
Cmim::plug::ll_nvptx::DeviceEmitter
Cmim::plug::ll_nvptx::HostEmitter
Cmim::sexpr::Emitter
Cmim::Emitter< Value, Type, BB, Child >
Cmim::ClosedMutPhase< Def >
Cmim::NestPhase< M >	Like ClosedMutPhase but computes a Nest for each NestPhase::visit
CNamed	Phase hook for compile.named
Cmim::Analysis	Traverses the current World using Rewriter infrastructure while staying in the same world
Cmim::ClosedMutPhase< M >	Transitively visits all reachable, closed mutables in the World
Cmim::PhaseMan	Organizes several Phases into a pipeline
Cmim::RWPhase	Rebuilds old_world() into new_world() and then swaps them
Cmim::plug::ll::Emit	Pipeline phase for ll.emit
Cmim::plug::ll_nvptx::Emit
Cmim::ast::Node
Cmim::ast::Decl
Cmim::ast::AxmDecl::Alias
Cmim::ast::DummyDecl
Cmim::ast::Ptrn
Cmim::ast::AliasPtrn	ptrn as id
Cmim::ast::ErrorPtrn
Cmim::ast::GrpPtrn	If you have x1 x2 x3 x4: T it consists of 3 GrpPtrns and 1 IdPtrn while each GrpPtrn references the last IdPtrn
Cmim::ast::IdPtrn	dbg: type
Cmim::ast::TuplePtrn	(ptrn_0, ..., ptrn_n-1), [ptrn_0, ..., ptrn_n-1], or {ptrn_0, ..., ptrn_n-1}
Cmim::ast::ValDecl
Cmim::ast::AxmDecl	axm ptrn: type = value;
Cmim::ast::CDecl	cfun dbg dom -> codom
Cmim::ast::LetDecl	let ptrn: type = value;
Cmim::ast::RecDecl	.rec dbg: type = body
Cmim::ast::LamDecl	One of:
Cmim::ast::RuleDecl	Rewrite rules rule (x:T, y:T) : x+y => y+x (when ); all meta variables have to be introduced
Cmim::ast::Expr
Cmim::ast::AppExpr	callee arg
Cmim::ast::ArrowExpr	dom -> codom
Cmim::ast::DeclExpr	decls e or e where decls if where is true
Cmim::ast::ErrorExpr
Cmim::ast::ExtractExpr	tuple#index
Cmim::ast::HoleExpr
Cmim::ast::IdExpr	sym
Cmim::ast::InjExpr	value inj t1 ∪ t2
Cmim::ast::InsertExpr	ins(tuple, index, value)
Cmim::ast::LamExpr	Wraps a LamDecl as Expr
Cmim::ast::LitExpr	tok:type
Cmim::ast::MatchExpr
Cmim::ast::PiExpr	One of:
Cmim::ast::PrimaryExpr	tag
Cmim::ast::RetExpr	ret ptrn = callee $ arg; body
Cmim::ast::RuleExpr	Reform (type of a rule) Rule type
Cmim::ast::SeqExpr	«dbg: arity; body» or ‹dbg: arity; body›
Cmim::ast::SigmaExpr	Just wraps TuplePtrn as Expr
Cmim::ast::TupleExpr	(elem_0, ..., elem_n-1)
Cmim::ast::TypeExpr	Type level
Cmim::ast::UnionExpr	t1 ∪ t2
Cmim::ast::UniqExpr	⦃ expr ⦄
Cmim::ast::Import
Cmim::ast::MatchExpr::Arm
Cmim::ast::Module
Cmim::ast::PiExpr::Dom
Cmim::ast::LamDecl::Dom
Cmim::ast::S
Cmim::Scheduler
Cmim::World::ScopedLoc
Cmim::ast::Scopes
Cmim::Select	Matches (ff, tt)#cond - where cond is not a Literal
Cmim::Branch	Matches (ff, tt)#cond arg where cond is not a Literal
Cmim::Sets< D, N >::Set
Cmim::Sets< D, N >
Cmim::Setters< P, D >	CRTP-based mixin to declare setters for Def::loc & Def::name using a covariant return type
Cmim::Setters< App >
Cmim::App
Cmim::Setters< Arr >
Cmim::Arr	A (possibly paramterized) Array
Cmim::Setters< Axm >
Cmim::Axm
Cmim::Setters< Extract >
Cmim::Extract	Extracts from a Sigma or Array-typed Extract::tuple the element at position Extract::index
Cmim::Setters< Global >
Cmim::Global
Cmim::Setters< Hole >
Cmim::Hole	This node is a hole in the IR that is inferred by its context later on
Cmim::Setters< Idx >
Cmim::Idx	A built-in constant of type Nat -> *
Cmim::Setters< Inj >
Cmim::Inj	Constructs a Join value
Cmim::Setters< Insert >
Cmim::Insert	Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple
Cmim::Setters< Lam >
Cmim::Lam	A function
Cmim::Setters< Lit >
Cmim::Lit
Cmim::Setters< Match >
Cmim::Match	Scrutinize Match::scrutinee() and dispatch to Match::arms
Cmim::Setters< Merge >
Cmim::Merge	Constructs a Meet value
Cmim::Setters< Nat >
Cmim::Nat
Cmim::Setters< Pack >
Cmim::Pack	A (possibly paramterized) Tuple
Cmim::Setters< Pi >
Cmim::Pi	A dependent function type
Cmim::Setters< Prod >
Cmim::Prod	Base class for Sigma and Tuple
Cmim::Setters< Proxy >
Cmim::Proxy
Cmim::Setters< Reform >
Cmim::Reform	Type formation of a rewrite Rule
Cmim::Setters< Rule >
Cmim::Rule	A rewrite rule
Cmim::Setters< Seq >
Cmim::Seq	Base class for Arr and Pack
Cmim::Setters< Sigma >
Cmim::Sigma	A dependent tuple type
Cmim::Setters< Split >
Cmim::Split	Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type)
Cmim::Setters< TBound< Up > >
Cmim::TBound< false >
Cmim::TBound< true >
Cmim::TBound< Up >	Specific Bound depending on Up
Cmim::Setters< TExt< Up > >
Cmim::TExt< false >
Cmim::TExt< true >
Cmim::TExt< Up >	Extremum. Either Top (Up) or Bottom
Cmim::Setters< Tuple >
Cmim::Tuple	Data constructor for a Sigma
Cmim::Setters< Type >
Cmim::Type
Cmim::Setters< UInc >
Cmim::UInc
Cmim::Setters< UMax >
Cmim::UMax
Cmim::Setters< Uniq >
Cmim::Uniq	A singleton wraps a type into a higher order type
Cmim::Setters< Univ >
Cmim::Univ
Cmim::Setters< Var >
Cmim::Var	A variable introduced by a binder (mutable)
Cmim::Nest::Node::SiblDeps< Forward >
Cmim::Profiler::Span	A single Phase run
Cstd::span
Cmim::Span< const T, N >
Cmim::Span< T, N >	This is a thin wrapper for std::span<T, N> with the following additional features:
Cmim::World::State
Cfe::SymPool
Cmim::Driver	Some "global" variables needed all over the place
Cmim::ast::Tok
Cstd::tuple_element< I, mim::Span< T, N > >
Cmim::unique_queue< Set >
Cmim::Use	Const Def*erences a user
Cmim::UseEq
Cmim::UseHash
Cmim::Version
Cmim::detail::w2f_< int >
Cmim::detail::w2s_< int >
Cmim::detail::w2s_< 1 >	See above
Cmim::detail::w2s_< 16 >
Cmim::detail::w2s_< 32 >
Cmim::detail::w2s_< 64 >
Cmim::detail::w2s_< 8 >
Cmim::detail::w2u_< int >
Cmim::detail::w2u_< 1 >	Map both signed 1 and unsigned 1 to bool
Cmim::detail::w2u_< 16 >
Cmim::detail::w2u_< 32 >
Cmim::detail::w2u_< 64 >
Cmim::detail::w2u_< 8 >
Cmim::World	The World represents the whole program and manages creation of MimIR nodes (Defs)
Cconst bool
Cint
Clist< DFANode >
Clist< NFANode >