// This fun is called (only) from:
//
// src/c/main/runtime-main.c
//
void load_and_run_heap_image (
// =======================
//
const char* heap_image_to_run_filename,
Heapcleaner_Args* heap_parameters
) {
// Load a heap image from a file and resume execution.
//
// The arguments
//
// agegroup0_buffer_bytesize
// active_agegroups
// oldest_agegroup_keeping_idle_fromspace_buffers
//
// possible command-line overrides of the heap parameters
// specified in the image being imported.
//
// (Non-negative values signify override.)
//
// This function is called in only one place, in
// src/c/main/runtime-main.c
Task* task = import_heap_image( heap_image_to_run_filename, heap_parameters );
set_up_fault_handlers ();
#ifdef SIZES_C_64_MYTHRYL_32
// Patch the 32-bit addresses:
//
patch_static_heapchunk_32_bit_addresses ();
#endif
run_mythryl_task_and_runtime_eventloop( task ); // run_mythryl_task_and_runtime_eventloop def in src/c/main/run-mythryl-code-and-runtime-eventloop.c
}
void load_compiled_files__may_heapclean (
// ==================================
//
const char* compiled_files_to_load_filename,
Heapcleaner_Args* heap_parameters, // See struct cleaner_args in src/c/h/heap.h
Roots* extra_roots
){
// Load into the runtime heap all the .compiled files
// listed one per line in given compiled_files_to_load file:
//
// This function is called from exactly one spot, in
//
// src/c/main/runtime-main.c
int max_boot_path_len;
char* filename_buf;
int seen_runtime_package_picklehash = FALSE; // FALSE until we see the picklehash naming our runtime.
open_logfile();
Task* task
=
make_task( // make_task def in src/c/main/runtime-state.c
TRUE, // is_boot
heap_parameters
);
// Set up handlers for ^C, divide-by-zero,
// integer overflow etc:
//
set_up_fault_handlers (); // set_up_fault_handlers def in src/c/machine-dependent/posix-arithmetic-trap-handlers.c
// set_up_fault_handlers def in src/c/machine-dependent/win32-fault.c
// set_up_fault_handlers def in src/c/machine-dependent/cygwin-fault.c
// Set up RunVec in CStruct in
//
// runtime_package__global.
//
// This constitutes an ersatz exports list implementing
//
// src/lib/core/init/runtime.api
//
// which we will later substitute for the (useless) code from
//
// src/lib/core/init/runtime.pkg
//
// thus providing access to critical assembly fns including
//
// find_cfun
//
// implemented in one of
//
// src/c/machine-dependent/prim.sparc32.asm
// src/c/machine-dependent/prim.pwrpc32.asm
// src/c/machine-dependent/prim.intel32.asm
// src/c/machine-dependent/prim.intel32.masm
//
construct_runtime_package__global( task ); // construct_runtime_package__global def in src/c/main/construct-runtime-package.c
// Construct the list of files to be loaded:
//
Val compiled_file_list
=
read_in_compiled_file_list__may_heapclean (
task,
compiled_files_to_load_filename,
&max_boot_path_len,
extra_roots
);
Roots roots1 = { &compiled_file_list, extra_roots };
// This space is ultimately wasted: XXX BUGGO FIXME
//
if (! (filename_buf = MALLOC( max_boot_path_len ))) {
//
die ("unable to allocate space for boot file names");
}
// Load all requested compiled_files into the heap:
//
while (compiled_file_list != LIST_NIL) {
//
char* filename = filename_buf;
// Need to make a copy of the filename because
// load_compiled_file__may_heapclean is going to scribble into it:
//
strcpy( filename_buf, HEAP_STRING_AS_C_STRING( LIST_HEAD( compiled_file_list )));
compiled_file_list = LIST_TAIL( compiled_file_list ); // Remove above filename from list of files to process.
// If 'filename' does not begin with "RUNTIME_PACKAGE_PICKLEHASH=" ...
//
if (strstr(filename,"RUNTIME_PACKAGE_PICKLEHASH=") != filename) {
//
// ... then we can load it normally:
//
load_compiled_file__may_heapclean( task, filename, &roots1 );
} else {
// We're processing the
//
// RUNTIME_PACKAGE_PICKLEHASH=...
//
// set up for us by
//
// src/app/makelib/mythryl-compiler-compiler/find-set-of-compiledfiles-for-executable.pkg
while (*filename++ != '='); // Step over "RUNTIME_PACKAGE_PICKLEHASH=" prefix.
if (seen_runtime_package_picklehash) {
//
if (log_fd) fclose( log_fd );
die ("Runtime system picklehash registered more than once!\n");
exit(1); // Just for gcc's sake -- cannot exectute.
}
// Most parts of the Mythryl implementation treat the C-coded
// runtime functions as being just like library functions
// coded in Mythryl -- to avoid special cases, we go to great
// lengths to hide the differences.
//
// But this is one of the places where the charade breaks
// down -- there isn't actually any (useful) .compiled file
// corresponding to the runtime picklehash: Instead, we
// must link runtime calls directly down into our C code.
//
// For more info, see the comments in
// src/lib/core/init/runtime.pkg
//
// So here we implement some of that special handling:
// Register the runtime system under the given picklehash:
//
Picklehash picklehash;
int l = strlen( filename );
for (int i = 0; i < PICKLEHASH_BYTES; i++) {
//
int i2 = 2 * i;
if (i2 + 1 < l) {
int c1 = filename[i2+0];
int c2 = filename[i2+1];
picklehash.bytes[i] = (hex(c1) << 4) + hex(c2);
}
}
fprintf(
log_fd ? log_fd : stderr,
"\n load-compiledfiles.c: Runtime system picklehash is %s\n\n",
filename
);
register_compiled_file_exports__may_heapclean( task, &picklehash, runtime_package__global, &roots1 );
seen_runtime_package_picklehash = TRUE; // Make sure that we register the runtime system picklehash only once.
}
}
if (log_fd) fclose( log_fd );
} // load_compiled_files__may_heapclean
