Changeset 08a40fd

Timestamp:

Jan 19, 2016, 4:17:14 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

d67a9a1

Parents:

6be0cf9

Message:

segfault in translator

Location:

src/examples/gc_no_raii

Files:

• bug-repro/assert.c (added)
• bug-repro/not_equal.c (added)
• out.test (added)
• src/internal/collector.c (modified) (8 diffs)

src/examples/gc_no_raii/src/internal/collector.c

@@ -2 +2 @@
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 
@@ -8 +9 @@
 #include "gc_tools.h"
 #include "state.h"
-#include "memory_pool.h"
+// #include "memory_pool.h"
 
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size);
@@ -18 +19 @@
 
         bool managed = gc_is_managed(target);
-        gc_object_header* obj = gc_get_object_ptr(target->ptr);
+        gc_object_header* obj = gc_get_object_ptr((void*)target->ptr);
 
         check(gc_is_valide(obj));
@@ -37 +38 @@
         check(size < POOL_SIZE_BYTES);
 
-        void* block = nullptr;
+        void* block = NULL;
         gc_state* gc = gc_get_state();
 
-        if((block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
+        if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
         gc_collect(gc);
 
-        if((block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
+        if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
         gc_allocate_pool(gc);
 
-        if((block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
+        if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
         ofstream_stderr() | "ERROR: allocation in new pool failed" | endl;
         abort();
 
-        return nullptr;
+        return NULL;
 }
 
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size)
 {
-        void* data = (void*)(intptr_t(block) + sizeof(object_header));
+        void* data = (void*)(((intptr_t)block) + sizeof(gc_object_header));
         void* header = block;
 
-        check(intptr_t(data) > intptr_t(block));
-        check(intptr_t(data) >= intptr_t(header));
+        check(((intptr_t)data) > ((intptr_t)block));
+        check(((intptr_t)data) >= ((intptr_t)header));
         check(is_aligned(data));
-        check(intptr_t(data) + target_size <= intptr_t(block) + actual_size);
+        check(((intptr_t)data) + target_size <= ((intptr_t)block) + actual_size);
 
-        object_header* obj = gc_object_header_placement_ctor(header, actual_size);
+        gc_object_header* obj = gc_object_header_placement_ctor(header, actual_size);
 
         (void)obj; //remove unsused warning since this is for debug
         check(obj == get_object_ptr(data));
 
-        gc_register_allocation(get_state(), actual_size);
+        gc_register_allocation(gc_get_state(), actual_size);
 
         return data;
@@ -78 +79 @@
 //      void process_reference(void** ref, std::vector<void**>& worklist)
 //      {
-//              check(!gc::get_state().is_in_heap(ref));
+//              check(!gc::gc_get_state().is_in_heap(ref));
 //
-//              if(object_header* ptr = get_object_ptr(*ref))
+//              if(gc_object_header* ptr = get_object_ptr(*ref))
 //              {
 //                      if(!ptr->is_forwarded)
@@ -98 +99 @@
 //      }
 //
-//      void assign_reference(void** ref, object_header* ptr)
+//      void assign_reference(void** ref, gc_object_header* ptr)
 //      {
-//              void* address = (void*)(intptr_t(ptr) + sizeof(object_header));
+//              void* address = (void*)(((intptr_t)ptr) + sizeof(gc_object_header));
 //
 //              write_aligned_ptr(ref, address);
 //      }
 //
-//      object_header* copy_object(object_header* ptr)
+//      gc_object_header* copy_object(gc_object_header* ptr)
 //      {
 //              check(!ptr->forward);
@@ -117 +118 @@
 //              std::memcpy(new_block, ptr, ptr->size);
 //
-//              object_header* fwd_ptr = new (new_block) object_header(ptr);
+//              gc_object_header* fwd_ptr = new (new_block) gc_object_header(ptr);
 //
 //              ptr->forward = fwd_ptr;
@@ -125 +126 @@
 //      }
 //
-//      void scan_object(object_header* object, std::vector<void**>& worklist)
+//      void scan_object(gc_object_header* object, std::vector<void**>& worklist)
 //      {
 //              gcpointer_base* type = object->type_chain;
 //              while(type)
 //              {
-//                      check(intptr_t(type) > intptr_t(object));
-//                      check(intptr_t(type) < intptr_t(intptr_t(object) + object->size));
+//                      check(((intptr_t)type) > ((intptr_t)object));
+//                      check(((intptr_t)type) < ((intptr_t)((intptr_t)object) + object->size));
 //
-//                      check(gc::get_state().is_in_to_space(&type->m_ptr));
+//                      check(gc::gc_get_state().is_in_to_space(&type->m_ptr));
 //
 //                      worklist.push_back(&type->m_ptr);