DisVM will now only use 0 initialized memory. - The alloc_memory function will only return 0 initialize memory - calloc_memory was removed

Floating point division is now relying on underlying FPU and IEEE for behavior with respect to divide by 0

arr committed 9 years ago

Commit b92328e1 parent bd1f49311 files · +48 −112Browse files

Showing the changes to src/include (3 of 11 files). Show all

Unified · Split

3 files

@@ -91,7 +91,7 @@ namespace disvm · 90 unmodified lines
91	{	91	{
92	#ifndef NDEBUG	92	#ifndef NDEBUG
93	assert(t != nullptr);	93	assert(t != nullptr);
94	t = reinterpret_cast<T >(0xbada110c);	94	assign_debug_memory(t, sizeof(t));
95	#endif	95	#endif
96	}	96	}
97	}	97	}

             static std::shared_ptr<const type_descriptor_t> type();
         };
-        // Type used to indicate allocated memory should be zeroed out.
-        struct zero_memory_t
-        { };
         // VM memory allocation
         class vm_alloc_t
         {
         public: // static
-            static const zero_memory_t zero_memory;
             static void *operator new(std::size_t sz);
             static void operator delete(void *ptr);
             static vm_alloc_t *allocate(std::shared_ptr<const type_descriptor_t> td);
-            static vm_alloc_t *allocate(std::shared_ptr<const type_descriptor_t> td, const zero_memory_t &);
             static vm_alloc_t *copy(const vm_alloc_t &other);
             static vm_alloc_t *from_allocation(pointer_t allocation);
         public:
             vm_array_t(std::shared_ptr<const type_descriptor_t> td, word_t length);
-            vm_array_t(std::shared_ptr<const type_descriptor_t> td, word_t length, const zero_memory_t&);
             vm_array_t(vm_array_t *original, word_t begin_index, word_t length);
             vm_array_t(const vm_string_t *s);
             ~vm_array_t();

         // While this lock is taken all further allocations will block.
         global_alloc_lock_t get_global_alloc_lock();
-        // Allocate memory from the VM heap
+        // 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>
             return reinterpret_cast<T *>(alloc_memory(amount_in_bytes));
         }
-        // Allocate memory from the VM heap and initialize to 0.
-        void *calloc_memory(std::size_t amount_in_bytes);
-        template<typename T>
-        T *calloc_memory(std::size_t amount_in_bytes = sizeof(T))
-        {
-            return reinterpret_cast<T *>(calloc_memory(amount_in_bytes));
-        }
         // Free memory on the VM heap
         void free_memory(void *memory);

Keyboard shortcuts