//// Dis VM// File: vm_memory.h// Author: arr// #ifndef _DISVM_SRC_INCLUDE_VM_MEMORY_H_#define _DISVM_SRC_INCLUDE_VM_MEMORY_H_ #include <cstdint>#include <cassert>#include <limits>#include <mutex>#include <memory>#include <bitset>#include <functional>#include "runtime.h" namespace disvm{    namespace runtime    {        // Allocate memory from the VM heap that is initialize to 0.        // [SPEC] All memory in this implementation of the Dis VM spec        // will be 0 initialized.        void *alloc_memory(std::size_t amount_in_bytes);         template<typename T>        T *alloc_memory(std::size_t amount_in_bytes = sizeof(T))        {            return reinterpret_cast<T *>(alloc_memory(amount_in_bytes));        }         // Free memory on the VM heap        void free_memory(void *memory);         // Initialize supplied memory based on the type descriptor        void init_memory(const type_descriptor_t &type_desc, void *data);         // Destroy supplied memory based on the type descriptor        void destroy_memory(const type_descriptor_t &type_desc, void *data);         // Increment the ref count of all pointers in the supplied memory allocation        void inc_ref_count_in_memory(const type_descriptor_t &type_desc, void *data);         // Decrement the ref count of all pointers in the supplied memory allocation        void dec_ref_count_in_memory(const type_descriptor_t &type_desc, void *data);         // Decrement the ref count and if 0 free the allocation        void dec_ref_count_and_free(vm_alloc_t *alloc);         // Function to enumerate pointer fields in an object. The function is defined        // as a template to permit raw function pointers or lambdas. The signature        // of the callback must be 'void(pointer_t *)' and is supplied a pointer to the        // non-null pointer field. The offset of the field is relative to the supplied        // 'data' pointer.        template<typename CB>        void enum_pointer_fields(const type_descriptor_t &type_desc, void *data, CB callback)        {            assert(data != nullptr);             auto memory = reinterpret_cast<word_t *>(data);            for (auto i = word_t{ 0 }; i < type_desc.map_in_bytes; ++i, memory += 8)            {                const auto words8 = type_desc.pointer_map[i];                assert(sizeof(words8) == 1);                if (words8 == 0)                    continue;                 const auto flags = std::bitset<sizeof(words8) * 8>{ words8 };                 // Enumerating the flags in reverse order so memory access is sequential.                if (flags[7] && (memory[0] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory));                if (flags[6] && (memory[1] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory) + 1);                if (flags[5] && (memory[2] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory) + 2);                if (flags[4] && (memory[3] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory) + 3);                if (flags[3] && (memory[4] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory) + 4);                if (flags[2] && (memory[5] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory) + 5);                if (flags[1] && (memory[6] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory) + 6);                if (flags[0] && (memory[7] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t *>(memory) + 7);            }        }         // Check if a specific pointer-sized offset in a type represents a pointer        bool is_offset_pointer(const type_descriptor_t &type_desc, std::size_t offset);    }} #endif // _DISVM_SRC_INCLUDE_VM_MEMORY_H_