void factor_vm::init_factor(vm_parameters *p)
{
/* Kilobytes */
p->datastack_size = align_page(p->datastack_size << 10);
p->retainstack_size = align_page(p->retainstack_size << 10);
p->callstack_size = align_page(p->callstack_size << 10);
p->callback_size = align_page(p->callback_size << 10);
/* Megabytes */
p->young_size <<= 20;
p->aging_size <<= 20;
p->tenured_size <<= 20;
p->code_size <<= 20;
/* Disable GC during init as a sanity check */
gc_off = true;
/* OS-specific initialization */
early_init();
const vm_char *executable_path = vm_executable_path();
if(executable_path)
p->executable_path = executable_path;
if(p->image_path == NULL)
p->image_path = default_image_path();
srand((unsigned int)nano_count());
init_ffi();
init_contexts(p->datastack_size,p->retainstack_size,p->callstack_size);
init_callbacks(p->callback_size);
load_image(p);
init_c_io();
init_inline_caching((int)p->max_pic_size);
if(p->signals)
init_signals();
if(p->console)
open_console();
init_profiler();
special_objects[OBJ_CPU] = allot_alien(false_object,(cell)FACTOR_CPU_STRING);
special_objects[OBJ_OS] = allot_alien(false_object,(cell)FACTOR_OS_STRING);
special_objects[OBJ_CELL_SIZE] = tag_fixnum(sizeof(cell));
special_objects[OBJ_EXECUTABLE] = allot_alien(false_object,(cell)p->executable_path);
special_objects[OBJ_ARGS] = false_object;
special_objects[OBJ_EMBEDDED] = false_object;
special_objects[OBJ_VM_COMPILER] = allot_alien(false_object,(cell)FACTOR_COMPILER_VERSION);
/* We can GC now */
gc_off = false;
if(!to_boolean(special_objects[OBJ_STAGE2]))
prepare_boot_image();
}
void factorvm::init_factor(vm_parameters *p)
{
/* Kilobytes */
p->ds_size = align_page(p->ds_size << 10);
p->rs_size = align_page(p->rs_size << 10);
/* Megabytes */
p->young_size <<= 20;
p->aging_size <<= 20;
p->tenured_size <<= 20;
p->code_size <<= 20;
/* Disable GC during init as a sanity check */
gc_off = true;
/* OS-specific initialization */
early_init();
const vm_char *executable_path = vm_executable_path();
if(executable_path)
p->executable_path = executable_path;
if(p->image_path == NULL)
p->image_path = default_image_path();
srand(current_micros());
init_ffi();
init_stacks(p->ds_size,p->rs_size);
load_image(p);
init_c_io();
init_inline_caching(p->max_pic_size);
init_signals();
if(p->console)
open_console();
init_profiler();
userenv[CPU_ENV] = allot_alien(F,(cell)FACTOR_CPU_STRING);
userenv[OS_ENV] = allot_alien(F,(cell)FACTOR_OS_STRING);
userenv[CELL_SIZE_ENV] = tag_fixnum(sizeof(cell));
userenv[EXECUTABLE_ENV] = allot_alien(F,(cell)p->executable_path);
userenv[ARGS_ENV] = F;
userenv[EMBEDDED_ENV] = F;
/* We can GC now */
gc_off = false;
if(userenv[STAGE2_ENV] == F)
{
userenv[STACK_TRACES_ENV] = tag_boolean(p->stack_traces);
do_stage1_init();
}
}
bool factor_vm::embedded_image_p() {
const vm_char* vm_path = vm_executable_path();
if (!vm_path)
return false;
FILE* file = OPEN_READ(vm_path);
if (!file)
return false;
embedded_image_footer footer;
bool embedded_p = read_embedded_image_footer(file, &footer);
fclose(file);
return embedded_p;
}
/* You must delete[] the result yourself. */
const char* default_image_path() {
const char* path = vm_executable_path();
if (!path)
return "factor.image";
int len = strlen(path);
char* new_path = new char[PATH_MAX + SUFFIX_LEN + 1];
memcpy(new_path, path, len + 1);
memcpy(new_path + len, SUFFIX, SUFFIX_LEN + 1);
free(const_cast<char*>(path));
return new_path;
}
const char *default_image_path()
{
const char *path = vm_executable_path();
if(!path)
return "factor.image";
/* We can't call strlen() here because with gcc 4.1.2 this
causes an internal compiler error. */
int len = 0;
const char *iter = path;
while(*iter) { len++; iter++; }
char *new_path = (char *)safe_malloc(PATH_MAX + SUFFIX_LEN + 1);
memcpy(new_path,path,len + 1);
memcpy(new_path + len,SUFFIX,SUFFIX_LEN + 1);
return new_path;
}
void init_factor_from_args(F_CHAR *image, int argc, F_CHAR **argv, bool embedded)
{
F_PARAMETERS p;
default_parameters(&p);
if(image) p.image = image;
CELL i;
posix_argc = argc;
posix_argv = safe_malloc(argc * sizeof(F_CHAR*));
posix_argv[0] = safe_strdup(argv[0]);
for(i = 1; i < argc; i++)
{
posix_argv[i] = safe_strdup(argv[i]);
if(factor_arg(argv[i],STR_FORMAT("-datastack=%d"),&p.ds_size));
else if(factor_arg(argv[i],STR_FORMAT("-retainstack=%d"),&p.rs_size));
else if(factor_arg(argv[i],STR_FORMAT("-generations=%d"),&p.gen_count));
else if(factor_arg(argv[i],STR_FORMAT("-young=%d"),&p.young_size));
else if(factor_arg(argv[i],STR_FORMAT("-aging=%d"),&p.aging_size));
else if(factor_arg(argv[i],STR_FORMAT("-tenured=%d"),&p.tenured_size));
else if(factor_arg(argv[i],STR_FORMAT("-codeheap=%d"),&p.code_size));
else if(STRCMP(argv[i],STR_FORMAT("-securegc")) == 0)
p.secure_gc = true;
else if(STRCMP(argv[i],STR_FORMAT("-fep")) == 0)
p.fep = true;
else if(STRNCMP(argv[i],STR_FORMAT("-i="),3) == 0)
p.image = argv[i] + 3;
else if(STRCMP(argv[i],STR_FORMAT("-console")) == 0)
p.console = true;
else if(STRCMP(argv[i],STR_FORMAT("-no-stack-traces")) == 0)
p.stack_traces = false;
}
init_factor(&p);
nest_stacks();
F_ARRAY *args = allot_array(ARRAY_TYPE,argc,F);
for(i = 1; i < argc; i++)
{
REGISTER_UNTAGGED(args);
CELL arg = tag_object(from_native_string(argv[i]));
UNREGISTER_UNTAGGED(args);
set_array_nth(args,i,arg);
}
userenv[ARGS_ENV] = tag_object(args);
const F_CHAR *executable_path = vm_executable_path();
if(!executable_path)
executable_path = argv[0];
userenv[EXECUTABLE_ENV] = tag_object(from_native_string(executable_path));
userenv[EMBEDDED_ENV] = (embedded ? T : F);
if(p.fep)
factorbug();
c_to_factor_toplevel(userenv[BOOT_ENV]);
unnest_stacks();
for(i = 0; i < argc; i++)
free(posix_argv[i]);
free(posix_argv);
}
void factor_vm::init_factor(vm_parameters* p) {
// Kilobytes
p->datastack_size = align_page(p->datastack_size << 10);
p->retainstack_size = align_page(p->retainstack_size << 10);
p->callstack_size = align_page(p->callstack_size << 10);
p->callback_size = align_page(p->callback_size << 10);
// Megabytes
p->young_size <<= 20;
p->aging_size <<= 20;
p->tenured_size <<= 20;
p->code_size <<= 20;
// Disable GC during init as a sanity check
gc_off = true;
// OS-specific initialization
early_init();
p->executable_path = vm_executable_path();
if (p->image_path == NULL) {
if (embedded_image_p()) {
p->embedded_image = true;
p->image_path = safe_strdup(p->executable_path);
} else
p->image_path = default_image_path();
}
srand((unsigned int)nano_count());
init_ffi();
datastack_size = p->datastack_size;
retainstack_size = p->retainstack_size;
callstack_size = p->callstack_size;
ctx = NULL;
spare_ctx = new_context();
callbacks = new callback_heap(p->callback_size, this);
load_image(p);
max_pic_size = (int)p->max_pic_size;
special_objects[OBJ_CELL_SIZE] = tag_fixnum(sizeof(cell));
special_objects[OBJ_ARGS] = false_object;
special_objects[OBJ_EMBEDDED] = false_object;
cell aliens[][2] = {
{OBJ_STDIN, (cell)stdin},
{OBJ_STDOUT, (cell)stdout},
{OBJ_STDERR, (cell)stderr},
{OBJ_CPU, (cell)FACTOR_CPU_STRING},
{OBJ_EXECUTABLE, (cell)safe_strdup(p->executable_path)},
{OBJ_IMAGE, (cell)safe_strdup(p->image_path)},
{OBJ_OS, (cell)FACTOR_OS_STRING},
{OBJ_VM_COMPILE_TIME, (cell)FACTOR_COMPILE_TIME},
{OBJ_VM_COMPILER, (cell)FACTOR_COMPILER_VERSION},
{OBJ_VM_GIT_LABEL, (cell)FACTOR_STRINGIZE(FACTOR_GIT_LABEL)},
{OBJ_VM_VERSION, (cell)FACTOR_STRINGIZE(FACTOR_VERSION)},
#if defined(WINDOWS)
{WIN_EXCEPTION_HANDLER, (cell)&factor::exception_handler}
#endif
};
int n_items = sizeof(aliens) / sizeof(cell[2]);
for (int n = 0; n < n_items; n++) {
cell idx = aliens[n][0];
special_objects[idx] = allot_alien(false_object, aliens[n][1]);
}
// We can GC now
gc_off = false;
if (!to_boolean(special_objects[OBJ_STAGE2]))
prepare_boot_image();
if (p->signals)
init_signals();
if (p->console)
open_console();
}