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 */
inline void factor_vm::primitive_displaced_alien()
void factor_vm::primitive_displaced_alien()
{
cell alien = 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
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()));
}
PRIMITIVE_FORWARD(alien_address)
/* pop ( alien n ) from datastack, return alien's address plus n */
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)
/* 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);
path.untag_check(this);
@ -125,10 +121,8 @@ inline void factor_vm::primitive_dlopen()
dpush(library.value());
}
PRIMITIVE_FORWARD(dlopen)
/* 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<byte_array> name(dpop(),this);
@ -149,19 +143,15 @@ inline void factor_vm::primitive_dlsym()
}
}
PRIMITIVE_FORWARD(dlsym)
/* close a native library handle */
inline void factor_vm::primitive_dlclose()
void factor_vm::primitive_dlclose()
{
dll *d = untag_check<dll>(dpop());
if(d->dll != NULL)
ffi_dlclose(d);
}
PRIMITIVE_FORWARD(dlclose)
inline void factor_vm::primitive_dll_validp()
void factor_vm::primitive_dll_validp()
{
cell library = dpop();
if(library == F)
@ -170,8 +160,6 @@ inline void factor_vm::primitive_dll_validp()
dpush(untag_check<dll>(library)->dll == NULL ? F : T);
}
PRIMITIVE_FORWARD(dll_validp)
/* gets the address of an object representing a C pointer */
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);
}
inline void factor_vm::primitive_vm_ptr()
void factor_vm::primitive_vm_ptr()
{
box_alien(this);
}
PRIMITIVE_FORWARD(vm_ptr)
}

37
vm/alien.hpp
View File

@ -1,43 +1,6 @@
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 *unbox_alien(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 */
inline void factor_vm::primitive_array()
void factor_vm::primitive_array()
{
cell initial = dpop();
cell size = unbox_array_size();
dpush(tag<array>(allot_array(size,initial)));
}
PRIMITIVE_FORWARD(array)
cell factor_vm::allot_array_1(cell obj_)
{
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();
}
inline void factor_vm::primitive_resize_array()
void factor_vm::primitive_resize_array()
{
array* a = untag_check<array>(dpop());
cell capacity = unbox_array_size();
dpush(tag<array>(reallot_array(a,capacity)));
}
PRIMITIVE_FORWARD(resize_array)
void growable_array::add(cell elt_)
{
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];
}
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(ulong_long,u64,u64)
#define BIGNUM_TO_FOO(name,type,utype) \
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;
}
inline void factor_vm::primitive_byte_array()
void factor_vm::primitive_byte_array()
{
cell size = unbox_array_size();
dpush(tag<byte_array>(allot_byte_array(size)));
}
PRIMITIVE_FORWARD(byte_array)
inline void factor_vm::primitive_uninitialized_byte_array()
void factor_vm::primitive_uninitialized_byte_array()
{
cell size = unbox_array_size();
dpush(tag<byte_array>(allot_array_internal<byte_array>(size)));
}
PRIMITIVE_FORWARD(uninitialized_byte_array)
inline void factor_vm::primitive_resize_byte_array()
void factor_vm::primitive_resize_byte_array()
{
byte_array *array = untag_check<byte_array>(dpop());
cell capacity = unbox_array_size();
dpush(tag<byte_array>(reallot_array(array,capacity)));
}
PRIMITIVE_FORWARD(resize_byte_array)
void growable_byte_array::append_bytes(void *elts, cell len)
{
cell new_size = count + len;

4
vm/byte_arrays.hpp
View File

@ -1,8 +1,4 @@
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;
}
inline void factor_vm::primitive_callstack()
void factor_vm::primitive_callstack()
{
stack_frame *top = capture_start();
stack_frame *bottom = stack_chain->callstack_bottom;
@ -60,9 +60,7 @@ inline void factor_vm::primitive_callstack()
dpush(tag<callstack>(stack));
}
PRIMITIVE_FORWARD(callstack)
inline void factor_vm::primitive_set_callstack()
void factor_vm::primitive_set_callstack()
{
callstack *stack = untag_check<callstack>(dpop());
@ -75,8 +73,6 @@ inline void factor_vm::primitive_set_callstack()
critical_error("Bug in set_callstack()",0);
}
PRIMITIVE_FORWARD(set_callstack)
code_block *factor_vm::frame_code(stack_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);
@ -166,8 +162,6 @@ inline void factor_vm::primitive_callstack_to_array()
dpush(accum.frames.elements.value());
}
PRIMITIVE_FORWARD(callstack_to_array)
stack_frame *factor_vm::innermost_stack_frame(callstack *stack)
{
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.
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()))));
}
PRIMITIVE_FORWARD(innermost_stack_frame_executing)
inline void factor_vm::primitive_innermost_stack_frame_scan()
void factor_vm::primitive_innermost_stack_frame_scan()
{
dpush(frame_scan(innermost_stack_frame_quot(untag_check<callstack>(dpop()))));
}
PRIMITIVE_FORWARD(innermost_stack_frame_scan)
inline void factor_vm::primitive_set_innermost_stack_frame_quot()
void factor_vm::primitive_set_innermost_stack_frame_quot()
{
gc_root<callstack> callstack(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;
}
PRIMITIVE_FORWARD(set_innermost_stack_frame_quot)
/* called before entry into Factor code. */
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;
}
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);
}

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);
}
inline void factor_vm::primitive_modify_code_heap()
void factor_vm::primitive_modify_code_heap()
{
gc_root<array> alist(dpop(),this);
@ -106,10 +106,8 @@ inline void factor_vm::primitive_modify_code_heap()
update_code_heap_words();
}
PRIMITIVE_FORWARD(modify_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;
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));
}
PRIMITIVE_FORWARD(code_room)
code_block *factor_vm::forward_xt(code_block *compiled)
{
return (code_block *)forwarding[compiled];

3
vm/code_heap.hpp
View File

@ -4,7 +4,4 @@ namespace factor
struct factor_vm;
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))
general_error(ERROR_DS_UNDERFLOW,F,F,NULL);
}
PRIMITIVE_FORWARD(datastack)
inline void factor_vm::primitive_retainstack()
void factor_vm::primitive_retainstack()
{
if(!stack_to_array(rs_bot,rs))
general_error(ERROR_RS_UNDERFLOW,F,F,NULL);
}
PRIMITIVE_FORWARD(retainstack)
/* returns pointer to top of stack */
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);
}
inline void factor_vm::primitive_set_datastack()
void factor_vm::primitive_set_datastack()
{
ds = array_to_stack(untag_check<array>(dpop()),ds_bot);
}
PRIMITIVE_FORWARD(set_datastack)
inline void factor_vm::primitive_set_retainstack()
void factor_vm::primitive_set_retainstack()
{
rs = array_to_stack(untag_check<array>(dpop()),rs_bot);
}
PRIMITIVE_FORWARD(set_retainstack)
/* Used to implement call( */
inline void factor_vm::primitive_check_datastack()
void factor_vm::primitive_check_datastack()
{
fixnum out = 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(r,rs)
PRIMITIVE(datastack);
PRIMITIVE(retainstack);
PRIMITIVE(set_datastack);
PRIMITIVE(set_retainstack);
PRIMITIVE(check_datastack);
struct factor_vm;
VM_C_API void nest_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);
}
inline void factor_vm::primitive_gc()
void factor_vm::primitive_gc()
{
gc();
}
PRIMITIVE_FORWARD(gc)
inline void factor_vm::primitive_gc_stats()
void factor_vm::primitive_gc_stats()
{
growable_array result(this);
@ -605,8 +603,6 @@ inline void factor_vm::primitive_gc_stats()
dpush(result.elements.value());
}
PRIMITIVE_FORWARD(gc_stats)
void factor_vm::clear_gc_stats()
{
for(cell i = 0; i < max_gen_count; i++)
@ -618,16 +614,14 @@ void factor_vm::clear_gc_stats()
code_heap_scans = 0;
}
inline void factor_vm::primitive_clear_gc_stats()
void factor_vm::primitive_clear_gc_stats()
{
clear_gc_stats();
}
PRIMITIVE_FORWARD(clear_gc_stats)
/* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this
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 *old_objects = untag_check<array>(dpop());
@ -656,8 +650,6 @@ inline void factor_vm::primitive_become()
compile_all_words();
}
PRIMITIVE_FORWARD(become)
void factor_vm::inline_gc(cell *gc_roots_base, cell gc_roots_size)
{
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 */
static const cell allot_buffer_zone = 1024;
PRIMITIVE(gc);
PRIMITIVE(gc_stats);
PRIMITIVE(clear_gc_stats);
PRIMITIVE(become);
struct factor_vm;
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()));
}
PRIMITIVE_FORWARD(size)
/* 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
we ignore. */
@ -251,7 +249,7 @@ cell factor_vm::binary_payload_start(object *pointer)
}
/* 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->decks_end - data->decks) >> 10));
@ -270,8 +268,6 @@ inline void factor_vm::primitive_data_room()
dpush(a.elements.value());
}
PRIMITIVE_FORWARD(data_room)
/* Disables GC and activates next-object ( -- obj ) primitive */
void factor_vm::begin_scan()
{
@ -284,13 +280,11 @@ void factor_vm::end_scan()
gc_off = false;
}
inline void factor_vm::primitive_begin_scan()
void factor_vm::primitive_begin_scan()
{
begin_scan();
}
PRIMITIVE_FORWARD(begin_scan)
cell factor_vm::next_object()
{
if(!gc_off)
@ -305,21 +299,17 @@ cell factor_vm::next_object()
}
/* 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());
}
PRIMITIVE_FORWARD(next_object)
/* Re-enables GC */
inline void factor_vm::primitive_end_scan()
void factor_vm::primitive_end_scan()
{
gc_off = false;
}
PRIMITIVE_FORWARD(end_scan)
template<typename TYPE> void factor_vm::each_object(TYPE &functor)
{
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;
}
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();
}
void factor_vm::find_data_references_step(cell *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("you have triggered a bug in Factor. Please report.\n");
factorbug();
}
PRIMITIVE_FORWARD(die)
}

2
vm/debug.hpp
View File

@ -1,6 +1,4 @@
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));
}
inline void factor_vm::primitive_lookup_method()
void factor_vm::primitive_lookup_method()
{
cell methods = dpop();
cell obj = dpop();
dpush(lookup_method(obj,methods));
}
PRIMITIVE_FORWARD(lookup_method)
cell factor_vm::object_class(cell 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);
}
inline void factor_vm::primitive_mega_cache_miss()
void factor_vm::primitive_mega_cache_miss()
{
megamorphic_cache_misses++;
@ -166,16 +164,12 @@ inline void factor_vm::primitive_mega_cache_miss()
dpush(method);
}
PRIMITIVE_FORWARD(mega_cache_miss)
inline void factor_vm::primitive_reset_dispatch_stats()
void factor_vm::primitive_reset_dispatch_stats()
{
megamorphic_cache_hits = megamorphic_cache_misses = 0;
}
PRIMITIVE_FORWARD(reset_dispatch_stats)
inline void factor_vm::primitive_dispatch_stats()
void factor_vm::primitive_dispatch_stats()
{
growable_array stats(this);
stats.add(allot_cell(megamorphic_cache_hits));
@ -184,8 +178,6 @@ inline void factor_vm::primitive_dispatch_stats()
dpush(stats.elements.value());
}
PRIMITIVE_FORWARD(dispatch_stats)
void quotation_jit::emit_mega_cache_lookup(cell methods_, fixnum index, cell cache_)
{
gc_root<array> methods(methods_,parent_vm);

5
vm/dispatch.hpp
View File

@ -1,9 +1,4 @@
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);
}
inline void factor_vm::primitive_call_clear()
void factor_vm::primitive_call_clear()
{
throw_impl(dpop(),stack_chain->callstack_bottom,this);
}
PRIMITIVE_FORWARD(call_clear)
/* For testing purposes */
inline void factor_vm::primitive_unimplemented()
void factor_vm::primitive_unimplemented()
{
not_implemented_error();
}
PRIMITIVE_FORWARD(unimplemented)
void factor_vm::memory_signal_handler_impl()
{
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,
};
PRIMITIVE(die);
PRIMITIVE(call_clear);
PRIMITIVE(unimplemented);
void fatal_error(const char* msg, cell tagged);
void memory_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;
}
inline void factor_vm::primitive_save_image()
void factor_vm::primitive_save_image()
{
/* do a full GC to push everything into tenured space */
gc();
@ -128,9 +128,7 @@ inline void factor_vm::primitive_save_image()
save_image((vm_char *)(path.untagged() + 1));
}
PRIMITIVE_FORWARD(save_image)
inline void factor_vm::primitive_save_image_and_exit()
void factor_vm::primitive_save_image_and_exit()
{
/* 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
@ -156,8 +154,6 @@ inline void factor_vm::primitive_save_image_and_exit()
exit(1);
}
PRIMITIVE_FORWARD(save_image_and_exit)
void factor_vm::data_fixup(cell *cell)
{
if(immediate_p(*cell))

3
vm/image.hpp
View File

@ -41,7 +41,4 @@ struct vm_parameters {
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);
}
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;
cell i;
for(i = 0; i < 4; i++) pic_counts[i] = 0;
}
PRIMITIVE_FORWARD(reset_inline_cache_stats)
inline void factor_vm::primitive_inline_cache_stats()
void factor_vm::primitive_inline_cache_stats()
{
growable_array stats(this);
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());
}
PRIMITIVE_FORWARD(inline_cache_stats)
}

4
vm/inline_cache.hpp
View File

@ -1,9 +1,5 @@
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);

32
vm/io.cpp
View File

@ -31,7 +31,7 @@ void factor_vm::io_error()
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> path(dpop(),this);
@ -52,9 +52,7 @@ inline void factor_vm::primitive_fopen()
}
}
PRIMITIVE_FORWARD(fopen)
inline void factor_vm::primitive_fgetc()
void factor_vm::primitive_fgetc()
{
FILE *file = (FILE *)unbox_alien();
@ -79,9 +77,7 @@ inline void factor_vm::primitive_fgetc()
}
}
PRIMITIVE_FORWARD(fgetc)
inline void factor_vm::primitive_fread()
void factor_vm::primitive_fread()
{
FILE *file = (FILE *)unbox_alien();
fixnum size = unbox_array_size();
@ -121,9 +117,7 @@ inline void factor_vm::primitive_fread()
}
}
PRIMITIVE_FORWARD(fread)
inline void factor_vm::primitive_fputc()
void factor_vm::primitive_fputc()
{
FILE *file = (FILE *)unbox_alien();
fixnum ch = to_fixnum(dpop());
@ -141,9 +135,7 @@ inline void factor_vm::primitive_fputc()
}
}
PRIMITIVE_FORWARD(fputc)
inline void factor_vm::primitive_fwrite()
void factor_vm::primitive_fwrite()
{
FILE *file = (FILE *)unbox_alien();
byte_array *text = untag_check<byte_array>(dpop());
@ -172,9 +164,7 @@ inline void factor_vm::primitive_fwrite()
}
}
PRIMITIVE_FORWARD(fwrite)
inline void factor_vm::primitive_fseek()
void factor_vm::primitive_fseek()
{
int whence = to_fixnum(dpop());
FILE *file = (FILE *)unbox_alien();
@ -199,9 +189,7 @@ inline void factor_vm::primitive_fseek()
}
}
PRIMITIVE_FORWARD(fseek)
inline void factor_vm::primitive_fflush()
void factor_vm::primitive_fflush()
{
FILE *file = (FILE *)unbox_alien();
for(;;)
@ -213,9 +201,7 @@ inline void factor_vm::primitive_fflush()
}
}
PRIMITIVE_FORWARD(fflush)
inline void factor_vm::primitive_fclose()
void factor_vm::primitive_fclose()
{
FILE *file = (FILE *)unbox_alien();
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
not portable, since on some libc's errno is not a global but a funky macro that
reads thread-local storage. */

12
vm/io.hpp
View File

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

176
vm/math.cpp
View File

@ -3,23 +3,19 @@
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()))));
}
PRIMITIVE_FORWARD(bignum_to_fixnum)
inline void factor_vm::primitive_float_to_fixnum()
void factor_vm::primitive_float_to_fixnum()
{
drepl(tag_fixnum(float_to_fixnum(dpeek())));
}
PRIMITIVE_FORWARD(float_to_fixnum)
/* Division can only overflow when we are dividing the most negative fixnum
by -1. */
inline void factor_vm::primitive_fixnum_divint()
void factor_vm::primitive_fixnum_divint()
{
fixnum y = untag_fixnum(dpop()); \
fixnum x = untag_fixnum(dpeek());
@ -30,9 +26,7 @@ inline void factor_vm::primitive_fixnum_divint()
drepl(tag_fixnum(result));
}
PRIMITIVE_FORWARD(fixnum_divint)
inline void factor_vm::primitive_fixnum_divmod()
void factor_vm::primitive_fixnum_divmod()
{
cell y = ((cell *)ds)[0];
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
* 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);
}
inline void factor_vm::primitive_fixnum_shift()
void factor_vm::primitive_fixnum_shift()
{
fixnum y = untag_fixnum(dpop());
fixnum x = untag_fixnum(dpeek());
@ -96,67 +88,51 @@ inline void factor_vm::primitive_fixnum_shift()
fixnum_to_bignum(x),y)));
}
PRIMITIVE_FORWARD(fixnum_shift)
inline void factor_vm::primitive_fixnum_to_bignum()
void factor_vm::primitive_fixnum_to_bignum()
{
drepl(tag<bignum>(fixnum_to_bignum(untag_fixnum(dpeek()))));
}
PRIMITIVE_FORWARD(fixnum_to_bignum)
inline void factor_vm::primitive_float_to_bignum()
void factor_vm::primitive_float_to_bignum()
{
drepl(tag<bignum>(float_to_bignum(dpeek())));
}
PRIMITIVE_FORWARD(float_to_bignum)
#define POP_BIGNUMS(x,y) \
bignum * y = 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);
box_boolean(bignum_equal_p(x,y));
}
PRIMITIVE_FORWARD(bignum_eq)
inline void factor_vm::primitive_bignum_add()
void factor_vm::primitive_bignum_add()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_add(x,y)));
}
PRIMITIVE_FORWARD(bignum_add)
inline void factor_vm::primitive_bignum_subtract()
void factor_vm::primitive_bignum_subtract()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_subtract(x,y)));
}
PRIMITIVE_FORWARD(bignum_subtract)
inline void factor_vm::primitive_bignum_multiply()
void factor_vm::primitive_bignum_multiply()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_multiply(x,y)));
}
PRIMITIVE_FORWARD(bignum_multiply)
inline void factor_vm::primitive_bignum_divint()
void factor_vm::primitive_bignum_divint()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_quotient(x,y)));
}
PRIMITIVE_FORWARD(bignum_divint)
inline void factor_vm::primitive_bignum_divmod()
void factor_vm::primitive_bignum_divmod()
{
bignum *q, *r;
POP_BIGNUMS(x,y);
@ -165,104 +141,78 @@ inline void factor_vm::primitive_bignum_divmod()
dpush(tag<bignum>(r));
}
PRIMITIVE_FORWARD(bignum_divmod)
inline void factor_vm::primitive_bignum_mod()
void factor_vm::primitive_bignum_mod()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_remainder(x,y)));
}
PRIMITIVE_FORWARD(bignum_mod)
inline void factor_vm::primitive_bignum_and()
void factor_vm::primitive_bignum_and()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_bitwise_and(x,y)));
}
PRIMITIVE_FORWARD(bignum_and)
inline void factor_vm::primitive_bignum_or()
void factor_vm::primitive_bignum_or()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_bitwise_ior(x,y)));
}
PRIMITIVE_FORWARD(bignum_or)
inline void factor_vm::primitive_bignum_xor()
void factor_vm::primitive_bignum_xor()
{
POP_BIGNUMS(x,y);
dpush(tag<bignum>(bignum_bitwise_xor(x,y)));
}
PRIMITIVE_FORWARD(bignum_xor)
inline void factor_vm::primitive_bignum_shift()
void factor_vm::primitive_bignum_shift()
{
fixnum y = untag_fixnum(dpop());
bignum* x = untag<bignum>(dpop());
dpush(tag<bignum>(bignum_arithmetic_shift(x,y)));
}
PRIMITIVE_FORWARD(bignum_shift)
inline void factor_vm::primitive_bignum_less()
void factor_vm::primitive_bignum_less()
{
POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) == bignum_comparison_less);
}
PRIMITIVE_FORWARD(bignum_less)
inline void factor_vm::primitive_bignum_lesseq()
void factor_vm::primitive_bignum_lesseq()
{
POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) != bignum_comparison_greater);
}
PRIMITIVE_FORWARD(bignum_lesseq)
inline void factor_vm::primitive_bignum_greater()
void factor_vm::primitive_bignum_greater()
{
POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) == bignum_comparison_greater);
}
PRIMITIVE_FORWARD(bignum_greater)
inline void factor_vm::primitive_bignum_greatereq()
void factor_vm::primitive_bignum_greatereq()
{
POP_BIGNUMS(x,y);
box_boolean(bignum_compare(x,y) != bignum_comparison_less);
}
PRIMITIVE_FORWARD(bignum_greatereq)
inline void factor_vm::primitive_bignum_not()
void factor_vm::primitive_bignum_not()
{
drepl(tag<bignum>(bignum_bitwise_not(untag<bignum>(dpeek()))));
}
PRIMITIVE_FORWARD(bignum_not)
inline void factor_vm::primitive_bignum_bitp()
void factor_vm::primitive_bignum_bitp()
{
fixnum bit = to_fixnum(dpop());
bignum *x = untag<bignum>(dpop());
box_boolean(bignum_logbitp(bit,x));
}
PRIMITIVE_FORWARD(bignum_bitp)
inline void factor_vm::primitive_bignum_log2()
void factor_vm::primitive_bignum_log2()
{
drepl(tag<bignum>(bignum_integer_length(untag<bignum>(dpeek()))));
}
PRIMITIVE_FORWARD(bignum_log2)
unsigned int factor_vm::bignum_producer(unsigned int digit)
{
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);
}
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()));
bignum * result = digit_stream_to_bignum(n_digits,factor::bignum_producer,0x100,0);
drepl(tag<bignum>(result));
}
PRIMITIVE_FORWARD(byte_array_to_bignum)
cell factor_vm::unbox_array_size()
{
switch(tagged<object>(dpeek()).type())
@ -316,21 +264,17 @@ cell factor_vm::unbox_array_size()
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())));
}
PRIMITIVE_FORWARD(fixnum_to_float)
inline void factor_vm::primitive_bignum_to_float()
void factor_vm::primitive_bignum_to_float()
{
drepl(allot_float(bignum_to_float(dpeek())));
}
PRIMITIVE_FORWARD(bignum_to_float)
inline void factor_vm::primitive_str_to_float()
void factor_vm::primitive_str_to_float()
{
byte_array *bytes = untag_check<byte_array>(dpeek());
cell capacity = array_capacity(bytes);
@ -344,129 +288,97 @@ inline void factor_vm::primitive_str_to_float()
drepl(F);
}
PRIMITIVE_FORWARD(str_to_float)
inline void factor_vm::primitive_float_to_str()
void factor_vm::primitive_float_to_str()
{
byte_array *array = allot_byte_array(33);
snprintf((char *)(array + 1),32,"%.16g",untag_float_check(dpop()));
dpush(tag<byte_array>(array));
}
PRIMITIVE_FORWARD(float_to_str)
#define POP_FLOATS(x,y) \
double y = 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);
box_boolean(x == y);
}
PRIMITIVE_FORWARD(float_eq)
inline void factor_vm::primitive_float_add()
void factor_vm::primitive_float_add()
{
POP_FLOATS(x,y);
box_double(x + y);
}
PRIMITIVE_FORWARD(float_add)
inline void factor_vm::primitive_float_subtract()
void factor_vm::primitive_float_subtract()
{
POP_FLOATS(x,y);
box_double(x - y);
}
PRIMITIVE_FORWARD(float_subtract)
inline void factor_vm::primitive_float_multiply()
void factor_vm::primitive_float_multiply()
{
POP_FLOATS(x,y);
box_double(x * y);
}
PRIMITIVE_FORWARD(float_multiply)
inline void factor_vm::primitive_float_divfloat()
void factor_vm::primitive_float_divfloat()
{
POP_FLOATS(x,y);
box_double(x / y);
}
PRIMITIVE_FORWARD(float_divfloat)
inline void factor_vm::primitive_float_mod()
void factor_vm::primitive_float_mod()
{
POP_FLOATS(x,y);
box_double(fmod(x,y));
}
PRIMITIVE_FORWARD(float_mod)
inline void factor_vm::primitive_float_less()
void factor_vm::primitive_float_less()
{
POP_FLOATS(x,y);
box_boolean(x < y);
}
PRIMITIVE_FORWARD(float_less)
inline void factor_vm::primitive_float_lesseq()
void factor_vm::primitive_float_lesseq()
{
POP_FLOATS(x,y);
box_boolean(x <= y);
}
PRIMITIVE_FORWARD(float_lesseq)
inline void factor_vm::primitive_float_greater()
void factor_vm::primitive_float_greater()
{
POP_FLOATS(x,y);
box_boolean(x > y);
}
PRIMITIVE_FORWARD(float_greater)
inline void factor_vm::primitive_float_greatereq()
void factor_vm::primitive_float_greatereq()
{
POP_FLOATS(x,y);
box_boolean(x >= y);
}
PRIMITIVE_FORWARD(float_greatereq)
inline void factor_vm::primitive_float_bits()
void factor_vm::primitive_float_bits()
{
box_unsigned_4(float_bits(untag_float_check(dpop())));
}
PRIMITIVE_FORWARD(float_bits)
inline void factor_vm::primitive_bits_float()
void factor_vm::primitive_bits_float()
{
box_float(bits_float(to_cell(dpop())));
}
PRIMITIVE_FORWARD(bits_float)
inline void factor_vm::primitive_double_bits()
void factor_vm::primitive_double_bits()
{
box_unsigned_8(double_bits(untag_float_check(dpop())));
}
PRIMITIVE_FORWARD(double_bits)
inline void factor_vm::primitive_bits_double()
void factor_vm::primitive_bits_double()
{
box_double(bits_double(to_unsigned_8(dpop())));
}
PRIMITIVE_FORWARD(bits_double)
fixnum factor_vm::to_fixnum(cell 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));
// 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 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;
}
inline void factor_vm::primitive_existsp()
void factor_vm::primitive_existsp()
{
struct stat sb;
char *path = (char *)(untag_check<byte_array>(dpop()) + 1);
box_boolean(stat(path,&sb) >= 0);
}
PRIMITIVE_FORWARD(existsp)
segment::segment(factor_vm *myvm_, cell size_)
{
myvm = myvm_;

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

@ -30,8 +30,6 @@ char *getenv(char *name)
return 0; /* unreachable */
}
PRIMITIVE_FORWARD(os_envs)
void c_to_factor_toplevel(cell quot)
{
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);
}
inline void factor_vm::primitive_existsp()
void factor_vm::primitive_existsp()
{
vm_char *path = untag_check<byte_array>(dpop())->data<vm_char>();
box_boolean(windows_stat(path));
}
PRIMITIVE_FORWARD(existsp)
segment::segment(factor_vm *myvm_, cell size_)
{
myvm = myvm_;

123
vm/primitives.cpp
View File

@ -165,4 +165,127 @@ const primitive_type primitives[] = {
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
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);
}
inline void factor_vm::primitive_profiling()
void factor_vm::primitive_profiling()
{
set_profiling(to_boolean(dpop()));
}
PRIMITIVE_FORWARD(profiling)
}

2
vm/profiler.hpp
View File

@ -1,6 +1,4 @@
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);
}
inline void factor_vm::primitive_jit_compile()
void factor_vm::primitive_jit_compile()
{
jit_compile(dpop(),true);
}
PRIMITIVE_FORWARD(jit_compile)
/* 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));
quot->array = dpeek();
@ -309,16 +307,12 @@ inline void factor_vm::primitive_array_to_quotation()
drepl(tag<quotation>(quot));
}
PRIMITIVE_FORWARD(array_to_quotation)
inline void factor_vm::primitive_quotation_xt()
void factor_vm::primitive_quotation_xt()
{
quotation *quot = untag_check<quotation>(dpeek());
drepl(allot_cell((cell)quot->xt));
}
PRIMITIVE_FORWARD(quotation_xt)
void factor_vm::compile_all_words()
{
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);
}
inline void factor_vm::primitive_quot_compiled_p()
void factor_vm::primitive_quot_compiled_p()
{
tagged<quotation> quot(dpop());
quot.untag_check(this);
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();
};
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);
PRIMITIVE(quot_compiled_p);
}

32
vm/run.cpp
View File

@ -3,45 +3,35 @@
namespace factor
{
inline void factor_vm::primitive_getenv()
void factor_vm::primitive_getenv()
{
fixnum e = untag_fixnum(dpeek());
drepl(userenv[e]);
}
PRIMITIVE_FORWARD(getenv)
inline void factor_vm::primitive_setenv()
void factor_vm::primitive_setenv()
{
fixnum e = untag_fixnum(dpop());
cell value = dpop();
userenv[e] = value;
}
PRIMITIVE_FORWARD(setenv)
inline void factor_vm::primitive_exit()
void factor_vm::primitive_exit()
{
exit(to_fixnum(dpop()));
}
PRIMITIVE_FORWARD(exit)
inline void factor_vm::primitive_micros()
void factor_vm::primitive_micros()
{
box_unsigned_8(current_micros());
}
PRIMITIVE_FORWARD(micros)
inline void factor_vm::primitive_sleep()
void factor_vm::primitive_sleep()
{
sleep_micros(to_cell(dpop()));
}
PRIMITIVE_FORWARD(sleep)
inline void factor_vm::primitive_set_slot()
void factor_vm::primitive_set_slot()
{
fixnum slot = untag_fixnum(dpop());
object *obj = untag<object>(dpop());
@ -51,9 +41,7 @@ inline void factor_vm::primitive_set_slot()
write_barrier(obj);
}
PRIMITIVE_FORWARD(set_slot)
inline void factor_vm::primitive_load_locals()
void factor_vm::primitive_load_locals()
{
fixnum count = untag_fixnum(dpop());
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;
}
PRIMITIVE_FORWARD(load_locals)
cell factor_vm::clone_object(cell obj_)
{
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()));
}
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;
}
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();
}
inline void factor_vm::primitive_string()
void factor_vm::primitive_string()
{
cell initial = to_cell(dpop());
cell length = unbox_array_size();
dpush(tag<string>(allot_string(length,initial)));
}
PRIMITIVE_FORWARD(string)
bool factor_vm::reallot_string_in_place_p(string *str, cell capacity)
{
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());
cell capacity = unbox_array_size();
dpush(tag<string>(reallot_string(str,capacity)));
}
PRIMITIVE_FORWARD(resize_string)
inline void factor_vm::primitive_string_nth()
void factor_vm::primitive_string_nth()
{
string *str = untag<string>(dpop());
cell index = untag_fixnum(dpop());
dpush(tag_fixnum(string_nth(str,index)));
}
PRIMITIVE_FORWARD(string_nth)
inline void factor_vm::primitive_set_string_nth_fast()
void factor_vm::primitive_set_string_nth_fast()
{
string *str = untag<string>(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);
}
PRIMITIVE_FORWARD(set_string_nth_fast)
inline void factor_vm::primitive_set_string_nth_slow()
void factor_vm::primitive_set_string_nth_slow()
{
string *str = untag<string>(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);
}
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;
}
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();
}
inline void factor_vm::primitive_tuple()
void factor_vm::primitive_tuple()
{
gc_root<tuple_layout> layout(dpop(),this);
tuple *t = allot_tuple(layout.value());
@ -23,10 +23,8 @@ inline void factor_vm::primitive_tuple()
dpush(tag<tuple>(t));
}
PRIMITIVE_FORWARD(tuple)
/* 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> t(allot_tuple(layout.value()),this);
@ -36,6 +34,4 @@ inline void factor_vm::primitive_tuple_boa()
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);
}
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_);
bool stack_to_array(cell bottom, cell top);
cell array_to_stack(array *array, cell bottom);
inline void primitive_datastack();
inline void primitive_retainstack();
inline void primitive_set_datastack();
inline void primitive_set_retainstack();
inline void primitive_check_datastack();
void primitive_datastack();
void primitive_retainstack();
void primitive_set_datastack();
void primitive_set_retainstack();
void primitive_check_datastack();
// run
inline void primitive_getenv();
inline void primitive_setenv();
inline void primitive_exit();
inline void primitive_micros();
inline void primitive_sleep();
inline void primitive_set_slot();
inline void primitive_load_locals();
void primitive_getenv();
void primitive_setenv();
void primitive_exit();
void primitive_micros();
void primitive_sleep();
void primitive_set_slot();
void primitive_load_locals();
cell clone_object(cell obj_);
inline void primitive_clone();
void primitive_clone();
// profiler
void init_profiler();
code_block *compile_profiling_stub(cell word_);
void set_profiling(bool profiling);
inline void primitive_profiling();
void primitive_profiling();
// errors
void out_of_memory();
@ -50,8 +50,8 @@ struct factor_vm : factor_vm_data {
void signal_error(int signal, stack_frame *native_stack);
void divide_by_zero_error();
void fp_trap_error(unsigned int fpu_status, stack_frame *signal_callstack_top);
inline void primitive_call_clear();
inline void primitive_unimplemented();
void primitive_call_clear();
void primitive_unimplemented();
void memory_signal_handler_impl();
void misc_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_);
cell untagged_object_size(object *pointer);
cell unaligned_object_size(object *pointer);
inline void primitive_size();
void primitive_size();
cell binary_payload_start(object *pointer);
inline void primitive_data_room();
void primitive_data_room();
void begin_scan();
void end_scan();
inline void primitive_begin_scan();
void primitive_begin_scan();
cell next_object();
inline void primitive_next_object();
inline void primitive_end_scan();
void primitive_next_object();
void primitive_end_scan();
template<typename T> void each_object(T &functor);
cell find_all_words();
cell object_size(cell tagged);
@ -185,10 +185,10 @@ struct factor_vm : factor_vm_data {
void end_gc(cell gc_elapsed);
void garbage_collection(cell gen,bool growing_data_heap_,cell requested_bytes);
void gc();
inline void primitive_gc();
inline void primitive_gc_stats();
void primitive_gc();
void primitive_gc_stats();
void clear_gc_stats();
inline void primitive_become();
void primitive_become();
void inline_gc(cell *gc_roots_base, cell gc_roots_size);
inline bool collecting_accumulation_gen_p();
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);
inline void check_data_pointer(object *pointer);
inline void check_tagged_pointer(cell tagged);
inline void primitive_clear_gc_stats();
void primitive_clear_gc_stats();
// generic arrays
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 dump_code_heap();
void factorbug();
inline void primitive_die();
void primitive_die();
//arrays
array *allot_array(cell capacity, cell fill_);
inline void primitive_array();
void primitive_array();
cell allot_array_1(cell obj_);
cell allot_array_2(cell v1_, cell v2_);
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);
//strings
@ -244,13 +244,13 @@ struct factor_vm : factor_vm_data {
string *allot_string_internal(cell capacity);
void fill_string(string *str_, cell start, 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);
string* reallot_string(string *str_, cell capacity);
inline void primitive_resize_string();
inline void primitive_string_nth();
inline void primitive_set_string_nth_fast();
inline void primitive_set_string_nth_slow();
void primitive_resize_string();
void primitive_string_nth();
void primitive_set_string_nth_fast();
void primitive_set_string_nth_slow();
//booleans
void box_boolean(bool value);
@ -259,28 +259,28 @@ struct factor_vm : factor_vm_data {
//byte arrays
byte_array *allot_byte_array(cell size);
inline void primitive_byte_array();
inline void primitive_uninitialized_byte_array();
inline void primitive_resize_byte_array();
void primitive_byte_array();
void primitive_uninitialized_byte_array();
void primitive_resize_byte_array();
//tuples
tuple *allot_tuple(cell layout_);
inline void primitive_tuple();
inline void primitive_tuple_boa();
void primitive_tuple();
void primitive_tuple_boa();
//words
word *allot_word(cell name_, cell vocab_, cell hashcode_);
inline void primitive_word();
inline void primitive_word_xt();
void primitive_word();
void primitive_word_xt();
void update_word_xt(cell w_);
inline void primitive_optimized_p();
inline void primitive_wrapper();
void primitive_optimized_p();
void primitive_wrapper();
//math
inline void primitive_bignum_to_fixnum();
inline void primitive_float_to_fixnum();
inline void primitive_fixnum_divint();
inline void primitive_fixnum_divmod();
void primitive_bignum_to_fixnum();
void primitive_float_to_fixnum();
void primitive_fixnum_divint();
void primitive_fixnum_divmod();
bignum *fixnum_to_bignum(fixnum);
bignum *cell_to_bignum(cell);
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 branchless_max(fixnum x, fixnum y);
inline fixnum branchless_abs(fixnum x);
inline void primitive_fixnum_shift();
inline void primitive_fixnum_to_bignum();
inline void primitive_float_to_bignum();
inline void primitive_bignum_eq();
inline void primitive_bignum_add();
inline void primitive_bignum_subtract();
inline void primitive_bignum_multiply();
inline void primitive_bignum_divint();
inline void primitive_bignum_divmod();
inline void primitive_bignum_mod();
inline void primitive_bignum_and();
inline void primitive_bignum_or();
inline void primitive_bignum_xor();
inline void primitive_bignum_shift();
inline void primitive_bignum_less();
inline void primitive_bignum_lesseq();
inline void primitive_bignum_greater();
inline void primitive_bignum_greatereq();
inline void primitive_bignum_not();
inline void primitive_bignum_bitp();
inline void primitive_bignum_log2();
void primitive_fixnum_shift();
void primitive_fixnum_to_bignum();
void primitive_float_to_bignum();
void primitive_bignum_eq();
void primitive_bignum_add();
void primitive_bignum_subtract();
void primitive_bignum_multiply();
void primitive_bignum_divint();
void primitive_bignum_divmod();
void primitive_bignum_mod();
void primitive_bignum_and();
void primitive_bignum_or();
void primitive_bignum_xor();
void primitive_bignum_shift();
void primitive_bignum_less();
void primitive_bignum_lesseq();
void primitive_bignum_greater();
void primitive_bignum_greatereq();
void primitive_bignum_not();
void primitive_bignum_bitp();
void primitive_bignum_log2();
unsigned int bignum_producer(unsigned int digit);
inline void primitive_byte_array_to_bignum();
void primitive_byte_array_to_bignum();
cell unbox_array_size();
inline void primitive_fixnum_to_float();
inline void primitive_bignum_to_float();
inline void primitive_str_to_float();
inline void primitive_float_to_str();
inline void primitive_float_eq();
inline void primitive_float_add();
inline void primitive_float_subtract();
inline void primitive_float_multiply();
inline void primitive_float_divfloat();
inline void primitive_float_mod();
inline void primitive_float_less();
inline void primitive_float_lesseq();
inline void primitive_float_greater();
inline void primitive_float_greatereq();
inline void primitive_float_bits();
inline void primitive_bits_float();
inline void primitive_double_bits();
inline void primitive_bits_double();
void primitive_fixnum_to_float();
void primitive_bignum_to_float();
void primitive_str_to_float();
void primitive_float_to_str();
void primitive_float_eq();
void primitive_float_add();
void primitive_float_subtract();
void primitive_float_multiply();
void primitive_float_divfloat();
void primitive_float_mod();
void primitive_float_less();
void primitive_float_lesseq();
void primitive_float_greater();
void primitive_float_greatereq();
void primitive_float_bits();
void primitive_bits_float();
void primitive_double_bits();
void primitive_bits_double();
fixnum to_fixnum(cell tagged);
cell to_cell(cell tagged);
void box_signed_1(s8 n);
@ -366,14 +366,14 @@ struct factor_vm : factor_vm_data {
//io
void init_c_io();
void io_error();
inline void primitive_fopen();
inline void primitive_fgetc();
inline void primitive_fread();
inline void primitive_fputc();
inline void primitive_fwrite();
inline void primitive_fseek();
inline void primitive_fflush();
inline void primitive_fclose();
void primitive_fopen();
void primitive_fgetc();
void primitive_fread();
void primitive_fputc();
void primitive_fwrite();
void primitive_fseek();
void primitive_fflush();
void primitive_fclose();
//code_block
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 copy_code_heap_roots();
void update_code_heap_words();
inline void primitive_modify_code_heap();
inline void primitive_code_room();
void primitive_modify_code_heap();
void primitive_code_room();
code_block *forward_xt(code_block *compiled);
void forward_frame_xt(stack_frame *frame);
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_code_heap(FILE *file, image_header *h, vm_parameters *p);
bool save_image(const vm_char *filename);
inline void primitive_save_image();
inline void primitive_save_image_and_exit();
void primitive_save_image();
void primitive_save_image_and_exit();
void data_fixup(cell *cell);
template <typename T> void code_fixup(T **handle);
void fixup_word(word *word);
@ -455,19 +455,19 @@ struct factor_vm : factor_vm_data {
callstack *allot_callstack(cell size);
stack_frame *fix_callstack_top(stack_frame *top, stack_frame *bottom);
stack_frame *capture_start();
inline void primitive_callstack();
inline void primitive_set_callstack();
void primitive_callstack();
void primitive_set_callstack();
code_block *frame_code(stack_frame *frame);
cell frame_type(stack_frame *frame);
cell frame_executing(stack_frame *frame);
stack_frame *frame_successor(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_quot(callstack *callstack);
inline void primitive_innermost_stack_frame_executing();
inline void primitive_innermost_stack_frame_scan();
inline void primitive_set_innermost_stack_frame_quot();
void primitive_innermost_stack_frame_executing();
void primitive_innermost_stack_frame_scan();
void primitive_set_innermost_stack_frame_quot();
void save_callstack_bottom(stack_frame *callstack_bottom);
template<typename T> void iterate_callstack(cell top, cell bottom, T &iterator);
inline void do_slots(cell obj, void (* iter)(cell *,factor_vm*));
@ -475,14 +475,14 @@ struct factor_vm : factor_vm_data {
//alien
char *pinned_alien_offset(cell obj);
cell allot_alien(cell delegate_, cell displacement);
inline void primitive_displaced_alien();
inline void primitive_alien_address();
void primitive_displaced_alien();
void primitive_alien_address();
void *alien_pointer();
inline void primitive_dlopen();
inline void primitive_dlsym();
inline void primitive_dlclose();
inline void primitive_dll_validp();
inline void primitive_vm_ptr();
void primitive_dlopen();
void primitive_dlsym();
void primitive_dlclose();
void primitive_dll_validp();
void primitive_vm_ptr();
char *alien_offset(cell obj);
char *unbox_alien();
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);
//quotations
inline void primitive_jit_compile();
inline void primitive_array_to_quotation();
inline void primitive_quotation_xt();
void primitive_jit_compile();
void primitive_array_to_quotation();
void primitive_quotation_xt();
void set_quot_xt(quotation *quot, code_block *code);
void jit_compile(cell quot_, bool relocating);
void compile_all_words();
fixnum quot_code_offset_to_scan(cell quot_, cell offset);
cell lazy_jit_compile_impl(cell quot_, stack_frame *stack);
inline void primitive_quot_compiled_p();
void primitive_quot_compiled_p();
//dispatch
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_hairy_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 method_cache_hashcode(cell klass, array *array);
void update_method_cache(cell cache, cell klass, cell method);
inline void primitive_mega_cache_miss();
inline void primitive_reset_dispatch_stats();
inline void primitive_dispatch_stats();
void primitive_mega_cache_miss();
void primitive_reset_dispatch_stats();
void primitive_dispatch_stats();
//inline cache
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_);
void update_pic_transitions(cell pic_size);
void *inline_cache_miss(cell return_address);
inline void primitive_reset_inline_cache_stats();
inline void primitive_inline_cache_stats();
void primitive_reset_inline_cache_stats();
void primitive_inline_cache_stats();
//factor
void default_parameters(vm_parameters *p);
@ -549,7 +549,7 @@ struct factor_vm : factor_vm_data {
void factor_sleep(long us);
// os-*
inline void primitive_existsp();
void primitive_existsp();
void init_ffi();
void ffi_dlopen(dll *dll);
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 ) */
inline void factor_vm::primitive_word()
void factor_vm::primitive_word()
{
cell hashcode = dpop();
cell vocab = dpop();
@ -40,10 +40,8 @@ inline void factor_vm::primitive_word()
dpush(tag<word>(allot_word(name,vocab,hashcode)));
}
PRIMITIVE_FORWARD(word)
/* word-xt ( word -- start end ) */
inline void factor_vm::primitive_word_xt()
void factor_vm::primitive_word_xt()
{
gc_root<word> w(dpop(),this);
w.untag_check(this);
@ -60,8 +58,6 @@ inline void factor_vm::primitive_word_xt()
}
}
PRIMITIVE_FORWARD(word_xt)
/* Allocates memory */
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();
}
inline void factor_vm::primitive_optimized_p()
void factor_vm::primitive_optimized_p()
{
drepl(tag_boolean(word_optimized_p(untag_check<word>(dpeek()))));
}
PRIMITIVE_FORWARD(optimized_p)
inline void factor_vm::primitive_wrapper()
void factor_vm::primitive_wrapper()
{
wrapper *new_wrapper = allot<wrapper>(sizeof(wrapper));
new_wrapper->object = dpeek();
drepl(tag<wrapper>(new_wrapper));
}
PRIMITIVE_FORWARD(wrapper)
}

6
vm/words.hpp
View File

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