 |
MimIR
MimIR is my Intermediate Representation
|
|
MimIR
MimIR is my Intermediate Representation
|
Static Argument Transformation. More...
#include <mim/phase/static_arg_opt.h>
Public Member Functions | |
| StaticArgOpt (World &world, flags_t annex) | |
| Public Member Functions inherited from mim::RWPhase | |
| RWPhase (World &world, std::string name, Analysis *analysis=nullptr) | |
| RWPhase (World &world, flags_t annex, Analysis *analysis=nullptr) | |
| void | rewrite_annex (flags_t, Sym, const Def *) override |
| void | rewrite_external (Def *) override |
| World & | world ()=delete |
| Hides both and forbids direct access. | |
| World & | old_world () |
| Get old Defs from here. | |
| World & | new_world () |
| Create new Defs into this. | |
| Public Member Functions inherited from mim::RWBase | |
| Analysis * | analysis () |
| const Analysis * | analysis () const |
| const Def * | lattice (const Def *def) const |
Returns the abstract value computed by the associated Analysis for def, or nullptr if no value is available. | |
| const Def * | abstracted (const Def *def) const |
Returns lattice(def) if it differs from def (i.e. we learned something), otherwise nullptr. | |
| bool | is_bootstrapping () const |
| Returns whether we are currently bootstrapping (rewriting annexes). | |
| Public Member Functions inherited from mim::Phase | |
| Phase (World &world, std::string name) | |
| Phase (World &world, flags_t annex) | |
| virtual | ~Phase ()=default |
| virtual std::unique_ptr< Phase > | recreate () |
| Creates a new instance; needed by a fixed-point PhaseMan. | |
| virtual void | apply (const App *) |
| Invoked if your Phase has additional args. | |
| virtual void | apply (Phase &) |
| Dito, but invoked by Phase::recreate. | |
| virtual bool | redirects () const |
| If true, Phase::create uses take_resolved(). | |
| virtual std::unique_ptr< Phase > | take_resolved () |
| The Phase to use instead; nullptr means elide. | |
| World & | world () |
| Driver & | driver () |
| const fe::Log & | log () const |
| std::string_view | name () const |
| flags_t | annex () const |
| const fe::Vector< std::string > & | args () |
| Command-line arguments passed to this Phase's plugin via -X <plugin>:<arg>. | |
| bool | todo () const |
| void | invalidate (bool todo=true) |
| Signals that another round of fixed-point iteration is required, either as part of. | |
| virtual void | run () |
| Entry point and generates some debug output; invokes Phase::start. | |
| void | profile_count (std::string_view key, uint64_t n=1) |
Adds n to the custom fe::Profiler counter key of the current run; no-op unless profiling is enabled. | |
| Public Member Functions inherited from mim::Rewriter | |
| template<class D = Def> | |
| D * | curr_mut () const |
| Rewriter (std::unique_ptr< World > &&ptr) | |
| Rewriter (World &world) | |
| virtual | ~Rewriter () |
| void | reset (std::unique_ptr< World > &&ptr) |
| void | reset () |
| World & | world () |
| virtual void | push () |
| virtual void | pop () |
| virtual const Def * | map (const Def *old_def, const Def *new_def) |
| const Def * | map_root (const Def *old_def, const Def *new_def) |
| Like map() but records into the root map, so the entry outlives the current push()/pop() scope. | |
| const Def * | map (const Def *old_def, Defs new_defs) |
| const Def * | map (Defs old_defs, const Def *new_def) |
| const Def * | map (Defs old_defs, Defs new_defs) |
| virtual const Def * | lookup (const Def *old_def) |
| Lookup old_def by searching in reverse through the stack of maps. | |
| virtual const Def * | rewrite (const Def *) |
| virtual const Def * | rewrite_imm (const Def *) |
| virtual const Def * | rewrite_mut (Def *) |
| virtual const Def * | rewrite_stub (Def *, Def *) |
| virtual DefVec | rewrite (Defs) |
| virtual const Def * | rewrite_imm_Seq (const Seq *seq) |
| virtual const Def * | rewrite_mut_Seq (Seq *seq) |
Private Member Functions | |
| bool | analyze () final |
| Runs the optional pre-analysis on Phase::world, typically to a fixed point, before rewriting begins. | |
| const Def * | rewrite_imm_App (const App *) final |
| const Def * | rewrite_mut_Lam (Lam *) final |
Additional Inherited Members | |
| Static Public Member Functions inherited from mim::Phase | |
| static std::unique_ptr< Phase > | create (const Flags2Phases &phases, const Def *def) |
| template<class A, class P> | |
| static void | hook (Flags2Phases &phases) |
| template<class P, class... Args> | |
| static void | run (Args &&... args) |
| Runs a single Phase. | |
| Protected Member Functions inherited from mim::RWPhase | |
| void | start () override |
| RWBase::start() and then swaps the two worlds. | |
| Protected Member Functions inherited from mim::RWBase | |
| virtual const Def * | rewrite_root (const Def *def) |
| Rewrites a root - i.e. an annex or an external. | |
| virtual void | finalize () |
| Run after all roots have been walked - but for an RWPhase still before the two worlds are swapped. | |
| RWBase (World &world, std::string name, Analysis *analysis) | |
| RWBase (World &world, flags_t annex, Analysis *analysis) | |
| RWBase (World &world, std::string name, Analysis *analysis, std::unique_ptr< World > &&new_world) | |
Rewrite the World of Phase::world into new_world. | |
| RWBase (World &world, flags_t annex, Analysis *analysis, std::unique_ptr< World > &&new_world) | |
| Protected Member Functions inherited from mim::Rewriter | |
| auto | enter (Def *new_mut) |
Updates curr_mut() to new_mut and restores it at the end of the scope. | |
| Protected Attributes inherited from mim::Phase | |
| std::string | name_ |
| Protected Attributes inherited from mim::Rewriter | |
| std::deque< Def2Def > | old2news_ |
Static Argument Transformation.
A recursive Lam whose self-calls merely forward some of its params is split into a wrapper wrap (same signature) and a loop that drops those params; self-calls forwarding all of them become jumps to loop, all others go through wrap. Tail recursion elimination is the special case where the dropped param is the ret var.
Definition at line 16 of file static_arg_opt.h.
Definition at line 18 of file static_arg_opt.h.
References mim::Phase::annex(), mim::RWPhase::RWPhase(), and mim::RWPhase::world().
|
finalprivatevirtual |
Runs the optional pre-analysis on Phase::world, typically to a fixed point, before rewriting begins.
If analysis() is set, this is the natural place to iterate until Phase::todo() becomes false. If no Analysis is needed, simply return false.
Reimplemented from mim::RWBase.
Definition at line 5 of file static_arg_opt.cpp.
References analyze(), and mim::RWPhase::old_world().
Referenced by analyze().
Definition at line 103 of file static_arg_opt.cpp.
References mim::World::app(), mim::Phase::args(), mim::App::callee(), mim::Phase::invalidate(), mim::RWBase::is_bootstrapping(), mim::Def::isa_mut(), mim::RWPhase::new_world(), and mim::Rewriter::rewrite().
Definition at line 66 of file static_arg_opt.cpp.
References mim::Phase::args(), mim::Lam::body(), mim::Lam::codom(), mim::Def::dbg_key(), mim::Lam::filter(), mim::RWBase::is_bootstrapping(), mim::Phase::log(), mim::Rewriter::map(), mim::RWPhase::new_world(), mim::Rewriter::rewrite(), mim::Lam::type(), and mim::Def::var().
1.18.0