0.7.3.10: Fix the SIGILL with ev6 and later Alphas: icache needs flushing

[sbcl.git] / src / compiler / x86 / move.lisp

diff --git a/src/compiler/x86/move.lisp b/src/compiler/x86/move.lisp
index 6308b3c..ad715a1 100644 (file)
--- a/src/compiler/x86/move.lisp
+++ b/src/compiler/x86/move.lisp
@@ -11,7 +11,7 @@
 
 (in-package "SB!VM")
 
-(define-move-function (load-immediate 1) (vop x y)
+(define-move-fun (load-immediate 1) (vop x y)
   ((immediate)
    (any-reg descriptor-reg))
   (let ((val (tn-value x)))
@@ -26,23 +26,23 @@
        (inst mov y (logior (ash (char-code val) n-widetag-bits)
                           base-char-widetag))))))
 
-(define-move-function (load-number 1) (vop x y)
+(define-move-fun (load-number 1) (vop x y)
   ((immediate) (signed-reg unsigned-reg))
   (inst mov y (tn-value x)))
 
-(define-move-function (load-base-char 1) (vop x y)
+(define-move-fun (load-base-char 1) (vop x y)
   ((immediate) (base-char-reg))
   (inst mov y (char-code (tn-value x))))
 
-(define-move-function (load-system-area-pointer 1) (vop x y)
+(define-move-fun (load-system-area-pointer 1) (vop x y)
   ((immediate) (sap-reg))
   (inst mov y (sap-int (tn-value x))))
 
-(define-move-function (load-constant 5) (vop x y)
+(define-move-fun (load-constant 5) (vop x y)
   ((constant) (descriptor-reg any-reg))
   (inst mov y x))
 
-(define-move-function (load-stack 5) (vop x y)
+(define-move-fun (load-stack 5) (vop x y)
   ((control-stack) (any-reg descriptor-reg)
    (base-char-stack) (base-char-reg)
    (sap-stack) (sap-reg)
@@ -50,7 +50,7 @@
    (unsigned-stack) (unsigned-reg))
   (inst mov y x))
 
-(define-move-function (store-stack 5) (vop x y)
+(define-move-fun (store-stack 5) (vop x y)
   ((any-reg descriptor-reg) (control-stack)
    (base-char-reg) (base-char-stack)
    (sap-reg) (sap-stack)
@@ -89,18 +89,18 @@
   (any-reg descriptor-reg immediate)
   (any-reg descriptor-reg))
 
-;;; Make Move the check VOP for T so that type check generation
+;;; Make MOVE the check VOP for T so that type check generation
 ;;; doesn't think it is a hairy type. This also allows checking of a
 ;;; few of the values in a continuation to fall out.
 (primitive-type-vop move (:check) t)
 
-;;; The Move-Argument VOP is used for moving descriptor values into
+;;; The MOVE-ARG VOP is used for moving descriptor values into
 ;;; another frame for argument or known value passing.
 ;;;
 ;;; Note: It is not going to be possible to move a constant directly
 ;;; to another frame, except if the destination is a register and in
 ;;; this case the loading works out.
-(define-vop (move-argument)
+(define-vop (move-arg)
   (:args (x :scs (any-reg descriptor-reg immediate) :target y
            :load-if (not (and (sc-is y any-reg descriptor-reg)
                               (sc-is x control-stack))))
@@ -155,7 +155,7 @@
           ;; Lisp stack
           (storew x fp (- (1+ (tn-offset y))))))))))
 
-(define-move-vop move-argument :move-argument
+(define-move-vop move-arg :move-arg
   (any-reg descriptor-reg)
   (any-reg descriptor-reg))
 \f
@@ -365,12 +365,12 @@
         (inst jmp :ns one-word-bignum)
         ;; two word bignum
         (inst mov y (logior (ash (1- (+ bignum-digits-offset 2))
-                                 sb!vm:n-widetag-bits)
+                                 n-widetag-bits)
                             bignum-widetag))
         (inst jmp L1)
         (emit-label one-word-bignum)
         (inst mov y (logior (ash (1- (+ bignum-digits-offset 1))
-                                 sb!vm:n-widetag-bits)
+                                 n-widetag-bits)
                             bignum-widetag))
         (emit-label L1)
         (pseudo-atomic
@@ -400,7 +400,7 @@
   (signed-reg unsigned-reg) (signed-reg unsigned-reg))
 
 ;;; Move untagged number arguments/return-values.
-(define-vop (move-word-argument)
+(define-vop (move-word-arg)
   (:args (x :scs (signed-reg unsigned-reg) :target y)
         (fp :scs (any-reg) :load-if (not (sc-is y sap-reg))))
   (:results (y))
@@ -413,10 +413,10 @@
        (if (= (tn-offset fp) esp-offset)
           (storew x fp (tn-offset y))  ; c-call
           (storew x fp (- (1+ (tn-offset y)))))))))
-(define-move-vop move-word-argument :move-argument
+(define-move-vop move-word-arg :move-arg
   (descriptor-reg any-reg signed-reg unsigned-reg) (signed-reg unsigned-reg))
 
-;;; Use standard MOVE-ARGUMENT and coercion to move an untagged number
+;;; Use standard MOVE-ARG and coercion to move an untagged number
 ;;; to a descriptor passing location.
-(define-move-vop move-argument :move-argument
+(define-move-vop move-arg :move-arg
   (signed-reg unsigned-reg) (any-reg descriptor-reg))