MimIR
MimIR is my Intermediate Representation
Loading...
Searching...
No Matches
mim::plug::mem::phase::FreeLocals Class Reference

Frees the memory a function allocates but does not let escape; see mem::EscapeAnalysis. More...

#include <mim/plug/mem/phase/free_locals.h>

Inheritance diagram for mim::plug::mem::phase::FreeLocals:
[legend]

Public Member Functions

 FreeLocals (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)
Analysis * analysis ()
const Analysis * analysis () const
const Def * lattice (const Def *old_def) const
 Returns the abstract value computed by the associated Analysis for the given old-world Def, or nullptr if no value is available.
const Def * abstracted (const Def *old_def) const
 Returns lattice(old_def) if it differs from old_def (i.e. we learned something), otherwise nullptr.
bool is_top (const Def *old_def) const
virtual void rewrite_external (Def *)
const Def * lookup (const Def *) override
 Lookup old_def by searching in reverse through the stack of maps.
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::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 (World &world)
virtual ~Rewriter ()
void reset ()
World & world ()
void push (Vars old_vars={}, Vars new_vars={})
void pop ()
void bind_old (const Var *var)
 Adds the old var - if any - to the innermost scope.
void bind_new (const Var *var)
 Adds the new var - if any - to the innermost scope.
void bind (const Var *old_var, const Var *new_var)
const Def * map (const Def *old_def, const Def *new_def)
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 * rewrite (const Def *)
virtual const Def * rewrite_imm (const Def *)
virtual const Def * rewrite_mut (Def *)
const Def * rewrite_stub (Def *old_mut, Def *new_mut, fe::View< size_t > new2old)
 Like above, but new_mut may have a different number of ops than old_mut: new_mut->op(i) is rewritten from old_mut->op(new2old[i]).
virtual DefVec rewrite (Defs)
virtual const Def * rewrite_imm_Lit (const Lit *)
virtual const Def * rewrite_imm_Axm (const Axm *)
virtual const Def * rewrite_imm_Var (const Var *)
virtual const Def * rewrite_imm_Proxy (const Proxy *)
virtual const Def * rewrite_imm_Type (const Type *)
virtual const Def * rewrite_imm_Level (const Level *)
virtual const Def * rewrite_imm_LMax (const LMax *)
virtual const Def * rewrite_imm_LSucc (const LSucc *)
virtual const Def * rewrite_imm_Pi (const Pi *)
virtual const Def * rewrite_imm_Lam (const Lam *)
virtual const Def * rewrite_imm_Sigma (const Sigma *)
virtual const Def * rewrite_imm_Extract (const Extract *)
virtual const Def * rewrite_imm_Insert (const Insert *)
virtual const Def * rewrite_imm_Arr (const Arr *)
virtual const Def * rewrite_imm_Pack (const Pack *)
virtual const Def * rewrite_imm_Join (const Join *)
virtual const Def * rewrite_imm_Inj (const Inj *)
virtual const Def * rewrite_imm_Match (const Match *)
virtual const Def * rewrite_imm_Variant (const Variant *)
virtual const Def * rewrite_imm_Top (const Top *)
virtual const Def * rewrite_imm_Bot (const Bot *)
virtual const Def * rewrite_imm_Reform (const Reform *)
virtual const Def * rewrite_imm_Rule (const Rule *)
virtual const Def * rewrite_imm_Single (const Single *)
virtual const Def * rewrite_imm_Wrap (const Wrap *)
virtual const Def * rewrite_imm_Nat (const Nat *)
virtual const Def * rewrite_imm_Idx (const Idx *)
virtual const Def * rewrite_imm_Nom (const Nom *)
virtual const Def * rewrite_imm_Name (const Name *)
virtual const Def * rewrite_imm_Struc (const Struc *)
virtual const Def * rewrite_mut_Hole (Hole *)
virtual const Def * rewrite_mut_Pi (Pi *)
virtual const Def * rewrite_mut_Lam (Lam *)
virtual const Def * rewrite_mut_Sigma (Sigma *)
virtual const Def * rewrite_mut_Arr (Arr *)
virtual const Def * rewrite_mut_Pack (Pack *)
virtual const Def * rewrite_mut_Variant (Variant *)
virtual const Def * rewrite_mut_Rule (Rule *)
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 old_world(), typically to a fixed point, before rewriting begins.
const Def * rewrite_imm_App (const App *) 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
 Actual entry.
virtual void finalize ()
 Run after all roots have been walked but still before the two worlds are swapped.
const Def * rewrite_imm_App (const App *) override
const Def * rewrite_imm_Tuple (const Tuple *) override
const Def * rewrite_stub (Def *, Def *) override
const Def * coerce (const Def *new_type, const Def *new_val)
 Converts the new new_val into a value of the new new_type, where a checking position demands it.
const Def * rewrite_stub (Def *old_mut, Def *new_mut, fe::View< size_t > new2old)
 Like above, but new_mut may have a different number of ops than old_mut: new_mut->op(i) is rewritten from old_mut->op(new2old[i]).
Protected Member Functions inherited from mim::Rewriter
Def2Def & old2new ()
 The map of the innermost push() scope.
bool has_intersection (const Def *old_def)
 Does old_def depend on the old Vars of any scope?
auto enter (Def *new_mut)
 Updates curr_mut() to new_mut and restores it at the end of the scope.
const Def * seal (Def *old_mut, Def *new_mut)
 The tail of rewrite_stub: immutabilizes new_mut in hindsight, as rewriting may have made it vacuous.
static bool splittable (const Def *type)
 Does coerce() explode and reassemble values of type?
Protected Attributes inherited from mim::Phase
std::string name_
Protected Attributes inherited from mim::Rewriter
fe::Vector< Scope > scopes_

Detailed Description

Frees the memory a function allocates but does not let escape; see mem::EscapeAnalysis.

An allocation only its home's own memory chain mentions is freed right after its last use there. Any other is freed as control passes from where it is live to where it is dead. It is live on entry to a Nest node if the node or a sibling it or one of its ancestors reaches mentions it. Since a recursive node reaches itself, this covers loops, too. This is closed under control flow: once dead, an allocation stays dead.

Definition at line 16 of file free_locals.h.

Constructor & Destructor Documentation

◆ FreeLocals()

mim::plug::mem::phase::FreeLocals::FreeLocals ( World & world,
flags_t annex )
inline

Definition at line 18 of file free_locals.h.

References mim::Phase::annex(), mim::RWPhase::RWPhase(), and mim::RWPhase::world().

Member Function Documentation

◆ analyze()

bool mim::plug::mem::phase::FreeLocals::analyze ( )
finalprivatevirtual

Runs the optional pre-analysis on old_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::RWPhase.

Definition at line 7 of file free_locals.cpp.

References mim::plug::mem::EscapeAnalysis::allocates(), mim::RWPhase::analyze(), mim::Phase::log(), mim::Nest::Nest(), mim::Def::nests(), and mim::RWPhase::old_world().

◆ rewrite_imm_App()

const Def * mim::plug::mem::phase::FreeLocals::rewrite_imm_App ( const App * app)
finalprivatevirtual

Reimplemented from mim::Rewriter.

Definition at line 107 of file free_locals.cpp.

References mim::App::arg(), mim::Phase::args(), mim::App::callee(), mim::Phase::log(), mim::plug::mem::mem_def(), mim::RWPhase::new_world(), mim::App::num_targs(), mim::Rewriter::rewrite(), and mim::RWPhase::rewrite_imm_App().

The documentation for this class was generated from the following files: