autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.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.Phase`
///@{
enum class Phase : flags_t {
};
 
///@}
 
/// @name `compile.aggr`
///@{
enum class aggr : flags_t {
};
 
const Def* normalize_aggr(const Def*, const Def*, const Def*);
///@}
 
/// @name `compile.cond`
///@{
enum class cond : flags_t {
};
 
const Def* normalize_cond(const Def*, const Def*, const Def*);
///@}
 
/// @name `compile.is_loaded`
///@{
enum class is_loaded : flags_t {
};
 
const Def* normalize_is_loaded(const Def*, const Def*, const Def*);
///@}
 
/// @name `compile.named`
///@{
enum class named : flags_t {
};
 
///@}
 
/// @name `compile.phases`
///@{
enum class phases : flags_t {
};
 
///@}
 
/// @name `compile.adce`
///@{
enum class adce : flags_t {
};
 
///@}
 
/// @name `compile.beta_red`
///@{
enum class beta_red : flags_t {
};
 
///@}
 
/// @name `compile.cleanup`
///@{
enum class cleanup : flags_t {
};
 
///@}
 
/// @name `compile.dispatch_normalize`
///@{
enum class dispatch_normalize : flags_t {
};
 
///@}
 
/// @name `compile.eta_conv`
///@{
enum class eta_conv : flags_t {
};
 
///@}
 
/// @name `compile.lam_spec`
///@{
enum class lam_spec : flags_t {
};
 
///@}
 
/// @name `compile.nom_erasure`
///@{
enum class nom_erasure : flags_t {
};
 
///@}
 
/// @name `compile.null`
///@{
enum class null : flags_t {
};
 
///@}
 
/// @name `compile.ret_wrap`
///@{
enum class ret_wrap : flags_t {
};
 
///@}
 
/// @name `compile.scalarize`
///@{
enum class scalarize : flags_t {
};
 
///@}
 
/// @name `compile.sccp`
///@{
enum class sccp : flags_t {
};
 
///@}
 
/// @name `compile.single_erasure`
///@{
enum class single_erasure : flags_t {
};
 
///@}
 
/// @name `compile.static_arg_opt`
///@{
enum class static_arg_opt : flags_t {
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_compile_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<aggr>)] = &normalize_aggr; \
        normalizers[flags_t(Annex::Base<cond>)] = &normalize_cond; \
        normalizers[flags_t(Annex::Base<is_loaded>)] = &normalize_is_loaded; \
    }
} // namespace plug::compile
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::compile::Phase> = 0x11039128d1800000;
template<> constexpr size_t Annex::Num<plug::compile::Phase> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::aggr> = 0x11039128d1800100;
template<> constexpr size_t Annex::Num<plug::compile::aggr> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::cond> = 0x11039128d1800200;
template<> constexpr size_t Annex::Num<plug::compile::cond> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::is_loaded> = 0x11039128d1800300;
template<> constexpr size_t Annex::Num<plug::compile::is_loaded> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::named> = 0x11039128d1800400;
template<> constexpr size_t Annex::Num<plug::compile::named> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::phases> = 0x11039128d1800500;
template<> constexpr size_t Annex::Num<plug::compile::phases> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::adce> = 0x11039128d1800600;
template<> constexpr size_t Annex::Num<plug::compile::adce> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::beta_red> = 0x11039128d1800700;
template<> constexpr size_t Annex::Num<plug::compile::beta_red> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::cleanup> = 0x11039128d1800800;
template<> constexpr size_t Annex::Num<plug::compile::cleanup> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::dispatch_normalize> = 0x11039128d1800900;
template<> constexpr size_t Annex::Num<plug::compile::dispatch_normalize> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::eta_conv> = 0x11039128d1800a00;
template<> constexpr size_t Annex::Num<plug::compile::eta_conv> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::lam_spec> = 0x11039128d1800b00;
template<> constexpr size_t Annex::Num<plug::compile::lam_spec> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::nom_erasure> = 0x11039128d1800c00;
template<> constexpr size_t Annex::Num<plug::compile::nom_erasure> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::null> = 0x11039128d1800d00;
template<> constexpr size_t Annex::Num<plug::compile::null> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::ret_wrap> = 0x11039128d1800e00;
template<> constexpr size_t Annex::Num<plug::compile::ret_wrap> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::scalarize> = 0x11039128d1800f00;
template<> constexpr size_t Annex::Num<plug::compile::scalarize> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::sccp> = 0x11039128d1801000;
template<> constexpr size_t Annex::Num<plug::compile::sccp> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::single_erasure> = 0x11039128d1801100;
template<> constexpr size_t Annex::Num<plug::compile::single_erasure> = 0;
template<> constexpr flags_t Annex::Base<plug::compile::static_arg_opt> = 0x11039128d1801200;
template<> constexpr size_t Annex::Num<plug::compile::static_arg_opt> = 0;
 
template<> struct Axm::IsANode<plug::compile::Phase> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::adce> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::beta_red> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::cleanup> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::dispatch_normalize> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::eta_conv> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::lam_spec> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::nom_erasure> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::null> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::ret_wrap> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::scalarize> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::sccp> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::single_erasure> { using type = Axm; };
template<> struct Axm::IsANode<plug::compile::static_arg_opt> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
 
#endif