steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

VM: Refactor image.cpp/hpp to Factor style

db4
Erik Charlebois 2013-05-11 22:05:00 -04:00
parent 4ea2e9ed06
commit cae6a5e855
2 changed files with 297 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
vm/image.cpp
View File

@ -1,11 +1,9 @@
#include "master.hpp" #include "master.hpp"
namespace factor namespace factor {
{
/* Certain special objects in the image are known to the runtime */ /* Certain special objects in the image are known to the runtime */
void factor_vm::init_objects(image_header *h) void factor_vm::init_objects(image_header* h) {
{
memcpy(special_objects, h->special_objects, sizeof(special_objects)); memcpy(special_objects, h->special_objects, sizeof(special_objects));
true_object = h->true_object; true_object = h->true_object;
@ -14,18 +12,15 @@ void factor_vm::init_objects(image_header *h)
bignum_neg_one = h->bignum_neg_one; bignum_neg_one = h->bignum_neg_one;
} }
void factor_vm::load_data_heap(FILE *file, image_header *h, vm_parameters *p) void factor_vm::load_data_heap(FILE* file, image_header* h, vm_parameters* p) {
{
p->tenured_size = std::max((h->data_size * 3) / 2, p->tenured_size); p->tenured_size = std::max((h->data_size * 3) / 2, p->tenured_size);
init_data_heap(p->young_size, init_data_heap(p->young_size, p->aging_size, p->tenured_size);
p->aging_size,
p->tenured_size);
fixnum bytes_read = safe_fread((void*)data->tenured->start,1,h->data_size,file); fixnum bytes_read =
safe_fread((void*)data->tenured->start, 1, h->data_size, file);
if((cell)bytes_read != h->data_size) if ((cell) bytes_read != h->data_size) {
{
std::cout << "truncated image: " << bytes_read << " bytes read, "; std::cout << "truncated image: " << bytes_read << " bytes read, ";
std::cout << h->data_size << " bytes expected\n"; std::cout << h->data_size << " bytes expected\n";
fatal_error("load_data_heap failed", 0); fatal_error("load_data_heap failed", 0);
@ -34,18 +29,16 @@ void factor_vm::load_data_heap(FILE *file, image_header *h, vm_parameters *p)
data->tenured->initial_free_list(h->data_size); data->tenured->initial_free_list(h->data_size);
} }
void factor_vm::load_code_heap(FILE *file, image_header *h, vm_parameters *p) void factor_vm::load_code_heap(FILE* file, image_header* h, vm_parameters* p) {
{
if (h->code_size > p->code_size) if (h->code_size > p->code_size)
fatal_error("Code heap too small to fit image", h->code_size); fatal_error("Code heap too small to fit image", h->code_size);
init_code_heap(p->code_size); init_code_heap(p->code_size);
if(h->code_size != 0) if (h->code_size != 0) {
{ size_t bytes_read =
size_t bytes_read = safe_fread(code->allocator->first_block(),1,h->code_size,file); safe_fread(code->allocator->first_block(), 1, h->code_size, file);
if(bytes_read != h->code_size) if (bytes_read != h->code_size) {
{
std::cout << "truncated image: " << bytes_read << " bytes read, "; std::cout << "truncated image: " << bytes_read << " bytes read, ";
std::cout << h->code_size << " bytes expected\n"; std::cout << h->code_size << " bytes expected\n";
fatal_error("load_code_heap failed", 0); fatal_error("load_code_heap failed", 0);
@ -62,38 +55,26 @@ struct startup_fixup {
cell data_offset; cell data_offset;
cell code_offset; cell code_offset;
explicit startup_fixup(cell data_offset_, cell code_offset_) : explicit startup_fixup(cell data_offset_, cell code_offset_)
data_offset(data_offset_), code_offset(code_offset_) {} : data_offset(data_offset_), code_offset(code_offset_) {}
object *fixup_data(object *obj) object* fixup_data(object* obj) {
{
return (object*)((cell) obj + data_offset); return (object*)((cell) obj + data_offset);
} }
code_block *fixup_code(code_block *obj) code_block* fixup_code(code_block* obj) {
{
return (code_block*)((cell) obj + code_offset); return (code_block*)((cell) obj + code_offset);
} }
object *translate_data(const object *obj) object* translate_data(const object* obj) { return fixup_data((object*)obj); }
{
return fixup_data((object *)obj);
}
code_block *translate_code(const code_block *compiled) code_block* translate_code(const code_block* compiled) {
{
return fixup_code((code_block*)compiled); return fixup_code((code_block*)compiled);
} }
cell size(const object *obj) cell size(const object* obj) { return obj->size(*this); }
{
return obj->size(*this);
}
cell size(code_block *compiled) cell size(code_block* compiled) { return compiled->size(*this); }
{
return compiled->size(*this);
}
}; };
struct start_object_updater { struct start_object_updater {
@ -102,22 +83,19 @@ struct start_object_updater {
slot_visitor<startup_fixup> data_visitor; slot_visitor<startup_fixup> data_visitor;
code_block_visitor<startup_fixup> code_visitor; code_block_visitor<startup_fixup> code_visitor;
start_object_updater(factor_vm *parent_, startup_fixup fixup_) : start_object_updater(factor_vm* parent_, startup_fixup fixup_)
parent(parent_), : parent(parent_),
fixup(fixup_), fixup(fixup_),
data_visitor(slot_visitor<startup_fixup>(parent_, fixup_)), data_visitor(slot_visitor<startup_fixup>(parent_, fixup_)),
code_visitor(code_block_visitor<startup_fixup>(parent_, fixup_)) {} code_visitor(code_block_visitor<startup_fixup>(parent_, fixup_)) {}
void operator()(object *obj, cell size) void operator()(object* obj, cell size) {
{
parent->data->tenured->starts.record_object_start_offset(obj); parent->data->tenured->starts.record_object_start_offset(obj);
data_visitor.visit_slots(obj); data_visitor.visit_slots(obj);
switch(obj->type()) switch (obj->type()) {
{ case ALIEN_TYPE: {
case ALIEN_TYPE:
{
alien* ptr = (alien*)obj; alien* ptr = (alien*)obj;
@ -127,13 +105,11 @@ struct start_object_updater {
ptr->expired = parent->true_object; ptr->expired = parent->true_object;
break; break;
} }
case DLL_TYPE: case DLL_TYPE: {
{
parent->ffi_dlopen((dll*)obj); parent->ffi_dlopen((dll*)obj);
break; break;
} }
default: default: {
{
code_visitor.visit_object_code_block(obj); code_visitor.visit_object_code_block(obj);
break; break;
} }
@ -141,8 +117,7 @@ struct start_object_updater {
} }
}; };
void factor_vm::fixup_data(cell data_offset, cell code_offset) void factor_vm::fixup_data(cell data_offset, cell code_offset) {
{
startup_fixup fixup(data_offset, code_offset); startup_fixup fixup(data_offset, code_offset);
slot_visitor<startup_fixup> data_workhorse(this, fixup); slot_visitor<startup_fixup> data_workhorse(this, fixup);
data_workhorse.visit_roots(); data_workhorse.visit_roots();
@ -156,32 +131,31 @@ struct startup_code_block_relocation_visitor {
startup_fixup fixup; startup_fixup fixup;
slot_visitor<startup_fixup> data_visitor; slot_visitor<startup_fixup> data_visitor;
startup_code_block_relocation_visitor(factor_vm *parent_, startup_fixup fixup_) : startup_code_block_relocation_visitor(factor_vm* parent_,
parent(parent_), startup_fixup fixup_)
: parent(parent_),
fixup(fixup_), fixup(fixup_),
data_visitor(slot_visitor<startup_fixup>(parent_, fixup_)) {} data_visitor(slot_visitor<startup_fixup>(parent_, fixup_)) {}
void operator()(instruction_operand op) void operator()(instruction_operand op) {
{
code_block* compiled = op.compiled; code_block* compiled = op.compiled;
cell old_offset = op.rel_offset() + (cell)compiled->entry_point() - fixup.code_offset; cell old_offset =
op.rel_offset() + (cell) compiled->entry_point() - fixup.code_offset;
switch(op.rel_type()) switch (op.rel_type()) {
{ case RT_LITERAL: {
case RT_LITERAL:
{
cell value = op.load_value(old_offset); cell value = op.load_value(old_offset);
if (immediate_p(value)) if (immediate_p(value))
op.store_value(value); op.store_value(value);
else else
op.store_value(RETAG(fixup.fixup_data(untag<object>(value)),TAG(value))); op.store_value(
RETAG(fixup.fixup_data(untag<object>(value)), TAG(value)));
break; break;
} }
case RT_ENTRY_POINT: case RT_ENTRY_POINT:
case RT_ENTRY_POINT_PIC: case RT_ENTRY_POINT_PIC:
case RT_ENTRY_POINT_PIC_TAIL: case RT_ENTRY_POINT_PIC_TAIL:
case RT_HERE: case RT_HERE: {
{
cell value = op.load_value(old_offset); cell value = op.load_value(old_offset);
cell offset = TAG(value); cell offset = TAG(value);
code_block* compiled = (code_block*)UNTAG(value); code_block* compiled = (code_block*)UNTAG(value);
@ -201,11 +175,10 @@ struct startup_code_block_updater {
factor_vm* parent; factor_vm* parent;
startup_fixup fixup; startup_fixup fixup;
startup_code_block_updater(factor_vm *parent_, startup_fixup fixup_) : startup_code_block_updater(factor_vm* parent_, startup_fixup fixup_)
parent(parent_), fixup(fixup_) {} : parent(parent_), fixup(fixup_) {}
void operator()(code_block *compiled, cell size) void operator()(code_block* compiled, cell size) {
{
slot_visitor<startup_fixup> data_visitor(parent, fixup); slot_visitor<startup_fixup> data_visitor(parent, fixup);
data_visitor.visit_code_block_objects(compiled); data_visitor.visit_code_block_objects(compiled);
@ -214,51 +187,43 @@ struct startup_code_block_updater {
} }
}; };
void factor_vm::fixup_code(cell data_offset, cell code_offset) void factor_vm::fixup_code(cell data_offset, cell code_offset) {
{
startup_fixup fixup(data_offset, code_offset); startup_fixup fixup(data_offset, code_offset);
startup_code_block_updater updater(this, fixup); startup_code_block_updater updater(this, fixup);
code->allocator->iterate(updater, fixup); code->allocator->iterate(updater, fixup);
} }
bool factor_vm::read_embedded_image_footer(FILE *file, embedded_image_footer *footer) bool factor_vm::read_embedded_image_footer(FILE* file,
{ embedded_image_footer* footer) {
safe_fseek(file, -(off_t) sizeof(embedded_image_footer), SEEK_END); safe_fseek(file, -(off_t) sizeof(embedded_image_footer), SEEK_END);
safe_fread(footer, (off_t) sizeof(embedded_image_footer), 1, file); safe_fread(footer, (off_t) sizeof(embedded_image_footer), 1, file);
return footer->magic == image_magic; return footer->magic == image_magic;
} }
FILE* factor_vm::open_image(vm_parameters *p) FILE* factor_vm::open_image(vm_parameters* p) {
{ if (p->embedded_image) {
if (p->embedded_image)
{
FILE* file = OPEN_READ(p->executable_path); FILE* file = OPEN_READ(p->executable_path);
if (file == NULL) if (file == NULL) {
{
std::cout << "Cannot open embedded image" << std::endl; std::cout << "Cannot open embedded image" << std::endl;
std::cout << strerror(errno) << std::endl; std::cout << strerror(errno) << std::endl;
exit(1); exit(1);
} }
embedded_image_footer footer; embedded_image_footer footer;
if (!read_embedded_image_footer(file, &footer)) if (!read_embedded_image_footer(file, &footer)) {
{
std::cout << "No embedded image" << std::endl; std::cout << "No embedded image" << std::endl;
exit(1); exit(1);
} }
safe_fseek(file, (off_t) footer.image_offset, SEEK_SET); safe_fseek(file, (off_t) footer.image_offset, SEEK_SET);
return file; return file;
} } else
else
return OPEN_READ(p->image_path); return OPEN_READ(p->image_path);
} }
/* Read an image file from disk, only done once during startup */ /* Read an image file from disk, only done once during startup */
/* This function also initializes the data and code heaps */ /* This function also initializes the data and code heaps */
void factor_vm::load_image(vm_parameters *p) void factor_vm::load_image(vm_parameters* p) {
{
FILE* file = open_image(p); FILE* file = open_image(p);
if(file == NULL) if (file == NULL) {
{
std::cout << "Cannot open image file: " << p->image_path << std::endl; std::cout << "Cannot open image file: " << p->image_path << std::endl;
std::cout << strerror(errno) << std::endl; std::cout << strerror(errno) << std::endl;
exit(1); exit(1);
@ -292,14 +257,13 @@ void factor_vm::load_image(vm_parameters *p)
} }
/* Save the current image to disk */ /* Save the current image to disk */
bool factor_vm::save_image(const vm_char *saving_filename, const vm_char *filename) bool factor_vm::save_image(const vm_char* saving_filename,
{ const vm_char* filename) {
FILE* file; FILE* file;
image_header h; image_header h;
file = OPEN_WRITE(saving_filename); file = OPEN_WRITE(saving_filename);
if(file == NULL) if (file == NULL) {
{
std::cout << "Cannot open image file: " << saving_filename << std::endl; std::cout << "Cannot open image file: " << saving_filename << std::endl;
std::cout << strerror(errno) << std::endl; std::cout << strerror(errno) << std::endl;
return false; return false;
@ -318,13 +282,17 @@ bool factor_vm::save_image(const vm_char *saving_filename, const vm_char *filena
h.bignum_neg_one = bignum_neg_one; h.bignum_neg_one = bignum_neg_one;
for (cell i = 0; i < special_object_count; i++) for (cell i = 0; i < special_object_count; i++)
h.special_objects[i] = (save_special_p(i) ? special_objects[i] : false_object); h.special_objects[i] =
(save_special_p(i) ? special_objects[i] : false_object);
bool ok = true; bool ok = true;
if(safe_fwrite(&h,sizeof(image_header),1,file) != 1) ok = false; if (safe_fwrite(&h, sizeof(image_header), 1, file) != 1)
if(safe_fwrite((void*)data->tenured->start,h.data_size,1,file) != 1) ok = false; ok = false;
if(safe_fwrite(code->allocator->first_block(),h.code_size,1,file) != 1) ok = false; if (safe_fwrite((void*)data->tenured->start, h.data_size, 1, file) != 1)
ok = false;
if (safe_fwrite(code->allocator->first_block(), h.code_size, 1, file) != 1)
ok = false;
safe_fclose(file); safe_fclose(file);
if (!ok) if (!ok)
@ -335,8 +303,7 @@ bool factor_vm::save_image(const vm_char *saving_filename, const vm_char *filena
return ok; return ok;
} }
void factor_vm::primitive_save_image() void factor_vm::primitive_save_image() {
{
/* do a full GC to push everything into tenured space */ /* do a full GC to push everything into tenured space */
primitive_compact_gc(); primitive_compact_gc();
@ -344,11 +311,11 @@ void factor_vm::primitive_save_image()
path2.untag_check(this); path2.untag_check(this);
data_root<byte_array> path1(ctx->pop(), this); data_root<byte_array> path1(ctx->pop(), this);
path1.untag_check(this); path1.untag_check(this);
save_image((vm_char *)(path1.untagged() + 1 ),(vm_char *)(path2.untagged() + 1)); save_image((vm_char*)(path1.untagged() + 1),
(vm_char*)(path2.untagged() + 1));
} }
void factor_vm::primitive_save_image_and_exit() void factor_vm::primitive_save_image_and_exit() {
{
/* We unbox this before doing anything else. This is the only point /* We unbox this before doing anything else. This is the only point
where we might throw an error, so we have to throw an error here since where we might throw an error, so we have to throw an error here since
later steps destroy the current image. */ later steps destroy the current image. */
@ -359,21 +326,21 @@ void factor_vm::primitive_save_image_and_exit()
/* strip out special_objects data which is set on startup anyway */ /* strip out special_objects data which is set on startup anyway */
for (cell i = 0; i < special_object_count; i++) for (cell i = 0; i < special_object_count; i++)
if(!save_special_p(i)) special_objects[i] = false_object; if (!save_special_p(i))
special_objects[i] = false_object;
gc(collect_compact_op, gc(collect_compact_op, 0, /* requested size */
0, /* requested size */
false /* discard objects only reachable from stacks */); false /* discard objects only reachable from stacks */);
/* Save the image */ /* Save the image */
if(save_image((vm_char *)(path1.untagged() + 1), (vm_char *)(path2.untagged() + 1))) if (save_image((vm_char*)(path1.untagged() + 1),
(vm_char*)(path2.untagged() + 1)))
exit(0); exit(0);
else else
exit(1); exit(1);
} }
bool factor_vm::embedded_image_p() bool factor_vm::embedded_image_p() {
{
const vm_char* vm_path = vm_executable_path(); const vm_char* vm_path = vm_executable_path();
if (!vm_path) if (!vm_path)
return false; return false;

3
vm/image.hpp
View File

@ -1,5 +1,4 @@
namespace factor namespace factor {
{
static const cell image_magic = 0x0f0e0d0c; static const cell image_magic = 0x0f0e0d0c;
static const cell image_version = 4; static const cell image_version = 4;