X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fsrctran.lisp;h=af914ef24b12693cd747f0f45e77949d194034ba;hb=4e3b57699314dbd3883470d9b196287b178f3e6d;hp=1bcfb8f5ca71e2d0548f16268e3c1b68ab295816;hpb=80304981972c91c1b3f3fca75f36dacf1fecf307;p=sbcl.git

diff --git a/src/compiler/srctran.lisp b/src/compiler/srctran.lisp
index 1bcfb8f..af914ef 100644
--- a/src/compiler/srctran.lisp
+++ b/src/compiler/srctran.lisp
@@ -40,7 +40,7 @@
 ;;; lambda with the appropriate fixed number of args. If the
 ;;; destination is a FUNCALL, then do the &REST APPLY thing, and let
 ;;; MV optimization figure things out.
-(deftransform complement ((fun) * * :node node :when :both)
+(deftransform complement ((fun) * * :node node)
   "open code"
   (multiple-value-bind (min max)
       (fun-type-nargs (continuation-type fun))
@@ -355,11 +355,11 @@
 (defun interval-bounded-p (x how)
   (declare (type interval x))
   (ecase how
-    ('above
+    (above
      (interval-high x))
-    ('below
+    (below
      (interval-low x))
-    ('both
+    (both
      (and (interval-low x) (interval-high x)))))
 
 ;;; signed zero comparison functions. Use these functions if we need
@@ -630,7 +630,7 @@
 	      :low (bound-mul (interval-low x) (interval-low y))
 	      :high (bound-mul (interval-high x) (interval-high y))))
 	    (t
-	     (error "internal error in INTERVAL-MUL"))))))
+	     (bug "excluded case in INTERVAL-MUL"))))))
 
 ;;; Divide two intervals.
 (defun interval-div (top bot)
@@ -680,7 +680,7 @@
 	      :low (bound-div (interval-low top) (interval-high bot) t)
 	      :high (bound-div (interval-high top) (interval-low bot) nil)))
 	    (t
-	     (error "internal error in INTERVAL-DIV"))))))
+	     (bug "excluded case in INTERVAL-DIV"))))))
 
 ;;; Apply the function F to the interval X. If X = [a, b], then the
 ;;; result is [f(a), f(b)]. It is up to the user to make sure the
@@ -732,9 +732,9 @@
 (defun interval-abs (x)
   (declare (type interval x))
   (case (interval-range-info x)
-    ('+
+    (+
      (copy-interval x))
-    ('-
+    (-
      (interval-neg x))
     (t
      (destructuring-bind (x- x+) (interval-split 0 x t t)
@@ -1354,14 +1354,14 @@
   (flet ((ash-outer (n s)
 	   (when (and (fixnump s)
 		      (<= s 64)
-		      (> s sb!vm:*target-most-negative-fixnum*))
+		      (> s sb!xc:most-negative-fixnum))
 	     (ash n s)))
          ;; KLUDGE: The bare 64's here should be related to
          ;; symbolic machine word size values somehow.
 
 	 (ash-inner (n s)
 	   (if (and (fixnump s)
-		    (> s sb!vm:*target-most-negative-fixnum*))
+		    (> s sb!xc:most-negative-fixnum))
              (ash n (min s 64))
              (if (minusp n) -1 0))))
     (or (and (csubtypep n-type (specifier-type 'integer))
@@ -1647,7 +1647,7 @@
 
 ;;; Define optimizers for FLOOR and CEILING.
 (macrolet
-    ((frob-opt (name q-name r-name)
+    ((def (name q-name r-name)
        (let ((q-aux (symbolicate q-name "-AUX"))
 	     (r-aux (symbolicate r-name "-AUX")))
 	 `(progn
@@ -1711,54 +1711,52 @@
 		 (when (and quot rem)
 		   (make-values-type :required (list quot rem))))))))))
 
-  ;; FIXME: DEF-FROB-OPT, not just FROB-OPT
-  (frob-opt floor floor-quotient-bound floor-rem-bound)
-  (frob-opt ceiling ceiling-quotient-bound ceiling-rem-bound))
+  (def floor floor-quotient-bound floor-rem-bound)
+  (def ceiling ceiling-quotient-bound ceiling-rem-bound))
 
 ;;; Define optimizers for FFLOOR and FCEILING
-(macrolet
-    ((frob-opt (name q-name r-name)
-       (let ((q-aux (symbolicate "F" q-name "-AUX"))
-	     (r-aux (symbolicate r-name "-AUX")))
-	 `(progn
-	   ;; Compute type of quotient (first) result.
-	   (defun ,q-aux (number-type divisor-type)
-	     (let* ((number-interval
-		     (numeric-type->interval number-type))
-		    (divisor-interval
-		     (numeric-type->interval divisor-type))
-		    (quot (,q-name (interval-div number-interval
-						 divisor-interval)))
-		    (res-type (numeric-contagion number-type divisor-type)))
-	       (make-numeric-type
-		:class (numeric-type-class res-type)
-		:format (numeric-type-format res-type)
-		:low  (interval-low quot)
-		:high (interval-high quot))))
-
-	   (defoptimizer (,name derive-type) ((number divisor))
-	     (flet ((derive-q (n d same-arg)
-		      (declare (ignore same-arg))
-		      (if (and (numeric-type-real-p n)
-			       (numeric-type-real-p d))
-			  (,q-aux n d)
-			  *empty-type*))
-		    (derive-r (n d same-arg)
-		      (declare (ignore same-arg))
-		      (if (and (numeric-type-real-p n)
-			       (numeric-type-real-p d))
-			  (,r-aux n d)
-			  *empty-type*)))
-	       (let ((quot (two-arg-derive-type
-			    number divisor #'derive-q #',name))
-		     (rem (two-arg-derive-type
-			   number divisor #'derive-r #'mod)))
-		 (when (and quot rem)
-		   (make-values-type :required (list quot rem))))))))))
-
-  ;; FIXME: DEF-FROB-OPT, not just FROB-OPT
-  (frob-opt ffloor floor-quotient-bound floor-rem-bound)
-  (frob-opt fceiling ceiling-quotient-bound ceiling-rem-bound))
+(macrolet ((def (name q-name r-name)
+	     (let ((q-aux (symbolicate "F" q-name "-AUX"))
+		   (r-aux (symbolicate r-name "-AUX")))
+	       `(progn
+		  ;; Compute type of quotient (first) result.
+		  (defun ,q-aux (number-type divisor-type)
+		    (let* ((number-interval
+			    (numeric-type->interval number-type))
+			   (divisor-interval
+			    (numeric-type->interval divisor-type))
+			   (quot (,q-name (interval-div number-interval
+							divisor-interval)))
+			   (res-type (numeric-contagion number-type
+							divisor-type)))
+		      (make-numeric-type
+		       :class (numeric-type-class res-type)
+		       :format (numeric-type-format res-type)
+		       :low  (interval-low quot)
+		       :high (interval-high quot))))
+
+		  (defoptimizer (,name derive-type) ((number divisor))
+		    (flet ((derive-q (n d same-arg)
+			     (declare (ignore same-arg))
+			     (if (and (numeric-type-real-p n)
+				      (numeric-type-real-p d))
+				 (,q-aux n d)
+				 *empty-type*))
+			   (derive-r (n d same-arg)
+			     (declare (ignore same-arg))
+			     (if (and (numeric-type-real-p n)
+				      (numeric-type-real-p d))
+				 (,r-aux n d)
+				 *empty-type*)))
+		      (let ((quot (two-arg-derive-type
+				   number divisor #'derive-q #',name))
+			    (rem (two-arg-derive-type
+				  number divisor #'derive-r #'mod)))
+			(when (and quot rem)
+			  (make-values-type :required (list quot rem))))))))))
+
+  (def ffloor floor-quotient-bound floor-rem-bound)
+  (def fceiling ceiling-quotient-bound ceiling-rem-bound))
 
 ;;; functions to compute the bounds on the quotient and remainder for
 ;;; the FLOOR function
@@ -2494,7 +2492,7 @@
 		 "place constant arg last"))
 
 ;;; Handle the case of a constant BOOLE-CODE.
-(deftransform boole ((op x y) * * :when :both)
+(deftransform boole ((op x y) * *)
   "convert to inline logical operations"
   (unless (constant-continuation-p op)
     (give-up-ir1-transform "BOOLE code is not a constant."))
@@ -2523,7 +2521,7 @@
 ;;;; converting special case multiply/divide to shifts
 
 ;;; If arg is a constant power of two, turn * into a shift.
-(deftransform * ((x y) (integer integer) * :when :both)
+(deftransform * ((x y) (integer integer) *)
   "convert x*2^k to shift"
   (unless (constant-continuation-p y)
     (give-up-ir1-transform))
@@ -2610,7 +2608,7 @@
     (frob y t)))
 
 ;;; Do the same for MOD.
-(deftransform mod ((x y) (integer integer) * :when :both)
+(deftransform mod ((x y) (integer integer) *)
   "convert remainder mod 2^k to LOGAND"
   (unless (constant-continuation-p y)
     (give-up-ir1-transform))
@@ -2647,7 +2645,7 @@
 		   (logand x ,mask))))))
 
 ;;; And the same for REM.
-(deftransform rem ((x y) (integer integer) * :when :both)
+(deftransform rem ((x y) (integer integer) *)
   "convert remainder mod 2^k to LOGAND"
   (unless (constant-continuation-p y)
     (give-up-ir1-transform))
@@ -2665,27 +2663,24 @@
 
 ;;; Flush calls to various arith functions that convert to the
 ;;; identity function or a constant.
-(macrolet ((def-frob (name identity result)
-             `(deftransform ,name ((x y) (* (constant-arg (member ,identity)))
-                                    * :when :both)
+(macrolet ((def (name identity result)
+             `(deftransform ,name ((x y) (* (constant-arg (member ,identity))) *)
                 "fold identity operations"
                 ',result)))
-  (def-frob ash 0 x)
-  (def-frob logand -1 x)
-  (def-frob logand 0 0)
-  (def-frob logior 0 x)
-  (def-frob logior -1 -1)
-  (def-frob logxor -1 (lognot x))
-  (def-frob logxor 0 x))
+  (def ash 0 x)
+  (def logand -1 x)
+  (def logand 0 0)
+  (def logior 0 x)
+  (def logior -1 -1)
+  (def logxor -1 (lognot x))
+  (def logxor 0 x))
 
 ;;; These are restricted to rationals, because (- 0 0.0) is 0.0, not -0.0, and
 ;;; (* 0 -4.0) is -0.0.
-(deftransform - ((x y) ((constant-arg (member 0)) rational) *
-		 :when :both)
+(deftransform - ((x y) ((constant-arg (member 0)) rational) *)
   "convert (- 0 x) to negate"
   '(%negate y))
-(deftransform * ((x y) (rational (constant-arg (member 0))) *
-		 :when :both)
+(deftransform * ((x y) (rational (constant-arg (member 0))) *)
   "convert (* x 0) to 0"
   0)
 
@@ -2727,7 +2722,7 @@
 ;;;
 ;;; If y is not constant, not zerop, or is contagious, or a positive
 ;;; float +0.0 then give up.
-(deftransform + ((x y) (t (constant-arg t)) * :when :both)
+(deftransform + ((x y) (t (constant-arg t)) *)
   "fold zero arg"
   (let ((val (continuation-value y)))
     (unless (and (zerop val)
@@ -2740,7 +2735,7 @@
 ;;;
 ;;; If y is not constant, not zerop, or is contagious, or a negative
 ;;; float -0.0 then give up.
-(deftransform - ((x y) (t (constant-arg t)) * :when :both)
+(deftransform - ((x y) (t (constant-arg t)) *)
   "fold zero arg"
   (let ((val (continuation-value y)))
     (unless (and (zerop val)
@@ -2750,18 +2745,17 @@
   'x)
 
 ;;; Fold (OP x +/-1)
-(macrolet ((def-frob (name result minus-result)
-             `(deftransform ,name ((x y) (t (constant-arg real))
-                                    * :when :both)
+(macrolet ((def (name result minus-result)
+             `(deftransform ,name ((x y) (t (constant-arg real)) *)
                 "fold identity operations"
                 (let ((val (continuation-value y)))
                   (unless (and (= (abs val) 1)
                                (not-more-contagious y x))
                     (give-up-ir1-transform))
                   (if (minusp val) ',minus-result ',result)))))
-  (def-frob * x (%negate x))
-  (def-frob / x (%negate x))
-  (def-frob expt x (/ 1 x)))
+  (def * x (%negate x))
+  (def / x (%negate x))
+  (def expt x (/ 1 x)))
 
 ;;; Fold (expt x n) into multiplications for small integral values of
 ;;; N; convert (expt x 1/2) to sqrt.
@@ -2787,24 +2781,23 @@
 ;;; transformations?
 ;;; Perhaps we should have to prove that the denominator is nonzero before
 ;;; doing them?  -- WHN 19990917
-(macrolet ((def-frob (name)
+(macrolet ((def (name)
              `(deftransform ,name ((x y) ((constant-arg (integer 0 0)) integer)
-                                   * :when :both)
+                                   *)
                 "fold zero arg"
                 0)))
-  (def-frob ash)
-  (def-frob /))
+  (def ash)
+  (def /))
 
-(macrolet ((def-frob (name)
+(macrolet ((def (name)
              `(deftransform ,name ((x y) ((constant-arg (integer 0 0)) integer)
-                                   * :when :both)
+                                   *)
                 "fold zero arg"
                 '(values 0 0))))
-  (def-frob truncate)
-  (def-frob round)
-  (def-frob floor)
-  (def-frob ceiling))
-
+  (def truncate)
+  (def round)
+  (def floor)
+  (def ceiling))
 
 ;;;; character operations
 
@@ -2852,8 +2845,7 @@
 ;;; if there is no intersection between the types of the arguments,
 ;;; then the result is definitely false.
 (deftransform simple-equality-transform ((x y) * *
-					 :defun-only t
-					 :when :both)
+					 :defun-only t)
   (cond ((same-leaf-ref-p x y)
 	 t)
 	((not (types-equal-or-intersect (continuation-type x)
@@ -2862,11 +2854,11 @@
 	(t
 	 (give-up-ir1-transform))))
 
-(macrolet ((def-frob (x)
+(macrolet ((def (x)
              `(%deftransform ',x '(function * *) #'simple-equality-transform)))
-  (def-frob eq)
-  (def-frob char=)
-  (def-frob equal))
+  (def eq)
+  (def char=)
+  (def equal))
 
 ;;; This is similar to SIMPLE-EQUALITY-PREDICATE, except that we also
 ;;; try to convert to a type-specific predicate or EQ:
@@ -2881,7 +2873,7 @@
 ;;;    these interesting cases.
 ;;; -- If Y is a fixnum, then we quietly pass because the back end can
 ;;;    handle that case, otherwise give an efficiency note.
-(deftransform eql ((x y) * * :when :both)
+(deftransform eql ((x y) * *)
   "convert to simpler equality predicate"
   (let ((x-type (continuation-type x))
 	(y-type (continuation-type y))
@@ -2907,7 +2899,7 @@
 
 ;;; Convert to EQL if both args are rational and complexp is specified
 ;;; and the same for both.
-(deftransform = ((x y) * * :when :both)
+(deftransform = ((x y) * *)
   "open code"
   (let ((x-type (continuation-type x))
 	(y-type (continuation-type y)))
@@ -2985,18 +2977,18 @@
 	      (t
 	       (give-up-ir1-transform))))))
 
-(deftransform < ((x y) (integer integer) * :when :both)
+(deftransform < ((x y) (integer integer) *)
   (ir1-transform-< x y x y '>))
 
-(deftransform > ((x y) (integer integer) * :when :both)
+(deftransform > ((x y) (integer integer) *)
   (ir1-transform-< y x x y '<))
 
 #-sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)
-(deftransform < ((x y) (float float) * :when :both)
+(deftransform < ((x y) (float float) *)
   (ir1-transform-< x y x y '>))
 
 #-sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)
-(deftransform > ((x y) (float float) * :when :both)
+(deftransform > ((x y) (float float) *)
   (ir1-transform-< y x x y '<))
 
 ;;;; converting N-arg comparisons
@@ -3060,7 +3052,7 @@
   (multi-compare 'char-lessp args t))
 
 ;;; This function does source transformation of N-arg inequality
-;;; functions such as /=. This is similar to Multi-Compare in the <3
+;;; functions such as /=. This is similar to MULTI-COMPARE in the <3
 ;;; arg cases. If there are more than two args, then we expand into
 ;;; the appropriate n^2 comparisons only when speed is important.
 (declaim (ftype (function (symbol list) *) multi-not-equal))
@@ -3112,13 +3104,13 @@
 ;;;; versions, and degenerate cases are flushed.
 
 ;;; Left-associate FIRST-ARG and MORE-ARGS using FUNCTION.
-(declaim (ftype (function (symbol t list) list) associate-arguments))
-(defun associate-arguments (function first-arg more-args)
+(declaim (ftype (function (symbol t list) list) associate-args))
+(defun associate-args (function first-arg more-args)
   (let ((next (rest more-args))
 	(arg (first more-args)))
     (if (null next)
 	`(,function ,first-arg ,arg)
-	(associate-arguments function `(,function ,first-arg ,arg) next))))
+	(associate-args function `(,function ,first-arg ,arg) next))))
 
 ;;; Do source transformations for transitive functions such as +.
 ;;; One-arg cases are replaced with the arg and zero arg cases with
@@ -3133,7 +3125,7 @@
 	   `(,leaf-fun ,(first args) ,(second args))
 	   (values nil t)))
     (t
-     (associate-arguments fun (first args) (rest args)))))
+     (associate-args fun (first args) (rest args)))))
 
 (define-source-transform + (&rest args)
   (source-transform-transitive '+ args 0))
@@ -3160,14 +3152,14 @@
     (0 0)
     (1 `(abs (the integer ,(first args))))
     (2 (values nil t))
-    (t (associate-arguments 'gcd (first args) (rest args)))))
+    (t (associate-args 'gcd (first args) (rest args)))))
 
 (define-source-transform lcm (&rest args)
   (case (length args)
     (0 1)
     (1 `(abs (the integer ,(first args))))
     (2 (values nil t))
-    (t (associate-arguments 'lcm (first args) (rest args)))))
+    (t (associate-args 'lcm (first args) (rest args)))))
 
 ;;; Do source transformations for intransitive n-arg functions such as
 ;;; /. With one arg, we form the inverse. With two args we pass.
@@ -3177,7 +3169,7 @@
   (case (length args)
     ((0 2) (values nil t))
     (1 `(,@inverse ,(first args)))
-    (t (associate-arguments function (first args) (rest args)))))
+    (t (associate-args function (first args) (rest args)))))
 
 (define-source-transform - (&rest args)
   (source-transform-intransitive '- args '(%negate)))