alien.syntax: clarify that we can dispatch off ENUM: members

[factor.git] / vm / code_heap.cpp

diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp
index 9879730307bfc834ea975724ca2b384dd5696847..77aa7ae287670a3186fb8489138af68e76561060 100644 (file)
--- a/vm/code_heap.cpp
+++ b/vm/code_heap.cpp
@@ -3,7 +3,7 @@
 namespace factor {
 
 code_heap::code_heap(cell size) {
-  if (size > ((uint64_t)1 << (sizeof(cell) * 8 - 6)))
+  if (size > ((uint64_t)1 << (sizeof(cell) * 8 - 5)))
     fatal_error("Heap too large", size);
   seg = new segment(align_page(size), true);
   if (!seg)
@@ -71,9 +71,11 @@ void code_heap::sweep() {
 
 void code_heap::verify_all_blocks_set() {
   auto all_blocks_set_verifier = [&](code_block* block, cell size) {
+    (void)block;
+    (void)size;
     FACTOR_ASSERT(all_blocks.find((cell)block) != all_blocks.end());
   };
-  allocator->iterate(all_blocks_set_verifier);
+  allocator->iterate(all_blocks_set_verifier, no_fixup());
 }
 
 code_block* code_heap::code_block_for_address(cell address) {
@@ -102,9 +104,10 @@ cell code_heap::frame_predecessor(cell frame_top) {
 void code_heap::initialize_all_blocks_set() {
   all_blocks.clear();
   auto all_blocks_set_inserter = [&](code_block* block, cell size) {
+    (void)size;
     all_blocks.insert((cell)block);
   };
-  allocator->iterate(all_blocks_set_inserter);
+  allocator->iterate(all_blocks_set_inserter, no_fixup());
 #ifdef FACTOR_DEBUG
   verify_all_blocks_set();
 #endif
@@ -115,21 +118,12 @@ void code_heap::initialize_all_blocks_set() {
 // If generic words were redefined, inline caches need to be reset.
 void factor_vm::update_code_heap_words(bool reset_inline_caches) {
   auto word_updater = [&](code_block* block, cell size) {
+    (void)size;
     update_word_references(block, reset_inline_caches);
   };
   each_code_block(word_updater);
 }
 
-// Fix up new words only.
-// Fast path for compilation units that only define new words.
-void factor_vm::initialize_code_blocks() {
-
-  FACTOR_FOR_EACH(code->uninitialized_blocks) {
-    initialize_code_block(iter->first, iter->second);
-  }
-  code->uninitialized_blocks.clear();
-}
-
 // Allocates memory
 void factor_vm::primitive_modify_code_heap() {
   bool reset_inline_caches = to_boolean(ctx->pop());
@@ -161,7 +155,7 @@ void factor_vm::primitive_modify_code_heap() {
         cell frame_size = untag_fixnum(array_nth(compiled_data, 5));
 
         code_block* compiled =
-            add_code_block(code_block_optimized, code, labels, word.value(),
+            add_code_block(CODE_BLOCK_OPTIMIZED, code, labels, word.value(),
                            relocation, parameters, literals, frame_size);
 
         word->entry_point = compiled->entry_point();
@@ -174,8 +168,14 @@ void factor_vm::primitive_modify_code_heap() {
 
   if (update_existing_words)
     update_code_heap_words(reset_inline_caches);
-  else
-    initialize_code_blocks();
+  else {
+    // Fast path for compilation units that only define new words.
+    FACTOR_FOR_EACH(code->uninitialized_blocks) {
+      initialize_code_block(iter->first, iter->second);
+    }
+    code->uninitialized_blocks.clear();
+  }
+  FACTOR_ASSERT(code->uninitialized_blocks.size() == 0);
 }
 
 // Allocates memory
@@ -186,6 +186,7 @@ void factor_vm::primitive_code_room() {
 
 void factor_vm::primitive_strip_stack_traces() {
   auto stack_trace_stripper = [](code_block* block, cell size) {
+    (void)size;
     block->owner = false_object;
   };
   each_code_block(stack_trace_stripper);
@@ -195,6 +196,7 @@ void factor_vm::primitive_strip_stack_traces() {
 void factor_vm::primitive_code_blocks() {
   std::vector<cell> objects;
   auto code_block_accumulator = [&](code_block* block, cell size) {
+    (void)size;
     objects.push_back(block->owner);
     objects.push_back(block->parameters);
     objects.push_back(block->relocation);