From: Phil Dawes Date: Sun, 27 Sep 2009 18:42:18 +0000 (+0100) Subject: Moved PRIMITIVE and PRIMITIVE_FORWARDs to primitives.[ch]pp X-Git-Tag: 0.97~5386^2~10 X-Git-Url: https://gitweb.factorcode.org/gitweb.cgi?p=factor.git;a=commitdiff_plain;h=9b7412b8f8a5becd583a8aa40d103362645cd7e3 Moved PRIMITIVE and PRIMITIVE_FORWARDs to primitives.[ch]pp --- diff --git a/vm/alien.cpp b/vm/alien.cpp index 2f82071aa8..0d2a45d134 100755 --- a/vm/alien.cpp +++ b/vm/alien.cpp @@ -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 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 library(dpop(),this); gc_root 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(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(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) - } diff --git a/vm/alien.hpp b/vm/alien.hpp index 839143b9e0..129cc2560a 100755 --- a/vm/alien.hpp +++ b/vm/alien.hpp @@ -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); diff --git a/vm/arrays.cpp b/vm/arrays.cpp index 4188c8bf0b..95a435eecd 100644 --- a/vm/arrays.cpp +++ b/vm/arrays.cpp @@ -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(allot_array(size,initial))); } -PRIMITIVE_FORWARD(array) - cell factor_vm::allot_array_1(cell obj_) { gc_root 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(dpop()); cell capacity = unbox_array_size(); dpush(tag(reallot_array(a,capacity))); } -PRIMITIVE_FORWARD(resize_array) - void growable_array::add(cell elt_) { factor_vm* parent_vm = elements.parent_vm; diff --git a/vm/arrays.hpp b/vm/arrays.hpp index 82113fe5dd..96d6dc137a 100755 --- a/vm/arrays.hpp +++ b/vm/arrays.hpp @@ -10,7 +10,4 @@ inline cell array_nth(array *array, cell slot) return array->data()[slot]; } -PRIMITIVE(array); -PRIMITIVE(resize_array); - } diff --git a/vm/bignum.cpp b/vm/bignum.cpp index 80bc58ce21..d8c5452b08 100755 --- a/vm/bignum.cpp +++ b/vm/bignum.cpp @@ -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) \ { \ diff --git a/vm/byte_arrays.cpp b/vm/byte_arrays.cpp index 9af981e61e..91155c96d2 100644 --- a/vm/byte_arrays.cpp +++ b/vm/byte_arrays.cpp @@ -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(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(allot_array_internal(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(dpop()); cell capacity = unbox_array_size(); dpush(tag(reallot_array(array,capacity))); } -PRIMITIVE_FORWARD(resize_byte_array) - void growable_byte_array::append_bytes(void *elts, cell len) { cell new_size = count + len; diff --git a/vm/byte_arrays.hpp b/vm/byte_arrays.hpp index 1c879a9535..412ef35bb4 100755 --- a/vm/byte_arrays.hpp +++ b/vm/byte_arrays.hpp @@ -1,8 +1,4 @@ namespace factor { -PRIMITIVE(byte_array); -PRIMITIVE(uninitialized_byte_array); -PRIMITIVE(resize_byte_array); - } diff --git a/vm/callstack.cpp b/vm/callstack.cpp index 3518feafc1..eb967df559 100755 --- a/vm/callstack.cpp +++ b/vm/callstack.cpp @@ -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(stack)); } -PRIMITIVE_FORWARD(callstack) - -inline void factor_vm::primitive_set_callstack() +void factor_vm::primitive_set_callstack() { callstack *stack = untag_check(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(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(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(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(dpop(),this); gc_root 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) { diff --git a/vm/callstack.hpp b/vm/callstack.hpp index 1ea98f883c..630332d7b0 100755 --- a/vm/callstack.hpp +++ b/vm/callstack.hpp @@ -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); - } diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp index c1139234ed..233a580980 100755 --- a/vm/code_heap.cpp +++ b/vm/code_heap.cpp @@ -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 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]; diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp index f68c80a2a1..1f2fbea349 100755 --- a/vm/code_heap.hpp +++ b/vm/code_heap.hpp @@ -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); - } diff --git a/vm/contexts.cpp b/vm/contexts.cpp index d2d9db2b51..2b7a55d491 100644 --- a/vm/contexts.cpp +++ b/vm/contexts.cpp @@ -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(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(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) - } diff --git a/vm/contexts.hpp b/vm/contexts.hpp index fae451f02c..18743c53ba 100644 --- a/vm/contexts.hpp +++ b/vm/contexts.hpp @@ -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); diff --git a/vm/data_gc.cpp b/vm/data_gc.cpp index 07f457b447..b20848b2aa 100755 --- a/vm/data_gc.cpp +++ b/vm/data_gc.cpp @@ -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(dpop()); array *old_objects = untag_check(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++) diff --git a/vm/data_gc.hpp b/vm/data_gc.hpp index 87c66f2433..5db7aa24a6 100755 --- a/vm/data_gc.hpp +++ b/vm/data_gc.hpp @@ -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); diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp index ecc891b369..1745d7721f 100755 --- a/vm/data_heap.cpp +++ b/vm/data_heap.cpp @@ -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 void factor_vm::each_object(TYPE &functor) { begin_scan(); diff --git a/vm/data_heap.hpp b/vm/data_heap.hpp index 8b8ca59185..515a0cc54e 100755 --- a/vm/data_heap.hpp +++ b/vm/data_heap.hpp @@ -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); } diff --git a/vm/debug.cpp b/vm/debug.cpp index 8cacbeca47..63c6958771 100755 --- a/vm/debug.cpp +++ b/vm/debug.cpp @@ -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) - } diff --git a/vm/debug.hpp b/vm/debug.hpp index 777c0c95e8..412ef35bb4 100755 --- a/vm/debug.hpp +++ b/vm/debug.hpp @@ -1,6 +1,4 @@ namespace factor { -PRIMITIVE(die); - } diff --git a/vm/dispatch.cpp b/vm/dispatch.cpp index c283a3b9d7..03323f811d 100755 --- a/vm/dispatch.cpp +++ b/vm/dispatch.cpp @@ -113,15 +113,13 @@ cell factor_vm::lookup_method(cell obj, cell methods) return array_nth(untag(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 methods(methods_,parent_vm); diff --git a/vm/dispatch.hpp b/vm/dispatch.hpp index b9cbcbbd85..412ef35bb4 100644 --- a/vm/dispatch.hpp +++ b/vm/dispatch.hpp @@ -1,9 +1,4 @@ namespace factor { -PRIMITIVE(lookup_method); -PRIMITIVE(mega_cache_miss); -PRIMITIVE(reset_dispatch_stats); -PRIMITIVE(dispatch_stats); - } diff --git a/vm/errors.cpp b/vm/errors.cpp index 78a6652902..205733bf94 100755 --- a/vm/errors.cpp +++ b/vm/errors.cpp @@ -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); diff --git a/vm/errors.hpp b/vm/errors.hpp index 4f45c55c73..b837381005 100755 --- a/vm/errors.hpp +++ b/vm/errors.hpp @@ -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(); diff --git a/vm/image.cpp b/vm/image.cpp index 14bd0926b9..97d193f5fd 100755 --- a/vm/image.cpp +++ b/vm/image.cpp @@ -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)) diff --git a/vm/image.hpp b/vm/image.hpp index eab0343716..a964d3eb13 100755 --- a/vm/image.hpp +++ b/vm/image.hpp @@ -41,7 +41,4 @@ struct vm_parameters { cell max_pic_size; }; -PRIMITIVE(save_image); -PRIMITIVE(save_image_and_exit); - } diff --git a/vm/inline_cache.cpp b/vm/inline_cache.cpp index 39147d0570..d68e76cc6e 100755 --- a/vm/inline_cache.cpp +++ b/vm/inline_cache.cpp @@ -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) - } diff --git a/vm/inline_cache.hpp b/vm/inline_cache.hpp index 4292adcd9d..d1573496c0 100644 --- a/vm/inline_cache.hpp +++ b/vm/inline_cache.hpp @@ -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); diff --git a/vm/io.cpp b/vm/io.cpp index b907813fdb..18a553af89 100755 --- a/vm/io.cpp +++ b/vm/io.cpp @@ -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 mode(dpop(),this); gc_root 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(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. */ diff --git a/vm/io.hpp b/vm/io.hpp index 1b5e281b54..7fa43e0006 100755 --- a/vm/io.hpp +++ b/vm/io.hpp @@ -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(); diff --git a/vm/math.cpp b/vm/math.cpp index fde2bc6748..93f0c695db 100755 --- a/vm/math.cpp +++ b/vm/math.cpp @@ -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(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(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(float_to_bignum(dpeek()))); } -PRIMITIVE_FORWARD(float_to_bignum) - #define POP_BIGNUMS(x,y) \ bignum * y = untag(dpop()); \ bignum * x = untag(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_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_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_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_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(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_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_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_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_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(dpop()); dpush(tag(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_bitwise_not(untag(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(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_integer_length(untag(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(dpeek())); bignum * result = digit_stream_to_bignum(n_digits,factor::bignum_producer,0x100,0); drepl(tag(result)); } -PRIMITIVE_FORWARD(byte_array_to_bignum) - cell factor_vm::unbox_array_size() { switch(tagged(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(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(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)) diff --git a/vm/math.hpp b/vm/math.hpp index f81de37650..891cc8d931 100644 --- a/vm/math.hpp +++ b/vm/math.hpp @@ -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); diff --git a/vm/os-unix.cpp b/vm/os-unix.cpp index d1af5cb565..c8566d8f39 100644 --- a/vm/os-unix.cpp +++ b/vm/os-unix.cpp @@ -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(dpop()) + 1); box_boolean(stat(path,&sb) >= 0); } -PRIMITIVE_FORWARD(existsp) - segment::segment(factor_vm *myvm_, cell size_) { myvm = myvm_; diff --git a/vm/os-windows-ce.cpp b/vm/os-windows-ce.cpp index 57e7cc69d0..f51953e6eb 100644 --- a/vm/os-windows-ce.cpp +++ b/vm/os-windows-ce.cpp @@ -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); diff --git a/vm/os-windows.cpp b/vm/os-windows.cpp index c4b011417d..0dfaecab69 100755 --- a/vm/os-windows.cpp +++ b/vm/os-windows.cpp @@ -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(dpop())->data(); box_boolean(windows_stat(path)); } -PRIMITIVE_FORWARD(existsp) - segment::segment(factor_vm *myvm_, cell size_) { myvm = myvm_; diff --git a/vm/primitives.cpp b/vm/primitives.cpp index 1cbad03001..f8552ab635 100644 --- a/vm/primitives.cpp +++ b/vm/primitives.cpp @@ -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) + } diff --git a/vm/primitives.hpp b/vm/primitives.hpp index d17ebe5833..983d2589b2 100644 --- a/vm/primitives.hpp +++ b/vm/primitives.hpp @@ -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); + } diff --git a/vm/profiler.cpp b/vm/profiler.cpp index b054ed1222..6f1e4ff63d 100755 --- a/vm/profiler.cpp +++ b/vm/profiler.cpp @@ -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) - } diff --git a/vm/profiler.hpp b/vm/profiler.hpp index 28bfbcc09f..412ef35bb4 100755 --- a/vm/profiler.hpp +++ b/vm/profiler.hpp @@ -1,6 +1,4 @@ namespace factor { -PRIMITIVE(profiling); - } diff --git a/vm/quotations.cpp b/vm/quotations.cpp index a0b4f08622..ca2dde494e 100755 --- a/vm/quotations.cpp +++ b/vm/quotations.cpp @@ -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(sizeof(quotation)); quot->array = dpeek(); @@ -309,16 +307,12 @@ inline void factor_vm::primitive_array_to_quotation() drepl(tag(quot)); } -PRIMITIVE_FORWARD(array_to_quotation) - -inline void factor_vm::primitive_quotation_xt() +void factor_vm::primitive_quotation_xt() { quotation *quot = untag_check(dpeek()); drepl(allot_cell((cell)quot->xt)); } -PRIMITIVE_FORWARD(quotation_xt) - void factor_vm::compile_all_words() { gc_root 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 quot(dpop()); quot.untag_check(this); dpush(tag_boolean(quot->code != NULL)); } -PRIMITIVE_FORWARD(quot_compiled_p) - } diff --git a/vm/quotations.hpp b/vm/quotations.hpp index 3dc8fa5851..e46b129918 100755 --- a/vm/quotations.hpp +++ b/vm/quotations.hpp @@ -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); - } diff --git a/vm/run.cpp b/vm/run.cpp index d2170f4055..59020b85e8 100755 --- a/vm/run.cpp +++ b/vm/run.cpp @@ -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(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 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) - } diff --git a/vm/run.hpp b/vm/run.hpp index 562eef9220..23eabdfe14 100755 --- a/vm/run.hpp +++ b/vm/run.hpp @@ -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); - } diff --git a/vm/strings.cpp b/vm/strings.cpp index fb5eb1093d..8c7582d35c 100644 --- a/vm/strings.cpp +++ b/vm/strings.cpp @@ -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(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(dpop()); cell capacity = unbox_array_size(); dpush(tag(reallot_string(str,capacity))); } -PRIMITIVE_FORWARD(resize_string) - -inline void factor_vm::primitive_string_nth() +void factor_vm::primitive_string_nth() { string *str = untag(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(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(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) - } diff --git a/vm/strings.hpp b/vm/strings.hpp index 87beb9a0a8..8e4e52b9e3 100644 --- a/vm/strings.hpp +++ b/vm/strings.hpp @@ -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); } diff --git a/vm/tuples.cpp b/vm/tuples.cpp index d2734d3dfb..5fdde6596e 100644 --- a/vm/tuples.cpp +++ b/vm/tuples.cpp @@ -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 layout(dpop(),this); tuple *t = allot_tuple(layout.value()); @@ -23,10 +23,8 @@ inline void factor_vm::primitive_tuple() dpush(tag(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 layout(dpop(),this); gc_root t(allot_tuple(layout.value()),this); @@ -36,6 +34,4 @@ inline void factor_vm::primitive_tuple_boa() dpush(t.value()); } -PRIMITIVE_FORWARD(tuple_boa) - } diff --git a/vm/tuples.hpp b/vm/tuples.hpp index 831bb3bbac..04b23b5857 100644 --- a/vm/tuples.hpp +++ b/vm/tuples.hpp @@ -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); - } diff --git a/vm/vm.hpp b/vm/vm.hpp index 837b5309f2..396c2523b5 100644 --- a/vm/vm.hpp +++ b/vm/vm.hpp @@ -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 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 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 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 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 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); diff --git a/vm/words.cpp b/vm/words.cpp index 7660d119ad..9d5ca80a01 100644 --- a/vm/words.cpp +++ b/vm/words.cpp @@ -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(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 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(dpeek())))); } -PRIMITIVE_FORWARD(optimized_p) - -inline void factor_vm::primitive_wrapper() +void factor_vm::primitive_wrapper() { wrapper *new_wrapper = allot(sizeof(wrapper)); new_wrapper->object = dpeek(); drepl(tag(new_wrapper)); } -PRIMITIVE_FORWARD(wrapper) - } diff --git a/vm/words.hpp b/vm/words.hpp index d3be2bde07..34cd48b640 100644 --- a/vm/words.hpp +++ b/vm/words.hpp @@ -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); - }