steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Moved PRIMITIVE and PRIMITIVE_FORWARDs to primitives.[ch]pp

db4
Phil Dawes 2009-09-27 19:42:18 +01:00
parent 0e97398da8
commit 9b7412b8f8
49 changed files with 523 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
vm/alien.cpp
View File

@ -46,7 +46,7 @@ cell factor_vm::allot_alien(cell delegate_, cell displacement)
} }
/* make an alien pointing at an offset of another alien */ /* make an alien pointing at an offset of another alien */
inline void factor_vm::primitive_displaced_alien() void factor_vm::primitive_displaced_alien()
{ {
cell alien = dpop(); cell alien = dpop();
cell displacement = to_cell(dpop()); cell displacement = to_cell(dpop());
@ -69,17 +69,13 @@ inline void factor_vm::primitive_displaced_alien()
} }
} }
PRIMITIVE_FORWARD(displaced_alien)
/* address of an object representing a C pointer. Explicitly throw an error /* address of an object representing a C pointer. Explicitly throw an error
if the object is a byte array, as a sanity check. */ if the object is a byte array, as a sanity check. */
inline void factor_vm::primitive_alien_address() void factor_vm::primitive_alien_address()
{ {
box_unsigned_cell((cell)pinned_alien_offset(dpop())); box_unsigned_cell((cell)pinned_alien_offset(dpop()));
} }
PRIMITIVE_FORWARD(alien_address)
/* pop ( alien n ) from datastack, return alien's address plus n */ /* pop ( alien n ) from datastack, return alien's address plus n */
void *factor_vm::alien_pointer() void *factor_vm::alien_pointer()
{ {
@ -115,7 +111,7 @@ DEFINE_ALIEN_ACCESSOR(double,double,box_double,to_double)
DEFINE_ALIEN_ACCESSOR(cell,void *,box_alien,pinned_alien_offset) DEFINE_ALIEN_ACCESSOR(cell,void *,box_alien,pinned_alien_offset)
/* open a native library and push a handle */ /* open a native library and push a handle */
inline void factor_vm::primitive_dlopen() void factor_vm::primitive_dlopen()
{ {
gc_root<byte_array> path(dpop(),this); gc_root<byte_array> path(dpop(),this);
path.untag_check(this); path.untag_check(this);
@ -125,10 +121,8 @@ inline void factor_vm::primitive_dlopen()
dpush(library.value()); dpush(library.value());
} }
PRIMITIVE_FORWARD(dlopen)
/* look up a symbol in a native library */ /* look up a symbol in a native library */
inline void factor_vm::primitive_dlsym() void factor_vm::primitive_dlsym()
{ {
gc_root<object> library(dpop(),this); gc_root<object> library(dpop(),this);
gc_root<byte_array> name(dpop(),this); gc_root<byte_array> name(dpop(),this);
@ -149,19 +143,15 @@ inline void factor_vm::primitive_dlsym()
} }
} }
PRIMITIVE_FORWARD(dlsym)
/* close a native library handle */ /* close a native library handle */
inline void factor_vm::primitive_dlclose() void factor_vm::primitive_dlclose()
{ {
dll *d = untag_check<dll>(dpop()); dll *d = untag_check<dll>(dpop());
if(d->dll != NULL) if(d->dll != NULL)
ffi_dlclose(d); ffi_dlclose(d);
} }
PRIMITIVE_FORWARD(dlclose) void factor_vm::primitive_dll_validp()
inline void factor_vm::primitive_dll_validp()
{ {
cell library = dpop(); cell library = dpop();
if(library == F) if(library == F)
@ -170,8 +160,6 @@ inline void factor_vm::primitive_dll_validp()
dpush(untag_check<dll>(library)->dll == NULL ? F : T); dpush(untag_check<dll>(library)->dll == NULL ? F : T);
} }
PRIMITIVE_FORWARD(dll_validp)
/* gets the address of an object representing a C pointer */ /* gets the address of an object representing a C pointer */
char *factor_vm::alien_offset(cell obj) char *factor_vm::alien_offset(cell obj)
{ {
@ -285,11 +273,9 @@ VM_C_API void box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size, f
return VM_PTR->box_medium_struct(x1, x2, x3, x4, size); return VM_PTR->box_medium_struct(x1, x2, x3, x4, size);
} }
inline void factor_vm::primitive_vm_ptr() void factor_vm::primitive_vm_ptr()
{ {
box_alien(this); box_alien(this);
} }
PRIMITIVE_FORWARD(vm_ptr)
} }

37
vm/alien.hpp
View File

@ -1,43 +1,6 @@
namespace factor namespace factor
{ {
PRIMITIVE(displaced_alien);
PRIMITIVE(alien_address);
PRIMITIVE(alien_signed_cell);
PRIMITIVE(set_alien_signed_cell);
PRIMITIVE(alien_unsigned_cell);
PRIMITIVE(set_alien_unsigned_cell);
PRIMITIVE(alien_signed_8);
PRIMITIVE(set_alien_signed_8);
PRIMITIVE(alien_unsigned_8);
PRIMITIVE(set_alien_unsigned_8);
PRIMITIVE(alien_signed_4);
PRIMITIVE(set_alien_signed_4);
PRIMITIVE(alien_unsigned_4);
PRIMITIVE(set_alien_unsigned_4);
PRIMITIVE(alien_signed_2);
PRIMITIVE(set_alien_signed_2);
PRIMITIVE(alien_unsigned_2);
PRIMITIVE(set_alien_unsigned_2);
PRIMITIVE(alien_signed_1);
PRIMITIVE(set_alien_signed_1);
PRIMITIVE(alien_unsigned_1);
PRIMITIVE(set_alien_unsigned_1);
PRIMITIVE(alien_float);
PRIMITIVE(set_alien_float);
PRIMITIVE(alien_double);
PRIMITIVE(set_alien_double);
PRIMITIVE(alien_cell);
PRIMITIVE(set_alien_cell);
PRIMITIVE(dlopen);
PRIMITIVE(dlsym);
PRIMITIVE(dlclose);
PRIMITIVE(dll_validp);
PRIMITIVE(vm_ptr);
VM_C_API char *alien_offset(cell object, factor_vm *vm); VM_C_API char *alien_offset(cell object, factor_vm *vm);
VM_C_API char *unbox_alien(factor_vm *vm); VM_C_API char *unbox_alien(factor_vm *vm);
VM_C_API void box_alien(void *ptr, factor_vm *vm); VM_C_API void box_alien(void *ptr, factor_vm *vm);

8
vm/arrays.cpp
View File

@ -24,15 +24,13 @@ array *factor_vm::allot_array(cell capacity, cell fill_)
} }
/* push a new array on the stack */ /* push a new array on the stack */
inline void factor_vm::primitive_array() void factor_vm::primitive_array()
{ {
cell initial = dpop(); cell initial = dpop();
cell size = unbox_array_size(); cell size = unbox_array_size();
dpush(tag<array>(allot_array(size,initial))); dpush(tag<array>(allot_array(size,initial)));
} }
PRIMITIVE_FORWARD(array)
cell factor_vm::allot_array_1(cell obj_) cell factor_vm::allot_array_1(cell obj_)
{ {
gc_root<object> obj(obj_,this); gc_root<object> obj(obj_,this);
@ -65,15 +63,13 @@ cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_)
return a.value(); return a.value();
} }
inline void factor_vm::primitive_resize_array() void factor_vm::primitive_resize_array()
{ {
array* a = untag_check<array>(dpop()); array* a = untag_check<array>(dpop());
cell capacity = unbox_array_size(); cell capacity = unbox_array_size();
dpush(tag<array>(reallot_array(a,capacity))); dpush(tag<array>(reallot_array(a,capacity)));
} }
PRIMITIVE_FORWARD(resize_array)
void growable_array::add(cell elt_) void growable_array::add(cell elt_)
{ {
factor_vm* parent_vm = elements.parent_vm; factor_vm* parent_vm = elements.parent_vm;

3
vm/arrays.hpp
View File

@ -10,7 +10,4 @@ inline cell array_nth(array *array, cell slot)
return array->data()[slot]; return array->data()[slot];
} }
PRIMITIVE(array);
PRIMITIVE(resize_array);
} }

1
vm/bignum.cpp
View File

@ -365,7 +365,6 @@ FOO_TO_BIGNUM(fixnum,fixnum,cell)
FOO_TO_BIGNUM(long_long,s64,u64) FOO_TO_BIGNUM(long_long,s64,u64)
FOO_TO_BIGNUM(ulong_long,u64,u64) FOO_TO_BIGNUM(ulong_long,u64,u64)
#define BIGNUM_TO_FOO(name,type,utype) \ #define BIGNUM_TO_FOO(name,type,utype) \
type factor_vm::bignum_to_##name(bignum * bignum) \ type factor_vm::bignum_to_##name(bignum * bignum) \
{ \ { \

12
vm/byte_arrays.cpp
View File

@ -10,31 +10,25 @@ byte_array *factor_vm::allot_byte_array(cell size)
return array; return array;
} }
inline void factor_vm::primitive_byte_array() void factor_vm::primitive_byte_array()
{ {
cell size = unbox_array_size(); cell size = unbox_array_size();
dpush(tag<byte_array>(allot_byte_array(size))); dpush(tag<byte_array>(allot_byte_array(size)));
} }
PRIMITIVE_FORWARD(byte_array) void factor_vm::primitive_uninitialized_byte_array()
inline void factor_vm::primitive_uninitialized_byte_array()
{ {
cell size = unbox_array_size(); cell size = unbox_array_size();
dpush(tag<byte_array>(allot_array_internal<byte_array>(size))); dpush(tag<byte_array>(allot_array_internal<byte_array>(size)));
} }
PRIMITIVE_FORWARD(uninitialized_byte_array) void factor_vm::primitive_resize_byte_array()
inline void factor_vm::primitive_resize_byte_array()
{ {
byte_array *array = untag_check<byte_array>(dpop()); byte_array *array = untag_check<byte_array>(dpop());
cell capacity = unbox_array_size(); cell capacity = unbox_array_size();
dpush(tag<byte_array>(reallot_array(array,capacity))); dpush(tag<byte_array>(reallot_array(array,capacity)));
} }
PRIMITIVE_FORWARD(resize_byte_array)
void growable_byte_array::append_bytes(void *elts, cell len) void growable_byte_array::append_bytes(void *elts, cell len)
{ {
cell new_size = count + len; cell new_size = count + len;

4
vm/byte_arrays.hpp
View File

@ -1,8 +1,4 @@
namespace factor namespace factor
{ {
PRIMITIVE(byte_array);
PRIMITIVE(uninitialized_byte_array);
PRIMITIVE(resize_byte_array);
} }

24
vm/callstack.cpp
View File

@ -46,7 +46,7 @@ stack_frame *factor_vm::capture_start()
return frame + 1; return frame + 1;
} }
inline void factor_vm::primitive_callstack() void factor_vm::primitive_callstack()
{ {
stack_frame *top = capture_start(); stack_frame *top = capture_start();
stack_frame *bottom = stack_chain->callstack_bottom; stack_frame *bottom = stack_chain->callstack_bottom;
@ -60,9 +60,7 @@ inline void factor_vm::primitive_callstack()
dpush(tag<callstack>(stack)); dpush(tag<callstack>(stack));
} }
PRIMITIVE_FORWARD(callstack) void factor_vm::primitive_set_callstack()
inline void factor_vm::primitive_set_callstack()
{ {
callstack *stack = untag_check<callstack>(dpop()); callstack *stack = untag_check<callstack>(dpop());
@ -75,8 +73,6 @@ inline void factor_vm::primitive_set_callstack()
critical_error("Bug in set_callstack()",0); critical_error("Bug in set_callstack()",0);
} }
PRIMITIVE_FORWARD(set_callstack)
code_block *factor_vm::frame_code(stack_frame *frame) code_block *factor_vm::frame_code(stack_frame *frame)
{ {
check_frame(frame); check_frame(frame);
@ -155,7 +151,7 @@ struct stack_frame_accumulator {
} }
inline void factor_vm::primitive_callstack_to_array() void factor_vm::primitive_callstack_to_array()
{ {
gc_root<callstack> callstack(dpop(),this); gc_root<callstack> callstack(dpop(),this);
@ -166,8 +162,6 @@ inline void factor_vm::primitive_callstack_to_array()
dpush(accum.frames.elements.value()); dpush(accum.frames.elements.value());
} }
PRIMITIVE_FORWARD(callstack_to_array)
stack_frame *factor_vm::innermost_stack_frame(callstack *stack) stack_frame *factor_vm::innermost_stack_frame(callstack *stack)
{ {
stack_frame *top = stack->top(); stack_frame *top = stack->top();
@ -189,21 +183,17 @@ stack_frame *factor_vm::innermost_stack_frame_quot(callstack *callstack)
/* Some primitives implementing a limited form of callstack mutation. /* Some primitives implementing a limited form of callstack mutation.
Used by the single stepper. */ Used by the single stepper. */
inline void factor_vm::primitive_innermost_stack_frame_executing() void factor_vm::primitive_innermost_stack_frame_executing()
{ {
dpush(frame_executing(innermost_stack_frame(untag_check<callstack>(dpop())))); dpush(frame_executing(innermost_stack_frame(untag_check<callstack>(dpop()))));
} }
PRIMITIVE_FORWARD(innermost_stack_frame_executing) void factor_vm::primitive_innermost_stack_frame_scan()
inline void factor_vm::primitive_innermost_stack_frame_scan()
{ {
dpush(frame_scan(innermost_stack_frame_quot(untag_check<callstack>(dpop())))); dpush(frame_scan(innermost_stack_frame_quot(untag_check<callstack>(dpop()))));
} }
PRIMITIVE_FORWARD(innermost_stack_frame_scan) void factor_vm::primitive_set_innermost_stack_frame_quot()
inline void factor_vm::primitive_set_innermost_stack_frame_quot()
{ {
gc_root<callstack> callstack(dpop(),this); gc_root<callstack> callstack(dpop(),this);
gc_root<quotation> quot(dpop(),this); gc_root<quotation> quot(dpop(),this);
@ -219,8 +209,6 @@ inline void factor_vm::primitive_set_innermost_stack_frame_quot()
FRAME_RETURN_ADDRESS(inner) = (char *)quot->xt + offset; FRAME_RETURN_ADDRESS(inner) = (char *)quot->xt + offset;
} }
PRIMITIVE_FORWARD(set_innermost_stack_frame_quot)
/* called before entry into Factor code. */ /* called before entry into Factor code. */
void factor_vm::save_callstack_bottom(stack_frame *callstack_bottom) void factor_vm::save_callstack_bottom(stack_frame *callstack_bottom)
{ {

8
vm/callstack.hpp
View File

@ -6,14 +6,6 @@ inline static cell callstack_size(cell size)
return sizeof(callstack) + size; return sizeof(callstack) + size;
} }
PRIMITIVE(callstack);
PRIMITIVE(set_callstack);
PRIMITIVE(callstack_to_array);
PRIMITIVE(innermost_stack_frame_executing);
PRIMITIVE(innermost_stack_frame_scan);
PRIMITIVE(set_innermost_stack_frame_quot);
VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom, factor_vm *vm); VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom, factor_vm *vm);
} }

8
vm/code_heap.cpp
View File

@ -55,7 +55,7 @@ void factor_vm::update_code_heap_words()
iterate_code_heap(factor::update_word_references); iterate_code_heap(factor::update_word_references);
} }
inline void factor_vm::primitive_modify_code_heap() void factor_vm::primitive_modify_code_heap()
{ {
gc_root<array> alist(dpop(),this); gc_root<array> alist(dpop(),this);
@ -106,10 +106,8 @@ inline void factor_vm::primitive_modify_code_heap()
update_code_heap_words(); update_code_heap_words();
} }
PRIMITIVE_FORWARD(modify_code_heap)
/* Push the free space and total size of the code heap */ /* Push the free space and total size of the code heap */
inline void factor_vm::primitive_code_room() void factor_vm::primitive_code_room()
{ {
cell used, total_free, max_free; cell used, total_free, max_free;
code->heap_usage(&used,&total_free,&max_free); code->heap_usage(&used,&total_free,&max_free);
@ -119,8 +117,6 @@ inline void factor_vm::primitive_code_room()
dpush(tag_fixnum(max_free / 1024)); dpush(tag_fixnum(max_free / 1024));
} }
PRIMITIVE_FORWARD(code_room)
code_block *factor_vm::forward_xt(code_block *compiled) code_block *factor_vm::forward_xt(code_block *compiled)
{ {
return (code_block *)forwarding[compiled]; return (code_block *)forwarding[compiled];

3
vm/code_heap.hpp
View File

@ -4,7 +4,4 @@ namespace factor
struct factor_vm; struct factor_vm;
typedef void (*code_heap_iterator)(code_block *compiled, factor_vm *myvm); typedef void (*code_heap_iterator)(code_block *compiled, factor_vm *myvm);
PRIMITIVE(modify_code_heap);
PRIMITIVE(code_room);
} }

20
vm/contexts.cpp
View File

@ -140,22 +140,18 @@ bool factor_vm::stack_to_array(cell bottom, cell top)
} }
} }
inline void factor_vm::primitive_datastack() void factor_vm::primitive_datastack()
{ {
if(!stack_to_array(ds_bot,ds)) if(!stack_to_array(ds_bot,ds))
general_error(ERROR_DS_UNDERFLOW,F,F,NULL); general_error(ERROR_DS_UNDERFLOW,F,F,NULL);
} }
PRIMITIVE_FORWARD(datastack) void factor_vm::primitive_retainstack()
inline void factor_vm::primitive_retainstack()
{ {
if(!stack_to_array(rs_bot,rs)) if(!stack_to_array(rs_bot,rs))
general_error(ERROR_RS_UNDERFLOW,F,F,NULL); general_error(ERROR_RS_UNDERFLOW,F,F,NULL);
} }
PRIMITIVE_FORWARD(retainstack)
/* returns pointer to top of stack */ /* returns pointer to top of stack */
cell factor_vm::array_to_stack(array *array, cell bottom) cell factor_vm::array_to_stack(array *array, cell bottom)
{ {
@ -164,22 +160,18 @@ cell factor_vm::array_to_stack(array *array, cell bottom)
return bottom + depth - sizeof(cell); return bottom + depth - sizeof(cell);
} }
inline void factor_vm::primitive_set_datastack() void factor_vm::primitive_set_datastack()
{ {
ds = array_to_stack(untag_check<array>(dpop()),ds_bot); ds = array_to_stack(untag_check<array>(dpop()),ds_bot);
} }
PRIMITIVE_FORWARD(set_datastack) void factor_vm::primitive_set_retainstack()
inline void factor_vm::primitive_set_retainstack()
{ {
rs = array_to_stack(untag_check<array>(dpop()),rs_bot); rs = array_to_stack(untag_check<array>(dpop()),rs_bot);
} }
PRIMITIVE_FORWARD(set_retainstack)
/* Used to implement call( */ /* Used to implement call( */
inline void factor_vm::primitive_check_datastack() void factor_vm::primitive_check_datastack()
{ {
fixnum out = to_fixnum(dpop()); fixnum out = to_fixnum(dpop());
fixnum in = to_fixnum(dpop()); fixnum in = to_fixnum(dpop());
@ -204,6 +196,4 @@ inline void factor_vm::primitive_check_datastack()
} }
} }
PRIMITIVE_FORWARD(check_datastack)
} }

6
vm/contexts.hpp
View File

@ -44,12 +44,6 @@ struct context {
DEFPUSHPOP(d,ds) DEFPUSHPOP(d,ds)
DEFPUSHPOP(r,rs) DEFPUSHPOP(r,rs)
PRIMITIVE(datastack);
PRIMITIVE(retainstack);
PRIMITIVE(set_datastack);
PRIMITIVE(set_retainstack);
PRIMITIVE(check_datastack);
struct factor_vm; struct factor_vm;
VM_C_API void nest_stacks(factor_vm *vm); VM_C_API void nest_stacks(factor_vm *vm);
VM_C_API void unnest_stacks(factor_vm *vm); VM_C_API void unnest_stacks(factor_vm *vm);

16
vm/data_gc.cpp
View File

@ -568,14 +568,12 @@ void factor_vm::gc()
garbage_collection(data->tenured(),false,0); garbage_collection(data->tenured(),false,0);
} }
inline void factor_vm::primitive_gc() void factor_vm::primitive_gc()
{ {
gc(); gc();
} }
PRIMITIVE_FORWARD(gc) void factor_vm::primitive_gc_stats()
inline void factor_vm::primitive_gc_stats()
{ {
growable_array result(this); growable_array result(this);
@ -605,8 +603,6 @@ inline void factor_vm::primitive_gc_stats()
dpush(result.elements.value()); dpush(result.elements.value());
} }
PRIMITIVE_FORWARD(gc_stats)
void factor_vm::clear_gc_stats() void factor_vm::clear_gc_stats()
{ {
for(cell i = 0; i < max_gen_count; i++) for(cell i = 0; i < max_gen_count; i++)
@ -618,16 +614,14 @@ void factor_vm::clear_gc_stats()
code_heap_scans = 0; code_heap_scans = 0;
} }
inline void factor_vm::primitive_clear_gc_stats() void factor_vm::primitive_clear_gc_stats()
{ {
clear_gc_stats(); clear_gc_stats();
} }
PRIMITIVE_FORWARD(clear_gc_stats)
/* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this /* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this
to coalesce equal but distinct quotations and wrappers. */ to coalesce equal but distinct quotations and wrappers. */
inline void factor_vm::primitive_become() void factor_vm::primitive_become()
{ {
array *new_objects = untag_check<array>(dpop()); array *new_objects = untag_check<array>(dpop());
array *old_objects = untag_check<array>(dpop()); array *old_objects = untag_check<array>(dpop());
@ -656,8 +650,6 @@ inline void factor_vm::primitive_become()
compile_all_words(); compile_all_words();
} }
PRIMITIVE_FORWARD(become)
void factor_vm::inline_gc(cell *gc_roots_base, cell gc_roots_size) void factor_vm::inline_gc(cell *gc_roots_base, cell gc_roots_size)
{ {
for(cell i = 0; i < gc_roots_size; i++) for(cell i = 0; i < gc_roots_size; i++)

4
vm/data_gc.hpp
View File

@ -15,10 +15,6 @@ allocation (which does not call GC because of possible roots in volatile
registers) does not run out of memory */ registers) does not run out of memory */
static const cell allot_buffer_zone = 1024; static const cell allot_buffer_zone = 1024;
PRIMITIVE(gc);
PRIMITIVE(gc_stats);
PRIMITIVE(clear_gc_stats);
PRIMITIVE(become);
struct factor_vm; struct factor_vm;
VM_C_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factor_vm *myvm); VM_C_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factor_vm *myvm);

20
vm/data_heap.cpp
View File

@ -206,13 +206,11 @@ cell factor_vm::unaligned_object_size(object *pointer)
} }
} }
inline void factor_vm::primitive_size() void factor_vm::primitive_size()
{ {
box_unsigned_cell(object_size(dpop())); box_unsigned_cell(object_size(dpop()));
} }
PRIMITIVE_FORWARD(size)
/* The number of cells from the start of the object which should be scanned by /* The number of cells from the start of the object which should be scanned by
the GC. Some types have a binary payload at the end (string, word, DLL) which the GC. Some types have a binary payload at the end (string, word, DLL) which
we ignore. */ we ignore. */
@ -251,7 +249,7 @@ cell factor_vm::binary_payload_start(object *pointer)
} }
/* Push memory usage statistics in data heap */ /* Push memory usage statistics in data heap */
inline void factor_vm::primitive_data_room() void factor_vm::primitive_data_room()
{ {
dpush(tag_fixnum((data->cards_end - data->cards) >> 10)); dpush(tag_fixnum((data->cards_end - data->cards) >> 10));
dpush(tag_fixnum((data->decks_end - data->decks) >> 10)); dpush(tag_fixnum((data->decks_end - data->decks) >> 10));
@ -270,8 +268,6 @@ inline void factor_vm::primitive_data_room()
dpush(a.elements.value()); dpush(a.elements.value());
} }
PRIMITIVE_FORWARD(data_room)
/* Disables GC and activates next-object ( -- obj ) primitive */ /* Disables GC and activates next-object ( -- obj ) primitive */
void factor_vm::begin_scan() void factor_vm::begin_scan()
{ {
@ -284,13 +280,11 @@ void factor_vm::end_scan()
gc_off = false; gc_off = false;
} }
inline void factor_vm::primitive_begin_scan() void factor_vm::primitive_begin_scan()
{ {
begin_scan(); begin_scan();
} }
PRIMITIVE_FORWARD(begin_scan)
cell factor_vm::next_object() cell factor_vm::next_object()
{ {
if(!gc_off) if(!gc_off)
@ -305,21 +299,17 @@ cell factor_vm::next_object()
} }
/* Push object at heap scan cursor and advance; pushes f when done */ /* Push object at heap scan cursor and advance; pushes f when done */
inline void factor_vm::primitive_next_object() void factor_vm::primitive_next_object()
{ {
dpush(next_object()); dpush(next_object());
} }
PRIMITIVE_FORWARD(next_object)
/* Re-enables GC */ /* Re-enables GC */
inline void factor_vm::primitive_end_scan() void factor_vm::primitive_end_scan()
{ {
gc_off = false; gc_off = false;
} }
PRIMITIVE_FORWARD(end_scan)
template<typename TYPE> void factor_vm::each_object(TYPE &functor) template<typename TYPE> void factor_vm::each_object(TYPE &functor)
{ {
begin_scan(); begin_scan();

6
vm/data_heap.hpp
View File

@ -62,11 +62,5 @@ inline static bool in_zone(zone *z, object *pointer)
return (cell)pointer >= z->start && (cell)pointer < z->end; return (cell)pointer >= z->start && (cell)pointer < z->end;
} }
PRIMITIVE(data_room);
PRIMITIVE(size);
PRIMITIVE(begin_scan);
PRIMITIVE(next_object);
PRIMITIVE(end_scan);
} }

5
vm/debug.cpp
View File

@ -263,7 +263,6 @@ void factor_vm::dump_objects(cell type)
end_scan(); end_scan();
} }
void factor_vm::find_data_references_step(cell *scan) void factor_vm::find_data_references_step(cell *scan)
{ {
if(look_for == *scan) if(look_for == *scan)
@ -477,13 +476,11 @@ void factor_vm::factorbug()
} }
} }
inline void factor_vm::primitive_die() void factor_vm::primitive_die()
{ {
print_string("The die word was called by the library. Unless you called it yourself,\n"); print_string("The die word was called by the library. Unless you called it yourself,\n");
print_string("you have triggered a bug in Factor. Please report.\n"); print_string("you have triggered a bug in Factor. Please report.\n");
factorbug(); factorbug();
} }
PRIMITIVE_FORWARD(die)
} }

2
vm/debug.hpp
View File

@ -1,6 +1,4 @@
namespace factor namespace factor
{ {
PRIMITIVE(die);
} }

16
vm/dispatch.cpp
View File

@ -113,15 +113,13 @@ cell factor_vm::lookup_method(cell obj, cell methods)
return array_nth(untag<array>(methods),TAG(obj)); return array_nth(untag<array>(methods),TAG(obj));
} }
inline void factor_vm::primitive_lookup_method() void factor_vm::primitive_lookup_method()
{ {
cell methods = dpop(); cell methods = dpop();
cell obj = dpop(); cell obj = dpop();
dpush(lookup_method(obj,methods)); dpush(lookup_method(obj,methods));
} }
PRIMITIVE_FORWARD(lookup_method)
cell factor_vm::object_class(cell obj) cell factor_vm::object_class(cell obj)
{ {
switch(TAG(obj)) switch(TAG(obj))
@ -149,7 +147,7 @@ void factor_vm::update_method_cache(cell cache, cell klass, cell method)
set_array_nth(cache_elements,hashcode + 1,method); set_array_nth(cache_elements,hashcode + 1,method);
} }
inline void factor_vm::primitive_mega_cache_miss() void factor_vm::primitive_mega_cache_miss()
{ {
megamorphic_cache_misses++; megamorphic_cache_misses++;
@ -166,16 +164,12 @@ inline void factor_vm::primitive_mega_cache_miss()
dpush(method); dpush(method);
} }
PRIMITIVE_FORWARD(mega_cache_miss) void factor_vm::primitive_reset_dispatch_stats()
inline void factor_vm::primitive_reset_dispatch_stats()
{ {
megamorphic_cache_hits = megamorphic_cache_misses = 0; megamorphic_cache_hits = megamorphic_cache_misses = 0;
} }
PRIMITIVE_FORWARD(reset_dispatch_stats) void factor_vm::primitive_dispatch_stats()
inline void factor_vm::primitive_dispatch_stats()
{ {
growable_array stats(this); growable_array stats(this);
stats.add(allot_cell(megamorphic_cache_hits)); stats.add(allot_cell(megamorphic_cache_hits));
@ -184,8 +178,6 @@ inline void factor_vm::primitive_dispatch_stats()
dpush(stats.elements.value()); dpush(stats.elements.value());
} }
PRIMITIVE_FORWARD(dispatch_stats)
void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index, cell cache_) void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index, cell cache_)
{ {
gc_root<array> methods(methods_,parent_vm); gc_root<array> methods(methods_,parent_vm);

5
vm/dispatch.hpp
View File

@ -1,9 +1,4 @@
namespace factor namespace factor
{ {
PRIMITIVE(lookup_method);
PRIMITIVE(mega_cache_miss);
PRIMITIVE(reset_dispatch_stats);
PRIMITIVE(dispatch_stats);
} }

8
vm/errors.cpp
View File

@ -128,21 +128,17 @@ void factor_vm::fp_trap_error(unsigned int fpu_status, stack_frame *signal_calls
general_error(ERROR_FP_TRAP,tag_fixnum(fpu_status),F,signal_callstack_top); general_error(ERROR_FP_TRAP,tag_fixnum(fpu_status),F,signal_callstack_top);
} }
inline void factor_vm::primitive_call_clear() void factor_vm::primitive_call_clear()
{ {
throw_impl(dpop(),stack_chain->callstack_bottom,this); throw_impl(dpop(),stack_chain->callstack_bottom,this);
} }
PRIMITIVE_FORWARD(call_clear)
/* For testing purposes */ /* For testing purposes */
inline void factor_vm::primitive_unimplemented() void factor_vm::primitive_unimplemented()
{ {
not_implemented_error(); not_implemented_error();
} }
PRIMITIVE_FORWARD(unimplemented)
void factor_vm::memory_signal_handler_impl() void factor_vm::memory_signal_handler_impl()
{ {
memory_protection_error(signal_fault_addr,signal_callstack_top); memory_protection_error(signal_fault_addr,signal_callstack_top);

4
vm/errors.hpp
View File

@ -23,10 +23,6 @@ enum vm_error_type
ERROR_FP_TRAP, ERROR_FP_TRAP,
}; };
PRIMITIVE(die);
PRIMITIVE(call_clear);
PRIMITIVE(unimplemented);
void fatal_error(const char* msg, cell tagged); void fatal_error(const char* msg, cell tagged);
void memory_signal_handler_impl(); void memory_signal_handler_impl();
void fp_signal_handler_impl(); void fp_signal_handler_impl();

8
vm/image.cpp
View File

@ -118,7 +118,7 @@ bool factor_vm::save_image(const vm_char *filename)
return ok; return ok;
} }
inline void factor_vm::primitive_save_image() void factor_vm::primitive_save_image()
{ {
/* do a full GC to push everything into tenured space */ /* do a full GC to push everything into tenured space */
gc(); gc();
@ -128,9 +128,7 @@ inline void factor_vm::primitive_save_image()
save_image((vm_char *)(path.untagged() + 1)); save_image((vm_char *)(path.untagged() + 1));
} }
PRIMITIVE_FORWARD(save_image) void factor_vm::primitive_save_image_and_exit()
inline void factor_vm::primitive_save_image_and_exit()
{ {
/* We unbox this before doing anything else. This is the only point /* We unbox this before doing anything else. This is the only point
where we might throw an error, so we have to throw an error here since where we might throw an error, so we have to throw an error here since
@ -156,8 +154,6 @@ inline void factor_vm::primitive_save_image_and_exit()
exit(1); exit(1);
} }
PRIMITIVE_FORWARD(save_image_and_exit)
void factor_vm::data_fixup(cell *cell) void factor_vm::data_fixup(cell *cell)
{ {
if(immediate_p(*cell)) if(immediate_p(*cell))

3
vm/image.hpp
View File

@ -41,7 +41,4 @@ struct vm_parameters {
cell max_pic_size; cell max_pic_size;
}; };
PRIMITIVE(save_image);
PRIMITIVE(save_image_and_exit);
} }

8
vm/inline_cache.cpp
View File

@ -250,16 +250,14 @@ VM_C_API void *inline_cache_miss(cell return_address, factor_vm *myvm)
return VM_PTR->inline_cache_miss(return_address); return VM_PTR->inline_cache_miss(return_address);
} }
inline void factor_vm::primitive_reset_inline_cache_stats() void factor_vm::primitive_reset_inline_cache_stats()
{ {
cold_call_to_ic_transitions = ic_to_pic_transitions = pic_to_mega_transitions = 0; cold_call_to_ic_transitions = ic_to_pic_transitions = pic_to_mega_transitions = 0;
cell i; cell i;
for(i = 0; i < 4; i++) pic_counts[i] = 0; for(i = 0; i < 4; i++) pic_counts[i] = 0;
} }
PRIMITIVE_FORWARD(reset_inline_cache_stats) void factor_vm::primitive_inline_cache_stats()
inline void factor_vm::primitive_inline_cache_stats()
{ {
growable_array stats(this); growable_array stats(this);
stats.add(allot_cell(cold_call_to_ic_transitions)); stats.add(allot_cell(cold_call_to_ic_transitions));
@ -272,6 +270,4 @@ inline void factor_vm::primitive_inline_cache_stats()
dpush(stats.elements.value()); dpush(stats.elements.value());
} }
PRIMITIVE_FORWARD(inline_cache_stats)
} }

4
vm/inline_cache.hpp
View File

@ -1,9 +1,5 @@
namespace factor namespace factor
{ {
PRIMITIVE(reset_inline_cache_stats);
PRIMITIVE(inline_cache_stats);
PRIMITIVE(inline_cache_miss);
PRIMITIVE(inline_cache_miss_tail);
VM_C_API void *inline_cache_miss(cell return_address, factor_vm *vm); VM_C_API void *inline_cache_miss(cell return_address, factor_vm *vm);

32
vm/io.cpp
View File

@ -31,7 +31,7 @@ void factor_vm::io_error()
general_error(ERROR_IO,tag_fixnum(errno),F,NULL); general_error(ERROR_IO,tag_fixnum(errno),F,NULL);
} }
inline void factor_vm::primitive_fopen() void factor_vm::primitive_fopen()
{ {
gc_root<byte_array> mode(dpop(),this); gc_root<byte_array> mode(dpop(),this);
gc_root<byte_array> path(dpop(),this); gc_root<byte_array> path(dpop(),this);
@ -52,9 +52,7 @@ inline void factor_vm::primitive_fopen()
} }
} }
PRIMITIVE_FORWARD(fopen) void factor_vm::primitive_fgetc()
inline void factor_vm::primitive_fgetc()
{ {
FILE *file = (FILE *)unbox_alien(); FILE *file = (FILE *)unbox_alien();
@ -79,9 +77,7 @@ inline void factor_vm::primitive_fgetc()
} }
} }
PRIMITIVE_FORWARD(fgetc) void factor_vm::primitive_fread()
inline void factor_vm::primitive_fread()
{ {
FILE *file = (FILE *)unbox_alien(); FILE *file = (FILE *)unbox_alien();
fixnum size = unbox_array_size(); fixnum size = unbox_array_size();
@ -121,9 +117,7 @@ inline void factor_vm::primitive_fread()
} }
} }
PRIMITIVE_FORWARD(fread) void factor_vm::primitive_fputc()
inline void factor_vm::primitive_fputc()
{ {
FILE *file = (FILE *)unbox_alien(); FILE *file = (FILE *)unbox_alien();
fixnum ch = to_fixnum(dpop()); fixnum ch = to_fixnum(dpop());
@ -141,9 +135,7 @@ inline void factor_vm::primitive_fputc()
} }
} }
PRIMITIVE_FORWARD(fputc) void factor_vm::primitive_fwrite()
inline void factor_vm::primitive_fwrite()
{ {
FILE *file = (FILE *)unbox_alien(); FILE *file = (FILE *)unbox_alien();
byte_array *text = untag_check<byte_array>(dpop()); byte_array *text = untag_check<byte_array>(dpop());
@ -172,9 +164,7 @@ inline void factor_vm::primitive_fwrite()
} }
} }
PRIMITIVE_FORWARD(fwrite) void factor_vm::primitive_fseek()
inline void factor_vm::primitive_fseek()
{ {
int whence = to_fixnum(dpop()); int whence = to_fixnum(dpop());
FILE *file = (FILE *)unbox_alien(); FILE *file = (FILE *)unbox_alien();
@ -199,9 +189,7 @@ inline void factor_vm::primitive_fseek()
} }
} }
PRIMITIVE_FORWARD(fseek) void factor_vm::primitive_fflush()
inline void factor_vm::primitive_fflush()
{ {
FILE *file = (FILE *)unbox_alien(); FILE *file = (FILE *)unbox_alien();
for(;;) for(;;)
@ -213,9 +201,7 @@ inline void factor_vm::primitive_fflush()
} }
} }
PRIMITIVE_FORWARD(fflush) void factor_vm::primitive_fclose()
inline void factor_vm::primitive_fclose()
{ {
FILE *file = (FILE *)unbox_alien(); FILE *file = (FILE *)unbox_alien();
for(;;) for(;;)
@ -227,8 +213,6 @@ inline void factor_vm::primitive_fclose()
} }
} }
PRIMITIVE_FORWARD(fclose)
/* This function is used by FFI I/O. Accessing the errno global directly is /* This function is used by FFI I/O. Accessing the errno global directly is
not portable, since on some libc's errno is not a global but a funky macro that not portable, since on some libc's errno is not a global but a funky macro that
reads thread-local storage. */ reads thread-local storage. */

12
vm/io.hpp
View File

@ -1,19 +1,7 @@
namespace factor namespace factor
{ {
PRIMITIVE(fopen);
PRIMITIVE(fgetc);
PRIMITIVE(fread);
PRIMITIVE(fputc);
PRIMITIVE(fwrite);
PRIMITIVE(fflush);
PRIMITIVE(fseek);
PRIMITIVE(fclose);
/* Platform specific primitives */ /* Platform specific primitives */
PRIMITIVE(open_file);
PRIMITIVE(existsp);
PRIMITIVE(read_dir);
VM_C_API int err_no(); VM_C_API int err_no();
VM_C_API void clear_err_no(); VM_C_API void clear_err_no();

176
vm/math.cpp
View File

@ -3,23 +3,19 @@
namespace factor namespace factor
{ {
inline void factor_vm::primitive_bignum_to_fixnum() void factor_vm::primitive_bignum_to_fixnum()
{ {
drepl(tag_fixnum(bignum_to_fixnum(untag<bignum>(dpeek())))); drepl(tag_fixnum(bignum_to_fixnum(untag<bignum>(dpeek()))));
} }
PRIMITIVE_FORWARD(bignum_to_fixnum) void factor_vm::primitive_float_to_fixnum()
inline void factor_vm::primitive_float_to_fixnum()
{ {
drepl(tag_fixnum(float_to_fixnum(dpeek()))); drepl(tag_fixnum(float_to_fixnum(dpeek())));
} }
PRIMITIVE_FORWARD(float_to_fixnum)
/* Division can only overflow when we are dividing the most negative fixnum /* Division can only overflow when we are dividing the most negative fixnum
by -1. */ by -1. */
inline void factor_vm::primitive_fixnum_divint() void factor_vm::primitive_fixnum_divint()
{ {
fixnum y = untag_fixnum(dpop()); \ fixnum y = untag_fixnum(dpop()); \
fixnum x = untag_fixnum(dpeek()); fixnum x = untag_fixnum(dpeek());
@ -30,9 +26,7 @@ inline void factor_vm::primitive_fixnum_divint()
drepl(tag_fixnum(result)); drepl(tag_fixnum(result));
} }
PRIMITIVE_FORWARD(fixnum_divint) void factor_vm::primitive_fixnum_divmod()
inline void factor_vm::primitive_fixnum_divmod()
{ {
cell y = ((cell *)ds)[0]; cell y = ((cell *)ds)[0];
cell x = ((cell *)ds)[-1]; cell x = ((cell *)ds)[-1];
@ -48,8 +42,6 @@ inline void factor_vm::primitive_fixnum_divmod()
} }
} }
PRIMITIVE_FORWARD(fixnum_divmod)
/* /*
* If we're shifting right by n bits, we won't overflow as long as none of the * If we're shifting right by n bits, we won't overflow as long as none of the
* high WORD_SIZE-TAG_BITS-n bits are set. * high WORD_SIZE-TAG_BITS-n bits are set.
@ -69,7 +61,7 @@ inline fixnum factor_vm::branchless_abs(fixnum x)
return (x ^ sign_mask(x)) - sign_mask(x); return (x ^ sign_mask(x)) - sign_mask(x);
} }
inline void factor_vm::primitive_fixnum_shift() void factor_vm::primitive_fixnum_shift()
{ {
fixnum y = untag_fixnum(dpop()); fixnum y = untag_fixnum(dpop());
fixnum x = untag_fixnum(dpeek()); fixnum x = untag_fixnum(dpeek());
@ -96,67 +88,51 @@ inline void factor_vm::primitive_fixnum_shift()
fixnum_to_bignum(x),y))); fixnum_to_bignum(x),y)));
} }
PRIMITIVE_FORWARD(fixnum_shift) void factor_vm::primitive_fixnum_to_bignum()
inline void factor_vm::primitive_fixnum_to_bignum()
{ {
drepl(tag<bignum>(fixnum_to_bignum(untag_fixnum(dpeek())))); drepl(tag<bignum>(fixnum_to_bignum(untag_fixnum(dpeek()))));
} }
PRIMITIVE_FORWARD(fixnum_to_bignum) void factor_vm::primitive_float_to_bignum()
inline void factor_vm::primitive_float_to_bignum()
{ {
drepl(tag<bignum>(float_to_bignum(dpeek()))); drepl(tag<bignum>(float_to_bignum(dpeek())));
} }
PRIMITIVE_FORWARD(float_to_bignum)
#define POP_BIGNUMS(x,y) \ #define POP_BIGNUMS(x,y) \
bignum * y = untag<bignum>(dpop()); \ bignum * y = untag<bignum>(dpop()); \
bignum * x = untag<bignum>(dpop()); bignum * x = untag<bignum>(dpop());
inline void factor_vm::primitive_bignum_eq() void factor_vm::primitive_bignum_eq()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
box_boolean(bignum_equal_p(x,y)); box_boolean(bignum_equal_p(x,y));
} }
PRIMITIVE_FORWARD(bignum_eq) void factor_vm::primitive_bignum_add()
inline void factor_vm::primitive_bignum_add()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_add(x,y))); dpush(tag<bignum>(bignum_add(x,y)));
} }
PRIMITIVE_FORWARD(bignum_add) void factor_vm::primitive_bignum_subtract()
inline void factor_vm::primitive_bignum_subtract()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_subtract(x,y))); dpush(tag<bignum>(bignum_subtract(x,y)));
} }
PRIMITIVE_FORWARD(bignum_subtract) void factor_vm::primitive_bignum_multiply()
inline void factor_vm::primitive_bignum_multiply()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_multiply(x,y))); dpush(tag<bignum>(bignum_multiply(x,y)));
} }
PRIMITIVE_FORWARD(bignum_multiply) void factor_vm::primitive_bignum_divint()
inline void factor_vm::primitive_bignum_divint()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_quotient(x,y))); dpush(tag<bignum>(bignum_quotient(x,y)));
} }
PRIMITIVE_FORWARD(bignum_divint) void factor_vm::primitive_bignum_divmod()
inline void factor_vm::primitive_bignum_divmod()
{ {
bignum *q, *r; bignum *q, *r;
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
@ -165,104 +141,78 @@ inline void factor_vm::primitive_bignum_divmod()
dpush(tag<bignum>(r)); dpush(tag<bignum>(r));
} }
PRIMITIVE_FORWARD(bignum_divmod) void factor_vm::primitive_bignum_mod()
inline void factor_vm::primitive_bignum_mod()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_remainder(x,y))); dpush(tag<bignum>(bignum_remainder(x,y)));
} }
PRIMITIVE_FORWARD(bignum_mod) void factor_vm::primitive_bignum_and()
inline void factor_vm::primitive_bignum_and()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_bitwise_and(x,y))); dpush(tag<bignum>(bignum_bitwise_and(x,y)));
} }
PRIMITIVE_FORWARD(bignum_and) void factor_vm::primitive_bignum_or()
inline void factor_vm::primitive_bignum_or()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_bitwise_ior(x,y))); dpush(tag<bignum>(bignum_bitwise_ior(x,y)));
} }
PRIMITIVE_FORWARD(bignum_or) void factor_vm::primitive_bignum_xor()
inline void factor_vm::primitive_bignum_xor()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_bitwise_xor(x,y))); dpush(tag<bignum>(bignum_bitwise_xor(x,y)));
} }
PRIMITIVE_FORWARD(bignum_xor) void factor_vm::primitive_bignum_shift()
inline void factor_vm::primitive_bignum_shift()
{ {
fixnum y = untag_fixnum(dpop()); fixnum y = untag_fixnum(dpop());
bignum* x = untag<bignum>(dpop()); bignum* x = untag<bignum>(dpop());
dpush(tag<bignum>(bignum_arithmetic_shift(x,y))); dpush(tag<bignum>(bignum_arithmetic_shift(x,y)));
} }
PRIMITIVE_FORWARD(bignum_shift) void factor_vm::primitive_bignum_less()
inline void factor_vm::primitive_bignum_less()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) == bignum_comparison_less); box_boolean(bignum_compare(x,y) == bignum_comparison_less);
} }
PRIMITIVE_FORWARD(bignum_less) void factor_vm::primitive_bignum_lesseq()
inline void factor_vm::primitive_bignum_lesseq()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) != bignum_comparison_greater); box_boolean(bignum_compare(x,y) != bignum_comparison_greater);
} }
PRIMITIVE_FORWARD(bignum_lesseq) void factor_vm::primitive_bignum_greater()
inline void factor_vm::primitive_bignum_greater()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) == bignum_comparison_greater); box_boolean(bignum_compare(x,y) == bignum_comparison_greater);
} }
PRIMITIVE_FORWARD(bignum_greater) void factor_vm::primitive_bignum_greatereq()
inline void factor_vm::primitive_bignum_greatereq()
{ {
POP_BIGNUMS(x,y); POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) != bignum_comparison_less); box_boolean(bignum_compare(x,y) != bignum_comparison_less);
} }
PRIMITIVE_FORWARD(bignum_greatereq) void factor_vm::primitive_bignum_not()
inline void factor_vm::primitive_bignum_not()
{ {
drepl(tag<bignum>(bignum_bitwise_not(untag<bignum>(dpeek())))); drepl(tag<bignum>(bignum_bitwise_not(untag<bignum>(dpeek()))));
} }
PRIMITIVE_FORWARD(bignum_not) void factor_vm::primitive_bignum_bitp()
inline void factor_vm::primitive_bignum_bitp()
{ {
fixnum bit = to_fixnum(dpop()); fixnum bit = to_fixnum(dpop());
bignum *x = untag<bignum>(dpop()); bignum *x = untag<bignum>(dpop());
box_boolean(bignum_logbitp(bit,x)); box_boolean(bignum_logbitp(bit,x));
} }
PRIMITIVE_FORWARD(bignum_bitp) void factor_vm::primitive_bignum_log2()
inline void factor_vm::primitive_bignum_log2()
{ {
drepl(tag<bignum>(bignum_integer_length(untag<bignum>(dpeek())))); drepl(tag<bignum>(bignum_integer_length(untag<bignum>(dpeek()))));
} }
PRIMITIVE_FORWARD(bignum_log2)
unsigned int factor_vm::bignum_producer(unsigned int digit) unsigned int factor_vm::bignum_producer(unsigned int digit)
{ {
unsigned char *ptr = (unsigned char *)alien_offset(dpeek()); unsigned char *ptr = (unsigned char *)alien_offset(dpeek());
@ -274,15 +224,13 @@ unsigned int bignum_producer(unsigned int digit, factor_vm *myvm)
return myvm->bignum_producer(digit); return myvm->bignum_producer(digit);
} }
inline void factor_vm::primitive_byte_array_to_bignum() void factor_vm::primitive_byte_array_to_bignum()
{ {
cell n_digits = array_capacity(untag_check<byte_array>(dpeek())); cell n_digits = array_capacity(untag_check<byte_array>(dpeek()));
bignum * result = digit_stream_to_bignum(n_digits,factor::bignum_producer,0x100,0); bignum * result = digit_stream_to_bignum(n_digits,factor::bignum_producer,0x100,0);
drepl(tag<bignum>(result)); drepl(tag<bignum>(result));
} }
PRIMITIVE_FORWARD(byte_array_to_bignum)
cell factor_vm::unbox_array_size() cell factor_vm::unbox_array_size()
{ {
switch(tagged<object>(dpeek()).type()) switch(tagged<object>(dpeek()).type())
@ -316,21 +264,17 @@ cell factor_vm::unbox_array_size()
return 0; /* can't happen */ return 0; /* can't happen */
} }
inline void factor_vm::primitive_fixnum_to_float() void factor_vm::primitive_fixnum_to_float()
{ {
drepl(allot_float(fixnum_to_float(dpeek()))); drepl(allot_float(fixnum_to_float(dpeek())));
} }
PRIMITIVE_FORWARD(fixnum_to_float) void factor_vm::primitive_bignum_to_float()
inline void factor_vm::primitive_bignum_to_float()
{ {
drepl(allot_float(bignum_to_float(dpeek()))); drepl(allot_float(bignum_to_float(dpeek())));
} }
PRIMITIVE_FORWARD(bignum_to_float) void factor_vm::primitive_str_to_float()
inline void factor_vm::primitive_str_to_float()
{ {
byte_array *bytes = untag_check<byte_array>(dpeek()); byte_array *bytes = untag_check<byte_array>(dpeek());
cell capacity = array_capacity(bytes); cell capacity = array_capacity(bytes);
@ -344,129 +288,97 @@ inline void factor_vm::primitive_str_to_float()
drepl(F); drepl(F);
} }
PRIMITIVE_FORWARD(str_to_float) void factor_vm::primitive_float_to_str()
inline void factor_vm::primitive_float_to_str()
{ {
byte_array *array = allot_byte_array(33); byte_array *array = allot_byte_array(33);
snprintf((char *)(array + 1),32,"%.16g",untag_float_check(dpop())); snprintf((char *)(array + 1),32,"%.16g",untag_float_check(dpop()));
dpush(tag<byte_array>(array)); dpush(tag<byte_array>(array));
} }
PRIMITIVE_FORWARD(float_to_str)
#define POP_FLOATS(x,y) \ #define POP_FLOATS(x,y) \
double y = untag_float(dpop()); \ double y = untag_float(dpop()); \
double x = untag_float(dpop()); double x = untag_float(dpop());
inline void factor_vm::primitive_float_eq() void factor_vm::primitive_float_eq()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_boolean(x == y); box_boolean(x == y);
} }
PRIMITIVE_FORWARD(float_eq) void factor_vm::primitive_float_add()
inline void factor_vm::primitive_float_add()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_double(x + y); box_double(x + y);
} }
PRIMITIVE_FORWARD(float_add) void factor_vm::primitive_float_subtract()
inline void factor_vm::primitive_float_subtract()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_double(x - y); box_double(x - y);
} }
PRIMITIVE_FORWARD(float_subtract) void factor_vm::primitive_float_multiply()
inline void factor_vm::primitive_float_multiply()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_double(x * y); box_double(x * y);
} }
PRIMITIVE_FORWARD(float_multiply) void factor_vm::primitive_float_divfloat()
inline void factor_vm::primitive_float_divfloat()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_double(x / y); box_double(x / y);
} }
PRIMITIVE_FORWARD(float_divfloat) void factor_vm::primitive_float_mod()
inline void factor_vm::primitive_float_mod()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_double(fmod(x,y)); box_double(fmod(x,y));
} }
PRIMITIVE_FORWARD(float_mod) void factor_vm::primitive_float_less()
inline void factor_vm::primitive_float_less()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_boolean(x < y); box_boolean(x < y);
} }
PRIMITIVE_FORWARD(float_less) void factor_vm::primitive_float_lesseq()
inline void factor_vm::primitive_float_lesseq()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_boolean(x <= y); box_boolean(x <= y);
} }
PRIMITIVE_FORWARD(float_lesseq) void factor_vm::primitive_float_greater()
inline void factor_vm::primitive_float_greater()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_boolean(x > y); box_boolean(x > y);
} }
PRIMITIVE_FORWARD(float_greater) void factor_vm::primitive_float_greatereq()
inline void factor_vm::primitive_float_greatereq()
{ {
POP_FLOATS(x,y); POP_FLOATS(x,y);
box_boolean(x >= y); box_boolean(x >= y);
} }
PRIMITIVE_FORWARD(float_greatereq) void factor_vm::primitive_float_bits()
inline void factor_vm::primitive_float_bits()
{ {
box_unsigned_4(float_bits(untag_float_check(dpop()))); box_unsigned_4(float_bits(untag_float_check(dpop())));
} }
PRIMITIVE_FORWARD(float_bits) void factor_vm::primitive_bits_float()
inline void factor_vm::primitive_bits_float()
{ {
box_float(bits_float(to_cell(dpop()))); box_float(bits_float(to_cell(dpop())));
} }
PRIMITIVE_FORWARD(bits_float) void factor_vm::primitive_double_bits()
inline void factor_vm::primitive_double_bits()
{ {
box_unsigned_8(double_bits(untag_float_check(dpop()))); box_unsigned_8(double_bits(untag_float_check(dpop())));
} }
PRIMITIVE_FORWARD(double_bits) void factor_vm::primitive_bits_double()
inline void factor_vm::primitive_bits_double()
{ {
box_double(bits_double(to_unsigned_8(dpop()))); box_double(bits_double(to_unsigned_8(dpop())));
} }
PRIMITIVE_FORWARD(bits_double)
fixnum factor_vm::to_fixnum(cell tagged) fixnum factor_vm::to_fixnum(cell tagged)
{ {
switch(TAG(tagged)) switch(TAG(tagged))

50
vm/math.hpp
View File

@ -6,60 +6,10 @@ static const fixnum fixnum_min = (-((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)));
static const fixnum array_size_max = ((cell)1 << (WORD_SIZE - TAG_BITS - 2)); static const fixnum array_size_max = ((cell)1 << (WORD_SIZE - TAG_BITS - 2));
// defined in assembler // defined in assembler
PRIMITIVE(fixnum_add);
PRIMITIVE(fixnum_subtract);
PRIMITIVE(fixnum_multiply);
PRIMITIVE(bignum_to_fixnum);
PRIMITIVE(float_to_fixnum);
PRIMITIVE(fixnum_divint);
PRIMITIVE(fixnum_divmod);
PRIMITIVE(fixnum_shift);
PRIMITIVE(fixnum_to_bignum);
PRIMITIVE(float_to_bignum);
PRIMITIVE(bignum_eq);
PRIMITIVE(bignum_add);
PRIMITIVE(bignum_subtract);
PRIMITIVE(bignum_multiply);
PRIMITIVE(bignum_divint);
PRIMITIVE(bignum_divmod);
PRIMITIVE(bignum_mod);
PRIMITIVE(bignum_and);
PRIMITIVE(bignum_or);
PRIMITIVE(bignum_xor);
PRIMITIVE(bignum_shift);
PRIMITIVE(bignum_less);
PRIMITIVE(bignum_lesseq);
PRIMITIVE(bignum_greater);
PRIMITIVE(bignum_greatereq);
PRIMITIVE(bignum_not);
PRIMITIVE(bignum_bitp);
PRIMITIVE(bignum_log2);
PRIMITIVE(byte_array_to_bignum);
PRIMITIVE(fixnum_to_float);
PRIMITIVE(bignum_to_float);
PRIMITIVE(str_to_float);
PRIMITIVE(float_to_str);
PRIMITIVE(float_to_bits);
PRIMITIVE(float_eq);
PRIMITIVE(float_add);
PRIMITIVE(float_subtract);
PRIMITIVE(float_multiply);
PRIMITIVE(float_divfloat);
PRIMITIVE(float_mod);
PRIMITIVE(float_less);
PRIMITIVE(float_lesseq);
PRIMITIVE(float_greater);
PRIMITIVE(float_greatereq);
PRIMITIVE(float_bits);
PRIMITIVE(bits_float);
PRIMITIVE(double_bits);
PRIMITIVE(bits_double);
VM_C_API void box_float(float flo, factor_vm *vm); VM_C_API void box_float(float flo, factor_vm *vm);
VM_C_API float to_float(cell value, factor_vm *vm); VM_C_API float to_float(cell value, factor_vm *vm);

4
vm/os-unix.cpp
View File

@ -74,15 +74,13 @@ void factor_vm::ffi_dlclose(dll *dll)
dll->dll = NULL; dll->dll = NULL;
} }
inline void factor_vm::primitive_existsp() void factor_vm::primitive_existsp()
{ {
struct stat sb; struct stat sb;
char *path = (char *)(untag_check<byte_array>(dpop()) + 1); char *path = (char *)(untag_check<byte_array>(dpop()) + 1);
box_boolean(stat(path,&sb) >= 0); box_boolean(stat(path,&sb) >= 0);
} }
PRIMITIVE_FORWARD(existsp)
segment::segment(factor_vm *myvm_, cell size_) segment::segment(factor_vm *myvm_, cell size_)
{ {
myvm = myvm_; myvm = myvm_;

2
vm/os-windows-ce.cpp
View File

@ -30,8 +30,6 @@ char *getenv(char *name)
return 0; /* unreachable */ return 0; /* unreachable */
} }
PRIMITIVE_FORWARD(os_envs)
void c_to_factor_toplevel(cell quot) void c_to_factor_toplevel(cell quot)
{ {
c_to_factor(quot,vm); c_to_factor(quot,vm);

4
vm/os-windows.cpp
View File

@ -90,14 +90,12 @@ const vm_char *factor_vm::vm_executable_path()
return safe_strdup(full_path); return safe_strdup(full_path);
} }
inline void factor_vm::primitive_existsp() void factor_vm::primitive_existsp()
{ {
vm_char *path = untag_check<byte_array>(dpop())->data<vm_char>(); vm_char *path = untag_check<byte_array>(dpop())->data<vm_char>();
box_boolean(windows_stat(path)); box_boolean(windows_stat(path));
} }
PRIMITIVE_FORWARD(existsp)
segment::segment(factor_vm *myvm_, cell size_) segment::segment(factor_vm *myvm_, cell size_)
{ {
myvm = myvm_; myvm = myvm_;

123
vm/primitives.cpp
View File

@ -165,4 +165,127 @@ const primitive_type primitives[] = {
primitive_vm_ptr, primitive_vm_ptr,
}; };
PRIMITIVE_FORWARD(bignum_to_fixnum)
PRIMITIVE_FORWARD(float_to_fixnum)
PRIMITIVE_FORWARD(fixnum_to_bignum)
PRIMITIVE_FORWARD(float_to_bignum)
PRIMITIVE_FORWARD(fixnum_to_float)
PRIMITIVE_FORWARD(bignum_to_float)
PRIMITIVE_FORWARD(str_to_float)
PRIMITIVE_FORWARD(float_to_str)
PRIMITIVE_FORWARD(float_bits)
PRIMITIVE_FORWARD(double_bits)
PRIMITIVE_FORWARD(bits_float)
PRIMITIVE_FORWARD(bits_double)
PRIMITIVE_FORWARD(fixnum_divint)
PRIMITIVE_FORWARD(fixnum_divmod)
PRIMITIVE_FORWARD(fixnum_shift)
PRIMITIVE_FORWARD(bignum_eq)
PRIMITIVE_FORWARD(bignum_add)
PRIMITIVE_FORWARD(bignum_subtract)
PRIMITIVE_FORWARD(bignum_multiply)
PRIMITIVE_FORWARD(bignum_divint)
PRIMITIVE_FORWARD(bignum_mod)
PRIMITIVE_FORWARD(bignum_divmod)
PRIMITIVE_FORWARD(bignum_and)
PRIMITIVE_FORWARD(bignum_or)
PRIMITIVE_FORWARD(bignum_xor)
PRIMITIVE_FORWARD(bignum_not)
PRIMITIVE_FORWARD(bignum_shift)
PRIMITIVE_FORWARD(bignum_less)
PRIMITIVE_FORWARD(bignum_lesseq)
PRIMITIVE_FORWARD(bignum_greater)
PRIMITIVE_FORWARD(bignum_greatereq)
PRIMITIVE_FORWARD(bignum_bitp)
PRIMITIVE_FORWARD(bignum_log2)
PRIMITIVE_FORWARD(byte_array_to_bignum)
PRIMITIVE_FORWARD(float_eq)
PRIMITIVE_FORWARD(float_add)
PRIMITIVE_FORWARD(float_subtract)
PRIMITIVE_FORWARD(float_multiply)
PRIMITIVE_FORWARD(float_divfloat)
PRIMITIVE_FORWARD(float_mod)
PRIMITIVE_FORWARD(float_less)
PRIMITIVE_FORWARD(float_lesseq)
PRIMITIVE_FORWARD(float_greater)
PRIMITIVE_FORWARD(float_greatereq)
PRIMITIVE_FORWARD(word)
PRIMITIVE_FORWARD(word_xt)
PRIMITIVE_FORWARD(getenv)
PRIMITIVE_FORWARD(setenv)
PRIMITIVE_FORWARD(existsp)
PRIMITIVE_FORWARD(gc)
PRIMITIVE_FORWARD(gc_stats)
PRIMITIVE_FORWARD(save_image)
PRIMITIVE_FORWARD(save_image_and_exit)
PRIMITIVE_FORWARD(datastack)
PRIMITIVE_FORWARD(retainstack)
PRIMITIVE_FORWARD(callstack)
PRIMITIVE_FORWARD(set_datastack)
PRIMITIVE_FORWARD(set_retainstack)
PRIMITIVE_FORWARD(set_callstack)
PRIMITIVE_FORWARD(exit)
PRIMITIVE_FORWARD(data_room)
PRIMITIVE_FORWARD(code_room)
PRIMITIVE_FORWARD(micros)
PRIMITIVE_FORWARD(modify_code_heap)
PRIMITIVE_FORWARD(dlopen)
PRIMITIVE_FORWARD(dlsym)
PRIMITIVE_FORWARD(dlclose)
PRIMITIVE_FORWARD(byte_array)
PRIMITIVE_FORWARD(uninitialized_byte_array)
PRIMITIVE_FORWARD(displaced_alien)
PRIMITIVE_FORWARD(alien_address)
PRIMITIVE_FORWARD(set_slot)
PRIMITIVE_FORWARD(string_nth)
PRIMITIVE_FORWARD(set_string_nth_fast)
PRIMITIVE_FORWARD(set_string_nth_slow)
PRIMITIVE_FORWARD(resize_array)
PRIMITIVE_FORWARD(resize_string)
PRIMITIVE_FORWARD(array)
PRIMITIVE_FORWARD(begin_scan)
PRIMITIVE_FORWARD(next_object)
PRIMITIVE_FORWARD(end_scan)
PRIMITIVE_FORWARD(size)
PRIMITIVE_FORWARD(die)
PRIMITIVE_FORWARD(fopen)
PRIMITIVE_FORWARD(fgetc)
PRIMITIVE_FORWARD(fread)
PRIMITIVE_FORWARD(fputc)
PRIMITIVE_FORWARD(fwrite)
PRIMITIVE_FORWARD(fflush)
PRIMITIVE_FORWARD(fseek)
PRIMITIVE_FORWARD(fclose)
PRIMITIVE_FORWARD(wrapper)
PRIMITIVE_FORWARD(clone)
PRIMITIVE_FORWARD(string)
PRIMITIVE_FORWARD(array_to_quotation)
PRIMITIVE_FORWARD(quotation_xt)
PRIMITIVE_FORWARD(tuple)
PRIMITIVE_FORWARD(profiling)
PRIMITIVE_FORWARD(become)
PRIMITIVE_FORWARD(sleep)
PRIMITIVE_FORWARD(tuple_boa)
PRIMITIVE_FORWARD(callstack_to_array)
PRIMITIVE_FORWARD(innermost_stack_frame_executing)
PRIMITIVE_FORWARD(innermost_stack_frame_scan)
PRIMITIVE_FORWARD(set_innermost_stack_frame_quot)
PRIMITIVE_FORWARD(call_clear)
PRIMITIVE_FORWARD(resize_byte_array)
PRIMITIVE_FORWARD(dll_validp)
PRIMITIVE_FORWARD(unimplemented)
PRIMITIVE_FORWARD(clear_gc_stats)
PRIMITIVE_FORWARD(jit_compile)
PRIMITIVE_FORWARD(load_locals)
PRIMITIVE_FORWARD(check_datastack)
PRIMITIVE_FORWARD(mega_cache_miss)
PRIMITIVE_FORWARD(lookup_method)
PRIMITIVE_FORWARD(reset_dispatch_stats)
PRIMITIVE_FORWARD(dispatch_stats)
PRIMITIVE_FORWARD(reset_inline_cache_stats)
PRIMITIVE_FORWARD(inline_cache_stats)
PRIMITIVE_FORWARD(optimized_p)
PRIMITIVE_FORWARD(quot_compiled_p)
PRIMITIVE_FORWARD(vm_ptr)
} }

155
vm/primitives.hpp
View File

@ -17,4 +17,159 @@ namespace factor
} }
#endif #endif
extern const primitive_type primitives[]; extern const primitive_type primitives[];
PRIMITIVE(bignum_to_fixnum);
PRIMITIVE(float_to_fixnum);
PRIMITIVE(fixnum_to_bignum);
PRIMITIVE(float_to_bignum);
PRIMITIVE(fixnum_to_float);
PRIMITIVE(bignum_to_float);
PRIMITIVE(str_to_float);
PRIMITIVE(float_to_str);
PRIMITIVE(float_bits);
PRIMITIVE(double_bits);
PRIMITIVE(bits_float);
PRIMITIVE(bits_double);
PRIMITIVE(fixnum_add);
PRIMITIVE(fixnum_subtract);
PRIMITIVE(fixnum_multiply);
PRIMITIVE(fixnum_divint);
PRIMITIVE(fixnum_divmod);
PRIMITIVE(fixnum_shift);
PRIMITIVE(bignum_eq);
PRIMITIVE(bignum_add);
PRIMITIVE(bignum_subtract);
PRIMITIVE(bignum_multiply);
PRIMITIVE(bignum_divint);
PRIMITIVE(bignum_mod);
PRIMITIVE(bignum_divmod);
PRIMITIVE(bignum_and);
PRIMITIVE(bignum_or);
PRIMITIVE(bignum_xor);
PRIMITIVE(bignum_not);
PRIMITIVE(bignum_shift);
PRIMITIVE(bignum_less);
PRIMITIVE(bignum_lesseq);
PRIMITIVE(bignum_greater);
PRIMITIVE(bignum_greatereq);
PRIMITIVE(bignum_bitp);
PRIMITIVE(bignum_log2);
PRIMITIVE(byte_array_to_bignum);
PRIMITIVE(float_eq);
PRIMITIVE(float_add);
PRIMITIVE(float_subtract);
PRIMITIVE(float_multiply);
PRIMITIVE(float_divfloat);
PRIMITIVE(float_mod);
PRIMITIVE(float_less);
PRIMITIVE(float_lesseq);
PRIMITIVE(float_greater);
PRIMITIVE(float_greatereq);
PRIMITIVE(word);
PRIMITIVE(word_xt);
PRIMITIVE(getenv);
PRIMITIVE(setenv);
PRIMITIVE(existsp);
PRIMITIVE(gc);
PRIMITIVE(gc_stats);
PRIMITIVE(save_image);
PRIMITIVE(save_image_and_exit);
PRIMITIVE(datastack);
PRIMITIVE(retainstack);
PRIMITIVE(callstack);
PRIMITIVE(set_datastack);
PRIMITIVE(set_retainstack);
PRIMITIVE(set_callstack);
PRIMITIVE(exit);
PRIMITIVE(data_room);
PRIMITIVE(code_room);
PRIMITIVE(micros);
PRIMITIVE(modify_code_heap);
PRIMITIVE(dlopen);
PRIMITIVE(dlsym);
PRIMITIVE(dlclose);
PRIMITIVE(byte_array);
PRIMITIVE(uninitialized_byte_array);
PRIMITIVE(displaced_alien);
PRIMITIVE(alien_signed_cell);
PRIMITIVE(set_alien_signed_cell);
PRIMITIVE(alien_unsigned_cell);
PRIMITIVE(set_alien_unsigned_cell);
PRIMITIVE(alien_signed_8);
PRIMITIVE(set_alien_signed_8);
PRIMITIVE(alien_unsigned_8);
PRIMITIVE(set_alien_unsigned_8);
PRIMITIVE(alien_signed_4);
PRIMITIVE(set_alien_signed_4);
PRIMITIVE(alien_unsigned_4);
PRIMITIVE(set_alien_unsigned_4);
PRIMITIVE(alien_signed_2);
PRIMITIVE(set_alien_signed_2);
PRIMITIVE(alien_unsigned_2);
PRIMITIVE(set_alien_unsigned_2);
PRIMITIVE(alien_signed_1);
PRIMITIVE(set_alien_signed_1);
PRIMITIVE(alien_unsigned_1);
PRIMITIVE(set_alien_unsigned_1);
PRIMITIVE(alien_float);
PRIMITIVE(set_alien_float);
PRIMITIVE(alien_double);
PRIMITIVE(set_alien_double);
PRIMITIVE(alien_cell);
PRIMITIVE(set_alien_cell);
PRIMITIVE(alien_address);
PRIMITIVE(set_slot);
PRIMITIVE(string_nth);
PRIMITIVE(set_string_nth_fast);
PRIMITIVE(set_string_nth_slow);
PRIMITIVE(resize_array);
PRIMITIVE(resize_string);
PRIMITIVE(array);
PRIMITIVE(begin_scan);
PRIMITIVE(next_object);
PRIMITIVE(end_scan);
PRIMITIVE(size);
PRIMITIVE(die);
PRIMITIVE(fopen);
PRIMITIVE(fgetc);
PRIMITIVE(fread);
PRIMITIVE(fputc);
PRIMITIVE(fwrite);
PRIMITIVE(fflush);
PRIMITIVE(fseek);
PRIMITIVE(fclose);
PRIMITIVE(wrapper);
PRIMITIVE(clone);
PRIMITIVE(string);
PRIMITIVE(array_to_quotation);
PRIMITIVE(quotation_xt);
PRIMITIVE(tuple);
PRIMITIVE(profiling);
PRIMITIVE(become);
PRIMITIVE(sleep);
PRIMITIVE(tuple_boa);
PRIMITIVE(callstack_to_array);
PRIMITIVE(innermost_stack_frame_executing);
PRIMITIVE(innermost_stack_frame_scan);
PRIMITIVE(set_innermost_stack_frame_quot);
PRIMITIVE(call_clear);
PRIMITIVE(resize_byte_array);
PRIMITIVE(dll_validp);
PRIMITIVE(unimplemented);
PRIMITIVE(clear_gc_stats);
PRIMITIVE(jit_compile);
PRIMITIVE(load_locals);
PRIMITIVE(check_datastack);
PRIMITIVE(inline_cache_miss);
PRIMITIVE(inline_cache_miss_tail);
PRIMITIVE(mega_cache_miss);
PRIMITIVE(lookup_method);
PRIMITIVE(reset_dispatch_stats);
PRIMITIVE(dispatch_stats);
PRIMITIVE(reset_inline_cache_stats);
PRIMITIVE(inline_cache_stats);
PRIMITIVE(optimized_p);
PRIMITIVE(quot_compiled_p);
PRIMITIVE(vm_ptr);
} }

4
vm/profiler.cpp
View File

@ -47,11 +47,9 @@ void factor_vm::set_profiling(bool profiling)
iterate_code_heap(factor::relocate_code_block); iterate_code_heap(factor::relocate_code_block);
} }
inline void factor_vm::primitive_profiling() void factor_vm::primitive_profiling()
{ {
set_profiling(to_boolean(dpop())); set_profiling(to_boolean(dpop()));
} }
PRIMITIVE_FORWARD(profiling)
} }

2
vm/profiler.hpp
View File

@ -1,6 +1,4 @@
namespace factor namespace factor
{ {
PRIMITIVE(profiling);
} }

16
vm/quotations.cpp
View File

@ -290,15 +290,13 @@ void factor_vm::jit_compile(cell quot_, bool relocating)
if(relocating) relocate_code_block(compiled); if(relocating) relocate_code_block(compiled);
} }
inline void factor_vm::primitive_jit_compile() void factor_vm::primitive_jit_compile()
{ {
jit_compile(dpop(),true); jit_compile(dpop(),true);
} }
PRIMITIVE_FORWARD(jit_compile)
/* push a new quotation on the stack */ /* push a new quotation on the stack */
inline void factor_vm::primitive_array_to_quotation() void factor_vm::primitive_array_to_quotation()
{ {
quotation *quot = allot<quotation>(sizeof(quotation)); quotation *quot = allot<quotation>(sizeof(quotation));
quot->array = dpeek(); quot->array = dpeek();
@ -309,16 +307,12 @@ inline void factor_vm::primitive_array_to_quotation()
drepl(tag<quotation>(quot)); drepl(tag<quotation>(quot));
} }
PRIMITIVE_FORWARD(array_to_quotation) void factor_vm::primitive_quotation_xt()
inline void factor_vm::primitive_quotation_xt()
{ {
quotation *quot = untag_check<quotation>(dpeek()); quotation *quot = untag_check<quotation>(dpeek());
drepl(allot_cell((cell)quot->xt)); drepl(allot_cell((cell)quot->xt));
} }
PRIMITIVE_FORWARD(quotation_xt)
void factor_vm::compile_all_words() void factor_vm::compile_all_words()
{ {
gc_root<array> words(find_all_words(),this); gc_root<array> words(find_all_words(),this);
@ -366,13 +360,11 @@ VM_ASM_API cell lazy_jit_compile_impl(cell quot_, stack_frame *stack, factor_vm
return VM_PTR->lazy_jit_compile_impl(quot_,stack); return VM_PTR->lazy_jit_compile_impl(quot_,stack);
} }
inline void factor_vm::primitive_quot_compiled_p() void factor_vm::primitive_quot_compiled_p()
{ {
tagged<quotation> quot(dpop()); tagged<quotation> quot(dpop());
quot.untag_check(this); quot.untag_check(this);
dpush(tag_boolean(quot->code != NULL)); dpush(tag_boolean(quot->code != NULL));
} }
PRIMITIVE_FORWARD(quot_compiled_p)
} }

6
vm/quotations.hpp
View File

@ -23,13 +23,7 @@ struct quotation_jit : public jit {
void iterate_quotation(); void iterate_quotation();
}; };
PRIMITIVE(jit_compile);
PRIMITIVE(array_to_quotation);
PRIMITIVE(quotation_xt);
VM_ASM_API cell lazy_jit_compile_impl(cell quot, stack_frame *stack, factor_vm *myvm); VM_ASM_API cell lazy_jit_compile_impl(cell quot, stack_frame *stack, factor_vm *myvm);
PRIMITIVE(quot_compiled_p);
} }

32
vm/run.cpp
View File

@ -3,45 +3,35 @@
namespace factor namespace factor
{ {
inline void factor_vm::primitive_getenv() void factor_vm::primitive_getenv()
{ {
fixnum e = untag_fixnum(dpeek()); fixnum e = untag_fixnum(dpeek());
drepl(userenv[e]); drepl(userenv[e]);
} }
PRIMITIVE_FORWARD(getenv) void factor_vm::primitive_setenv()
inline void factor_vm::primitive_setenv()
{ {
fixnum e = untag_fixnum(dpop()); fixnum e = untag_fixnum(dpop());
cell value = dpop(); cell value = dpop();
userenv[e] = value; userenv[e] = value;
} }
PRIMITIVE_FORWARD(setenv) void factor_vm::primitive_exit()
inline void factor_vm::primitive_exit()
{ {
exit(to_fixnum(dpop())); exit(to_fixnum(dpop()));
} }
PRIMITIVE_FORWARD(exit) void factor_vm::primitive_micros()
inline void factor_vm::primitive_micros()
{ {
box_unsigned_8(current_micros()); box_unsigned_8(current_micros());
} }
PRIMITIVE_FORWARD(micros) void factor_vm::primitive_sleep()
inline void factor_vm::primitive_sleep()
{ {
sleep_micros(to_cell(dpop())); sleep_micros(to_cell(dpop()));
} }
PRIMITIVE_FORWARD(sleep) void factor_vm::primitive_set_slot()
inline void factor_vm::primitive_set_slot()
{ {
fixnum slot = untag_fixnum(dpop()); fixnum slot = untag_fixnum(dpop());
object *obj = untag<object>(dpop()); object *obj = untag<object>(dpop());
@ -51,9 +41,7 @@ inline void factor_vm::primitive_set_slot()
write_barrier(obj); write_barrier(obj);
} }
PRIMITIVE_FORWARD(set_slot) void factor_vm::primitive_load_locals()
inline void factor_vm::primitive_load_locals()
{ {
fixnum count = untag_fixnum(dpop()); fixnum count = untag_fixnum(dpop());
memcpy((cell *)(rs + sizeof(cell)),(cell *)(ds - sizeof(cell) * (count - 1)),sizeof(cell) * count); memcpy((cell *)(rs + sizeof(cell)),(cell *)(ds - sizeof(cell) * (count - 1)),sizeof(cell) * count);
@ -61,8 +49,6 @@ inline void factor_vm::primitive_load_locals()
rs += sizeof(cell) * count; rs += sizeof(cell) * count;
} }
PRIMITIVE_FORWARD(load_locals)
cell factor_vm::clone_object(cell obj_) cell factor_vm::clone_object(cell obj_)
{ {
gc_root<object> obj(obj_,this); gc_root<object> obj(obj_,this);
@ -78,11 +64,9 @@ cell factor_vm::clone_object(cell obj_)
} }
} }
inline void factor_vm::primitive_clone() void factor_vm::primitive_clone()
{ {
drepl(clone_object(dpeek())); drepl(clone_object(dpeek()));
} }
PRIMITIVE_FORWARD(clone)
} }

9
vm/run.hpp
View File

@ -99,15 +99,6 @@ inline static bool save_env_p(cell i)
return (i >= FIRST_SAVE_ENV && i <= LAST_SAVE_ENV) || i == STACK_TRACES_ENV; return (i >= FIRST_SAVE_ENV && i <= LAST_SAVE_ENV) || i == STACK_TRACES_ENV;
} }
PRIMITIVE(getenv);
PRIMITIVE(setenv);
PRIMITIVE(exit);
PRIMITIVE(micros);
PRIMITIVE(sleep);
PRIMITIVE(set_slot);
PRIMITIVE(load_locals);
PRIMITIVE(clone);
} }

20
vm/strings.cpp
View File

@ -99,15 +99,13 @@ string *factor_vm::allot_string(cell capacity, cell fill)
return str.untagged(); return str.untagged();
} }
inline void factor_vm::primitive_string() void factor_vm::primitive_string()
{ {
cell initial = to_cell(dpop()); cell initial = to_cell(dpop());
cell length = unbox_array_size(); cell length = unbox_array_size();
dpush(tag<string>(allot_string(length,initial))); dpush(tag<string>(allot_string(length,initial)));
} }
PRIMITIVE_FORWARD(string)
bool factor_vm::reallot_string_in_place_p(string *str, cell capacity) bool factor_vm::reallot_string_in_place_p(string *str, cell capacity)
{ {
return in_zone(&nursery,str) return in_zone(&nursery,str)
@ -157,25 +155,21 @@ string* factor_vm::reallot_string(string *str_, cell capacity)
} }
} }
inline void factor_vm::primitive_resize_string() void factor_vm::primitive_resize_string()
{ {
string* str = untag_check<string>(dpop()); string* str = untag_check<string>(dpop());
cell capacity = unbox_array_size(); cell capacity = unbox_array_size();
dpush(tag<string>(reallot_string(str,capacity))); dpush(tag<string>(reallot_string(str,capacity)));
} }
PRIMITIVE_FORWARD(resize_string) void factor_vm::primitive_string_nth()
inline void factor_vm::primitive_string_nth()
{ {
string *str = untag<string>(dpop()); string *str = untag<string>(dpop());
cell index = untag_fixnum(dpop()); cell index = untag_fixnum(dpop());
dpush(tag_fixnum(string_nth(str,index))); dpush(tag_fixnum(string_nth(str,index)));
} }
PRIMITIVE_FORWARD(string_nth) void factor_vm::primitive_set_string_nth_fast()
inline void factor_vm::primitive_set_string_nth_fast()
{ {
string *str = untag<string>(dpop()); string *str = untag<string>(dpop());
cell index = untag_fixnum(dpop()); cell index = untag_fixnum(dpop());
@ -183,9 +177,7 @@ inline void factor_vm::primitive_set_string_nth_fast()
set_string_nth_fast(str,index,value); set_string_nth_fast(str,index,value);
} }
PRIMITIVE_FORWARD(set_string_nth_fast) void factor_vm::primitive_set_string_nth_slow()
inline void factor_vm::primitive_set_string_nth_slow()
{ {
string *str = untag<string>(dpop()); string *str = untag<string>(dpop());
cell index = untag_fixnum(dpop()); cell index = untag_fixnum(dpop());
@ -193,6 +185,4 @@ inline void factor_vm::primitive_set_string_nth_slow()
set_string_nth_slow(str,index,value); set_string_nth_slow(str,index,value);
} }
PRIMITIVE_FORWARD(set_string_nth_slow)
} }

6
vm/strings.hpp
View File

@ -11,11 +11,5 @@ inline static cell string_size(cell size)
return sizeof(string) + size; return sizeof(string) + size;
} }
PRIMITIVE(string);
PRIMITIVE(resize_string);
PRIMITIVE(string_nth);
PRIMITIVE(set_string_nth_slow);
PRIMITIVE(set_string_nth_fast);
} }

8
vm/tuples.cpp
View File

@ -12,7 +12,7 @@ tuple *factor_vm::allot_tuple(cell layout_)
return t.untagged(); return t.untagged();
} }
inline void factor_vm::primitive_tuple() void factor_vm::primitive_tuple()
{ {
gc_root<tuple_layout> layout(dpop(),this); gc_root<tuple_layout> layout(dpop(),this);
tuple *t = allot_tuple(layout.value()); tuple *t = allot_tuple(layout.value());
@ -23,10 +23,8 @@ inline void factor_vm::primitive_tuple()
dpush(tag<tuple>(t)); dpush(tag<tuple>(t));
} }
PRIMITIVE_FORWARD(tuple)
/* push a new tuple on the stack, filling its slots from the stack */ /* push a new tuple on the stack, filling its slots from the stack */
inline void factor_vm::primitive_tuple_boa() void factor_vm::primitive_tuple_boa()
{ {
gc_root<tuple_layout> layout(dpop(),this); gc_root<tuple_layout> layout(dpop(),this);
gc_root<tuple> t(allot_tuple(layout.value()),this); gc_root<tuple> t(allot_tuple(layout.value()),this);
@ -36,6 +34,4 @@ inline void factor_vm::primitive_tuple_boa()
dpush(t.value()); dpush(t.value());
} }
PRIMITIVE_FORWARD(tuple_boa)
} }

4
vm/tuples.hpp
View File

@ -7,8 +7,4 @@ inline static cell tuple_size(tuple_layout *layout)
return sizeof(tuple) + size * sizeof(cell); return sizeof(tuple) + size * sizeof(cell);
} }
PRIMITIVE(tuple);
PRIMITIVE(tuple_boa);
PRIMITIVE(tuple_layout);
} }

244
vm/vm.hpp
View File

@ -17,28 +17,28 @@ struct factor_vm : factor_vm_data {
void init_stacks(cell ds_size_, cell rs_size_); void init_stacks(cell ds_size_, cell rs_size_);
bool stack_to_array(cell bottom, cell top); bool stack_to_array(cell bottom, cell top);
cell array_to_stack(array *array, cell bottom); cell array_to_stack(array *array, cell bottom);
inline void primitive_datastack(); void primitive_datastack();
inline void primitive_retainstack(); void primitive_retainstack();
inline void primitive_set_datastack(); void primitive_set_datastack();
inline void primitive_set_retainstack(); void primitive_set_retainstack();
inline void primitive_check_datastack(); void primitive_check_datastack();
// run // run
inline void primitive_getenv(); void primitive_getenv();
inline void primitive_setenv(); void primitive_setenv();
inline void primitive_exit(); void primitive_exit();
inline void primitive_micros(); void primitive_micros();
inline void primitive_sleep(); void primitive_sleep();
inline void primitive_set_slot(); void primitive_set_slot();
inline void primitive_load_locals(); void primitive_load_locals();
cell clone_object(cell obj_); cell clone_object(cell obj_);
inline void primitive_clone(); void primitive_clone();
// profiler // profiler
void init_profiler(); void init_profiler();
code_block *compile_profiling_stub(cell word_); code_block *compile_profiling_stub(cell word_);
void set_profiling(bool profiling); void set_profiling(bool profiling);
inline void primitive_profiling(); void primitive_profiling();
// errors // errors
void out_of_memory(); void out_of_memory();
@ -50,8 +50,8 @@ struct factor_vm : factor_vm_data {
void signal_error(int signal, stack_frame *native_stack); void signal_error(int signal, stack_frame *native_stack);
void divide_by_zero_error(); void divide_by_zero_error();
void fp_trap_error(unsigned int fpu_status, stack_frame *signal_callstack_top); void fp_trap_error(unsigned int fpu_status, stack_frame *signal_callstack_top);
inline void primitive_call_clear(); void primitive_call_clear();
inline void primitive_unimplemented(); void primitive_unimplemented();
void memory_signal_handler_impl(); void memory_signal_handler_impl();
void misc_signal_handler_impl(); void misc_signal_handler_impl();
void fp_signal_handler_impl(); void fp_signal_handler_impl();
@ -135,15 +135,15 @@ struct factor_vm : factor_vm_data {
void init_data_heap(cell gens,cell young_size,cell aging_size,cell tenured_size,bool secure_gc_); void init_data_heap(cell gens,cell young_size,cell aging_size,cell tenured_size,bool secure_gc_);
cell untagged_object_size(object *pointer); cell untagged_object_size(object *pointer);
cell unaligned_object_size(object *pointer); cell unaligned_object_size(object *pointer);
inline void primitive_size(); void primitive_size();
cell binary_payload_start(object *pointer); cell binary_payload_start(object *pointer);
inline void primitive_data_room(); void primitive_data_room();
void begin_scan(); void begin_scan();
void end_scan(); void end_scan();
inline void primitive_begin_scan(); void primitive_begin_scan();
cell next_object(); cell next_object();
inline void primitive_next_object(); void primitive_next_object();
inline void primitive_end_scan(); void primitive_end_scan();
template<typename T> void each_object(T &functor); template<typename T> void each_object(T &functor);
cell find_all_words(); cell find_all_words();
cell object_size(cell tagged); cell object_size(cell tagged);
@ -185,10 +185,10 @@ struct factor_vm : factor_vm_data {
void end_gc(cell gc_elapsed); void end_gc(cell gc_elapsed);
void garbage_collection(cell gen,bool growing_data_heap_,cell requested_bytes); void garbage_collection(cell gen,bool growing_data_heap_,cell requested_bytes);
void gc(); void gc();
inline void primitive_gc(); void primitive_gc();
inline void primitive_gc_stats(); void primitive_gc_stats();
void clear_gc_stats(); void clear_gc_stats();
inline void primitive_become(); void primitive_become();
void inline_gc(cell *gc_roots_base, cell gc_roots_size); void inline_gc(cell *gc_roots_base, cell gc_roots_size);
inline bool collecting_accumulation_gen_p(); inline bool collecting_accumulation_gen_p();
inline object *allot_zone(zone *z, cell a); inline object *allot_zone(zone *z, cell a);
@ -196,7 +196,7 @@ struct factor_vm : factor_vm_data {
template <typename TYPE> TYPE *allot(cell size); template <typename TYPE> TYPE *allot(cell size);
inline void check_data_pointer(object *pointer); inline void check_data_pointer(object *pointer);
inline void check_tagged_pointer(cell tagged); inline void check_tagged_pointer(cell tagged);
inline void primitive_clear_gc_stats(); void primitive_clear_gc_stats();
// generic arrays // generic arrays
template <typename T> T *allot_array_internal(cell capacity); template <typename T> T *allot_array_internal(cell capacity);
@ -225,15 +225,15 @@ struct factor_vm : factor_vm_data {
void find_data_references(cell look_for_); void find_data_references(cell look_for_);
void dump_code_heap(); void dump_code_heap();
void factorbug(); void factorbug();
inline void primitive_die(); void primitive_die();
//arrays //arrays
array *allot_array(cell capacity, cell fill_); array *allot_array(cell capacity, cell fill_);
inline void primitive_array(); void primitive_array();
cell allot_array_1(cell obj_); cell allot_array_1(cell obj_);
cell allot_array_2(cell v1_, cell v2_); cell allot_array_2(cell v1_, cell v2_);
cell allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_); cell allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_);
inline void primitive_resize_array(); void primitive_resize_array();
inline void set_array_nth(array *array, cell slot, cell value); inline void set_array_nth(array *array, cell slot, cell value);
//strings //strings
@ -244,13 +244,13 @@ struct factor_vm : factor_vm_data {
string *allot_string_internal(cell capacity); string *allot_string_internal(cell capacity);
void fill_string(string *str_, cell start, cell capacity, cell fill); void fill_string(string *str_, cell start, cell capacity, cell fill);
string *allot_string(cell capacity, cell fill); string *allot_string(cell capacity, cell fill);
inline void primitive_string(); void primitive_string();
bool reallot_string_in_place_p(string *str, cell capacity); bool reallot_string_in_place_p(string *str, cell capacity);
string* reallot_string(string *str_, cell capacity); string* reallot_string(string *str_, cell capacity);
inline void primitive_resize_string(); void primitive_resize_string();
inline void primitive_string_nth(); void primitive_string_nth();
inline void primitive_set_string_nth_fast(); void primitive_set_string_nth_fast();
inline void primitive_set_string_nth_slow(); void primitive_set_string_nth_slow();
//booleans //booleans
void box_boolean(bool value); void box_boolean(bool value);
@ -259,28 +259,28 @@ struct factor_vm : factor_vm_data {
//byte arrays //byte arrays
byte_array *allot_byte_array(cell size); byte_array *allot_byte_array(cell size);
inline void primitive_byte_array(); void primitive_byte_array();
inline void primitive_uninitialized_byte_array(); void primitive_uninitialized_byte_array();
inline void primitive_resize_byte_array(); void primitive_resize_byte_array();
//tuples //tuples
tuple *allot_tuple(cell layout_); tuple *allot_tuple(cell layout_);
inline void primitive_tuple(); void primitive_tuple();
inline void primitive_tuple_boa(); void primitive_tuple_boa();
//words //words
word *allot_word(cell name_, cell vocab_, cell hashcode_); word *allot_word(cell name_, cell vocab_, cell hashcode_);
inline void primitive_word(); void primitive_word();
inline void primitive_word_xt(); void primitive_word_xt();
void update_word_xt(cell w_); void update_word_xt(cell w_);
inline void primitive_optimized_p(); void primitive_optimized_p();
inline void primitive_wrapper(); void primitive_wrapper();
//math //math
inline void primitive_bignum_to_fixnum(); void primitive_bignum_to_fixnum();
inline void primitive_float_to_fixnum(); void primitive_float_to_fixnum();
inline void primitive_fixnum_divint(); void primitive_fixnum_divint();
inline void primitive_fixnum_divmod(); void primitive_fixnum_divmod();
bignum *fixnum_to_bignum(fixnum); bignum *fixnum_to_bignum(fixnum);
bignum *cell_to_bignum(cell); bignum *cell_to_bignum(cell);
bignum *long_long_to_bignum(s64 n); bignum *long_long_to_bignum(s64 n);
@ -288,48 +288,48 @@ struct factor_vm : factor_vm_data {
inline fixnum sign_mask(fixnum x); inline fixnum sign_mask(fixnum x);
inline fixnum branchless_max(fixnum x, fixnum y); inline fixnum branchless_max(fixnum x, fixnum y);
inline fixnum branchless_abs(fixnum x); inline fixnum branchless_abs(fixnum x);
inline void primitive_fixnum_shift(); void primitive_fixnum_shift();
inline void primitive_fixnum_to_bignum(); void primitive_fixnum_to_bignum();
inline void primitive_float_to_bignum(); void primitive_float_to_bignum();
inline void primitive_bignum_eq(); void primitive_bignum_eq();
inline void primitive_bignum_add(); void primitive_bignum_add();
inline void primitive_bignum_subtract(); void primitive_bignum_subtract();
inline void primitive_bignum_multiply(); void primitive_bignum_multiply();
inline void primitive_bignum_divint(); void primitive_bignum_divint();
inline void primitive_bignum_divmod(); void primitive_bignum_divmod();
inline void primitive_bignum_mod(); void primitive_bignum_mod();
inline void primitive_bignum_and(); void primitive_bignum_and();
inline void primitive_bignum_or(); void primitive_bignum_or();
inline void primitive_bignum_xor(); void primitive_bignum_xor();
inline void primitive_bignum_shift(); void primitive_bignum_shift();
inline void primitive_bignum_less(); void primitive_bignum_less();
inline void primitive_bignum_lesseq(); void primitive_bignum_lesseq();
inline void primitive_bignum_greater(); void primitive_bignum_greater();
inline void primitive_bignum_greatereq(); void primitive_bignum_greatereq();
inline void primitive_bignum_not(); void primitive_bignum_not();
inline void primitive_bignum_bitp(); void primitive_bignum_bitp();
inline void primitive_bignum_log2(); void primitive_bignum_log2();
unsigned int bignum_producer(unsigned int digit); unsigned int bignum_producer(unsigned int digit);
inline void primitive_byte_array_to_bignum(); void primitive_byte_array_to_bignum();
cell unbox_array_size(); cell unbox_array_size();
inline void primitive_fixnum_to_float(); void primitive_fixnum_to_float();
inline void primitive_bignum_to_float(); void primitive_bignum_to_float();
inline void primitive_str_to_float(); void primitive_str_to_float();
inline void primitive_float_to_str(); void primitive_float_to_str();
inline void primitive_float_eq(); void primitive_float_eq();
inline void primitive_float_add(); void primitive_float_add();
inline void primitive_float_subtract(); void primitive_float_subtract();
inline void primitive_float_multiply(); void primitive_float_multiply();
inline void primitive_float_divfloat(); void primitive_float_divfloat();
inline void primitive_float_mod(); void primitive_float_mod();
inline void primitive_float_less(); void primitive_float_less();
inline void primitive_float_lesseq(); void primitive_float_lesseq();
inline void primitive_float_greater(); void primitive_float_greater();
inline void primitive_float_greatereq(); void primitive_float_greatereq();
inline void primitive_float_bits(); void primitive_float_bits();
inline void primitive_bits_float(); void primitive_bits_float();
inline void primitive_double_bits(); void primitive_double_bits();
inline void primitive_bits_double(); void primitive_bits_double();
fixnum to_fixnum(cell tagged); fixnum to_fixnum(cell tagged);
cell to_cell(cell tagged); cell to_cell(cell tagged);
void box_signed_1(s8 n); void box_signed_1(s8 n);
@ -366,14 +366,14 @@ struct factor_vm : factor_vm_data {
//io //io
void init_c_io(); void init_c_io();
void io_error(); void io_error();
inline void primitive_fopen(); void primitive_fopen();
inline void primitive_fgetc(); void primitive_fgetc();
inline void primitive_fread(); void primitive_fread();
inline void primitive_fputc(); void primitive_fputc();
inline void primitive_fwrite(); void primitive_fwrite();
inline void primitive_fseek(); void primitive_fseek();
inline void primitive_fflush(); void primitive_fflush();
inline void primitive_fclose(); void primitive_fclose();
//code_block //code_block
relocation_type relocation_type_of(relocation_entry r); relocation_type relocation_type_of(relocation_entry r);
@ -420,8 +420,8 @@ struct factor_vm : factor_vm_data {
void iterate_code_heap(code_heap_iterator iter); void iterate_code_heap(code_heap_iterator iter);
void copy_code_heap_roots(); void copy_code_heap_roots();
void update_code_heap_words(); void update_code_heap_words();
inline void primitive_modify_code_heap(); void primitive_modify_code_heap();
inline void primitive_code_room(); void primitive_code_room();
code_block *forward_xt(code_block *compiled); code_block *forward_xt(code_block *compiled);
void forward_frame_xt(stack_frame *frame); void forward_frame_xt(stack_frame *frame);
void forward_object_xts(); void forward_object_xts();
@ -434,8 +434,8 @@ struct factor_vm : factor_vm_data {
void load_data_heap(FILE *file, image_header *h, vm_parameters *p); void load_data_heap(FILE *file, image_header *h, vm_parameters *p);
void load_code_heap(FILE *file, image_header *h, vm_parameters *p); void load_code_heap(FILE *file, image_header *h, vm_parameters *p);
bool save_image(const vm_char *filename); bool save_image(const vm_char *filename);
inline void primitive_save_image(); void primitive_save_image();
inline void primitive_save_image_and_exit(); void primitive_save_image_and_exit();
void data_fixup(cell *cell); void data_fixup(cell *cell);
template <typename T> void code_fixup(T **handle); template <typename T> void code_fixup(T **handle);
void fixup_word(word *word); void fixup_word(word *word);
@ -455,19 +455,19 @@ struct factor_vm : factor_vm_data {
callstack *allot_callstack(cell size); callstack *allot_callstack(cell size);
stack_frame *fix_callstack_top(stack_frame *top, stack_frame *bottom); stack_frame *fix_callstack_top(stack_frame *top, stack_frame *bottom);
stack_frame *capture_start(); stack_frame *capture_start();
inline void primitive_callstack(); void primitive_callstack();
inline void primitive_set_callstack(); void primitive_set_callstack();
code_block *frame_code(stack_frame *frame); code_block *frame_code(stack_frame *frame);
cell frame_type(stack_frame *frame); cell frame_type(stack_frame *frame);
cell frame_executing(stack_frame *frame); cell frame_executing(stack_frame *frame);
stack_frame *frame_successor(stack_frame *frame); stack_frame *frame_successor(stack_frame *frame);
cell frame_scan(stack_frame *frame); cell frame_scan(stack_frame *frame);
inline void primitive_callstack_to_array(); void primitive_callstack_to_array();
stack_frame *innermost_stack_frame(callstack *stack); stack_frame *innermost_stack_frame(callstack *stack);
stack_frame *innermost_stack_frame_quot(callstack *callstack); stack_frame *innermost_stack_frame_quot(callstack *callstack);
inline void primitive_innermost_stack_frame_executing(); void primitive_innermost_stack_frame_executing();
inline void primitive_innermost_stack_frame_scan(); void primitive_innermost_stack_frame_scan();
inline void primitive_set_innermost_stack_frame_quot(); void primitive_set_innermost_stack_frame_quot();
void save_callstack_bottom(stack_frame *callstack_bottom); void save_callstack_bottom(stack_frame *callstack_bottom);
template<typename T> void iterate_callstack(cell top, cell bottom, T &iterator); template<typename T> void iterate_callstack(cell top, cell bottom, T &iterator);
inline void do_slots(cell obj, void (* iter)(cell *,factor_vm*)); inline void do_slots(cell obj, void (* iter)(cell *,factor_vm*));
@ -475,14 +475,14 @@ struct factor_vm : factor_vm_data {
//alien //alien
char *pinned_alien_offset(cell obj); char *pinned_alien_offset(cell obj);
cell allot_alien(cell delegate_, cell displacement); cell allot_alien(cell delegate_, cell displacement);
inline void primitive_displaced_alien(); void primitive_displaced_alien();
inline void primitive_alien_address(); void primitive_alien_address();
void *alien_pointer(); void *alien_pointer();
inline void primitive_dlopen(); void primitive_dlopen();
inline void primitive_dlsym(); void primitive_dlsym();
inline void primitive_dlclose(); void primitive_dlclose();
inline void primitive_dll_validp(); void primitive_dll_validp();
inline void primitive_vm_ptr(); void primitive_vm_ptr();
char *alien_offset(cell obj); char *alien_offset(cell obj);
char *unbox_alien(); char *unbox_alien();
void box_alien(void *ptr); void box_alien(void *ptr);
@ -492,15 +492,15 @@ struct factor_vm : factor_vm_data {
void box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size); void box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size);
//quotations //quotations
inline void primitive_jit_compile(); void primitive_jit_compile();
inline void primitive_array_to_quotation(); void primitive_array_to_quotation();
inline void primitive_quotation_xt(); void primitive_quotation_xt();
void set_quot_xt(quotation *quot, code_block *code); void set_quot_xt(quotation *quot, code_block *code);
void jit_compile(cell quot_, bool relocating); void jit_compile(cell quot_, bool relocating);
void compile_all_words(); void compile_all_words();
fixnum quot_code_offset_to_scan(cell quot_, cell offset); fixnum quot_code_offset_to_scan(cell quot_, cell offset);
cell lazy_jit_compile_impl(cell quot_, stack_frame *stack); cell lazy_jit_compile_impl(cell quot_, stack_frame *stack);
inline void primitive_quot_compiled_p(); void primitive_quot_compiled_p();
//dispatch //dispatch
cell search_lookup_alist(cell table, cell klass); cell search_lookup_alist(cell table, cell klass);
@ -511,13 +511,13 @@ struct factor_vm : factor_vm_data {
cell lookup_hi_tag_method(cell obj, cell methods); cell lookup_hi_tag_method(cell obj, cell methods);
cell lookup_hairy_method(cell obj, cell methods); cell lookup_hairy_method(cell obj, cell methods);
cell lookup_method(cell obj, cell methods); cell lookup_method(cell obj, cell methods);
inline void primitive_lookup_method(); void primitive_lookup_method();
cell object_class(cell obj); cell object_class(cell obj);
cell method_cache_hashcode(cell klass, array *array); cell method_cache_hashcode(cell klass, array *array);
void update_method_cache(cell cache, cell klass, cell method); void update_method_cache(cell cache, cell klass, cell method);
inline void primitive_mega_cache_miss(); void primitive_mega_cache_miss();
inline void primitive_reset_dispatch_stats(); void primitive_reset_dispatch_stats();
inline void primitive_dispatch_stats(); void primitive_dispatch_stats();
//inline cache //inline cache
void init_inline_caching(int max_size); void init_inline_caching(int max_size);
@ -530,8 +530,8 @@ struct factor_vm : factor_vm_data {
cell add_inline_cache_entry(cell cache_entries_, cell klass_, cell method_); cell add_inline_cache_entry(cell cache_entries_, cell klass_, cell method_);
void update_pic_transitions(cell pic_size); void update_pic_transitions(cell pic_size);
void *inline_cache_miss(cell return_address); void *inline_cache_miss(cell return_address);
inline void primitive_reset_inline_cache_stats(); void primitive_reset_inline_cache_stats();
inline void primitive_inline_cache_stats(); void primitive_inline_cache_stats();
//factor //factor
void default_parameters(vm_parameters *p); void default_parameters(vm_parameters *p);
@ -549,7 +549,7 @@ struct factor_vm : factor_vm_data {
void factor_sleep(long us); void factor_sleep(long us);
// os-* // os-*
inline void primitive_existsp(); void primitive_existsp();
void init_ffi(); void init_ffi();
void ffi_dlopen(dll *dll); void ffi_dlopen(dll *dll);
void *ffi_dlsym(dll *dll, symbol_char *symbol); void *ffi_dlsym(dll *dll, symbol_char *symbol);

16
vm/words.cpp
View File

@ -32,7 +32,7 @@ word *factor_vm::allot_word(cell name_, cell vocab_, cell hashcode_)
} }
/* (word) ( name vocabulary hashcode -- word ) */ /* (word) ( name vocabulary hashcode -- word ) */
inline void factor_vm::primitive_word() void factor_vm::primitive_word()
{ {
cell hashcode = dpop(); cell hashcode = dpop();
cell vocab = dpop(); cell vocab = dpop();
@ -40,10 +40,8 @@ inline void factor_vm::primitive_word()
dpush(tag<word>(allot_word(name,vocab,hashcode))); dpush(tag<word>(allot_word(name,vocab,hashcode)));
} }
PRIMITIVE_FORWARD(word)
/* word-xt ( word -- start end ) */ /* word-xt ( word -- start end ) */
inline void factor_vm::primitive_word_xt() void factor_vm::primitive_word_xt()
{ {
gc_root<word> w(dpop(),this); gc_root<word> w(dpop(),this);
w.untag_check(this); w.untag_check(this);
@ -60,8 +58,6 @@ inline void factor_vm::primitive_word_xt()
} }
} }
PRIMITIVE_FORWARD(word_xt)
/* Allocates memory */ /* Allocates memory */
void factor_vm::update_word_xt(cell w_) void factor_vm::update_word_xt(cell w_)
{ {
@ -84,20 +80,16 @@ void factor_vm::update_word_xt(cell w_)
w->xt = w->code->xt(); w->xt = w->code->xt();
} }
inline void factor_vm::primitive_optimized_p() void factor_vm::primitive_optimized_p()
{ {
drepl(tag_boolean(word_optimized_p(untag_check<word>(dpeek())))); drepl(tag_boolean(word_optimized_p(untag_check<word>(dpeek()))));
} }
PRIMITIVE_FORWARD(optimized_p) void factor_vm::primitive_wrapper()
inline void factor_vm::primitive_wrapper()
{ {
wrapper *new_wrapper = allot<wrapper>(sizeof(wrapper)); wrapper *new_wrapper = allot<wrapper>(sizeof(wrapper));
new_wrapper->object = dpeek(); new_wrapper->object = dpeek();
drepl(tag<wrapper>(new_wrapper)); drepl(tag<wrapper>(new_wrapper));
} }
PRIMITIVE_FORWARD(wrapper)
} }

6
vm/words.hpp
View File

@ -1,15 +1,9 @@
namespace factor namespace factor
{ {
PRIMITIVE(word);
PRIMITIVE(word_xt);
inline bool word_optimized_p(word *word) inline bool word_optimized_p(word *word)
{ {
return word->code->type == WORD_TYPE; return word->code->type == WORD_TYPE;
} }
PRIMITIVE(optimized_p);
PRIMITIVE(wrapper);
} }