factor/vm/master.hpp

#ifndef __FACTOR_MASTER_H__
#define __FACTOR_MASTER_H__

#ifndef _THREAD_SAFE
#define _THREAD_SAFE
#endif

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include <errno.h>

/* C headers */
#include <fcntl.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <wchar.h>
#include <stdint.h>

/* C++ headers */
#include <algorithm>
#include <list>
#include <map>
#include <set>
#include <vector>
#include <iostream>
#include <iomanip>
#include <limits>
#include <sstream>
#include <string>

#define FACTOR_STRINGIZE_I(x) #x
#define FACTOR_STRINGIZE(x) FACTOR_STRINGIZE_I(x)

/* Record compiler version */
#if defined(__clang__)
#define FACTOR_COMPILER_VERSION "Clang (GCC " __VERSION__ ")"
#elif defined(__INTEL_COMPILER)
#define FACTOR_COMPILER_VERSION \
  "Intel C Compiler " FACTOR_STRINGIZE(__INTEL_COMPILER)
#elif defined(__GNUC__)
#define FACTOR_COMPILER_VERSION "GCC " __VERSION__
#elif defined(_MSC_FULL_VER)
#define FACTOR_COMPILER_VERSION \
  "Microsoft Visual C++ " FACTOR_STRINGIZE(_MSC_FULL_VER)
#else
#define FACTOR_COMPILER_VERSION "unknown"
#endif

/* Record compilation time */
#define FACTOR_COMPILE_TIME __TIMESTAMP__

/* Detect target CPU type */
#if defined(__arm__)
#define FACTOR_ARM
#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64)
#define FACTOR_AMD64
#define FACTOR_64
#elif defined(i386) || defined(__i386) || defined(__i386__) || defined(_M_IX86)
#define FACTOR_X86
#elif(defined(__POWERPC__) || defined(__ppc__) || defined(_ARCH_PPC)) && \
    (defined(__PPC64__) || defined(__64BIT__))
#define FACTOR_PPC64
#define FACTOR_PPC
#define FACTOR_64
#elif defined(__POWERPC__) || defined(__ppc__) || defined(_ARCH_PPC)
#define FACTOR_PPC32
#define FACTOR_PPC
#else
#error "Unsupported architecture"
#endif

#if defined(_MSC_VER)
#define WINDOWS
#define WINNT
#elif defined(WIN32)
#define WINDOWS
#endif

/* Forward-declare this since it comes up in function prototypes */
namespace factor { struct factor_vm; }

/* Factor headers */
#include "assert.hpp"
#include "debug.hpp"
#include "layouts.hpp"
#include "platform.hpp"
#include "utilities.hpp"
#include "primitives.hpp"
#include "errors.hpp"
#include "segments.hpp"
#include "gc_info.hpp"
#include "contexts.hpp"
#include "run.hpp"
#include "objects.hpp"
#include "sampling_profiler.hpp"
#include "bignumint.hpp"
#include "bignum.hpp"
#include "booleans.hpp"
#include "instruction_operands.hpp"
#include "tagged.hpp"
#include "code_blocks.hpp"
#include "bump_allocator.hpp"
#include "bitwise_hacks.hpp"
#include "mark_bits.hpp"
#include "fixup.hpp"
#include "free_list.hpp"
#include "write_barrier.hpp"
#include "object_start_map.hpp"
#include "aging_space.hpp"
#include "tenured_space.hpp"
#include "data_heap.hpp"
#include "code_heap.hpp"
#include "gc.hpp"
#include "float_bits.hpp"
#include "io.hpp"
#include "image.hpp"
#include "callbacks.hpp"
#include "dispatch.hpp"
#include "vm.hpp"
#include "allot.hpp"
#include "data_roots.hpp"
#include "code_roots.hpp"
#include "generic_arrays.hpp"
#include "callstack.hpp"
#include "slot_visitor.hpp"
#include "collector.hpp"
#include "to_tenured_collector.hpp"
#include "arrays.hpp"
#include "math.hpp"
#include "byte_arrays.hpp"
#include "jit.hpp"
#include "quotations.hpp"
#include "inline_cache.hpp"
#include "mvm.hpp"
#include "factor.hpp"

#endif /* __FACTOR_MASTER_H__ */
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#ifndef __FACTOR_MASTER_H__`
			`#define __FACTOR_MASTER_H__`

32 and 64 bit Linux PPC support 2011-05-20 18:11:50 -04:00			`#ifndef _THREAD_SAFE`
added threadsafe defines. Dunno if they do much 2009-08-28 15:23:01 -04:00			`#define _THREAD_SAFE`
32 and 64 bit Linux PPC support 2011-05-20 18:11:50 -04:00			`#endif`

			`#ifndef _REENTRANT`
added threadsafe defines. Dunno if they do much 2009-08-28 15:23:01 -04:00			`#define _REENTRANT`
32 and 64 bit Linux PPC support 2011-05-20 18:11:50 -04:00			`#endif`
added threadsafe defines. Dunno if they do much 2009-08-28 15:23:01 -04:00
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include <errno.h>`

Store forwarding table off to the side instead of in the code block; saves one cell per code block 2009-05-05 12:07:20 -04:00			`/* C headers */`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include <fcntl.h>`
			`#include <limits.h>`
			`#include <math.h>`
			`#include <stdio.h>`
			`#include <stdlib.h>`
			`#include <string.h>`
			`#include <time.h>`
vm: remove some mixed use of stdio/iostream. when monotonic timer decreases, log old and new values 2010-08-01 19:14:20 -04:00			`#include <wchar.h>`
VM: Replace u8-64, s8-64, cell, fixnum with stdint.h equivalents 2013-05-13 00:28:25 -04:00			`#include <stdint.h>`
Porting VM to C++ 2009-05-02 05:04:19 -04:00
Store forwarding table off to the side instead of in the code block; saves one cell per code block 2009-05-05 12:07:20 -04:00			`/* C++ headers */`
vm: number of generations is not configurable anymore, split up begin_gc() and end_gc() into collect_{nursery,aging,aging_again,tenured}() 2009-10-06 03:39:12 -04:00			`#include <algorithm>`
vm: don't keep more than 10 unused contexts around to prevent address space wastage on low-budget operating systems like OpenBSD 2010-09-17 23:52:27 -04:00			`#include <list>`
vm: new mark_bits data structure replaces hashtable when compacting code heap 2009-10-19 03:21:11 -04:00			`#include <map>`
Big VM cleanup - Move forward declarations of 'struct factor_vm' to one place - Rename template parameters from T and TYPE to descriptive names. New convention: CamelCase for template parameters - Change some higher-order functions taking function pointers into templates, and define classes overriding operator(). There's a bit of new boilerplate here but its more consistent than the old mish-mash approaches - Put GC state into a gc_state struct - Use exceptions instead of longjmp for non-local control transfer in GC - In code GC, instead of interleaving code block tracing with copying, add code blocks which need to be revisited to an std::set stored in the gc_state 2009-10-03 09:47:05 -04:00			`#include <set>`
vm: number of generations is not configurable anymore, split up begin_gc() and end_gc() into collect_{nursery,aging,aging_again,tenured}() 2009-10-06 03:39:12 -04:00			`#include <vector>`
vm: use iostreams instead of printf for debug messages, clean up a few things 2009-10-21 21:12:57 -04:00			`#include <iostream>`
vm: remove some mixed use of stdio/iostream. when monotonic timer decreases, log old and new values 2010-08-01 19:14:20 -04:00			`#include <iomanip>`
vm: move bignum.cpp includes to master.hpp That way they get PCHed 2011-11-07 20:44:21 -05:00			`#include <limits>`
VM: fix the debug printing so that instead of always printing to std::cout, you supply the stream to print to 2015-01-28 08:27:20 -05:00			`#include <sstream>`
vm: Fix compilation on Windows. Fixes #1086. 2014-07-03 14:20:08 -04:00			`#include <string>`
vm: move bignum.cpp includes to master.hpp That way they get PCHed 2011-11-07 20:44:21 -05:00
32 and 64 bit Linux PPC support 2011-05-20 18:11:50 -04:00			`#define FACTOR_STRINGIZE_I(x) #x`
			`#define FACTOR_STRINGIZE(x) FACTOR_STRINGIZE_I(x)`
yay C89 2010-03-01 20:56:17 -05:00
record the C++ compiler version in the VM, and expose it with a vm-compiler word 2010-03-01 16:32:07 -05:00			`/* Record compiler version */`
			`#if defined(__clang__)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_COMPILER_VERSION "Clang (GCC " __VERSION__ ")"`
record the C++ compiler version in the VM, and expose it with a vm-compiler word 2010-03-01 16:32:07 -05:00			`#elif defined(__INTEL_COMPILER)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_COMPILER_VERSION \`
			`"Intel C Compiler " FACTOR_STRINGIZE(__INTEL_COMPILER)`
record the C++ compiler version in the VM, and expose it with a vm-compiler word 2010-03-01 16:32:07 -05:00			`#elif defined(__GNUC__)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_COMPILER_VERSION "GCC " __VERSION__`
record the C++ compiler version in the VM, and expose it with a vm-compiler word 2010-03-01 16:32:07 -05:00			`#elif defined(_MSC_FULL_VER)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_COMPILER_VERSION \`
			`"Microsoft Visual C++ " FACTOR_STRINGIZE(_MSC_FULL_VER)`
record the C++ compiler version in the VM, and expose it with a vm-compiler word 2010-03-01 16:32:07 -05:00			`#else`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_COMPILER_VERSION "unknown"`
record the C++ compiler version in the VM, and expose it with a vm-compiler word 2010-03-01 16:32:07 -05:00			`#endif`

VM: Three new special objects added to keep track of the builds version number, git label and compilation time respectively. The info is exposed in the system:version-info word and also shown in the banner during startup. Conflicts: Nmakefile basis/ui/tools/listener/listener.factor core/alien/strings/strings.factor 2013-08-19 11:34:29 -04:00			`/* Record compilation time */`
			`#define FACTOR_COMPILE_TIME __TIMESTAMP__`

vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`/* Detect target CPU type */`
			`#if defined(__arm__)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_ARM`
Update Win64 support 2010-01-24 08:17:18 -05:00			`#elif defined(__amd64__) \|\| defined(__x86_64__) \|\| defined(_M_AMD64)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_AMD64`
			`#define FACTOR_64`
Update Win64 support 2010-01-24 08:17:18 -05:00			`#elif defined(i386) \|\| defined(__i386) \|\| defined(__i386__) \|\| defined(_M_IX86)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_X86`
			`#elif(defined(__POWERPC__) \|\| defined(__ppc__) \|\| defined(_ARCH_PPC)) && \`
			`(defined(__PPC64__) \|\| defined(__64BIT__))`
			`#define FACTOR_PPC64`
			`#define FACTOR_PPC`
			`#define FACTOR_64`
vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`#elif defined(__POWERPC__) \|\| defined(__ppc__) \|\| defined(_ARCH_PPC)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define FACTOR_PPC32`
			`#define FACTOR_PPC`
vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`#else`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#error "Unsupported architecture"`
vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`#endif`

vm: Tweak Factor VM to compile with Microsoft Visual Studio on Windows, in addition to Mingw. Add an Nmakefile which can be used for this purpose. Rename Makefile to GNUmakefile. 2010-01-16 09:43:22 -05:00			`#if defined(_MSC_VER)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define WINDOWS`
			`#define WINNT`
vm: Tweak Factor VM to compile with Microsoft Visual Studio on Windows, in addition to Mingw. Add an Nmakefile which can be used for this purpose. Rename Makefile to GNUmakefile. 2010-01-16 09:43:22 -05:00			`#elif defined(WIN32)`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`#define WINDOWS`
vm: Tweak Factor VM to compile with Microsoft Visual Studio on Windows, in addition to Mingw. Add an Nmakefile which can be used for this purpose. Rename Makefile to GNUmakefile. 2010-01-16 09:43:22 -05:00			`#endif`

Big VM cleanup - Move forward declarations of 'struct factor_vm' to one place - Rename template parameters from T and TYPE to descriptive names. New convention: CamelCase for template parameters - Change some higher-order functions taking function pointers into templates, and define classes overriding operator(). There's a bit of new boilerplate here but its more consistent than the old mish-mash approaches - Put GC state into a gc_state struct - Use exceptions instead of longjmp for non-local control transfer in GC - In code GC, instead of interleaving code block tracing with copying, add code blocks which need to be revisited to an std::set stored in the gc_state 2009-10-03 09:47:05 -04:00			`/* Forward-declare this since it comes up in function prototypes */`
VM: Refactor master.hpp to Factor style 2013-05-11 22:13:10 -04:00			`namespace factor { struct factor_vm; }`
Big VM cleanup - Move forward declarations of 'struct factor_vm' to one place - Rename template parameters from T and TYPE to descriptive names. New convention: CamelCase for template parameters - Change some higher-order functions taking function pointers into templates, and define classes overriding operator(). There's a bit of new boilerplate here but its more consistent than the old mish-mash approaches - Put GC state into a gc_state struct - Use exceptions instead of longjmp for non-local control transfer in GC - In code GC, instead of interleaving code block tracing with copying, add code blocks which need to be revisited to an std::set stored in the gc_state 2009-10-03 09:47:05 -04:00
Store forwarding table off to the side instead of in the code block; saves one cell per code block 2009-05-05 12:07:20 -04:00			`/* Factor headers */`
vm: replace assert with FACTOR_ASSERT Factor is finally a real C++ project and has a custom assert macro. Assertion failures were still getting caught as exceptions and causing failure loops. Write our own macro that calls factor::abort on failure. 2011-11-17 23:42:30 -05:00			`#include "assert.hpp"`
VM: debug macros FACTOR_PRINT and FACTOR_PRINT_MARK to make better debug printing messages than just using std::cout 2015-05-03 08:13:28 -04:00			`#include "debug.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "layouts.hpp"`
added VM relocation type 2009-08-18 15:40:26 -04:00			`#include "platform.hpp"`
Build: other hpp's use utilities.hpp so it must be included earlier 2014-11-12 02:11:15 -05:00			`#include "utilities.hpp"`
vm ptr passed to primitives on X86.32 (other cpus still use singleton vm ptr) 2009-08-18 15:49:22 -04:00			`#include "primitives.hpp"`
VM: set_border_locked is the same on windows and unix 2016-06-27 10:27:56 -04:00			`#include "errors.hpp"`
VM: use better abstractions for tagged pointers, eliminate get()/set() stuff, clean up array, string, and byte-array element access 2009-05-04 02:00:30 -04:00			`#include "segments.hpp"`
GC maps for more compact inline GC checks 2010-06-11 20:06:00 -04:00			`#include "gc_info.hpp"`
VM: use better abstractions for tagged pointers, eliminate get()/set() stuff, clean up array, string, and byte-array element access 2009-05-04 02:00:30 -04:00			`#include "contexts.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "run.hpp"`
vm: rewrite 'become' primitive so that it uses a slot visitor instead of GC 2009-11-05 20:03:51 -05:00			`#include "objects.hpp"`
vm: groundwork for sampling profiler Set up the state necessary to collect samples. We still need to add GC support for walking the sample set, and the compiler needs to register GC roots before safepoints as well. We also need primitives to expose the data to Factor for reporting. 2011-10-28 18:42:33 -04:00			`#include "sampling_profiler.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "bignumint.hpp"`
			`#include "bignum.hpp"`
Big cleanup of literal table and relocation-related code - new way to iterate over instruction_operands cleans up relocation code - move some methods out of the VM class to clean up code - if debugging is on, die earlier if attempting to allocate inside GC - callback heap entries are now code_blocks - replace block_granularity with data_alignment 2009-12-02 01:48:41 -05:00			`#include "booleans.hpp"`
vm: mark sweep now traces code block references; rename embedded_pointer to instruction_operand 2009-11-23 19:51:08 -05:00			`#include "instruction_operands.hpp"`
VM: refactor tagged.hpp so it's not dependent on the factor_vm class this way untag<byte_array>(relocation) can be used in code_blocks.hpp 2015-11-24 10:00:50 -05:00			`#include "tagged.hpp"`
vm: eliminating literal table work in progress 2009-11-07 17:16:09 -05:00			`#include "code_blocks.hpp"`
vm: split off free_list_allocator from heap class, rename zone to bump_allocator 2009-10-20 16:15:05 -04:00			`#include "bump_allocator.hpp"`
vm: faster sweep algorithm 2009-11-01 21:15:42 -05:00			`#include "bitwise_hacks.hpp"`
vm: split off free_list_allocator from heap class, rename zone to bump_allocator 2009-10-20 16:15:05 -04:00			`#include "mark_bits.hpp"`
GC maps for more compact inline GC checks 2010-06-11 20:06:00 -04:00			`#include "fixup.hpp"`
VM: merge of free_list_allocator.hpp into free_list.hpp It's better if all the free list stuff is in a single header. 2016-04-11 19:47:40 -04:00			`#include "free_list.hpp"`
The great type renaming 2009-05-04 05:50:24 -04:00			`#include "write_barrier.hpp"`
vm: split off free_list_allocator from heap class, rename zone to bump_allocator 2009-10-20 16:15:05 -04:00			`#include "object_start_map.hpp"`
vm: working on new object-oriented garbage collector 2009-10-07 16:48:09 -04:00			`#include "aging_space.hpp"`
			`#include "tenured_space.hpp"`
vm: make a new old_space type to encapsulate a few things, split up generations array somewhat 2009-10-07 15:05:09 -04:00			`#include "data_heap.hpp"`
vm: clean up gc events, remove -verbosegc switch, fix compaction bug 2009-10-27 22:31:28 -04:00			`#include "code_heap.hpp"`
vm: rename data_gc.cpp to gc.cpp 2009-10-08 03:11:29 -04:00			`#include "gc.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "float_bits.hpp"`
			`#include "io.hpp"`
			`#include "image.hpp"`
vm: code heap compaction at runtime using compact-gc primitive 2009-10-16 12:39:22 -04:00			`#include "callbacks.hpp"`
tools.time: overhaul 2009-11-05 02:07:59 -05:00			`#include "dispatch.hpp"`
reordered master to untangle dependency chain a bit 2009-08-17 16:37:12 -04:00			`#include "vm.hpp"`
vm: various minor optimizations speeding up gc0 and dispatch1 benchmarks, as well as bootstrap - make allot_object() inline, move slow case to allot_large_object() - reduce number of conditional branches in megamorphic cache miss handler - make unbox_array_size() inline, move slow case to unbox_array_size_slow() - new memset_cell() function uses memset_pattern4/8() on Mac OS X 2009-10-31 03:30:48 -04:00			`#include "allot.hpp"`
vm: rename gc_root to data_root, add code_root to fix a problem where code blocks would move underneath the PIC compiler if PIC compiler allocated enough 2009-11-02 19:10:34 -05:00			`#include "data_roots.hpp"`
			`#include "code_roots.hpp"`
vm: minor GC traces embedded pointers 2009-11-22 14:37:39 -05:00			`#include "generic_arrays.hpp"`
GC maps for more compact inline GC checks 2010-06-11 20:06:00 -04:00			`#include "callstack.hpp"`
vm: factor out code that visits object slots and code heap blocks into slot_visitor and code_block_visitor 2009-10-24 04:54:53 -04:00			`#include "slot_visitor.hpp"`
vm: working on new object-oriented garbage collector 2009-10-07 16:48:09 -04:00			`#include "collector.hpp"`
			`#include "to_tenured_collector.hpp"`
inlineimpl.hpp is toast 2009-09-29 14:53:10 -04:00			`#include "arrays.hpp"`
			`#include "math.hpp"`
			`#include "byte_arrays.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "jit.hpp"`
Cleaning up VM code 2009-05-02 10:19:09 -04:00			`#include "quotations.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "inline_cache.hpp"`
vm: split up TLS code and add a dummy implementation for a dummy OS known as NetBSD 2010-03-29 02:23:21 -04:00			`#include "mvm.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "factor.hpp"`

			`#endif /* __FACTOR_MASTER_H__ */`