factor/vm/vm.cpp

#include "master.hpp"

namespace factor
{

factor_vm::factor_vm(THREADHANDLE thread) :
	nursery(0,0),
	faulting_p(false),
	thread(thread),
	callback_id(0),
	c_to_factor_func(NULL),
	sampling_profiler_p(false),
	signal_pipe_input(0),
	signal_pipe_output(0),
	gc_off(false),
	current_gc(NULL),
	current_gc_p(false),
	current_jit_count(0),
	gc_events(NULL),
	fep_p(false),
	fep_help_was_shown(false),
	fep_disabled(false),
	full_output(false),
	last_nano_count(0),
	signal_callstack_seg(NULL),
	safepoint()
{
	primitive_reset_dispatch_stats();
}

factor_vm::~factor_vm()
{
	delete_contexts();
	if(signal_callstack_seg)
	{
		delete signal_callstack_seg;
		signal_callstack_seg = NULL;
	}
	std::list<void **>::const_iterator iter = function_descriptors.begin();
	std::list<void **>::const_iterator end = function_descriptors.end();
	while(iter != end)
	{
		delete [] *iter;
		iter++;
	}
}

}
Merge up 2010-01-30 23:39:43 -05:00			`#include "master.hpp"`

			`namespace factor`
			`{`

vm: sample pc on windows 2011-11-03 00:18:31 -04:00			`factor_vm::factor_vm(THREADHANDLE thread) :`
Merge up 2010-01-30 23:39:43 -05:00			`nursery(0,0),`
vm: close_console before exiting anywhere Add a factor_vm::exit function that does close_console() before ::exit-ing 2011-11-12 17:47:32 -05:00			`faulting_p(false),`
			`thread(thread),`
vm: actually use context callstacks when running code 2010-03-26 22:44:43 -04:00			`callback_id(0),`
Merge up 2010-01-30 23:39:43 -05:00			`c_to_factor_func(NULL),`
cleanups from code review 2011-10-27 23:24:51 -04:00			`sampling_profiler_p(false),`
vm: write async signals to pipe for multiplexer also factor out safepoint logic into its own file 2011-11-07 15:51:49 -05:00			`signal_pipe_input(0),`
			`signal_pipe_output(0),`
Merge up 2010-01-30 23:39:43 -05:00			`gc_off(false),`
			`current_gc(NULL),`
vm: separate 'current_gc_p' from 'current_gc' The 'current_gc' handle doesn't need to be volatile, just the state of GC-ness 2011-11-02 00:01:40 -04:00			`current_gc_p(false),`
vm: count samples during unoptimized compiler 2011-11-02 02:40:46 -04:00			`current_jit_count(0),`
Merge up 2010-01-30 23:39:43 -05:00			`gc_events(NULL),`
vm: fep on SIGINT or SIGQUIT instead of exception It's not robust currently to raise an exception because a lot of our code that isn't already written with exceptions in mind breaks. Also, a signal is likely to be received by an FFI callback installed on the IO multiplexer, which will cause Factor to die since the callback cannot handle the exception. We need a more robust solution to dealing with SIGINT. Also lay some groundwork for counting profile samples and reporting non-interrupting asynchronous signals. 2011-10-21 00:00:25 -04:00			`fep_p(false),`
vm: only show factorbug help the first time 2011-10-31 20:38:42 -04:00			`fep_help_was_shown(false),`
Merge up 2010-01-30 23:39:43 -05:00			`fep_disabled(false),`
			`full_output(false),`
vm: use sigaltstack to handle callstack overflow properly 2010-03-28 11:37:28 -04:00			`last_nano_count(0),`
vm: die if we fault in a fault 2011-11-01 21:22:46 -04:00			`signal_callstack_seg(NULL),`
vm: don't pass this to safepoint constructor It's bad juju and MSVC calls us out on it. 2011-11-08 14:06:00 -05:00			`safepoint()`
Merge up 2010-01-30 23:39:43 -05:00			`{`
			`primitive_reset_dispatch_stats();`
			`}`

vm: actually use context callstacks when running code 2010-03-26 22:44:43 -04:00			`factor_vm::~factor_vm()`
			`{`
			`delete_contexts();`
vm: use sigaltstack to handle callstack overflow properly 2010-03-28 11:37:28 -04:00			`if(signal_callstack_seg)`
			`{`
			`delete signal_callstack_seg;`
			`signal_callstack_seg = NULL;`
			`}`
32 and 64 bit Linux PPC support 2011-05-20 18:11:50 -04:00			`std::list<void **>::const_iterator iter = function_descriptors.begin();`
			`std::list<void **>::const_iterator end = function_descriptors.end();`
			`while(iter != end)`
			`{`
			`delete [] *iter;`
			`iter++;`
			`}`
vm: actually use context callstacks when running code 2010-03-26 22:44:43 -04:00			`}`

Merge up 2010-01-30 23:39:43 -05:00			`}`