autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::mem @ref mem 
namespace mim {
namespace plug::mem {
 
static constexpr plugin_t Plugin_Id = 0x3863800000000000;
 
/// @name %%mem.M
///@{
enum class M : flags_t {
};
 
///@}
 
/// @name %%mem.Ptr
///@{
enum class Ptr : flags_t {
};
 
///@}
 
/// @name %%mem.Ptr0
///@{
enum class Ptr0 : flags_t {
};
 
///@}
 
/// @name %%mem.load
///@{
enum class load : flags_t {
};
 
const Def* normalize_load(const Def*, const Def*, const Def*);
///@}
 
/// @name %%mem.store
///@{
enum class store : flags_t {
};
 
const Def* normalize_store(const Def*, const Def*, const Def*);
///@}
 
/// @name %%mem.remem
///@{
enum class remem : flags_t {
};
 
const Def* normalize_remem(const Def*, const Def*, const Def*);
///@}
 
/// @name %%mem.alloc
///@{
enum class alloc : flags_t {
};
 
///@}
 
/// @name %%mem.slot
///@{
enum class slot : flags_t {
};
 
///@}
 
/// @name %%mem.malloc
///@{
enum class malloc : flags_t {
};
 
///@}
 
/// @name %%mem.free
///@{
enum class free : flags_t {
};
 
///@}
 
/// @name %%mem.mslot
///@{
enum class mslot : flags_t {
};
 
///@}
 
/// @name %%mem.lea
///@{
enum class lea : flags_t {
};
 
const Def* normalize_lea(const Def*, const Def*, const Def*);
///@}
 
/// @name %%mem.add_mem_phase
///@{
enum class add_mem_phase : flags_t {
};
 
///@}
 
/// @name %%mem.remem_repl
///@{
enum class remem_repl : flags_t {
};
 
///@}
 
/// @name %%mem.alloc2malloc_repl
///@{
enum class alloc2malloc_repl : flags_t {
};
 
///@}
 
/// @name %%mem.ssa_pass
///@{
enum class ssa_pass : flags_t {
};
 
///@}
 
/// @name %%mem.copy_prop_pass
///@{
enum class copy_prop_pass : flags_t {
};
 
///@}
 
/// @name %%mem.reshape_mode
///@{
enum class reshape_mode : flags_t {
};
 
///@}
 
/// @name %%mem.reshape_flat
///@{
enum class reshape_flat : flags_t {
};
 
///@}
 
/// @name %%mem.reshape_arg
///@{
enum class reshape_arg : flags_t {
};
 
///@}
 
/// @name %%mem.reshape_pass
///@{
enum class reshape_pass : flags_t {
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_mem_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<load>)] = &normalize_load; \
        normalizers[flags_t(Annex::Base<store>)] = &normalize_store; \
        normalizers[flags_t(Annex::Base<remem>)] = &normalize_remem; \
        normalizers[flags_t(Annex::Base<lea>)] = &normalize_lea; \
    }
} // namespace plug::mem
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::mem::M> = 0x3863800000000000;
template<> constexpr size_t Annex::Num<plug::mem::M> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::Ptr> = 0x3863800000000100;
template<> constexpr size_t Annex::Num<plug::mem::Ptr> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::Ptr0> = 0x3863800000000200;
template<> constexpr size_t Annex::Num<plug::mem::Ptr0> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::load> = 0x3863800000000300;
template<> constexpr size_t Annex::Num<plug::mem::load> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::store> = 0x3863800000000400;
template<> constexpr size_t Annex::Num<plug::mem::store> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::remem> = 0x3863800000000500;
template<> constexpr size_t Annex::Num<plug::mem::remem> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::alloc> = 0x3863800000000600;
template<> constexpr size_t Annex::Num<plug::mem::alloc> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::slot> = 0x3863800000000700;
template<> constexpr size_t Annex::Num<plug::mem::slot> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::malloc> = 0x3863800000000800;
template<> constexpr size_t Annex::Num<plug::mem::malloc> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::free> = 0x3863800000000900;
template<> constexpr size_t Annex::Num<plug::mem::free> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::mslot> = 0x3863800000000a00;
template<> constexpr size_t Annex::Num<plug::mem::mslot> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::lea> = 0x3863800000000b00;
template<> constexpr size_t Annex::Num<plug::mem::lea> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::add_mem_phase> = 0x3863800000000c00;
template<> constexpr size_t Annex::Num<plug::mem::add_mem_phase> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::remem_repl> = 0x3863800000000d00;
template<> constexpr size_t Annex::Num<plug::mem::remem_repl> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::alloc2malloc_repl> = 0x3863800000000e00;
template<> constexpr size_t Annex::Num<plug::mem::alloc2malloc_repl> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::ssa_pass> = 0x3863800000000f00;
template<> constexpr size_t Annex::Num<plug::mem::ssa_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::copy_prop_pass> = 0x3863800000001000;
template<> constexpr size_t Annex::Num<plug::mem::copy_prop_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_mode> = 0x3863800000001100;
template<> constexpr size_t Annex::Num<plug::mem::reshape_mode> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_flat> = 0x3863800000001200;
template<> constexpr size_t Annex::Num<plug::mem::reshape_flat> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_arg> = 0x3863800000001300;
template<> constexpr size_t Annex::Num<plug::mem::reshape_arg> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_pass> = 0x3863800000001400;
template<> constexpr size_t Annex::Num<plug::mem::reshape_pass> = 0;
 
template<> struct Axm::IsANode<plug::mem::Ptr0> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::add_mem_phase> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::remem_repl> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::alloc2malloc_repl> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::ssa_pass> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::reshape_mode> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::reshape_flat> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::reshape_arg> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
 
#endif