0.pre7.139:

[sbcl.git] / src / compiler / alpha / float.lisp

diff --git a/src/compiler/alpha/float.lisp b/src/compiler/alpha/float.lisp
index 67eff15..dba65bd 100644 (file)
--- a/src/compiler/alpha/float.lisp
+++ b/src/compiler/alpha/float.lisp
@@ -13,27 +13,26 @@
 \f
 ;;;; float move functions
 
-(define-move-function (load-fp-zero 1) (vop x y)
+(define-move-fun (load-fp-zero 1) (vop x y)
   ((fp-single-zero) (single-reg)
    (fp-double-zero) (double-reg))
   (inst fmove x y))
 
-(define-move-function (load-single 1) (vop x y)
+(define-move-fun (load-single 1) (vop x y)
   ((single-stack) (single-reg))
   (inst lds y (* (tn-offset x) n-word-bytes) (current-nfp-tn vop)))
 
-(define-move-function (store-single 1) (vop x y)
+(define-move-fun (store-single 1) (vop x y)
   ((single-reg) (single-stack))
   (inst sts x (* (tn-offset y) n-word-bytes) (current-nfp-tn vop)))
 
-
-(define-move-function (load-double 2) (vop x y)
+(define-move-fun (load-double 2) (vop x y)
   ((double-stack) (double-reg))
   (let ((nfp (current-nfp-tn vop))
        (offset (* (tn-offset x) n-word-bytes)))
     (inst ldt y offset nfp)))
 
-(define-move-function (store-double 2) (vop x y)
+(define-move-fun (store-double 2) (vop x y)
   ((double-reg) (double-stack))
   (let ((nfp (current-nfp-tn vop))
        (offset (* (tn-offset y) n-word-bytes)))
@@ -119,10 +118,10 @@
                         ,@(if double-p
                               '((inst stt x offset nfp))
                               '((inst sts x offset nfp))))))))
-               (define-move-vop ,name :move-argument
+               (define-move-vop ,name :move-arg
                  (,sc descriptor-reg) (,sc)))))
-  (frob move-single-float-argument single-reg single-stack nil)
-  (frob move-double-float-argument double-reg double-stack t))
+  (frob move-single-float-arg single-reg single-stack nil)
+  (frob move-double-float-arg double-reg double-stack t))
 \f
 ;;;; complex float move functions
 
@@ -141,7 +140,7 @@
                  :offset (1+ (tn-offset x))))
 
 
-(define-move-function (load-complex-single 2) (vop x y)
+(define-move-fun (load-complex-single 2) (vop x y)
   ((complex-single-stack) (complex-single-reg))
   (let ((nfp (current-nfp-tn vop))
        (offset (* (tn-offset x) n-word-bytes)))
@@ -150,7 +149,7 @@
     (let ((imag-tn (complex-single-reg-imag-tn y)))
       (inst lds imag-tn (+ offset n-word-bytes) nfp))))
 
-(define-move-function (store-complex-single 2) (vop x y)
+(define-move-fun (store-complex-single 2) (vop x y)
   ((complex-single-reg) (complex-single-stack))
   (let ((nfp (current-nfp-tn vop))
        (offset (* (tn-offset y) n-word-bytes)))
@@ -160,7 +159,7 @@
       (inst sts imag-tn (+ offset n-word-bytes) nfp))))
 
 
-(define-move-function (load-complex-double 4) (vop x y)
+(define-move-fun (load-complex-double 4) (vop x y)
   ((complex-double-stack) (complex-double-reg))
   (let ((nfp (current-nfp-tn vop))
        (offset (* (tn-offset x) n-word-bytes)))
@@ -169,7 +168,7 @@
     (let ((imag-tn (complex-double-reg-imag-tn y)))
       (inst ldt imag-tn (+ offset (* 2 n-word-bytes)) nfp))))
 
-(define-move-function (store-complex-double 4) (vop x y)
+(define-move-fun (store-complex-double 4) (vop x y)
   ((complex-double-reg) (complex-double-stack))
   (let ((nfp (current-nfp-tn vop))
        (offset (* (tn-offset y) n-word-bytes)))
@@ -307,9 +306,9 @@
   (descriptor-reg) (complex-double-reg))
 
 ;;;
-;;; complex float move-argument vop
+;;; complex float MOVE-ARG VOP
 ;;;
-(define-vop (move-complex-single-float-argument)
+(define-vop (move-complex-single-float-arg)
   (:args (x :scs (complex-single-reg) :target y)
         (nfp :scs (any-reg) :load-if (not (sc-is y complex-single-reg))))
   (:results (y))
@@ -330,10 +329,10 @@
           (inst sts real-tn offset nfp))
         (let ((imag-tn (complex-single-reg-imag-tn x)))
           (inst sts imag-tn (+ offset n-word-bytes) nfp)))))))
-(define-move-vop move-complex-single-float-argument :move-argument
+(define-move-vop move-complex-single-float-arg :move-arg
   (complex-single-reg descriptor-reg) (complex-single-reg))
 
-(define-vop (move-complex-double-float-argument)
+(define-vop (move-complex-double-float-arg)
   (:args (x :scs (complex-double-reg) :target y)
         (nfp :scs (any-reg) :load-if (not (sc-is y complex-double-reg))))
   (:results (y))
@@ -354,11 +353,11 @@
           (inst stt real-tn offset nfp))
         (let ((imag-tn (complex-double-reg-imag-tn x)))
           (inst stt imag-tn (+ offset (* 2 n-word-bytes)) nfp)))))))
-(define-move-vop move-complex-double-float-argument :move-argument
+(define-move-vop move-complex-double-float-arg :move-arg
   (complex-double-reg descriptor-reg) (complex-double-reg))
 
 
-(define-move-vop move-argument :move-argument
+(define-move-vop move-arg :move-arg
   (single-reg double-reg complex-single-reg complex-double-reg)
   (descriptor-reg))