5 bool factor_arg(const vm_char* str, const vm_char* arg, cell* value) {
7 if (SSCANF(str, arg, &val) > 0) {
14 vm_parameters::vm_parameters() {
15 embedded_image = false;
17 executable_path = NULL;
19 datastack_size = 32 * sizeof(cell);
20 retainstack_size = 32 * sizeof(cell);
22 #if defined(FACTOR_PPC)
23 callstack_size = 256 * sizeof(cell);
25 callstack_size = 128 * sizeof(cell);
29 young_size = sizeof(cell) / 4;
30 aging_size = sizeof(cell) / 2;
31 tenured_size = 24 * sizeof(cell);
39 console = GetConsoleWindow() != NULL;
47 vm_parameters::~vm_parameters() {
48 free((vm_char *)image_path);
49 free((vm_char *)executable_path);
52 void vm_parameters::init_from_args(int argc, vm_char** argv) {
55 for (i = 1; i < argc; i++) {
56 vm_char* arg = argv[i];
57 if (STRCMP(arg, STRING_LITERAL("--")) == 0)
59 else if (factor_arg(arg, STRING_LITERAL("-datastack=%d"),
62 else if (factor_arg(arg, STRING_LITERAL("-retainstack=%d"),
65 else if (factor_arg(arg, STRING_LITERAL("-callstack=%d"),
68 else if (factor_arg(arg, STRING_LITERAL("-young=%d"), &young_size))
70 else if (factor_arg(arg, STRING_LITERAL("-aging=%d"), &aging_size))
72 else if (factor_arg(arg, STRING_LITERAL("-tenured=%d"), &tenured_size))
74 else if (factor_arg(arg, STRING_LITERAL("-codeheap=%d"), &code_size))
76 else if (factor_arg(arg, STRING_LITERAL("-pic=%d"), &max_pic_size))
78 else if (factor_arg(arg, STRING_LITERAL("-callbacks=%d"), &callback_size))
80 else if (STRNCMP(arg, STRING_LITERAL("-i="), 3) == 0) {
81 // In case you specify -i more than once.
83 free((vm_char *)image_path);
85 image_path = safe_strdup(arg + 3);
87 else if (STRCMP(arg, STRING_LITERAL("-fep")) == 0)
89 else if (STRCMP(arg, STRING_LITERAL("-nosignals")) == 0)
91 else if (STRCMP(arg, STRING_LITERAL("-console")) == 0)
96 void factor_vm::load_data_heap(FILE* file, image_header* h, vm_parameters* p) {
97 p->tenured_size = std::max((h->data_size * 3) / 2, p->tenured_size);
99 data_heap *d = new data_heap(&nursery,
100 p->young_size, p->aging_size, p->tenured_size);
103 raw_fread((void*)data->tenured->start, 1, h->data_size, file);
105 if ((cell)bytes_read != h->data_size) {
106 std::cout << "truncated image: " << bytes_read << " bytes read, ";
107 std::cout << h->data_size << " bytes expected\n";
108 fatal_error("load_data_heap failed", 0);
111 data->tenured->initial_free_list(h->data_size);
114 void factor_vm::load_code_heap(FILE* file, image_header* h, vm_parameters* p) {
115 if (h->code_size > p->code_size)
116 fatal_error("Code heap too small to fit image", h->code_size);
118 code = new code_heap(p->code_size);
120 if (h->code_size != 0) {
122 raw_fread((void*)code->allocator->start, 1, h->code_size, file);
123 if (bytes_read != h->code_size) {
124 std::cout << "truncated image: " << bytes_read << " bytes read, ";
125 std::cout << h->code_size << " bytes expected\n";
126 fatal_error("load_code_heap failed", 0);
130 code->allocator->initial_free_list(h->code_size);
131 code->initialize_all_blocks_set();
134 struct startup_fixup {
135 static const bool translated_code_block_map = true;
140 startup_fixup(cell data_offset, cell code_offset)
141 : data_offset(data_offset), code_offset(code_offset) {}
143 object* fixup_data(object* obj) {
144 return (object*)((cell)obj + data_offset);
147 code_block* fixup_code(code_block* obj) {
148 return (code_block*)((cell)obj + code_offset);
151 object* translate_data(const object* obj) { return fixup_data((object*)obj); }
153 code_block* translate_code(const code_block* compiled) {
154 return fixup_code((code_block*)compiled);
157 cell size(const object* obj) { return obj->size(*this); }
159 cell size(code_block* compiled) { return compiled->size(*this); }
162 void factor_vm::fixup_heaps(cell data_offset, cell code_offset) {
163 startup_fixup fixup(data_offset, code_offset);
164 slot_visitor<startup_fixup> visitor(this, fixup);
165 visitor.visit_all_roots();
167 auto start_object_updater = [&](object *obj, cell size) {
168 data->tenured->starts.record_object_start_offset(obj);
169 visitor.visit_slots(obj);
170 switch (obj->type()) {
172 alien* ptr = (alien*)obj;
173 if (to_boolean(ptr->base))
174 ptr->update_address();
176 ptr->expired = special_objects[OBJ_CANONICAL_TRUE];
180 ffi_dlopen((dll*)obj);
184 visitor.visit_object_code_block(obj);
189 data->tenured->iterate(start_object_updater, fixup);
191 auto updater = [&](code_block* compiled, cell size) {
192 visitor.visit_code_block_objects(compiled);
193 cell rel_base = compiled->entry_point() - fixup.code_offset;
194 visitor.visit_instruction_operands(compiled, rel_base);
196 code->allocator->iterate(updater, fixup);
199 bool factor_vm::read_embedded_image_footer(FILE* file,
200 embedded_image_footer* footer) {
201 safe_fseek(file, -(off_t)sizeof(embedded_image_footer), SEEK_END);
202 safe_fread(footer, (off_t)sizeof(embedded_image_footer), 1, file);
203 return footer->magic == image_magic;
206 char *threadsafe_strerror(int errnum) {
207 char *buf = (char *) malloc(STRERROR_BUFFER_SIZE);
209 fatal_error("Out of memory in threadsafe_strerror, errno", errnum);
211 THREADSAFE_STRERROR(errnum, buf, STRERROR_BUFFER_SIZE);
215 // Read an image file from disk, only done once during startup
216 // This function also initializes the data and code heaps
217 void factor_vm::load_image(vm_parameters* p) {
219 FILE* file = OPEN_READ(p->image_path);
221 std::cout << "Cannot open image file: " << p->image_path << std::endl;
222 char *msg = threadsafe_strerror(errno);
223 std::cout << "strerror:2: " << msg << std::endl;
227 if (p->embedded_image) {
228 embedded_image_footer footer;
229 if (!read_embedded_image_footer(file, &footer)) {
230 std::cout << "No embedded image" << std::endl;
233 safe_fseek(file, (off_t)footer.image_offset, SEEK_SET);
237 if (raw_fread(&h, sizeof(image_header), 1, file) != 1)
238 fatal_error("Cannot read image header", 0);
240 if (h.magic != image_magic)
241 fatal_error("Bad image: magic number check failed", h.magic);
243 if (h.version != image_version)
244 fatal_error("Bad image: version number check failed", h.version);
246 load_data_heap(file, &h, p);
247 load_code_heap(file, &h, p);
251 // Certain special objects in the image are known to the runtime
252 memcpy(special_objects, h.special_objects, sizeof(special_objects));
254 cell data_offset = data->tenured->start - h.data_relocation_base;
255 cell code_offset = code->allocator->start - h.code_relocation_base;
256 fixup_heaps(data_offset, code_offset);
259 // Save the current image to disk. We don't throw any exceptions here
260 // because if the 'then-die' argument is t it is not safe to do
261 // so. Instead we signal failure by returning false.
262 bool factor_vm::save_image(const vm_char* saving_filename,
263 const vm_char* filename) {
266 h.magic = image_magic;
267 h.version = image_version;
268 h.data_relocation_base = data->tenured->start;
269 h.data_size = data->tenured->occupied_space();
270 h.code_relocation_base = code->allocator->start;
271 h.code_size = code->allocator->occupied_space();
273 for (cell i = 0; i < special_object_count; i++)
274 h.special_objects[i] =
275 (save_special_p(i) ? special_objects[i] : false_object);
277 FILE* file = OPEN_WRITE(saving_filename);
280 if (safe_fwrite(&h, sizeof(image_header), 1, file) != 1)
282 if (h.data_size > 0 &&
283 safe_fwrite((void*)data->tenured->start, h.data_size, 1, file) != 1)
285 if (h.code_size > 0 &&
286 safe_fwrite((void*)code->allocator->start, h.code_size, 1, file) != 1)
288 if (raw_fclose(file) == -1)
290 if (!move_file(saving_filename, filename))
296 void factor_vm::primitive_save_image() {
297 // We unbox this before doing anything else. This is the only point
298 // where we might throw an error, so we have to throw an error here since
299 // later steps destroy the current image.
300 bool then_die = to_boolean(ctx->pop());
301 byte_array* path2 = untag_check<byte_array>(ctx->pop());
302 byte_array* path1 = untag_check<byte_array>(ctx->pop());
304 // Copy the paths to non-gc memory to avoid them hanging around in
306 vm_char* path1_saved = safe_strdup(path1->data<vm_char>());
307 vm_char* path2_saved = safe_strdup(path2->data<vm_char>());
310 // strip out special_objects data which is set on startup anyway
311 for (cell i = 0; i < special_object_count; i++)
312 if (!save_special_p(i))
313 special_objects[i] = false_object;
315 // dont trace objects only reachable from context stacks so we don't
316 // get volatile data saved in the image.
317 active_contexts.clear();
318 code->uninitialized_blocks.clear();
320 // I think clearing the callback heap should be fine too.
321 callbacks->allocator->initial_free_list(0);
324 // do a full GC to push everything remaining into tenured space
325 primitive_compact_gc();
328 bool ret = save_image(path1_saved, path2_saved);
336 general_error(ERROR_IO, tag_fixnum(errno), false_object);
340 bool factor_vm::embedded_image_p() {
341 const vm_char* vm_path = vm_executable_path();
342 FILE* file = OPEN_READ(vm_path);
344 free((vm_char *)vm_path);
347 embedded_image_footer footer;
348 bool embedded_p = read_embedded_image_footer(file, &footer);
350 free((vm_char *)vm_path);