autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axiom.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::core @ref core 
namespace mim {
namespace plug::core {
 
static constexpr plugin_t Plugin_Id = 0x1104c60000000000;
 
/// @name %%core.nat
///@{
enum class nat : flags_t {
    add = 0x1104c60000000000,
    sub = 0x1104c60000000001,
    mul = 0x1104c60000000002,
};
 
template<nat>
Ref normalize_nat(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.ncmp
///@{
enum class ncmp : flags_t {
    gle = 0x1104c60000000100,
    f = gle,
    glE = 0x1104c60000000101,
    e = glE,
    gLe = 0x1104c60000000102,
    l = gLe,
    gLE = 0x1104c60000000103,
    le = gLE,
    Gle = 0x1104c60000000104,
    g = Gle,
    GlE = 0x1104c60000000105,
    ge = GlE,
    GLe = 0x1104c60000000106,
    ne = GLe,
    GLE = 0x1104c60000000107,
    t = GLE,
};
 
template<ncmp>
Ref normalize_ncmp(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.mode
///@{
enum class mode : flags_t {
    us = 0x1104c60000000200,
    uS = 0x1104c60000000201,
    Us = 0x1104c60000000202,
    US = 0x1104c60000000203,
    nuw = 0x1104c60000000204,
    nsw = 0x1104c60000000205,
    nusw = 0x1104c60000000206,
};
 
///@}
 
/// @name %%core.idx
///@{
enum class idx : flags_t {
};
 
Ref normalize_idx(Ref, Ref, Ref);
///@}
 
/// @name %%core.bit1
///@{
enum class bit1 : flags_t {
    f = 0x1104c60000000400,
    neg = 0x1104c60000000401,
    id = 0x1104c60000000402,
    t = 0x1104c60000000403,
};
 
template<bit1>
Ref normalize_bit1(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.bit2
///@{
enum class bit2 : flags_t {
    f = 0x1104c60000000500,
    nor = 0x1104c60000000501,
    nciff = 0x1104c60000000502,
    nfst = 0x1104c60000000503,
    niff = 0x1104c60000000504,
    nsnd = 0x1104c60000000505,
    xor_ = 0x1104c60000000506,
    nand = 0x1104c60000000507,
    and_ = 0x1104c60000000508,
    nxor = 0x1104c60000000509,
    snd = 0x1104c6000000050a,
    iff = 0x1104c6000000050b,
    fst = 0x1104c6000000050c,
    ciff = 0x1104c6000000050d,
    or_ = 0x1104c6000000050e,
    t = 0x1104c6000000050f,
};
 
template<bit2>
Ref normalize_bit2(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.shr
///@{
enum class shr : flags_t {
    a = 0x1104c60000000600,
    l = 0x1104c60000000601,
};
 
template<shr>
Ref normalize_shr(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.wrap
///@{
enum class wrap : flags_t {
    add = 0x1104c60000000700,
    sub = 0x1104c60000000701,
    mul = 0x1104c60000000702,
    shl = 0x1104c60000000703,
};
 
template<wrap>
Ref normalize_wrap(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.minus
///@{
enum class minus : flags_t {
};
 
///@}
 
/// @name %%core.div
///@{
enum class div : flags_t {
    sdiv = 0x1104c60000000900,
    udiv = 0x1104c60000000901,
    srem = 0x1104c60000000902,
    urem = 0x1104c60000000903,
};
 
template<div>
Ref normalize_div(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.icmp
///@{
enum class icmp : flags_t {
    xygle = 0x1104c60000000a00,
    f = xygle,
    xyglE = 0x1104c60000000a01,
    e = xyglE,
    xygLe = 0x1104c60000000a02,
    xygLE = 0x1104c60000000a03,
    xyGle = 0x1104c60000000a04,
    xyGlE = 0x1104c60000000a05,
    xyGLe = 0x1104c60000000a06,
    xyGLE = 0x1104c60000000a07,
    xYgle = 0x1104c60000000a08,
    xYglE = 0x1104c60000000a09,
    xYgLe = 0x1104c60000000a0a,
    sl = xYgLe,
    xYgLE = 0x1104c60000000a0b,
    sle = xYgLE,
    xYGle = 0x1104c60000000a0c,
    ug = xYGle,
    xYGlE = 0x1104c60000000a0d,
    uge = xYGlE,
    xYGLe = 0x1104c60000000a0e,
    xYGLE = 0x1104c60000000a0f,
    Xygle = 0x1104c60000000a10,
    XyglE = 0x1104c60000000a11,
    XygLe = 0x1104c60000000a12,
    ul = XygLe,
    XygLE = 0x1104c60000000a13,
    ule = XygLE,
    XyGle = 0x1104c60000000a14,
    sg = XyGle,
    XyGlE = 0x1104c60000000a15,
    sge = XyGlE,
    XyGLe = 0x1104c60000000a16,
    XyGLE = 0x1104c60000000a17,
    XYgle = 0x1104c60000000a18,
    XYglE = 0x1104c60000000a19,
    XYgLe = 0x1104c60000000a1a,
    XYgLE = 0x1104c60000000a1b,
    XYGle = 0x1104c60000000a1c,
    XYGlE = 0x1104c60000000a1d,
    XYGLe = 0x1104c60000000a1e,
    ne = XYGLe,
    XYGLE = 0x1104c60000000a1f,
    t = XYGLE,
};
 
template<icmp>
Ref normalize_icmp(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.extrema
///@{
enum class extrema : flags_t {
    sm = 0x1104c60000000b00,
    umin = sm,
    sM = 0x1104c60000000b01,
    umax = sM,
    Sm = 0x1104c60000000b02,
    smin = Sm,
    SM = 0x1104c60000000b03,
    smax = SM,
};
 
template<extrema>
Ref normalize_extrema(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.abs
///@{
enum class abs : flags_t {
};
 
Ref normalize_abs(Ref, Ref, Ref);
///@}
 
/// @name %%core.conv
///@{
enum class conv : flags_t {
    s = 0x1104c60000000d00,
    u = 0x1104c60000000d01,
};
 
template<conv>
Ref normalize_conv(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.bitcast
///@{
enum class bitcast : flags_t {
};
 
Ref normalize_bitcast(Ref, Ref, Ref);
///@}
 
/// @name %%core.trait
///@{
enum class trait : flags_t {
    size = 0x1104c60000000f00,
    align = 0x1104c60000000f01,
};
 
template<trait>
Ref normalize_trait(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.pe
///@{
enum class pe : flags_t {
    hlt = 0x1104c60000001000,
    run = 0x1104c60000001001,
    known = 0x1104c60000001002,
};
 
template<pe>
Ref normalize_pe(Ref, Ref, Ref);
 
///@}
 
/// @name %%core.zip
///@{
enum class zip : flags_t {
};
 
Ref normalize_zip(Ref, Ref, Ref);
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_core_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(nat::add)] = &normalize_nat<nat::add>; \
        normalizers[flags_t(nat::sub)] = &normalize_nat<nat::sub>; \
        normalizers[flags_t(nat::mul)] = &normalize_nat<nat::mul>; \
        normalizers[flags_t(ncmp::gle)] = &normalize_ncmp<ncmp::gle>; \
        normalizers[flags_t(ncmp::glE)] = &normalize_ncmp<ncmp::glE>; \
        normalizers[flags_t(ncmp::gLe)] = &normalize_ncmp<ncmp::gLe>; \
        normalizers[flags_t(ncmp::gLE)] = &normalize_ncmp<ncmp::gLE>; \
        normalizers[flags_t(ncmp::Gle)] = &normalize_ncmp<ncmp::Gle>; \
        normalizers[flags_t(ncmp::GlE)] = &normalize_ncmp<ncmp::GlE>; \
        normalizers[flags_t(ncmp::GLe)] = &normalize_ncmp<ncmp::GLe>; \
        normalizers[flags_t(ncmp::GLE)] = &normalize_ncmp<ncmp::GLE>; \
        normalizers[flags_t(Annex::Base<idx>)] = &normalize_idx; \
        normalizers[flags_t(bit1::f)] = &normalize_bit1<bit1::f>; \
        normalizers[flags_t(bit1::neg)] = &normalize_bit1<bit1::neg>; \
        normalizers[flags_t(bit1::id)] = &normalize_bit1<bit1::id>; \
        normalizers[flags_t(bit1::t)] = &normalize_bit1<bit1::t>; \
        normalizers[flags_t(bit2::f)] = &normalize_bit2<bit2::f>; \
        normalizers[flags_t(bit2::nor)] = &normalize_bit2<bit2::nor>; \
        normalizers[flags_t(bit2::nciff)] = &normalize_bit2<bit2::nciff>; \
        normalizers[flags_t(bit2::nfst)] = &normalize_bit2<bit2::nfst>; \
        normalizers[flags_t(bit2::niff)] = &normalize_bit2<bit2::niff>; \
        normalizers[flags_t(bit2::nsnd)] = &normalize_bit2<bit2::nsnd>; \
        normalizers[flags_t(bit2::xor_)] = &normalize_bit2<bit2::xor_>; \
        normalizers[flags_t(bit2::nand)] = &normalize_bit2<bit2::nand>; \
        normalizers[flags_t(bit2::and_)] = &normalize_bit2<bit2::and_>; \
        normalizers[flags_t(bit2::nxor)] = &normalize_bit2<bit2::nxor>; \
        normalizers[flags_t(bit2::snd)] = &normalize_bit2<bit2::snd>; \
        normalizers[flags_t(bit2::iff)] = &normalize_bit2<bit2::iff>; \
        normalizers[flags_t(bit2::fst)] = &normalize_bit2<bit2::fst>; \
        normalizers[flags_t(bit2::ciff)] = &normalize_bit2<bit2::ciff>; \
        normalizers[flags_t(bit2::or_)] = &normalize_bit2<bit2::or_>; \
        normalizers[flags_t(bit2::t)] = &normalize_bit2<bit2::t>; \
        normalizers[flags_t(shr::a)] = &normalize_shr<shr::a>; \
        normalizers[flags_t(shr::l)] = &normalize_shr<shr::l>; \
        normalizers[flags_t(wrap::add)] = &normalize_wrap<wrap::add>; \
        normalizers[flags_t(wrap::sub)] = &normalize_wrap<wrap::sub>; \
        normalizers[flags_t(wrap::mul)] = &normalize_wrap<wrap::mul>; \
        normalizers[flags_t(wrap::shl)] = &normalize_wrap<wrap::shl>; \
        normalizers[flags_t(div::sdiv)] = &normalize_div<div::sdiv>; \
        normalizers[flags_t(div::udiv)] = &normalize_div<div::udiv>; \
        normalizers[flags_t(div::srem)] = &normalize_div<div::srem>; \
        normalizers[flags_t(div::urem)] = &normalize_div<div::urem>; \
        normalizers[flags_t(icmp::xygle)] = &normalize_icmp<icmp::xygle>; \
        normalizers[flags_t(icmp::xyglE)] = &normalize_icmp<icmp::xyglE>; \
        normalizers[flags_t(icmp::xygLe)] = &normalize_icmp<icmp::xygLe>; \
        normalizers[flags_t(icmp::xygLE)] = &normalize_icmp<icmp::xygLE>; \
        normalizers[flags_t(icmp::xyGle)] = &normalize_icmp<icmp::xyGle>; \
        normalizers[flags_t(icmp::xyGlE)] = &normalize_icmp<icmp::xyGlE>; \
        normalizers[flags_t(icmp::xyGLe)] = &normalize_icmp<icmp::xyGLe>; \
        normalizers[flags_t(icmp::xyGLE)] = &normalize_icmp<icmp::xyGLE>; \
        normalizers[flags_t(icmp::xYgle)] = &normalize_icmp<icmp::xYgle>; \
        normalizers[flags_t(icmp::xYglE)] = &normalize_icmp<icmp::xYglE>; \
        normalizers[flags_t(icmp::xYgLe)] = &normalize_icmp<icmp::xYgLe>; \
        normalizers[flags_t(icmp::xYgLE)] = &normalize_icmp<icmp::xYgLE>; \
        normalizers[flags_t(icmp::xYGle)] = &normalize_icmp<icmp::xYGle>; \
        normalizers[flags_t(icmp::xYGlE)] = &normalize_icmp<icmp::xYGlE>; \
        normalizers[flags_t(icmp::xYGLe)] = &normalize_icmp<icmp::xYGLe>; \
        normalizers[flags_t(icmp::xYGLE)] = &normalize_icmp<icmp::xYGLE>; \
        normalizers[flags_t(icmp::Xygle)] = &normalize_icmp<icmp::Xygle>; \
        normalizers[flags_t(icmp::XyglE)] = &normalize_icmp<icmp::XyglE>; \
        normalizers[flags_t(icmp::XygLe)] = &normalize_icmp<icmp::XygLe>; \
        normalizers[flags_t(icmp::XygLE)] = &normalize_icmp<icmp::XygLE>; \
        normalizers[flags_t(icmp::XyGle)] = &normalize_icmp<icmp::XyGle>; \
        normalizers[flags_t(icmp::XyGlE)] = &normalize_icmp<icmp::XyGlE>; \
        normalizers[flags_t(icmp::XyGLe)] = &normalize_icmp<icmp::XyGLe>; \
        normalizers[flags_t(icmp::XyGLE)] = &normalize_icmp<icmp::XyGLE>; \
        normalizers[flags_t(icmp::XYgle)] = &normalize_icmp<icmp::XYgle>; \
        normalizers[flags_t(icmp::XYglE)] = &normalize_icmp<icmp::XYglE>; \
        normalizers[flags_t(icmp::XYgLe)] = &normalize_icmp<icmp::XYgLe>; \
        normalizers[flags_t(icmp::XYgLE)] = &normalize_icmp<icmp::XYgLE>; \
        normalizers[flags_t(icmp::XYGle)] = &normalize_icmp<icmp::XYGle>; \
        normalizers[flags_t(icmp::XYGlE)] = &normalize_icmp<icmp::XYGlE>; \
        normalizers[flags_t(icmp::XYGLe)] = &normalize_icmp<icmp::XYGLe>; \
        normalizers[flags_t(icmp::XYGLE)] = &normalize_icmp<icmp::XYGLE>; \
        normalizers[flags_t(extrema::sm)] = &normalize_extrema<extrema::sm>; \
        normalizers[flags_t(extrema::sM)] = &normalize_extrema<extrema::sM>; \
        normalizers[flags_t(extrema::Sm)] = &normalize_extrema<extrema::Sm>; \
        normalizers[flags_t(extrema::SM)] = &normalize_extrema<extrema::SM>; \
        normalizers[flags_t(Annex::Base<abs>)] = &normalize_abs; \
        normalizers[flags_t(conv::s)] = &normalize_conv<conv::s>; \
        normalizers[flags_t(conv::u)] = &normalize_conv<conv::u>; \
        normalizers[flags_t(Annex::Base<bitcast>)] = &normalize_bitcast; \
        normalizers[flags_t(trait::size)] = &normalize_trait<trait::size>; \
        normalizers[flags_t(trait::align)] = &normalize_trait<trait::align>; \
        normalizers[flags_t(pe::hlt)] = &normalize_pe<pe::hlt>; \
        normalizers[flags_t(pe::run)] = &normalize_pe<pe::run>; \
        normalizers[flags_t(pe::known)] = &normalize_pe<pe::known>; \
        normalizers[flags_t(Annex::Base<zip>)] = &normalize_zip; \
    }
} // namespace plug::core
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::core::nat> = 0x1104c60000000000;
template<> constexpr size_t Annex::Num<plug::core::nat> = 3;
template<> constexpr flags_t Annex::Base<plug::core::ncmp> = 0x1104c60000000100;
template<> constexpr size_t Annex::Num<plug::core::ncmp> = 8;
template<> constexpr flags_t Annex::Base<plug::core::mode> = 0x1104c60000000200;
template<> constexpr size_t Annex::Num<plug::core::mode> = 7;
template<> constexpr flags_t Annex::Base<plug::core::idx> = 0x1104c60000000300;
template<> constexpr size_t Annex::Num<plug::core::idx> = 0;
template<> constexpr flags_t Annex::Base<plug::core::bit1> = 0x1104c60000000400;
template<> constexpr size_t Annex::Num<plug::core::bit1> = 4;
template<> constexpr flags_t Annex::Base<plug::core::bit2> = 0x1104c60000000500;
template<> constexpr size_t Annex::Num<plug::core::bit2> = 16;
template<> constexpr flags_t Annex::Base<plug::core::shr> = 0x1104c60000000600;
template<> constexpr size_t Annex::Num<plug::core::shr> = 2;
template<> constexpr flags_t Annex::Base<plug::core::wrap> = 0x1104c60000000700;
template<> constexpr size_t Annex::Num<plug::core::wrap> = 4;
template<> constexpr flags_t Annex::Base<plug::core::minus> = 0x1104c60000000800;
template<> constexpr size_t Annex::Num<plug::core::minus> = 0;
template<> constexpr flags_t Annex::Base<plug::core::div> = 0x1104c60000000900;
template<> constexpr size_t Annex::Num<plug::core::div> = 4;
template<> constexpr flags_t Annex::Base<plug::core::icmp> = 0x1104c60000000a00;
template<> constexpr size_t Annex::Num<plug::core::icmp> = 32;
template<> constexpr flags_t Annex::Base<plug::core::extrema> = 0x1104c60000000b00;
template<> constexpr size_t Annex::Num<plug::core::extrema> = 4;
template<> constexpr flags_t Annex::Base<plug::core::abs> = 0x1104c60000000c00;
template<> constexpr size_t Annex::Num<plug::core::abs> = 0;
template<> constexpr flags_t Annex::Base<plug::core::conv> = 0x1104c60000000d00;
template<> constexpr size_t Annex::Num<plug::core::conv> = 2;
template<> constexpr flags_t Annex::Base<plug::core::bitcast> = 0x1104c60000000e00;
template<> constexpr size_t Annex::Num<plug::core::bitcast> = 0;
template<> constexpr flags_t Annex::Base<plug::core::trait> = 0x1104c60000000f00;
template<> constexpr size_t Annex::Num<plug::core::trait> = 2;
template<> constexpr flags_t Annex::Base<plug::core::pe> = 0x1104c60000001000;
template<> constexpr size_t Annex::Num<plug::core::pe> = 3;
template<> constexpr flags_t Annex::Base<plug::core::zip> = 0x1104c60000001100;
template<> constexpr size_t Annex::Num<plug::core::zip> = 0;
 
template<> struct Axiom::Match<plug::core::mode> { using type = Axiom; };
template<> struct Axiom::Match<plug::core::minus> { using type = Axiom; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> struct fe::is_bit_enum<mim::plug::core::nat> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::ncmp> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::mode> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::bit1> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::bit2> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::shr> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::wrap> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::div> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::icmp> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::extrema> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::conv> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::trait> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::core::pe> : std::true_type {};
 
#endif