//
// Dis VM
// File: builtin_module.h
// Author: arr
//

#ifndef _DISVM_SRC_INCLUDE_BUILTIN_MODULE_H_
#define _DISVM_SRC_INCLUDE_BUILTIN_MODULE_H_

#include <cstdint>
#include <memory>
#include "runtime.h"

#define BUILTIN_MODULE_PREFIX_STR "$"
#define BUILTIN_MODULE_PREFIX_CHAR '$'

namespace disvm
{
    namespace runtime
    {
        namespace builtin
        {
            // Called to initialize built-in modules.
            // This will be called once per process hosting a VM.
            void initialize_builtin_modules();

            // Defined as 'Runtab' in Inferno (limbo/stubs.c)
            struct vm_runtab_t
            {
                // Function identification
                const char *name;
                uint32_t sig;

                // Function pointer
                vm_exec_t fn;

                // Function frame type
                word_t frame_size;
                word_t frame_pointer_count;
                byte_t frame_pointer_map[16];
            };

            // Called by the built-in module during initialization
            void register_module_exports(const char *name, word_t table_length, const vm_runtab_t *module_runtime_table);

            // Get the supplied built-in module.
            std::shared_ptr<vm_module_t> get_builtin_module(const char *name);
        }

        // [SPEC] All allocated frames have the following base layout.
        // See 'struct Frame' in Inferno (include/interp.h)
        // The base frame does not include the return register since that
        // is typed on the generated function frame type.
        struct vm_frame_base_alloc_t
        {
            vm_pc_t p_pc; // Previous PC
            vm_frame_t *p_fp; // Previous frame pointer
            vm_module_ref_t *p_mr; // Previous module ref
            pointer_t reserved; // Reserved for VM
        };

        struct vm_frame_constants
        {
            static constexpr auto register_size_in_bytes() { return sizeof(word_t); }

            // Includes registers on base frame plus the implied return register
            static constexpr auto default_register_count() { return (sizeof(vm_frame_base_alloc_t) / register_size_in_bytes()) + 1; }

            // [SPEC] The fixed point registers are defined by their usage in the
            // Inferno implementation. They rely on the 'temp' registers defined below.
            // See fixed point opcodes in Inferno (libinterp/xec.c).
            static constexpr auto fixed_point_register_1_offset() { return default_register_count() * register_size_in_bytes(); }
            static constexpr auto fixed_point_register_2_offset() { return fixed_point_register_1_offset() + (2 * register_size_in_bytes()); }

            // [SPEC] The official Limbo compiler allocates additional 'temp' registers on all call frames.
            // See 'STemp', 'RTemp', and 'DTemp' in Inferno (limbo/limbo.h)
            static constexpr auto limbo_temp_register_count() { return 3; }

            // Define the first argument offset in a Limbo compiler generated call frame.
            static constexpr auto limbo_first_arg_register_offset() { return (default_register_count() + limbo_temp_register_count()) * register_size_in_bytes(); }
        };

        //
        // Helpers for accessing VM types
        //

        // Get value-type reference
        template<typename ValueType>
        ValueType& vt_ref(pointer_t vt)
        {
            assert(vt != nullptr);
            return *reinterpret_cast<ValueType *>(vt);
        }

        // Get allocation type value
        template<typename AllocType>
        typename std::enable_if<std::is_base_of<vm_alloc_t, AllocType>::value, AllocType *>::type
            at_val(pointer_t at)
        {
            assert(at != nullptr);
            return vm_alloc_t::from_allocation<AllocType>(*reinterpret_cast<pointer_t *>(at));
        }

        // Get allocation type value - base alloc type
        template<>
        inline vm_alloc_t *at_val<vm_alloc_t>(pointer_t at)
        {
            assert(at != nullptr);
            return vm_alloc_t::from_allocation(*reinterpret_cast<pointer_t *>(at));
        }

        // Get pointer type reference
        inline pointer_t &pt_ref(pointer_t pt)
        {
            assert(pt != nullptr);
            return *reinterpret_cast<pointer_t *>(pt);
        }
    }
}

#endif // _DISVM_SRC_INCLUDE_BUILTIN_MODULE_H_