autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axiom.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::compile @ref compile 
namespace mim {
namespace plug::compile {
 
static constexpr plugin_t Plugin_Id = 0x11039128d1800000;
 
/// @name %%compile.Pass
///@{
enum class Pass : flags_t {
};
 
///@}
 
/// @name %%compile.Phase
///@{
enum class Phase : flags_t {
};
 
///@}
 
/// @name %%compile.Pipeline
///@{
enum class Pipeline : flags_t {
};
 
///@}
 
/// @name %%compile.PassList
///@{
enum class PassList : flags_t {
};
 
///@}
 
/// @name %%compile.CombinedPhase
///@{
enum class CombinedPhase : flags_t {
};
 
///@}
 
/// @name %%compile.Plugin
///@{
enum class Plugin : flags_t {
};
 
///@}
 
/// @name %%compile.core_plugin
///@{
enum class core_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.mem_plugin
///@{
enum class mem_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.demo_plugin
///@{
enum class demo_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.affine_plugin
///@{
enum class affine_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.autodiff_plugin
///@{
enum class autodiff_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.clos_plugin
///@{
enum class clos_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.direct_plugin
///@{
enum class direct_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.refly_plugin
///@{
enum class refly_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.regex_plugin
///@{
enum class regex_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.matrix_plugin
///@{
enum class matrix_plugin : flags_t {
};
 
///@}
 
/// @name %%compile.pipe
///@{
enum class pipe : flags_t {
};
 
///@}
 
/// @name %%compile.debug_phase
///@{
enum class debug_phase : flags_t {
};
 
///@}
 
/// @name %%compile.pass_list
///@{
enum class pass_list : flags_t {
};
 
///@}
 
/// @name %%compile.pass_phase
///@{
enum class pass_phase : flags_t {
};
 
const Def* normalize_pass_phase(const Def*, const Def*, const Def*);
///@}
 
/// @name %%compile.passes_to_phase
///@{
enum class passes_to_phase : flags_t {
};
 
///@}
 
/// @name %%compile.combine_pass_list
///@{
enum class combine_pass_list : flags_t {
};
 
const Def* normalize_combine_pass_list(const Def*, const Def*, const Def*);
///@}
 
/// @name %%compile.single_pass_phase
///@{
enum class single_pass_phase : flags_t {
};
 
const Def* normalize_single_pass_phase(const Def*, const Def*, const Def*);
///@}
 
/// @name %%compile.phase_list
///@{
enum class phase_list : flags_t {
};
 
///@}
 
/// @name %%compile.combined_phase
///@{
enum class combined_phase : flags_t {
};
 
const Def* normalize_combined_phase(const Def*, const Def*, const Def*);
///@}
 
/// @name %%compile.phases_to_phase
///@{
enum class phases_to_phase : flags_t {
};
 
///@}
 
/// @name %%compile.beta_red_pass
///@{
enum class beta_red_pass : flags_t {
};
 
///@}
 
/// @name %%compile.eta_red_pass
///@{
enum class eta_red_pass : flags_t {
};
 
///@}
 
/// @name %%compile.eta_exp_pass
///@{
enum class eta_exp_pass : flags_t {
};
 
///@}
 
/// @name %%compile.scalarize_pass
///@{
enum class scalarize_pass : flags_t {
};
 
///@}
 
/// @name %%compile.tail_rec_elim_pass
///@{
enum class tail_rec_elim_pass : flags_t {
};
 
///@}
 
/// @name %%compile.lam_spec_pass
///@{
enum class lam_spec_pass : flags_t {
};
 
///@}
 
/// @name %%compile.ret_wrap_pass
///@{
enum class ret_wrap_pass : flags_t {
};
 
///@}
 
/// @name %%compile.nullptr_pass
///@{
enum class nullptr_pass : flags_t {
};
 
///@}
 
/// @name %%compile.internal_cleanup_pass
///@{
enum class internal_cleanup_pass : flags_t {
};
 
///@}
 
/// @name %%compile.plugin_select
///@{
enum class plugin_select : flags_t {
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_compile_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<pass_phase>)] = &normalize_pass_phase; \
        normalizers[flags_t(Annex::Base<combine_pass_list>)] = &normalize_combine_pass_list; \
        normalizers[flags_t(Annex::Base<single_pass_phase>)] = &normalize_single_pass_phase; \
        normalizers[flags_t(Annex::Base<combined_phase>)] = &normalize_combined_phase; \
    }
} // namespace plug::compile
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::compile::Pass> = 0x11039128d1800000;
template<> constexpr size_t Annex::Num<plug::compile::Pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::Phase> = 0x11039128d1800100;
template<> constexpr size_t Annex::Num<plug::compile::Phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::Pipeline> = 0x11039128d1800200;
template<> constexpr size_t Annex::Num<plug::compile::Pipeline> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::PassList> = 0x11039128d1800300;
template<> constexpr size_t Annex::Num<plug::compile::PassList> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::CombinedPhase> = 0x11039128d1800400;
template<> constexpr size_t Annex::Num<plug::compile::CombinedPhase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::Plugin> = 0x11039128d1800500;
template<> constexpr size_t Annex::Num<plug::compile::Plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::core_plugin> = 0x11039128d1800600;
template<> constexpr size_t Annex::Num<plug::compile::core_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::mem_plugin> = 0x11039128d1800700;
template<> constexpr size_t Annex::Num<plug::compile::mem_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::demo_plugin> = 0x11039128d1800800;
template<> constexpr size_t Annex::Num<plug::compile::demo_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::affine_plugin> = 0x11039128d1800900;
template<> constexpr size_t Annex::Num<plug::compile::affine_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::autodiff_plugin> = 0x11039128d1800a00;
template<> constexpr size_t Annex::Num<plug::compile::autodiff_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::clos_plugin> = 0x11039128d1800b00;
template<> constexpr size_t Annex::Num<plug::compile::clos_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::direct_plugin> = 0x11039128d1800c00;
template<> constexpr size_t Annex::Num<plug::compile::direct_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::refly_plugin> = 0x11039128d1800d00;
template<> constexpr size_t Annex::Num<plug::compile::refly_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::regex_plugin> = 0x11039128d1800e00;
template<> constexpr size_t Annex::Num<plug::compile::regex_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::matrix_plugin> = 0x11039128d1800f00;
template<> constexpr size_t Annex::Num<plug::compile::matrix_plugin> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::pipe> = 0x11039128d1801000;
template<> constexpr size_t Annex::Num<plug::compile::pipe> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::debug_phase> = 0x11039128d1801100;
template<> constexpr size_t Annex::Num<plug::compile::debug_phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::pass_list> = 0x11039128d1801200;
template<> constexpr size_t Annex::Num<plug::compile::pass_list> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::pass_phase> = 0x11039128d1801300;
template<> constexpr size_t Annex::Num<plug::compile::pass_phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::passes_to_phase> = 0x11039128d1801400;
template<> constexpr size_t Annex::Num<plug::compile::passes_to_phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::combine_pass_list> = 0x11039128d1801500;
template<> constexpr size_t Annex::Num<plug::compile::combine_pass_list> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::single_pass_phase> = 0x11039128d1801600;
template<> constexpr size_t Annex::Num<plug::compile::single_pass_phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::phase_list> = 0x11039128d1801700;
template<> constexpr size_t Annex::Num<plug::compile::phase_list> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::combined_phase> = 0x11039128d1801800;
template<> constexpr size_t Annex::Num<plug::compile::combined_phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::phases_to_phase> = 0x11039128d1801900;
template<> constexpr size_t Annex::Num<plug::compile::phases_to_phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::beta_red_pass> = 0x11039128d1801a00;
template<> constexpr size_t Annex::Num<plug::compile::beta_red_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::eta_red_pass> = 0x11039128d1801b00;
template<> constexpr size_t Annex::Num<plug::compile::eta_red_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::eta_exp_pass> = 0x11039128d1801c00;
template<> constexpr size_t Annex::Num<plug::compile::eta_exp_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::scalarize_pass> = 0x11039128d1801d00;
template<> constexpr size_t Annex::Num<plug::compile::scalarize_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::tail_rec_elim_pass> = 0x11039128d1801e00;
template<> constexpr size_t Annex::Num<plug::compile::tail_rec_elim_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::lam_spec_pass> = 0x11039128d1801f00;
template<> constexpr size_t Annex::Num<plug::compile::lam_spec_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::ret_wrap_pass> = 0x11039128d1802000;
template<> constexpr size_t Annex::Num<plug::compile::ret_wrap_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::nullptr_pass> = 0x11039128d1802100;
template<> constexpr size_t Annex::Num<plug::compile::nullptr_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::internal_cleanup_pass> = 0x11039128d1802200;
template<> constexpr size_t Annex::Num<plug::compile::internal_cleanup_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::plugin_select> = 0x11039128d1802300;
template<> constexpr size_t Annex::Num<plug::compile::plugin_select> = 0;
 
template<> struct Axiom::Match<plug::compile::Pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::Phase> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::Pipeline> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::PassList> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::CombinedPhase> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::Plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::core_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::mem_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::demo_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::affine_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::autodiff_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::clos_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::direct_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::refly_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::regex_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::matrix_plugin> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::beta_red_pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::eta_red_pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::lam_spec_pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::ret_wrap_pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::nullptr_pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::compile::internal_cleanup_pass> { using type = Axiom; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
 
#endif