//// Dis VM// File: array.cpp// Author: arr// #include <runtime.h>#include <vm_memory.h>#include <debug.h>#include <exceptions.h> using disvm::debug::component_trace_t;using disvm::debug::log_level_t; using disvm::runtime::intrinsic_type_desc;using disvm::runtime::pointer_t;using disvm::runtime::type_descriptor_t;using disvm::runtime::vm_alloc_t;using disvm::runtime::vm_array_t;using disvm::runtime::vm_string_t;using disvm::runtime::word_t; std::shared_ptr<const type_descriptor_t> vm_array_t::type_desc(){    return intrinsic_type_desc::type<vm_array_t>();} vm_array_t::vm_array_t(std::shared_ptr<const type_descriptor_t> td, word_t length)    : vm_alloc_t(vm_array_t::type_desc())    , _arr{ nullptr }    , _element_type{ std::move(td) }    , _length{ length }    , _original{ nullptr }{    assert(_element_type != nullptr);    assert(_length >= 0);    _arr = alloc_memory<byte_t>(_length * _element_type->size_in_bytes);    disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "init: vm array: %d", _length);     // [SPEC] Element memory is already initialized to zero based on the alloc_memory contract} vm_array_t::vm_array_t(vm_array_t &original, word_t begin_index, word_t length)    : vm_alloc_t(vm_array_t::type_desc())    , _arr{ nullptr }    , _element_type{ original.get_element_type() }    , _length{ length }    , _original{ &original }{    assert(0 <= begin_index && (begin_index < _original->get_length() || (begin_index == _original->get_length() && length == 0)));     if (disvm::debug::is_component_tracing_enabled<component_trace_t::memory>())        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "init: vm array: slice: %d %d", begin_index, _length);     // Set the data to reference the original array    _arr = _original->_arr + (begin_index * _element_type->size_in_bytes);     // Check if this is a slice of a slice.    if (_original->_original != nullptr)    {        auto actual_original = _original->_original;        dec_ref_count_and_free(_original);         _original = actual_original;        _original->add_ref();    }} vm_array_t::vm_array_t(const vm_string_t *s)    : vm_alloc_t(vm_array_t::type_desc())    , _arr{ nullptr }    , _element_type{ intrinsic_type_desc::type<byte_t>() }    , _length{ 0 }    , _original{ nullptr }{    if (s != nullptr && s->get_length() > 0)    {        auto str = s->str();         // Ignoring the null terminator.        _length = std::strlen(str);        _arr = alloc_memory<byte_t>(_length);        static_assert(sizeof(byte_t) == sizeof(char), "String characters should be byte size");         std::memcpy(_arr, str, _length);    }     if (disvm::debug::is_component_tracing_enabled<component_trace_t::memory>())        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "init: vm array: vm string: %d", _length);} vm_array_t::~vm_array_t(){    if (_original != nullptr)    {        // If the array is a sliced (based off of another array) then the        // inner pointer simply points into the original array.        debug::assign_debug_pointer(&_arr);         dec_ref_count_and_free(_original);        debug::assign_debug_pointer(&_original);         disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "destroy: vm array: slice");    }    else    {        // Free the array        auto arr_local = _arr;        const auto array_len = _length;        const auto &element_type = *_element_type;        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "begin: destroy: elements: %d", array_len);        for (word_t i = 0; i < array_len; ++i)        {            destroy_memory(element_type, arr_local);            arr_local += element_type.size_in_bytes;        }        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "end: destroy: elements: %d", array_len);         // Free array memory        free_memory(_arr);         debug::assign_debug_pointer(&_arr);        disvm::debug::log_msg(component_trace_t::memory, log_level_t::debug, "destroy: vm array");    } } std::shared_ptr<const type_descriptor_t> vm_array_t::get_element_type() const{    return _element_type;} word_t vm_array_t::get_length() const{    return _length;} pointer_t vm_array_t::at(word_t index) const{    if (index < 0 || _length <= index)        throw index_out_of_range_memory{ 0, _length - 1, index };     return reinterpret_cast<pointer_t>(_arr + (index * _element_type->size_in_bytes));} void vm_array_t::copy_from(const vm_array_t &source, word_t this_begin_index){    if (this_begin_index < 0 || _length < (this_begin_index + source._length))        throw out_of_range_memory{};     if (!source._element_type->is_equal(_element_type.get()))        throw type_violation{};     auto dest_arr = _arr + (this_begin_index * _element_type->size_in_bytes);     // If we have reference types, increment references in the    // source array and decrement them in the destination array.    if (_element_type->map_in_bytes != 0)    {        // [PERF] There is a chance this copy is within the same array, therefore        // a check could be made to not ref count memory that is going to be moved.        const auto &type_desc = *_element_type;        auto source_array_element = source._arr;        auto dest_array_element = dest_arr;        for (auto i = word_t{ 0 }; i < source._length; ++i)        {            inc_ref_count_in_memory(type_desc, source_array_element);            source_array_element += type_desc.size_in_bytes;             dec_ref_count_in_memory(type_desc, dest_array_element);            dest_array_element += type_desc.size_in_bytes;        }    }     // Copy data from within the same array is permitted.    std::memmove(dest_arr, source._arr, (source._length * _element_type->size_in_bytes));}