autogen.h

Go to the documentation of this file.

#pragma once
 
#include <thorin/axiom.h>
#include <thorin/plugin.h>
 
/// @namespace thorin::plug::mem @ref mem 
namespace thorin {
namespace plug::mem {
 
static constexpr plugin_t Plugin_Id = 0x3863800000000000;
 
/// @name %%mem.M
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum M : flags_t {
#else
enum class M : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.Ptr
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum Ptr : flags_t {
#else
enum class Ptr : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.Ptr0
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum Ptr0 : flags_t {
#else
enum class Ptr0 : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.load
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum load : flags_t {
#else
enum class load : flags_t {
#endif
};
 
Ref normalize_load(Ref, Ref, Ref);
///@}
 
/// @name %%mem.store
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum store : flags_t {
#else
enum class store : flags_t {
#endif
};
 
Ref normalize_store(Ref, Ref, Ref);
///@}
 
/// @name %%mem.remem
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum remem : flags_t {
#else
enum class remem : flags_t {
#endif
};
 
Ref normalize_remem(Ref, Ref, Ref);
///@}
 
/// @name %%mem.alloc
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum alloc : flags_t {
#else
enum class alloc : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.slot
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum slot : flags_t {
#else
enum class slot : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.malloc
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum malloc : flags_t {
#else
enum class malloc : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.free
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum free : flags_t {
#else
enum class free : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.mslot
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum mslot : flags_t {
#else
enum class mslot : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.lea
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum lea : flags_t {
#else
enum class lea : flags_t {
#endif
};
 
Ref normalize_lea(Ref, Ref, Ref);
///@}
 
/// @name %%mem.m
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum m : flags_t {
#else
enum class m : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.ignore
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum ignore : flags_t {
#else
enum class ignore : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.rm
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum rm : flags_t {
#else
enum class rm : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.reshape_mode
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum reshape_mode : flags_t {
#else
enum class reshape_mode : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.reshape_flat
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum reshape_flat : flags_t {
#else
enum class reshape_flat : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.reshape_arg
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum reshape_arg : flags_t {
#else
enum class reshape_arg : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.ssa_pass
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum ssa_pass : flags_t {
#else
enum class ssa_pass : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.copy_prop_pass
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum copy_prop_pass : flags_t {
#else
enum class copy_prop_pass : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.remem_elim_pass
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum remem_elim_pass : flags_t {
#else
enum class remem_elim_pass : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.alloc2malloc_pass
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum alloc2malloc_pass : flags_t {
#else
enum class alloc2malloc_pass : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.reshape_pass
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum reshape_pass : flags_t {
#else
enum class reshape_pass : flags_t {
#endif
};
 
///@}
 
/// @name %%mem.add_mem_phase
///@{
#ifdef DOXYGEN // see https://github.com/doxygen/doxygen/issues/9668
enum add_mem_phase : flags_t {
#else
enum class add_mem_phase : flags_t {
#endif
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define THORIN_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::m> = 0x3863800000000c00;
template<> constexpr size_t Annex::Num<plug::mem::m> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::ignore> = 0x3863800000000d00;
template<> constexpr size_t Annex::Num<plug::mem::ignore> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::rm> = 0x3863800000000e00;
template<> constexpr size_t Annex::Num<plug::mem::rm> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_mode> = 0x3863800000000f00;
template<> constexpr size_t Annex::Num<plug::mem::reshape_mode> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_flat> = 0x3863800000001000;
template<> constexpr size_t Annex::Num<plug::mem::reshape_flat> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_arg> = 0x3863800000001100;
template<> constexpr size_t Annex::Num<plug::mem::reshape_arg> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::ssa_pass> = 0x3863800000001200;
template<> constexpr size_t Annex::Num<plug::mem::ssa_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::copy_prop_pass> = 0x3863800000001300;
template<> constexpr size_t Annex::Num<plug::mem::copy_prop_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::remem_elim_pass> = 0x3863800000001400;
template<> constexpr size_t Annex::Num<plug::mem::remem_elim_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::alloc2malloc_pass> = 0x3863800000001500;
template<> constexpr size_t Annex::Num<plug::mem::alloc2malloc_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::reshape_pass> = 0x3863800000001600;
template<> constexpr size_t Annex::Num<plug::mem::reshape_pass> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::add_mem_phase> = 0x3863800000001700;
template<> constexpr size_t Annex::Num<plug::mem::add_mem_phase> = 0;
 
template<> struct Axiom::Match<plug::mem::M> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::Ptr0> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::m> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::ignore> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::rm> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::reshape_mode> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::reshape_flat> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::reshape_arg> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::remem_elim_pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::alloc2malloc_pass> { using type = Axiom; };
template<> struct Axiom::Match<plug::mem::add_mem_phase> { using type = Axiom; };
#endif
} // namespace thorin