vm: make all_blocks a set of cells

gcc was doing bad things assuming the pointer given to upper_bound was aligned

diff --git a/vm/code_blocks.cpp b/vm/code_blocks.cpp
index 4e1944b79263376ec49acac39cd19d8c118b53fe..9610205797fac44922b7476fc7f0052249a991fc 100755 (executable)
--- a/vm/code_blocks.cpp
+++ b/vm/code_blocks.cpp
@@ -440,7 +440,7 @@ code_block *factor_vm::add_code_block(code_block_type type, cell code_, cell lab
        method returns, except when compiling words with the non-optimizing
        compiler at the beginning of bootstrap */
        this->code->uninitialized_blocks.insert(std::make_pair(compiled,literals.value()));
-       this->code->all_blocks.insert(compiled);
+       this->code->all_blocks.insert((cell)compiled);
 
        /* next time we do a minor GC, we have to trace this code block, since
        the fields of the code_block struct might point into nursery or aging */

diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp
index 4060b17cee9d73046f6e87a852fbdab0372d6122..12f903f66a0081b7d0a0a3a328c756721b79be36 100755 (executable)
--- a/vm/code_heap.cpp
+++ b/vm/code_heap.cpp
@@ -63,7 +63,7 @@ void code_heap::free(code_block *compiled)
        FACTOR_ASSERT(!uninitialized_p(compiled));
        points_to_nursery.erase(compiled);
        points_to_aging.erase(compiled);
-       all_blocks.erase(compiled);
+       all_blocks.erase((cell)compiled);
        allocator->free(compiled);
 }
 
@@ -98,14 +98,13 @@ void code_heap::sweep()
 }
 
 struct all_blocks_set_verifier {
-       std::set<code_block*> *all_blocks;
+       std::set<cell> *all_blocks;
 
-       all_blocks_set_verifier(std::set<code_block*> *all_blocks) : all_blocks(all_blocks) {}
+       all_blocks_set_verifier(std::set<cell> *all_blocks) : all_blocks(all_blocks) {}
 
        void operator()(code_block *block, cell size)
        {
-               FACTOR_ASSERT(all_blocks->find(block) != all_blocks->end());
-               all_blocks->erase(block);
+               FACTOR_ASSERT(all_blocks->find((cell)block) != all_blocks->end());
        }
 };
 
@@ -117,11 +116,11 @@ void code_heap::verify_all_blocks_set()
 
 code_block *code_heap::code_block_for_address(cell address)
 {
-       std::set<code_block*>::const_iterator blocki =
+       std::set<cell>::const_iterator blocki =
                all_blocks.upper_bound((code_block*)address);
        FACTOR_ASSERT(blocki != all_blocks.begin());
        --blocki;
-       code_block* found_block = *blocki;
+       code_block* found_block = (code_block*)*blocki;
 #ifdef FACTOR_DEBUG
        if (!((cell)found_block->entry_point() <= address
                && address - (cell)found_block->entry_point() < found_block->size()))
@@ -146,7 +145,7 @@ struct all_blocks_set_inserter {
 
        void operator()(code_block *block, cell size)
        {
-               code->all_blocks.insert(block);
+               code->all_blocks.insert((cell)block);
        }
 };
 

diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp
index 83b3ae586d16b2d5a584d9c5c195871f50785f79..a7bf9284f3c03d0fe033c3e2abfbc03ad6272f1e 100755 (executable)
--- a/vm/code_heap.hpp
+++ b/vm/code_heap.hpp
@@ -20,7 +20,7 @@ struct code_heap {
        /* Memory allocator */
        free_list_allocator<code_block> *allocator;
 
-       std::set<code_block *> all_blocks;
+       std::set<cell> all_blocks;
 
        /* Keys are blocks which need to be initialized by initialize_code_block().
        Values are literal tables. Literal table arrays are GC roots until the