factor/vm/code_heap.cpp

#include "master.hpp"

namespace factor
{

code_heap::code_heap(cell size)
{
	if(size > ((u64)1 << (sizeof(cell) * 8 - 6))) fatal_error("Heap too large",size);
	seg = new segment(align_page(size),true);
	if(!seg) fatal_error("Out of memory in code_heap constructor",size);

	cell start = seg->start + getpagesize() + seh_area_size;

	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;
	seh_area = (char *)seg->start + getpagesize();
}

code_heap::~code_heap()
{
	delete allocator;
	allocator = NULL;
	delete seg;
	seg = NULL;
}

void code_heap::write_barrier(code_block *compiled)
{
	points_to_nursery.insert(compiled);
	points_to_aging.insert(compiled);
}

void code_heap::clear_remembered_set()
{
	points_to_nursery.clear();
	points_to_aging.clear();
}

bool code_heap::uninitialized_p(code_block *compiled)
{
	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);
	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::sweep()
{
	clear_free_blocks_from_all_blocks_iterator clearer(this);
	allocator->sweep(clearer);
#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);
}

code_block *code_heap::code_block_for_address(cell address)
{
	std::set<cell>::const_iterator blocki =
		all_blocks.upper_bound(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()*/);
	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);
	}
};

void code_heap::initialize_all_blocks_set()
{
	all_blocks.clear();
	all_blocks_set_inserter inserter(this);
	allocator->iterate(inserter);
#if defined(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. */
void factor_vm::update_code_heap_words(bool reset_inline_caches)
{
	word_updater updater(this,reset_inline_caches);
	each_code_block(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 */
void factor_vm::primitive_modify_code_heap()
{
	bool reset_inline_caches = to_boolean(ctx->pop());
	bool update_existing_words = to_boolean(ctx->pop());
	data_root<array> alist(ctx->pop(),this);

	cell count = array_capacity(alist.untagged());

	if(count == 0)
		return;

	for(cell i = 0; i < count; i++)
	{
		data_root<array> pair(array_nth(alist.untagged(),i),this);

		data_root<word> word(array_nth(pair.untagged(),0),this);
		data_root<object> data(array_nth(pair.untagged(),1),this);

		switch(data.type())
		{
		case QUOTATION_TYPE:
			jit_compile_word(word.value(),data.value(),false);
			break;
		case ARRAY_TYPE:
			{
				array *compiled_data = data.as<array>().untagged();
				cell parameters = array_nth(compiled_data,0);
				cell literals = array_nth(compiled_data,1);
				cell relocation = array_nth(compiled_data,2);
				cell labels = array_nth(compiled_data,3);
				cell code = array_nth(compiled_data,4);
				cell frame_size = untag_fixnum(array_nth(compiled_data,5));

				code_block *compiled = add_code_block(
					code_block_optimized,
					code,
					labels,
					word.value(),
					relocation,
					parameters,
					literals,
					frame_size);

				word->entry_point = compiled->entry_point();
			}
			break;
		default:
			critical_error("Expected a quotation or an array",data.value());
			break;
		}
	}

	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;
}

/* Allocates memory */
void factor_vm::primitive_code_room()
{
	code_heap_room room = code_room();
	ctx->push(tag<byte_array>(byte_array_from_value(&room)));
}

struct stack_trace_stripper {
	explicit 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);
}

struct code_block_accumulator {
	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();
		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);
}

/* Allocates memory */
void factor_vm::primitive_code_blocks()
{
	ctx->push(code_blocks());
}

}