vm: remove VM_ASM_API

diff --git a/basis/cpu/x86/32/32.factor b/basis/cpu/x86/32/32.factor
index 6996417edf12561de9866cc09496e34ac899fa87..f904f7c3fbb08ddf9f101a7e2f38889bdea5fe97 100644 (file)
--- a/basis/cpu/x86/32/32.factor
+++ b/basis/cpu/x86/32/32.factor
@@ -53,10 +53,6 @@ M:: x86.32 %dispatch ( src temp -- )
     [ align-code ]
     bi ;
 
-! Registers for fastcall
-: param-reg-1 ( -- reg ) EAX ;
-: param-reg-2 ( -- reg ) EDX ;
-
 M: x86.32 pic-tail-reg EBX ;
 
 M: x86.32 reserved-stack-space 4 cells ;
@@ -242,7 +238,8 @@ M: x86.32 %alien-indirect ( -- )
 
 M: x86.32 %alien-callback ( quot -- )
     EAX swap %load-reference
-    EDX %mov-vm-ptr
+    0 stack@ EAX MOV
+    4 save-vm-ptr
     "c_to_factor" f %alien-invoke ;
 
 M: x86.32 %callback-value ( ctype -- )

diff --git a/basis/cpu/x86/32/bootstrap.factor b/basis/cpu/x86/32/bootstrap.factor
index ed5d1950bb9c2921e5415312dd8de7169041aa91..0b7a1fad5cdd694089d22f0293e8250956d9ae0d 100644 (file)
--- a/basis/cpu/x86/32/bootstrap.factor
+++ b/basis/cpu/x86/32/bootstrap.factor
@@ -1,7 +1,7 @@
 ! Copyright (C) 2007, 2009 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: bootstrap.image.private kernel namespaces system
-cpu.x86.assembler cpu.x86.assembler.operands layouts
+USING: bootstrap.image.private kernel kernel.private namespaces
+system cpu.x86.assembler cpu.x86.assembler.operands layouts
 vocabs parser compiler.constants sequences math math.private
 generic.single.private ;
 IN: bootstrap.x86
@@ -12,8 +12,6 @@ IN: bootstrap.x86
 : shift-arg ( -- reg ) ECX ;
 : div-arg ( -- reg ) EAX ;
 : mod-arg ( -- reg ) EDX ;
-: arg1 ( -- reg ) EAX ;
-: arg2 ( -- reg ) EDX ;
 : temp0 ( -- reg ) EAX ;
 : temp1 ( -- reg ) EDX ;
 : temp2 ( -- reg ) ECX ;
@@ -67,6 +65,33 @@ IN: bootstrap.x86
     jit-restore-context
 ] jit-primitive jit-define
 
+[
+    ! load from stack
+    EAX ds-reg [] MOV
+    ! pop stack
+    ds-reg bootstrap-cell SUB
+    ! load VM pointer
+    EDX 0 MOV 0 rc-absolute-cell jit-vm
+]
+[
+    
+    ! pass quotation
+    ESP [] EAX MOV
+    ! pass VM pointer
+    ESP 4 [+] EDX MOV
+    ! call XT
+    EAX quot-xt-offset [+] CALL
+]
+[
+    ! pass quotation
+    ESP 4 [+] EAX MOV
+    ! pass VM pointer
+    ESP 8 [+] EDX MOV
+    ! jump to XT
+    EAX quot-xt-offset [+] JMP
+]
+\ (call) define-sub-primitive*
+
 ! Inline cache miss entry points
 : jit-load-return-address ( -- )
     EBX ESP stack-frame-size bootstrap-cell - [+] MOV ;
@@ -103,7 +128,9 @@ IN: bootstrap.x86
     ds-reg [] ECX MOV
     [ JNO ]
     [
-        ECX EBP MOV
+        ESP [] EAX MOV
+        ESP 4 [+] EDX MOV
+        ESP 8 [+] EBP MOV
         [ 0 CALL ] dip f rc-relative jit-dlsym
     ]
     jit-conditional ;
@@ -124,10 +151,10 @@ IN: bootstrap.x86
     ds-reg [] EAX MOV
     [ JNO ]
     [
-        EAX ECX MOV
-        EAX tag-bits get SAR
-        EDX EBX MOV
-        ECX EBP MOV
+        ECX tag-bits get SAR
+        ESP [] ECX MOV
+        ESP 4 [+] EBX MOV
+        ESP 8 [+] EBP MOV
         0 CALL "overflow_fixnum_multiply" f rc-relative jit-dlsym
     ]
     jit-conditional

diff --git a/basis/cpu/x86/bootstrap.factor b/basis/cpu/x86/bootstrap.factor
index 6eeb3d64efa0e7b779c45091f1ad5c4e81d09e36..d4e50694bf5094224d8c8f923ae01a2abbbb7dda 100644 (file)
--- a/basis/cpu/x86/bootstrap.factor
+++ b/basis/cpu/x86/bootstrap.factor
@@ -120,30 +120,18 @@ big-endian off
 
 [
     ! load from stack
-    arg1 ds-reg [] MOV
-    ! pop stack
-    ds-reg bootstrap-cell SUB
-    ! pass vm pointer
-    arg2 0 MOV 0 rc-absolute-cell jit-vm
-]
-[ arg1 quot-xt-offset [+] CALL ]
-[ arg1 quot-xt-offset [+] JMP ]
-\ (call) define-sub-primitive*
-
-[
-    ! load from stack
-    arg1 ds-reg [] MOV
+    temp0 ds-reg [] MOV
     ! pop stack
     ds-reg bootstrap-cell SUB
 ]
-[ arg1 word-xt-offset [+] CALL ]
-[ arg1 word-xt-offset [+] JMP ]
+[ temp0 word-xt-offset [+] CALL ]
+[ temp0 word-xt-offset [+] JMP ]
 \ (execute) define-sub-primitive*
 
 [
-    arg1 ds-reg [] MOV
+    temp0 ds-reg [] MOV
     ds-reg bootstrap-cell SUB
-    arg1 word-xt-offset [+] JMP
+    temp0 word-xt-offset [+] JMP
 ] jit-execute jit-define
 
 [

diff --git a/vm/code_block_visitor.hpp b/vm/code_block_visitor.hpp
index 8819dc8134b1f36495cc63dea9e8752f212e7e80..0624adb268b5fe0545d43004f6f133f25c91b4ac 100644 (file)
--- a/vm/code_block_visitor.hpp
+++ b/vm/code_block_visitor.hpp
@@ -73,7 +73,7 @@ void code_block_visitor<Visitor>::visit_object_code_block(object *obj)
                        if(q->code)
                                parent->set_quot_xt(q,visitor(q->code));
                        else
-                               q->xt = (void *)lazy_jit_compile;
+                               q->xt = (void *)lazy_jit_compile_impl;
                        break;
                }
        case CALLSTACK_TYPE:

diff --git a/vm/cpu-ppc.S b/vm/cpu-ppc.S
index 876b633a02caabe1ab8551414ef7a9f9717d35e6..9517154e1a6d601d84ff2a41af5cc0c34d143d66 100644 (file)
--- a/vm/cpu-ppc.S
+++ b/vm/cpu-ppc.S
@@ -225,11 +225,11 @@ DEF(void,throw_impl,(cell quot, F_STACK_FRAME *rewind_to, void *vm)):
        mtlr r0
        JUMP_QUOT          /* call the quotation */
 
-DEF(void,lazy_jit_compile,(cell quot, void *vm)):
+DEF(void,lazy_jit_compile_impl,(cell quot, void *vm)):
        mr r5,r4           /* vm ptr is 3rd arg */
        mr r4,r1           /* save stack pointer */
        PROLOGUE
-       bl MANGLE(lazy_jit_compile_impl)
+       bl MANGLE(lazy_jit_compile)
        EPILOGUE
        JUMP_QUOT          /* call the quotation */
 

diff --git a/vm/cpu-ppc.hpp b/vm/cpu-ppc.hpp
index e46db4d1f3c7fd3670b2d0621c0f5c8d03fa074e..f0f6f80ae355da0b00fbc719928ffbe0195afdeb 100644 (file)
--- a/vm/cpu-ppc.hpp
+++ b/vm/cpu-ppc.hpp
@@ -2,7 +2,6 @@ namespace factor
 {
 
 #define FACTOR_CPU_STRING "ppc"
-#define VM_ASM_API VM_C_API
 
 /* In the instruction sequence:
 
@@ -80,7 +79,7 @@ inline static unsigned int fpu_status(unsigned int status)
 /* Defined in assembly */
 VM_C_API void c_to_factor(cell quot, void *vm);
 VM_C_API void throw_impl(cell quot, void *new_stack, void *vm);
-VM_C_API void lazy_jit_compile(cell quot, void *vm);
+VM_C_API void lazy_jit_compile_impl(cell quot, void *vm);
 VM_C_API void flush_icache(cell start, cell len);
 
 VM_C_API void set_callstack(

diff --git a/vm/cpu-x86.32.S b/vm/cpu-x86.32.S
index 6c1e0cfc93b7cebe2ee1f54977ae2da044618019..ad9f699ededce2ccffe882856030ef76441d443b 100644 (file)
--- a/vm/cpu-x86.32.S
+++ b/vm/cpu-x86.32.S
@@ -1,50 +1,102 @@
 #include "asm.h"
 
-#define ARG0 %eax
-#define ARG1 %edx
-#define ARG2 %ecx
-#define STACK_REG %esp
 #define DS_REG %esi
 #define RS_REG %edi
 #define RETURN_REG %eax
 
-#define NV0 %ebx
-#define NV1 %ebp
+#define QUOT_XT_OFFSET 12
 
-#define CELL_SIZE 4
-#define STACK_PADDING 12
+DEF(void,c_to_factor,(cell quot, void *vm)):
+       /* Load parameters */
+       mov 4(%esp),%eax
+       mov 8(%esp),%edx
 
-#define PUSH_NONVOLATILE \
-       push %ebx ; \
-       push %ebp ; \
-       push %esi ; \
+       /* Save non-volatile registers */
+       push %ebx
+       push %ebp
+       push %esi
        push %edi
 
-#define POP_NONVOLATILE \
-       pop %edi ; \
-       pop %esi ; \
-       pop %ebp ; \
+       /* Save old stack pointer and align */
+       mov %esp,%ebp
+       and $-16,%esp
+       push %ebp
+
+       /* Set up stack frame for the call to the boot quotation */
+       sub $4,%esp
+       push %edx
+       push %eax
+
+       /* Load context */
+       mov (%edx),%ecx
+
+       /* Load ctx->datastack */
+       mov 8(%ecx),DS_REG
+
+       /* Load ctx->retainstack */
+       mov 12(%ecx),RS_REG
+
+       /* Save ctx->callstack_bottom */
+       lea -4(%esp),%ebx
+       mov %ebx,4(%ecx)
+
+       /* Call quot-xt. Parameters are already on the stack */
+       call *QUOT_XT_OFFSET(%eax)
+
+       /* Tear down stack frame for the call to the boot quotation */
+       pop %edx
+       pop %eax
+       add $4,%esp
+
+       /* Undo stack alignment */
+       pop %ebp
+       mov %ebp,%esp
+
+       /* Load context */
+       mov (%edx),%ecx
+
+       /* Save ctx->datastack */
+       mov DS_REG,8(%ecx)
+
+       /* Save ctx->retainstack */
+       mov RS_REG,12(%ecx)
+
+       /* Restore non-volatile registers */
+       pop %edi
+       pop %esi
+       pop %ebp
        pop %ebx
 
-#define QUOT_XT_OFFSET 12
+       ret
 
 DEF(void,set_callstack,(void *vm, stack_frame *to, stack_frame *from, cell length, void *memcpy)):
-       mov 4(%esp),%ebx                   /* vm */
-       mov 8(%esp),%ebp                   /* to */
-       mov 12(%esp),%edx                  /* from */
-       mov 16(%esp),%ecx                  /* length */
-       mov 20(%esp),%eax                  /* memcpy */
-       sub %ecx,%ebp                      /* compute new stack pointer */
+       /* load arguments */
+       mov 4(%esp),%ebx  /* vm - to non-volatile register */
+       mov 8(%esp),%ebp  /* to */
+       mov 12(%esp),%edx /* from */
+       mov 16(%esp),%ecx /* length */
+       mov 20(%esp),%eax /* memcpy */
+
+       /* compute new stack pointer */
+       sub %ecx,%ebp
        mov %ebp,%esp
-       push %ecx                          /* pass length */
-       push %edx                          /* pass src */
-       push %ebp                          /* pass dst */
-       call *%eax                         /* call memcpy */
-       add $12,%esp                       /* pop args from the stack */
-       mov (%ebx),%ebx                    /* load context */
-       mov 8(%ebx),DS_REG                 /* load datastack */
-       mov 12(%ebx),RS_REG                /* load retainstack */
-       ret                                /* return _with new stack_ */
+
+       /* call memcpy */
+       push %ecx /* pass length */
+       push %edx /* pass src */
+       push %ebp /* pass dst */
+       call *%eax
+       add $12,%esp
+
+       /* load context */
+       mov (%ebx),%ecx
+       /* load datastack */
+       mov 8(%ecx),DS_REG
+       /* load retainstack */
+       mov 12(%ecx),RS_REG
+
+       /* return with new stack */
+       ret
 
 DEF(void,throw_impl,(cell quot, void *new_stack, void *vm)):
        /* clear x87 stack, but preserve rounding mode and exception flags */
@@ -53,36 +105,50 @@ DEF(void,throw_impl,(cell quot, void *new_stack, void *vm)):
        fninit
        fldcw (%esp)
        add $2,%esp
+
        /* load quotation and vm parameters */
        mov 4(%esp),%eax
        mov 12(%esp),%edx
+
        /* load new stack pointer */
        mov 8(%esp),%esp
+
        /* load context */
-       mov (%edx),%ebx
+       mov (%edx),%ecx
        /* load datastack */
-       mov 8(%ebx),DS_REG
+       mov 8(%ecx),DS_REG
        /* load retainstack */
-       mov 12(%ebx),RS_REG
+       mov 12(%ecx),RS_REG
+
+       /* pass arguments to error handler */
+       mov %eax,4(%esp)
+       mov %edx,8(%esp)
+
        /* call the error handler */
        jmp *QUOT_XT_OFFSET(%eax)
 
-DEF(VM_ASM_API void,lazy_jit_compile,(cell quot, void *vm)):
+DEF(void,lazy_jit_compile_impl,(cell quot, void *vm)):
+       /* load arguments */
+       mov 4(%esp),%eax 
+       mov 8(%esp),%edx
+
        /* load context */
-       mov (ARG1),%ebx
-       /* save callstack */
-       lea -4(%esp),%ebp
-       mov %ebp,(%ebx)
+       mov (%edx),%ecx
        /* save datastack */
-       mov DS_REG,8(%ebx)
+       mov DS_REG,8(%ecx)
        /* save retainstack */
-       mov RS_REG,12(%ebx)
+       mov RS_REG,12(%ecx)
+       /* save callstack */
+       lea -4(%esp),%ebp
+       mov %ebp,(%ecx)
+
        /* compile quotation */
        sub $4,%esp
-       push ARG1
-       push ARG0
-       call MANGLE(lazy_jit_compile_impl)
+       push %edx
+       push %eax
+       call MANGLE(lazy_jit_compile)
        add $12,%esp
+
        /* call quotation */
        jmp *QUOT_XT_OFFSET(%eax)
 

diff --git a/vm/cpu-x86.32.hpp b/vm/cpu-x86.32.hpp
index 24b176147294c2f72aa3048ffd8591d21ace6804..6143631abc25ea8b3d50065835328ae8b33e243b 100644 (file)
--- a/vm/cpu-x86.32.hpp
+++ b/vm/cpu-x86.32.hpp
@@ -2,6 +2,5 @@ namespace factor
 {
 
 #define FACTOR_CPU_STRING "x86.32"
-#define VM_ASM_API VM_C_API __attribute__ ((regparm (3)))
 
 }

diff --git a/vm/cpu-x86.64.S b/vm/cpu-x86.64.S
index 5df375d29fc5f5835fce736203a3127575f38ff7..e8972b533c33ae9b2324537cbaeb1a972afa7890 100644 (file)
--- a/vm/cpu-x86.64.S
+++ b/vm/cpu-x86.64.S
@@ -65,6 +65,52 @@
 
 #define QUOT_XT_OFFSET 28
 
+DEF(F_FASTCALL void,c_to_factor,(CELL quot, void *vm)):
+       PUSH_NONVOLATILE
+       mov ARG0,NV0
+       mov ARG1,NV1
+
+       push ARG0
+       push ARG1
+
+       /* Create register shadow area (required for Win64 only) */
+       sub $32,STACK_REG
+
+       /* Load context */
+       mov (NV1),ARG0
+
+       /* Save ctx->callstack_bottom */
+       lea -CELL_SIZE(STACK_REG),ARG1
+       mov ARG1,CELL_SIZE(ARG0)
+
+       /* Load ctx->datastack */
+       mov (CELL_SIZE * 2)(ARG0),DS_REG
+
+       /* Load ctx->retainstack */
+       mov (CELL_SIZE * 3)(ARG0),RS_REG
+
+       /* Call quot-xt */
+       mov NV0,ARG0
+       mov NV1,ARG1
+       call *QUOT_XT_OFFSET(ARG0)
+
+       /* Tear down register shadow area */
+       add $32,STACK_REG
+
+       /* Load context */
+       pop ARG1
+       pop ARG0
+       mov (ARG1),ARG0
+
+       /* Save ctx->datastack */
+       mov DS_REG,(CELL_SIZE * 2)(ARG0)
+
+       /* Save ctx->retainstack */
+       mov RS_REG,(CELL_SIZE * 3)(ARG0)
+
+       POP_NONVOLATILE
+       ret
+
 /* We pass a function pointer to memcpy to work around a Mac OS X
 ABI limitation which would otherwise require us to do a bizzaro PC-relative
 trampoline to retrieve the function address */
@@ -82,14 +128,14 @@ DEF(F_FASTCALL void,throw_impl,(CELL quot, F_STACK_FRAME *rewind_to, void *vm)):
        fldcw (STACK_REG)
        /* rewind_to */
        mov ARG1,STACK_REG
-       mov ARG2,ARG1  /* make vm ptr 2nd arg in case quot_xt = lazy_jit_compile */
+       mov ARG2,ARG1  /* make vm ptr 2nd arg in case quot_xt = lazy_jit_compile_impl */
        jmp *QUOT_XT_OFFSET(ARG0)
 
-DEF(F_FASTCALL void,lazy_jit_compile,(CELL quot, void *vm)):
+DEF(F_FASTCALL void,lazy_jit_compile_impl,(CELL quot, void *vm)):
        mov ARG1,ARG2                /* vm is 3rd arg */
        mov STACK_REG,ARG1           /* Save stack pointer */
        sub $STACK_PADDING,STACK_REG
-       call MANGLE(lazy_jit_compile_impl)
+       call MANGLE(lazy_jit_compile)
        mov RETURN_REG,ARG0          /* No-op on 32-bit */
        add $STACK_PADDING,STACK_REG
         jmp *QUOT_XT_OFFSET(ARG0)    /* Call the quotation */

diff --git a/vm/cpu-x86.64.hpp b/vm/cpu-x86.64.hpp
index aa1a77842f82fca8e01a4405c512e6bfa9a27f3c..e6a759d0069cd81e7d4e7c1ca46249732feeb06e 100644 (file)
--- a/vm/cpu-x86.64.hpp
+++ b/vm/cpu-x86.64.hpp
@@ -2,6 +2,5 @@ namespace factor
 {
 
 #define FACTOR_CPU_STRING "x86.64"
-#define VM_ASM_API VM_C_API
 
 }

diff --git a/vm/cpu-x86.S b/vm/cpu-x86.S
index 013aa481d9b70ee5517533f24afc7be28a15ad79..d59d0df7fbd1b6f295e55537ff90116898118f5d 100644 (file)
--- a/vm/cpu-x86.S
+++ b/vm/cpu-x86.S
@@ -1,58 +1,3 @@
-DEF(F_FASTCALL void,c_to_factor,(CELL quot, void *vm)):
-       PUSH_NONVOLATILE
-       mov ARG0,NV0
-       mov ARG1,NV1
-
-       push ARG0
-       push ARG1
-
-       /* Save old stack pointer and align */
-       mov STACK_REG,ARG0
-       and $-16,STACK_REG
-       add $CELL_SIZE,STACK_REG
-       push ARG0
-
-       /* Create register shadow area (required for Win64 only) */
-       sub $32,STACK_REG
-
-       /* Load context */
-       mov (NV1),ARG0
-
-       /* Save ctx->callstack_bottom */
-       lea -CELL_SIZE(STACK_REG),ARG1
-       mov ARG1,CELL_SIZE(ARG0)
-
-       /* Load ctx->datastack */
-       mov (CELL_SIZE * 2)(ARG0),DS_REG
-
-       /* Load ctx->retainstack */
-       mov (CELL_SIZE * 3)(ARG0),RS_REG
-
-       /* Call quot-xt */
-       mov NV0,ARG0
-       mov NV1,ARG1
-       call *QUOT_XT_OFFSET(ARG0)
-
-       /* Tear down register shadow area */
-       add $32,STACK_REG
-
-       /* Undo stack alignment */
-       mov (STACK_REG),STACK_REG
-
-       /* Load context */
-       pop ARG1
-       pop ARG0
-       mov (ARG1),ARG0
-
-       /* Save ctx->datastack */
-       mov DS_REG,(CELL_SIZE * 2)(ARG0)
-
-       /* Save ctx->retainstack */
-       mov RS_REG,(CELL_SIZE * 3)(ARG0)
-
-       POP_NONVOLATILE
-       ret
-
 /* cpu.x86.features calls this */
 DEF(bool,sse_version,(void)):
        mov $0x1,RETURN_REG

diff --git a/vm/cpu-x86.hpp b/vm/cpu-x86.hpp
index 6c63edf212f7ed0bce5c11184c9d22a953796958..35327b2940710bfb394cc31e521acf204f10ecfb 100644 (file)
--- a/vm/cpu-x86.hpp
+++ b/vm/cpu-x86.hpp
@@ -74,9 +74,9 @@ inline static unsigned int fpu_status(unsigned int status)
 }
 
 /* Defined in assembly */
-VM_ASM_API void c_to_factor(cell quot, void *vm);
+VM_C_API void c_to_factor(cell quot, void *vm);
 VM_C_API void throw_impl(cell quot, void *new_stack, void *vm);
-VM_ASM_API void lazy_jit_compile(cell quot, void *vm);
+VM_C_API void lazy_jit_compile_impl(cell quot, void *vm);
 
 VM_C_API void set_callstack(
        void *vm,

diff --git a/vm/math.cpp b/vm/math.cpp
index 4deb3b3f081c1a33c73083f81553d4d92ac114a3..f2056ee32e95ba15499e6c240156407c5938cd16 100755 (executable)
--- a/vm/math.cpp
+++ b/vm/math.cpp
@@ -581,7 +581,7 @@ inline void factor_vm::overflow_fixnum_add(fixnum x, fixnum y)
                untag_fixnum(x) + untag_fixnum(y))));
 }
 
-VM_ASM_API void overflow_fixnum_add(fixnum x, fixnum y, factor_vm *parent)
+VM_C_API void overflow_fixnum_add(fixnum x, fixnum y, factor_vm *parent)
 {
        parent->overflow_fixnum_add(x,y);
 }
@@ -592,7 +592,7 @@ inline void factor_vm::overflow_fixnum_subtract(fixnum x, fixnum y)
                untag_fixnum(x) - untag_fixnum(y))));
 }
 
-VM_ASM_API void overflow_fixnum_subtract(fixnum x, fixnum y, factor_vm *parent)
+VM_C_API void overflow_fixnum_subtract(fixnum x, fixnum y, factor_vm *parent)
 {
        parent->overflow_fixnum_subtract(x,y);
 }
@@ -606,7 +606,7 @@ inline void factor_vm::overflow_fixnum_multiply(fixnum x, fixnum y)
        ctx->replace(tag<bignum>(bignum_multiply(bx,by)));
 }
 
-VM_ASM_API void overflow_fixnum_multiply(fixnum x, fixnum y, factor_vm *parent)
+VM_C_API void overflow_fixnum_multiply(fixnum x, fixnum y, factor_vm *parent)
 {
        parent->overflow_fixnum_multiply(x,y);
 }

diff --git a/vm/math.hpp b/vm/math.hpp
index 9f677d254b71a7e3e3e23b61d6467a0c14b4bb7a..d78ae54010af1bbfb7027e9569c83668e537b86e 100644 (file)
--- a/vm/math.hpp
+++ b/vm/math.hpp
@@ -96,8 +96,8 @@ VM_C_API u64 to_unsigned_8(cell obj, factor_vm *vm);
 VM_C_API fixnum to_fixnum(cell tagged, factor_vm *vm);
 VM_C_API cell to_cell(cell tagged, factor_vm *vm);
 
-VM_ASM_API void overflow_fixnum_add(fixnum x, fixnum y, factor_vm *parent);
-VM_ASM_API void overflow_fixnum_subtract(fixnum x, fixnum y, factor_vm *parent);
-VM_ASM_API void overflow_fixnum_multiply(fixnum x, fixnum y, factor_vm *parent);
+VM_C_API void overflow_fixnum_add(fixnum x, fixnum y, factor_vm *parent);
+VM_C_API void overflow_fixnum_subtract(fixnum x, fixnum y, factor_vm *parent);
+VM_C_API void overflow_fixnum_multiply(fixnum x, fixnum y, factor_vm *parent);
 
 }

diff --git a/vm/quotations.cpp b/vm/quotations.cpp
index 05411aab7a8349aa7d56d159ab48cfd88becb003..89665c551ad50f0a95cc945c5bf7c6c77dbd6dce 100755 (executable)
--- a/vm/quotations.cpp
+++ b/vm/quotations.cpp
@@ -307,7 +307,7 @@ void factor_vm::primitive_array_to_quotation()
        quot->array = ctx->peek();
        quot->cached_effect = false_object;
        quot->cache_counter = false_object;
-       quot->xt = (void *)lazy_jit_compile;
+       quot->xt = (void *)lazy_jit_compile_impl;
        quot->code = NULL;
        ctx->replace(tag<quotation>(quot));
 }
@@ -332,16 +332,16 @@ fixnum factor_vm::quot_code_offset_to_scan(cell quot_, cell offset)
        return compiler.get_position();
 }
 
-cell factor_vm::lazy_jit_compile_impl(cell quot_)
+cell factor_vm::lazy_jit_compile(cell quot_)
 {
        data_root<quotation> quot(quot_,this);
        jit_compile_quot(quot.value(),true);
        return quot.value();
 }
 
-VM_C_API cell lazy_jit_compile_impl(cell quot, factor_vm *parent)
+VM_C_API cell lazy_jit_compile(cell quot, factor_vm *parent)
 {
-       return parent->lazy_jit_compile_impl(quot);
+       return parent->lazy_jit_compile(quot);
 }
 
 void factor_vm::primitive_quot_compiled_p()

diff --git a/vm/quotations.hpp b/vm/quotations.hpp
index cd867dc22f1557dedb49361e197ecc4a1ecc6d53..69755302ea8df5cdd901b24a12c1555acaa047d3 100755 (executable)
--- a/vm/quotations.hpp
+++ b/vm/quotations.hpp
@@ -27,6 +27,6 @@ struct quotation_jit : public jit {
        void iterate_quotation();
 };
 
-VM_C_API cell lazy_jit_compile_impl(cell quot, factor_vm *parent);
+VM_C_API cell lazy_jit_compile(cell quot, factor_vm *parent);
 
 }

diff --git a/vm/vm.hpp b/vm/vm.hpp
index ffdb9f25917296572991a876f1736559d73a2a78..101b47c298730cb01ca29a57fe6913ac519f2334 100755 (executable)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -603,7 +603,7 @@ struct factor_vm
        code_block *jit_compile_quot(cell owner_, cell quot_, bool relocating);
        void jit_compile_quot(cell quot_, bool relocating);
        fixnum quot_code_offset_to_scan(cell quot_, cell offset);
-       cell lazy_jit_compile_impl(cell quot);
+       cell lazy_jit_compile(cell quot);
        void primitive_quot_compiled_p();
 
        //dispatch