autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.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>
const Def* normalize_nat(const Def*, const Def*, const Def*);
 
///@}
 
/// @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>
const Def* normalize_ncmp(const Def*, const Def*, const Def*);
 
///@}
 
/// @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 {
};
 
const Def* normalize_idx(const Def*, const Def*, const Def*);
///@}
 
/// @name %%core.idx_unsafe
///@{
enum class idx_unsafe : flags_t {
};
 
const Def* normalize_idx_unsafe(const Def*, const Def*, const Def*);
///@}
 
/// @name %%core.bit1
///@{
enum class bit1 : flags_t {
    f = 0x1104c60000000500,
    neg = 0x1104c60000000501,
    id = 0x1104c60000000502,
    t = 0x1104c60000000503,
};
 
template<bit1>
const Def* normalize_bit1(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.bit2
///@{
enum class bit2 : flags_t {
    f = 0x1104c60000000600,
    nor = 0x1104c60000000601,
    nciff = 0x1104c60000000602,
    nfst = 0x1104c60000000603,
    niff = 0x1104c60000000604,
    nsnd = 0x1104c60000000605,
    xor_ = 0x1104c60000000606,
    nand = 0x1104c60000000607,
    and_ = 0x1104c60000000608,
    nxor = 0x1104c60000000609,
    snd = 0x1104c6000000060a,
    iff = 0x1104c6000000060b,
    fst = 0x1104c6000000060c,
    ciff = 0x1104c6000000060d,
    or_ = 0x1104c6000000060e,
    t = 0x1104c6000000060f,
};
 
template<bit2>
const Def* normalize_bit2(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.shr
///@{
enum class shr : flags_t {
    a = 0x1104c60000000700,
    l = 0x1104c60000000701,
};
 
template<shr>
const Def* normalize_shr(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.wrap
///@{
enum class wrap : flags_t {
    add = 0x1104c60000000800,
    sub = 0x1104c60000000801,
    mul = 0x1104c60000000802,
    shl = 0x1104c60000000803,
};
 
template<wrap>
const Def* normalize_wrap(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.minus
///@{
enum class minus : flags_t {
};
 
///@}
 
/// @name %%core.div
///@{
enum class div : flags_t {
    sdiv = 0x1104c60000000a00,
    udiv = 0x1104c60000000a01,
    srem = 0x1104c60000000a02,
    urem = 0x1104c60000000a03,
};
 
template<div>
const Def* normalize_div(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.icmp
///@{
enum class icmp : flags_t {
    xygle = 0x1104c60000000b00,
    f = xygle,
    xyglE = 0x1104c60000000b01,
    e = xyglE,
    xygLe = 0x1104c60000000b02,
    xygLE = 0x1104c60000000b03,
    xyGle = 0x1104c60000000b04,
    xyGlE = 0x1104c60000000b05,
    xyGLe = 0x1104c60000000b06,
    xyGLE = 0x1104c60000000b07,
    xYgle = 0x1104c60000000b08,
    xYglE = 0x1104c60000000b09,
    xYgLe = 0x1104c60000000b0a,
    sl = xYgLe,
    xYgLE = 0x1104c60000000b0b,
    sle = xYgLE,
    xYGle = 0x1104c60000000b0c,
    ug = xYGle,
    xYGlE = 0x1104c60000000b0d,
    uge = xYGlE,
    xYGLe = 0x1104c60000000b0e,
    xYGLE = 0x1104c60000000b0f,
    Xygle = 0x1104c60000000b10,
    XyglE = 0x1104c60000000b11,
    XygLe = 0x1104c60000000b12,
    ul = XygLe,
    XygLE = 0x1104c60000000b13,
    ule = XygLE,
    XyGle = 0x1104c60000000b14,
    sg = XyGle,
    XyGlE = 0x1104c60000000b15,
    sge = XyGlE,
    XyGLe = 0x1104c60000000b16,
    XyGLE = 0x1104c60000000b17,
    XYgle = 0x1104c60000000b18,
    XYglE = 0x1104c60000000b19,
    XYgLe = 0x1104c60000000b1a,
    XYgLE = 0x1104c60000000b1b,
    XYGle = 0x1104c60000000b1c,
    XYGlE = 0x1104c60000000b1d,
    XYGLe = 0x1104c60000000b1e,
    ne = XYGLe,
    XYGLE = 0x1104c60000000b1f,
    t = XYGLE,
};
 
template<icmp>
const Def* normalize_icmp(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.extrema
///@{
enum class extrema : flags_t {
    sm = 0x1104c60000000c00,
    umin = sm,
    sM = 0x1104c60000000c01,
    umax = sM,
    Sm = 0x1104c60000000c02,
    smin = Sm,
    SM = 0x1104c60000000c03,
    smax = SM,
};
 
template<extrema>
const Def* normalize_extrema(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.abs
///@{
enum class abs : flags_t {
};
 
const Def* normalize_abs(const Def*, const Def*, const Def*);
///@}
 
/// @name %%core.conv
///@{
enum class conv : flags_t {
    s = 0x1104c60000000e00,
    u = 0x1104c60000000e01,
};
 
template<conv>
const Def* normalize_conv(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.bitcast
///@{
enum class bitcast : flags_t {
};
 
const Def* normalize_bitcast(const Def*, const Def*, const Def*);
///@}
 
/// @name %%core.trait
///@{
enum class trait : flags_t {
    size = 0x1104c60000001000,
    align = 0x1104c60000001001,
};
 
template<trait>
const Def* normalize_trait(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.pe
///@{
enum class pe : flags_t {
    hlt = 0x1104c60000001100,
    run = 0x1104c60000001101,
    is_closed = 0x1104c60000001102,
};
 
template<pe>
const Def* normalize_pe(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%core.select
///@{
enum class select : flags_t {
};
 
///@}
 
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(Annex::Base<idx_unsafe>)] = &normalize_idx_unsafe; \
        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::is_closed)] = &normalize_pe<pe::is_closed>; \
    }
} // 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::idx_unsafe> = 0x1104c60000000400;
template<> constexpr size_t Annex::Num<plug::core::idx_unsafe> = 0;
template<> constexpr flags_t Annex::Base<plug::core::bit1> = 0x1104c60000000500;
template<> constexpr size_t Annex::Num<plug::core::bit1> = 4;
template<> constexpr flags_t Annex::Base<plug::core::bit2> = 0x1104c60000000600;
template<> constexpr size_t Annex::Num<plug::core::bit2> = 16;
template<> constexpr flags_t Annex::Base<plug::core::shr> = 0x1104c60000000700;
template<> constexpr size_t Annex::Num<plug::core::shr> = 2;
template<> constexpr flags_t Annex::Base<plug::core::wrap> = 0x1104c60000000800;
template<> constexpr size_t Annex::Num<plug::core::wrap> = 4;
template<> constexpr flags_t Annex::Base<plug::core::minus> = 0x1104c60000000900;
template<> constexpr size_t Annex::Num<plug::core::minus> = 0;
template<> constexpr flags_t Annex::Base<plug::core::div> = 0x1104c60000000a00;
template<> constexpr size_t Annex::Num<plug::core::div> = 4;
template<> constexpr flags_t Annex::Base<plug::core::icmp> = 0x1104c60000000b00;
template<> constexpr size_t Annex::Num<plug::core::icmp> = 32;
template<> constexpr flags_t Annex::Base<plug::core::extrema> = 0x1104c60000000c00;
template<> constexpr size_t Annex::Num<plug::core::extrema> = 4;
template<> constexpr flags_t Annex::Base<plug::core::abs> = 0x1104c60000000d00;
template<> constexpr size_t Annex::Num<plug::core::abs> = 0;
template<> constexpr flags_t Annex::Base<plug::core::conv> = 0x1104c60000000e00;
template<> constexpr size_t Annex::Num<plug::core::conv> = 2;
template<> constexpr flags_t Annex::Base<plug::core::bitcast> = 0x1104c60000000f00;
template<> constexpr size_t Annex::Num<plug::core::bitcast> = 0;
template<> constexpr flags_t Annex::Base<plug::core::trait> = 0x1104c60000001000;
template<> constexpr size_t Annex::Num<plug::core::trait> = 2;
template<> constexpr flags_t Annex::Base<plug::core::pe> = 0x1104c60000001100;
template<> constexpr size_t Annex::Num<plug::core::pe> = 3;
template<> constexpr flags_t Annex::Base<plug::core::select> = 0x1104c60000001200;
template<> constexpr size_t Annex::Num<plug::core::select> = 0;
 
template<> struct Axm::IsANode<plug::core::mode> { using type = Axm; };
template<> struct Axm::IsANode<plug::core::minus> { using type = Axm; };
template<> struct Axm::IsANode<plug::core::select> { using type = Axm; };
 
#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