| Cmim::Annex | Holds info about an entity defined within a Plugin (called Annex) |
| 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::ll::BB | |
| Cmim::BitSet | |
| Cmim::CFA | Control Flow Analysis |
| Cmim::CFG< bool > | A Control-Flow Graph |
| Cmim::CFG< forward > | |
| Cmim::CFNode | A Control-Flow Node |
| Cmim::Check | |
| Cmim::plug::clos::ClosLit | Wrapper around a Def that can be used to match closures (see isa_clos_lit) |
| Cmim::PooledSet< T >::Data | |
| Cmim::Dbg | |
| Cmim::DefDefEq | |
| Cmim::DefDefHash | |
| Cmim::DepNode | |
| Cmim::DepTree | |
| Cautomaton::DFANode | |
| Cmim::DomFrontierBase< forward > | A Dominance Frontier Graph |
| Cmim::DomTreeBase< bool > | A Dominance Tree |
| Cmim::Elem< R, F > | |
| Cmim::ast::Emitter | |
| Cmim::PooledSet< T >::Data::Equal | |
| ▼Cstd::exception | |
| Cmim::Error | |
| Cmim::Flags | Compiler switches that must be saved and looked up in later phases of compilation |
| Cmim::FNV1 | |
| Cmim::plug::clos::FreeDefAna | Transitively compute free Def's on demand |
| Cmim::World::Freezer | Use to World::freeze and automatically unfreeze at the end of scope |
| Cmim::GIDEq< T > | |
| Cmim::GIDHash< T > | |
| Cmim::GIDLt< T > | |
| Cmim::IndexMap< Indexer, Key, Value > | |
| Cmim::IndexMap< const mim::CFNode * > | |
| Cmim::IndexSet< Indexer, Key > | |
| Cmim::plug::mem::SSAConstr::Info | |
| ▼Cabsl::InlinedVector | |
| Cmim::Vector< Value > | |
| Cmim::Vector< uint64_t > | |
| Cmim::Vector< const mim::CFNode * > | |
| Cmim::Vector< const Def * > | |
| Cmim::Vector< void * > | |
| Cmim::Vector< T, N, A > | This is a thin wrapper for absl::InlinedVector<T, N, / A> which in turn is a drop-in replacement for std::vector<T, A> |
| ▼Cabsl::InlinedVector< std::unique_ptr< mim::LoopTree::Base >, Default_Inlined_Size< std::unique_ptr< mim::LoopTree::Base > >, std::allocator< std::unique_ptr< mim::LoopTree::Base > > > | |
| Cmim::Vector< std::unique_ptr< mim::LoopTree::Base > > | |
| ▼Cstd::integral_constant | |
| Cstd::tuple_size< mim::Span< T, N > > | |
| ▼Cfe::Lexer | |
| Cmim::ast::Lexer | |
| Cmim::Log | Facility to log what you are doing |
| Cmim::LoopTree< forward > | Calculates a loop nesting forest rooted at LoopTree::root_ |
| Cmim::LoopTreeBuilder< forward > | |
| Cmim::Axiom::Match< T > | Type of Match::def_ |
| Cmim::Match< Id, D > | |
| Cmim::Error::Msg | |
| Cautomaton::NFANode | |
| ▼Cfe::Parser | |
| Cmim::ast::Parser | Parses Mim code as AST |
| ▼Cmim::Pass | All Passes that want to be registered in the PassMan must implement this interface |
| ▼Cmim::RWPass< DebugDump, Lam > | |
| CDebugDump | A pass that just dumps the world |
| ▼Cmim::RWPass< BetaRed, Def > | |
| ▼Cmim::FPPass< BetaRed, Def > | |
| Cmim::BetaRed | Optimistically performs β-reduction (aka inlining) |
| ▼Cmim::RWPass< EtaExp, Lam > | |
| ▼Cmim::FPPass< EtaExp, Lam > | |
| Cmim::EtaExp | Performs η-expansion: f -> λx.f x, if f is a Lam with more than one user and does not appear in callee position |
| ▼Cmim::RWPass< EtaRed, Def > | |
| ▼Cmim::FPPass< EtaRed, Def > | |
| Cmim::EtaRed | Performs η-reduction |
| ▼Cmim::RWPass< P, Def > | |
| Cmim::FPPass< P, M > | Inherit from this class using CRTP, if you do need a Pass with a state and a fixed-point |
| ▼Cmim::RWPass< LamSpec, Lam > | |
| Cmim::LamSpec | |
| ▼Cmim::RWPass< RetWrap, Lam > | |
| Cmim::RetWrap | |
| ▼Cmim::RWPass< Scalarize, Lam > | |
| Cmim::Scalarize | Perform Scalarization (= Argument simplification) |
| ▼Cmim::RWPass< TailRecElim, Lam > | |
| ▼Cmim::FPPass< TailRecElim, Lam > | |
| Cmim::TailRecElim | |
| ▼Cmim::RWPass< LowerFor, Lam > | |
| Cmim::plug::affine::LowerFor | Lowers the for axiom to actual control flow in CPS |
| ▼Cmim::RWPass< AutoDiffEval, Lam > | |
| Cmim::plug::autodiff::AutoDiffEval | This pass is the heart of AD |
| ▼Cmim::RWPass< AutoDiffZero, Lam > | |
| Cmim::plug::autodiff::AutoDiffZero | Replaces calls to the zero axioms with actual zeros |
| ▼Cmim::RWPass< AutoDiffZeroCleanup, Lam > | |
| Cmim::plug::autodiff::AutoDiffZeroCleanup | Replaces remaining zeros (not resolvable) with ⊥ |
| ▼Cmim::RWPass< BranchClosElim, Lam > | |
| Cmim::plug::clos::BranchClosElim | |
| ▼Cmim::RWPass< Clos2SJLJ, Lam > | |
| Cmim::plug::clos::Clos2SJLJ | |
| ▼Cmim::RWPass< ClosConvPrep, Lam > | |
| Cmim::plug::clos::ClosConvPrep | |
| ▼Cmim::RWPass< LowerTypedClosPrep, Lam > | |
| ▼Cmim::FPPass< LowerTypedClosPrep, Lam > | |
| Cmim::plug::clos::LowerTypedClosPrep | |
| ▼Cmim::RWPass< DebugPrint, Lam > | |
| Cmim::plug::compile::DebugPrint | |
| ▼Cmim::RWPass< InternalCleanup, Lam > | |
| Cmim::plug::compile::InternalCleanup | |
| ▼Cmim::RWPass< CPS2DS, Lam > | |
| Cmim::plug::direct::CPS2DS | This is the second part of ds2cps |
| ▼Cmim::RWPass< DS2CPS, Lam > | |
| Cmim::plug::direct::DS2CPS | Converts direct style function to cps functions |
| ▼Cmim::RWPass< LowerMatrixHighLevelMapRed, Lam > | |
| Cmim::plug::matrix::LowerMatrixHighLevelMapRed | Resolves lowering of high level operations into medium/other high-level operations |
| ▼Cmim::RWPass< LowerMatrixMediumLevel, Lam > | |
| Cmim::plug::matrix::LowerMatrixMediumLevel | In this step, we lower map_reduce operations into affine for loops making the iteration scheme explicit |
| ▼Cmim::RWPass< Alloc2Malloc, Lam > | |
| Cmim::plug::mem::Alloc2Malloc | |
| ▼Cmim::RWPass< CopyProp, Lam > | |
| ▼Cmim::FPPass< CopyProp, Lam > | |
| Cmim::plug::mem::CopyProp | This FPPass is similar to sparse conditional constant propagation (SCCP) |
| ▼Cmim::RWPass< RememElim, Lam > | |
| Cmim::plug::mem::RememElim | |
| ▼Cmim::RWPass< Reshape, Lam > | |
| Cmim::plug::mem::Reshape | The general idea of this pass/phase is to change the shape of signatures of functions |
| ▼Cmim::RWPass< SSAConstr, Lam > | |
| ▼Cmim::FPPass< SSAConstr, Lam > | |
| Cmim::plug::mem::SSAConstr | SSA construction algorithm that promotes slots, loads, and stores to SSA values |
| ▼Cmim::RWPass< RemoveDbgPerm, Lam > | |
| Cmim::plug::refly::RemoveDbgPerm | Removes all refly.debug.perm markers for code gen |
| ▼Cmim::RWPass< LowerRegex, Lam > | |
| Cmim::plug::regex::LowerRegex | |
| Cmim::RWPass< P, M > | Inherit from this class using CRTP, if your Pass does not need state and a fixed-point iteration |
| Cmim::PassMan | An optimizer that combines several optimizations in an optimal way |
| ▼Cmim::Phase | As opposed to a Pass, a Phase does one thing at a time and does not mix with other Phases |
| Cmim::Cleanup | Removes unreachable and dead code by rebuilding the whole World into a new one and swapping afterwards |
| Cmim::ClosedMutPhase< M > | Transitively visits all reachable closed mutables (Def::is_closed()) in World |
| Cmim::PassManPhase | Wraps a PassMan pipeline as a Phase |
| Cmim::PassPhase< P > | Wraps a Pass as a Phase |
| Cmim::Pipeline | Organizes several Phases as a pipeline |
| ▼Cmim::RWPhase | Visits the current Phase::world and constructs a new RWPhase::world along the way |
| Cmim::FPPhase | Like a RWPhase but starts with a fixed-point loop of FPPhase::analyze beforehand |
| Cmim::plug::matrix::LowerMatrixLowLevel | In this phase, we lower all matrix operations and types to the low-level representation using pointers |
| ▼Cmim::ScopePhase | Transitively visits all reachable Scopes in World that do not have free variables |
| ▼Cmim::Emitter< std::string, std::string, BB, Emitter > | |
| Cmim::ll::Emitter | |
| Cmim::Emitter< Value, Type, BB, Child > | |
| Cmim::plug::mem::AddMem | This phase adds mems to all lambdas and continuations |
| Cmim::plug::clos::ClosConv | Performs typed closure conversion |
| Cmim::plug::clos::LowerTypedClos | This pass lowers typed closures to untyped closures |
| Cmim::PipelineBuilder | |
| Cmim::Plugin | Basic info and registration function pointer to be returned from a specific plugin |
| Cmim::World::State::POD | Plain Old Data |
| Cmim::Pool< T > | Maintains PooledSets within a fe::Arena and unifies them in a absl::flat_hash_set |
| Cmim::Pool< const mim::Var * > | |
| Cmim::Pool< mim::Def * > | |
| Cmim::PooledSet< T > | Ordered set maintained in a consecutive buffer and unified in Pool |
| Cmim::PooledSet< const Var * > | |
| Cmim::PooledSet< Def * > | |
| Cmim::ast::R< T > | |
| Cautomaton::RangeCompare | |
| Cmim::Ref | Helper class to retrieve Infer::arg if present |
| Cmim::BitSet::reference | |
| Cmim::IndexSet< Indexer, Key >::reference | |
| Cmim::Res | Utility class when folding constants in normalizers |
| ▼Cmim::Rewriter | Recurseivly rewrites part of a program into the provided World |
| Cmim::RWPhase | Visits the current Phase::world and constructs a new RWPhase::world along the way |
| Cmim::VarRewriter | |
| ▼Cfe::RuntimeCast | |
| ▼Cmim::Def | Base class for all Defs |
| Cmim::Ac | Constructs a Meet value |
| Cmim::App | |
| Cmim::Arr | A (possibly paramterized) Array |
| Cmim::Axiom | |
| ▼Cmim::Bound | Common base for TBound |
| Cmim::TBound< Up > | Specific Bound depending on Up |
| ▼Cmim::Ext | Common base for TExtremum |
| 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::Idx | A built-in constant of type .Nat -> * |
| Cmim::Infer | This node is a hole in the IR that is inferred by its context later on |
| 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::Nat | |
| Cmim::Pack | A (possibly paramterized) Tuple |
| Cmim::Pi | A dependent function type |
| Cmim::Pick | Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type) |
| Cmim::Proxy | |
| Cmim::Sigma | A dependent tuple type |
| Cmim::Singleton | A singleton wraps a type into a higher order type |
| Cmim::Test | Test whether Test::value currently holds type Test::probe: |
| Cmim::Tuple | Data constructor for a Sigma |
| Cmim::Type | |
| Cmim::UInc | |
| Cmim::UMax | |
| Cmim::Univ | |
| Cmim::Var | |
| Cmim::Vel | Constructs a Join value |
| ▼Cmim::LoopTree< forward >::Base | Represents a node of a loop nesting forest |
| Cmim::LoopTree< forward >::Head | A Head owns further nodes as children |
| Cmim::LoopTree< forward >::Leaf | A Leaf only holds a single CFNode and does not have any children |
| ▼Cmim::ast::Node | |
| ▼Cmim::ast::Decl | |
| Cmim::ast::AxiomDecl::Alias | |
| Cmim::ast::DummyDecl | |
| ▼Cmim::ast::Ptrn | |
| Cmim::ast::ErrorPtrn | |
| Cmim::ast::GrpPtrn | dbg_0 ... dbg_n-2 id where id = dbg_n-1: type |
| Cmim::ast::IdPtrn | dbg: type |
| Cmim::ast::TuplePtrn | dbg::(ptrn_0, ..., ptrn_n-1) or dbg::[ptrn_0, ..., ptrn_n-1] |
| ▼Cmim::ast::ValDecl | |
| Cmim::ast::AxiomDecl | .ax 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::Expr | |
| Cmim::ast::AppExpr | callee arg |
| Cmim::ast::ArrOrPackExpr< arr > | «dbg: shape; body» or ‹dbg: shape; body› |
| 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::IdExpr | sym |
| Cmim::ast::InferExpr | |
| Cmim::ast::InsertExpr | .ins(tuple, index, value) |
| Cmim::ast::LamExpr | Wraps a LamDecl as Expr |
| Cmim::ast::LitExpr | tok:type |
| Cmim::ast::PiExpr | One of: |
| Cmim::ast::PrimaryExpr | tag |
| Cmim::ast::RetExpr | .ret ptrn = callee $ arg; body |
| Cmim::ast::SigmaExpr | Just wraps TuplePtrn as Expr |
| Cmim::ast::TupleExpr | (elem_0, ..., elem_n-1) |
| Cmim::ast::TypeExpr | .Type level |
| Cmim::ast::Import | |
| Cmim::ast::Module | |
| ▼Cmim::ast::PiExpr::Dom | |
| Cmim::ast::LamDecl::Dom | |
| Cmim::ast::S | |
| Cmim::Scheduler | |
| Cmim::Scope | A Scope represents a region of Defs that are live from the view of an entry's Var |
| Cmim::World::ScopedLoc | |
| Cmim::ast::Scopes | |
| ▼Cstd::span | |
| 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::Tab | Keeps track of indentation level |
| Cmim::ast::Tok | |
| Cstd::tuple_element< I, mim::Span< T, N > > | |
| Cmim::unique_queue< Set > | |
| Cmim::unique_stack< Set > | |
| Cmim::Use | References a user |
| Cmim::UseEq | |
| Cmim::UseHash | |
| Cmim::detail::w2f_< int > | |
| Cmim::detail::w2f_< 16 > | |
| Cmim::detail::w2f_< 32 > | |
| Cmim::detail::w2f_< 64 > | |
| 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) |
| CDefMap< mim::std::string > | |
| CDefMap< std::string > | |
| CLamMap< BB > | |
| Clist< DFANode > | |
| Clist< NFANode > | |
1.12.0