namespace factor {
code_heap::code_heap(cell size) {
- if (size > ((u64) 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)
allocator = new free_list_allocator<code_block>(seg->end - start, start);
- /* See os-windows-x86.64.cpp for seh_area usage */
- safepoint_page = (void*)seg->start;
+ // See os-windows-x86.64.cpp for seh_area usage
+ safepoint_page = seg->start;
seh_area = (char*)seg->start + getpagesize();
}
return uninitialized_blocks.count(compiled) > 0;
}
-bool code_heap::marked_p(code_block* compiled) {
- return allocator->state.marked_p(compiled);
-}
-
-void code_heap::set_marked_p(code_block* compiled) {
- allocator->state.set_marked_p(compiled);
-}
-
-void code_heap::clear_mark_bits() { allocator->state.clear_mark_bits(); }
-
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((cell) compiled);
+ all_blocks.erase((cell)compiled);
allocator->free(compiled);
}
void code_heap::flush_icache() { factor::flush_icache(seg->start, seg->size); }
-struct clear_free_blocks_from_all_blocks_iterator {
- code_heap* code;
-
- clear_free_blocks_from_all_blocks_iterator(code_heap* code) : code(code) {}
-
- void operator()(code_block* free_block, cell size) {
- std::set<cell>::iterator erase_from =
- code->all_blocks.lower_bound((cell) free_block);
- std::set<cell>::iterator erase_to =
- code->all_blocks.lower_bound((cell) free_block + size);
-
- code->all_blocks.erase(erase_from, erase_to);
+void code_heap::set_safepoint_guard(bool locked) {
+ if (!set_memory_locked(safepoint_page, getpagesize(), locked)) {
+ fatal_error("Cannot (un)protect safepoint guard page", safepoint_page);
}
-};
+}
void code_heap::sweep() {
- clear_free_blocks_from_all_blocks_iterator clearer(this);
- allocator->sweep(clearer);
+ auto clear_free_blocks_from_all_blocks = [&](code_block* block, cell size) {
+ std::set<cell>::iterator erase_from =
+ all_blocks.lower_bound((cell)block);
+ std::set<cell>::iterator erase_to =
+ all_blocks.lower_bound((cell)block + size);
+ all_blocks.erase(erase_from, erase_to);
+ };
+ allocator->sweep(clear_free_blocks_from_all_blocks);
#ifdef FACTOR_DEBUG
verify_all_blocks_set();
#endif
}
-struct all_blocks_set_verifier {
- std::set<cell>* 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((cell) block) != all_blocks->end());
- }
-};
-
void code_heap::verify_all_blocks_set() {
- all_blocks_set_verifier verifier(&all_blocks);
- allocator->iterate(verifier);
+ 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, no_fixup());
}
code_block* code_heap::code_block_for_address(cell address) {
FACTOR_ASSERT(blocki != all_blocks.begin());
--blocki;
code_block* found_block = (code_block*)*blocki;
- FACTOR_ASSERT((cell) found_block->entry_point() <=
- address /* XXX this isn't valid during fixup. should store the
- size in the map
- && address - (cell)found_block->entry_point() <
- found_block->size()*/);
+ FACTOR_ASSERT(found_block->entry_point() <=
+ address // XXX this isn't valid during fixup. should store the
+ // size in the map
+ // && address - found_block->entry_point() <
+ // found_block->size()
+ );
return found_block;
}
-struct all_blocks_set_inserter {
- code_heap* code;
-
- all_blocks_set_inserter(code_heap* code) : code(code) {}
-
- void operator()(code_block* block, cell size) {
- code->all_blocks.insert((cell) block);
- }
-};
+cell code_heap::frame_predecessor(cell frame_top) {
+ cell addr = *(cell*)frame_top;
+ FACTOR_ASSERT(seg->in_segment_p(addr));
+ code_block* owner = code_block_for_address(addr);
+ cell frame_size = owner->stack_frame_size_for_address(addr);
+ return frame_top + frame_size;
+}
+// Recomputes the all_blocks set of code blocks
void code_heap::initialize_all_blocks_set() {
all_blocks.clear();
- all_blocks_set_inserter inserter(this);
- allocator->iterate(inserter);
+ auto all_blocks_set_inserter = [&](code_block* block, cell size) {
+ (void)size;
+ all_blocks.insert((cell)block);
+ };
+ allocator->iterate(all_blocks_set_inserter, no_fixup());
#ifdef FACTOR_DEBUG
verify_all_blocks_set();
#endif
}
-/* Allocate a code heap during startup */
-void factor_vm::init_code_heap(cell size) { code = new code_heap(size); }
-
-struct word_updater {
- factor_vm* parent;
- bool reset_inline_caches;
-
- word_updater(factor_vm* parent, bool reset_inline_caches)
- : parent(parent), reset_inline_caches(reset_inline_caches) {}
-
- void operator()(code_block* compiled, cell size) {
- parent->update_word_references(compiled, reset_inline_caches);
- }
-};
-
-/* Update pointers to words referenced from all code blocks.
-Only needed after redefining an existing word.
-If generic words were redefined, inline caches need to be reset. */
+// Update pointers to words referenced from all code blocks.
+// Only needed after redefining an existing word.
+// If generic words were redefined, inline caches need to be reset.
void factor_vm::update_code_heap_words(bool reset_inline_caches) {
- word_updater updater(this, reset_inline_caches);
- each_code_block(updater);
+ 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() {
- std::map<code_block*, cell>::const_iterator iter =
- code->uninitialized_blocks.begin();
- std::map<code_block*, cell>::const_iterator end =
- code->uninitialized_blocks.end();
-
- for (; iter != end; iter++)
- initialize_code_block(iter->first, iter->second);
-
- code->uninitialized_blocks.clear();
-}
-
-/* Allocates memory */
+// Allocates memory
void factor_vm::primitive_modify_code_heap() {
bool reset_inline_caches = to_boolean(ctx->pop());
bool update_existing_words = to_boolean(ctx->pop());
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();
if (update_existing_words)
update_code_heap_words(reset_inline_caches);
- else
- initialize_code_blocks();
-}
-
-code_heap_room factor_vm::code_room() {
- code_heap_room room;
-
- room.size = code->allocator->size;
- room.occupied_space = code->allocator->occupied_space();
- room.total_free = code->allocator->free_space();
- room.contiguous_free = code->allocator->largest_free_block();
- room.free_block_count = code->allocator->free_block_count();
-
- return room;
+ 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 */
+// Allocates memory
void factor_vm::primitive_code_room() {
- code_heap_room room = code_room();
+ allocator_room room = code->allocator->as_allocator_room();
ctx->push(tag<byte_array>(byte_array_from_value(&room)));
}
-struct stack_trace_stripper {
- stack_trace_stripper() {}
-
- void operator()(code_block* compiled, cell size) {
- compiled->owner = false_object;
- }
-};
-
void factor_vm::primitive_strip_stack_traces() {
- stack_trace_stripper stripper;
- each_code_block(stripper);
+ auto stack_trace_stripper = [](code_block* block, cell size) {
+ (void)size;
+ block->owner = false_object;
+ };
+ each_code_block(stack_trace_stripper);
}
-struct code_block_accumulator {
+// Allocates memory
+void factor_vm::primitive_code_blocks() {
std::vector<cell> objects;
-
- void operator()(code_block* compiled, cell size) {
- objects.push_back(compiled->owner);
- objects.push_back(compiled->parameters);
- objects.push_back(compiled->relocation);
-
- objects.push_back(tag_fixnum(compiled->type()));
- objects.push_back(tag_fixnum(compiled->size()));
-
- /* Note: the entry point is always a multiple of the heap
- alignment (16 bytes). We cannot allocate while iterating
- through the code heap, so it is not possible to call
- from_unsigned_cell() here. It is OK, however, to add it as
- if it were a fixnum, and have library code shift it to the
- left by 4. */
- cell entry_point = (cell) compiled->entry_point();
+ 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);
+
+ objects.push_back(tag_fixnum(block->type()));
+ objects.push_back(tag_fixnum(block->size()));
+
+ // Note: the entry point is always a multiple of the heap
+ // alignment (16 bytes). We cannot allocate while iterating
+ // through the code heap, so it is not possible to call
+ // from_unsigned_cell() here. It is OK, however, to add it as
+ // if it were a fixnum, and have library code shift it to the
+ // left by 4.
+ cell entry_point = block->entry_point();
FACTOR_ASSERT((entry_point & (data_alignment - 1)) == 0);
FACTOR_ASSERT((entry_point & TAG_MASK) == FIXNUM_TYPE);
objects.push_back(entry_point);
- }
-};
-
-/* Allocates memory */
-cell factor_vm::code_blocks() {
- code_block_accumulator accum;
- each_code_block(accum);
- return std_vector_to_array(accum.objects);
+ };
+ each_code_block(code_block_accumulator);
+ ctx->push(std_vector_to_array(objects));
}
-/* Allocates memory */
-void factor_vm::primitive_code_blocks() { ctx->push(code_blocks()); }
-
}
projects / factor.git / blobdiff