autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
#include <mim/plug/core/autogen.h>
 
/// @namespace mim::plug::mem @ref mem
namespace mim {
namespace plug::mem {
 
static constexpr plugin_t Plugin_Id = 0x3863800000000000;
 
using M = plug::core::M;
using Ptr = plug::core::Ptr;
 
/// @name `mem.Ptr0`
///@{
enum class Ptr0 : flags_t {
};
 
///@}
 
/// @name `mem.Char`
///@{
enum class Char : flags_t {
};
 
///@}
 
/// @name `mem.Str`
///@{
enum class Str : 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.fresh`
///@{
enum class fresh : flags_t {
};
 
///@}
 
/// @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.decay`
///@{
enum class decay : flags_t {
};
 
///@}
 
/// @name `mem.assume`
///@{
enum class assume : flags_t {
};
 
///@}
 
/// @name `mem.cstr`
///@{
enum class cstr : flags_t {
};
 
///@}
 
/// @name `mem.add_mem`
///@{
enum class add_mem : flags_t {
};
 
///@}
 
/// @name `mem.free_locals`
///@{
enum class free_locals : flags_t {
};
 
///@}
 
/// @name `mem.heap2stack`
///@{
enum class heap2stack : flags_t {
};
 
///@}
 
/// @name `mem.seo`
///@{
enum class seo : flags_t {
};
 
///@}
 
/// @name `mem.alloc2malloc_repl`
///@{
enum class alloc2malloc_repl : 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<lea>)] = &normalize_lea; \
    }
} // namespace plug::mem
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::mem::Ptr0> = 0x3863800000000000;
template<> constexpr size_t Annex::Num<plug::mem::Ptr0> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::Char> = 0x3863800000000100;
template<> constexpr size_t Annex::Num<plug::mem::Char> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::Str> = 0x3863800000000200;
template<> constexpr size_t Annex::Num<plug::mem::Str> = 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::fresh> = 0x3863800000000500;
template<> constexpr size_t Annex::Num<plug::mem::fresh> = 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::decay> = 0x3863800000000c00;
template<> constexpr size_t Annex::Num<plug::mem::decay> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::assume> = 0x3863800000000d00;
template<> constexpr size_t Annex::Num<plug::mem::assume> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::cstr> = 0x3863800000000e00;
template<> constexpr size_t Annex::Num<plug::mem::cstr> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::add_mem> = 0x3863800000000f00;
template<> constexpr size_t Annex::Num<plug::mem::add_mem> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::free_locals> = 0x3863800000001000;
template<> constexpr size_t Annex::Num<plug::mem::free_locals> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::heap2stack> = 0x3863800000001100;
template<> constexpr size_t Annex::Num<plug::mem::heap2stack> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::seo> = 0x3863800000001200;
template<> constexpr size_t Annex::Num<plug::mem::seo> = 0;
template<> constexpr flags_t Annex::Base<plug::mem::alloc2malloc_repl> = 0x3863800000001300;
template<> constexpr size_t Annex::Num<plug::mem::alloc2malloc_repl> = 0;
 
template<> struct Axm::IsANode<plug::mem::Ptr0> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::Char> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::Str> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::decay> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::cstr> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::add_mem> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::free_locals> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::heap2stack> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::seo> { using type = Axm; };
template<> struct Axm::IsANode<plug::mem::alloc2malloc_repl> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
 
#endif