compile.cpp

Go to the documentation of this file.

#include "mim/plug/compile/compile.h"
 
#include <memory>
 
#include <mim/config.h>
#include <mim/driver.h>
#include <mim/phase.h>
 
#include <mim/phase/adce.h>
#include <mim/phase/beta_red.h>
#include <mim/phase/dispatch_normalize.h>
#include <mim/phase/eta_conv.h>
#include <mim/phase/lam_spec.h>
#include <mim/phase/nom_erasure.h>
#include <mim/phase/ret_wrap.h>
#include <mim/phase/scalarize.h>
#include <mim/phase/sccp.h>
#include <mim/phase/single_erasure.h>
#include <mim/phase/static_arg_opt.h>
 
#include "mim/plug/compile/autogen.h"
 
using namespace mim;
using namespace mim::plug;
 
/// Phase hook for `compile.named`.
/// Reads the fully-qualified annex name (e.g. `"clos.clos_conv"`) from the driving App at phase-build time,
/// looks up the matching annex `Def` in the current `World`, and *redirects* Phase::create to that annex's own
/// Phase. If the plugin part of the name is not loaded or the annex is missing, it elides (resolves to nothing),
/// so the enclosing `compile.phases` simply skips it.
class Named : public Phase {
public:
    Named(World& w, flags_t a)
        : Phase(w, a) {}
 
    void start() final { std::unreachable(); } // a Named always redirects and never runs itself
 
    void apply(const App* app) final {
        if (!app) return;
        auto str = tuple2str(app->arg());
        if (str.empty()) return;
 
        auto dot = str.find('.');
        if (dot == std::string::npos) return;
        if (!driver().is_loaded(std::string_view(str).substr(0, dot))) return;
 
        if (auto def = world().annex(driver().sym(str))) resolved_ = Phase::create(driver().phases(), def);
    }
 
    bool redirects() const override { return true; }
    std::unique_ptr<Phase> take_resolved() override { return std::move(resolved_); }
 
private:
    std::unique_ptr<Phase> resolved_;
};
 
static void reg_phases(Flags2Phases& phases) {
    // clang-format off
    fe::assert_emplace(phases, Annex::base<compile::null>(), [](World&) { return std::unique_ptr<Phase>{}; });
    Phase::hook<compile::adce,               ADCE             >(phases);
    Phase::hook<compile::beta_red,           BetaRed          >(phases);
    Phase::hook<compile::cleanup,            Cleanup          >(phases);
    Phase::hook<compile::dispatch_normalize, DispatchNormalize>(phases);
    Phase::hook<compile::eta_conv,           EtaConv          >(phases);
    Phase::hook<compile::lam_spec,           LamSpec          >(phases);
    Phase::hook<compile::named,              Named            >(phases);
    Phase::hook<compile::nom_erasure,        NomErasure       >(phases);
    Phase::hook<compile::phases,             PhaseMan         >(phases);
    Phase::hook<compile::ret_wrap,           RetWrap          >(phases);
    Phase::hook<compile::scalarize,          Scalarize        >(phases);
    Phase::hook<compile::sccp,               SCCP             >(phases);
    Phase::hook<compile::single_erasure,     SingleErasure    >(phases);
    Phase::hook<compile::static_arg_opt,     StaticArgOpt     >(phases);
    // clang-format on
}
 
// clang-format off
static constexpr PluginArg known_args[] = {
    {"aggr",    "Forces `compile.aggr` to `tt`, switching fixed-point iteration of the `opt` pipeline's `optimize` stage on (off by default)."},
    {"no-aggr", "Forces `compile.aggr` to `ff`, switching that fixed-point iteration off."},
};
// clang-format on
 
MIM_PLUGIN_ENTRY(compile) {
    plugin.register_normalizers = compile::register_normalizers;
    plugin.register_phases      = reg_phases;
    plugin.args                 = known_args;
    plugin.num_args             = std::size(known_args);
}