X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fsrctran.lisp;h=e4084c355533509cc10c4d18d24096f689f29a52;hb=e0697854ef9f4999c8585b64be1b282ce4725176;hp=f4b00457b754474d14102057cae23bb450de33c8;hpb=ffdebb412afde6c9cd9f433c8537519135d648c2;p=sbcl.git

diff --git a/src/compiler/srctran.lisp b/src/compiler/srctran.lisp
index f4b0045..e4084c3 100644
--- a/src/compiler/srctran.lisp
+++ b/src/compiler/srctran.lisp
@@ -65,10 +65,14 @@
 (defun source-transform-cxr (form)
   (if (/= (length form) 2)
       (values nil t)
-      (let ((name (symbol-name (car form))))
-	(do ((i (- (length name) 2) (1- i))
+      (let* ((name (car form))
+	     (string (symbol-name
+		      (etypecase name
+			(symbol name)
+			(leaf (leaf-source-name name))))))
+	(do ((i (- (length string) 2) (1- i))
 	     (res (cadr form)
-		  `(,(ecase (char name i)
+		  `(,(ecase (char string i)
 		       (#\A 'car)
 		       (#\D 'cdr))
 		    ,res)))
@@ -1616,6 +1620,13 @@
 		       #'%unary-truncate-derive-type-aux
 		       #'%unary-truncate))
 
+(defoptimizer (%unary-ftruncate derive-type) ((number))
+  (let ((divisor (specifier-type '(integer 1 1))))
+    (one-arg-derive-type number
+                         #'(lambda (n)
+                             (ftruncate-derive-type-quot-aux n divisor nil))
+                         #'%unary-ftruncate)))
+
 ;;; Define optimizers for FLOOR and CEILING.
 (macrolet
     ((def (name q-name r-name)
@@ -2121,7 +2132,8 @@
       (values nil t t)))
 
 (defun logand-derive-type-aux (x y &optional same-leaf)
-  (declare (ignore same-leaf))
+  (when same-leaf
+    (return-from logand-derive-type-aux x))
   (multiple-value-bind (x-len x-pos x-neg) (integer-type-length x)
     (declare (ignore x-pos))
     (multiple-value-bind (y-len y-pos y-neg) (integer-type-length  y)
@@ -2153,7 +2165,8 @@
 		  (specifier-type 'integer)))))))
 
 (defun logior-derive-type-aux (x y &optional same-leaf)
-  (declare (ignore same-leaf))
+  (when same-leaf
+    (return-from logior-derive-type-aux x))
   (multiple-value-bind (x-len x-pos x-neg) (integer-type-length x)
     (multiple-value-bind (y-len y-pos y-neg) (integer-type-length y)
       (cond
@@ -2192,7 +2205,8 @@
 		(specifier-type 'integer))))))))
 
 (defun logxor-derive-type-aux (x y &optional same-leaf)
-  (declare (ignore same-leaf))
+  (when same-leaf
+    (return-from logxor-derive-type-aux (specifier-type '(eql 0))))
   (multiple-value-bind (x-len x-pos x-neg) (integer-type-length x)
     (multiple-value-bind (y-len y-pos y-neg) (integer-type-length y)
       (cond
@@ -2230,7 +2244,7 @@
 (defoptimizer (logeqv derive-type) ((x y))
   (two-arg-derive-type x y (lambda (x y same-leaf)
 			     (lognot-derive-type-aux 
-			      (logxor-derive-type-aux x y same-leaf))) 
+			      (logxor-derive-type-aux x y same-leaf)))
 		       #'logeqv))
 (defoptimizer (lognand derive-type) ((x y))
   (two-arg-derive-type x y (lambda (x y same-leaf)
@@ -2242,25 +2256,34 @@
 			     (lognot-derive-type-aux
 			      (logior-derive-type-aux x y same-leaf)))
 		       #'lognor))
+;;; FIXME: use SAME-LEAF instead of ignoring it.
 (defoptimizer (logandc1 derive-type) ((x y))
   (two-arg-derive-type x y (lambda (x y same-leaf)
-			     (logand-derive-type-aux
-			      (lognot-derive-type-aux x) y nil))
+			     (if same-leaf
+				 (specifier-type '(eql 0))
+				 (logand-derive-type-aux
+				  (lognot-derive-type-aux x) y nil)))
 		       #'logandc1))
 (defoptimizer (logandc2 derive-type) ((x y))
   (two-arg-derive-type x y (lambda (x y same-leaf)
-			     (logand-derive-type-aux
-			      x (lognot-derive-type-aux y) nil))
+			     (if same-leaf
+				 (specifier-type '(eql 0))
+				 (logand-derive-type-aux
+				  x (lognot-derive-type-aux y) nil)))
 		       #'logandc2))
 (defoptimizer (logorc1 derive-type) ((x y))
   (two-arg-derive-type x y (lambda (x y same-leaf)
-			     (logior-derive-type-aux
-			      (lognot-derive-type-aux x) y nil))
+			     (if same-leaf
+				 (specifier-type '(eql -1))
+				 (logior-derive-type-aux
+				  (lognot-derive-type-aux x) y nil)))
 		       #'logorc1))
 (defoptimizer (logorc2 derive-type) ((x y))
   (two-arg-derive-type x y (lambda (x y same-leaf)
-			     (logior-derive-type-aux
-			      x (lognot-derive-type-aux y) nil))
+			     (if same-leaf
+				 (specifier-type '(eql -1))
+				 (logior-derive-type-aux
+				  x (lognot-derive-type-aux y) nil)))
 		       #'logorc2))
 
 ;;;; miscellaneous derive-type methods
@@ -2537,7 +2560,7 @@
            (cut-node (node &aux did-something)
              (when (and (not (block-delete-p (node-block node)))
                         (combination-p node)
-                        (fun-info-p (basic-combination-kind node)))
+			(eq (basic-combination-kind node) :known))
                (let* ((fun-ref (lvar-use (combination-fun node)))
                       (fun-name (leaf-source-name (ref-leaf fun-ref)))
                       (modular-fun (find-modular-version fun-name width)))
@@ -2642,7 +2665,7 @@
   (let* ((y (lvar-value y))
 	 (y-abs (abs y))
 	 (len (1- (integer-length y-abs))))
-    (unless (= y-abs (ash 1 len))
+    (unless (and (> y-abs 0) (= y-abs (ash 1 len)))
       (give-up-ir1-transform))
     (if (minusp y)
 	`(- (ash x ,len))
@@ -2657,7 +2680,7 @@
 	 (let* ((y (lvar-value y))
 		(y-abs (abs y))
 		(len (1- (integer-length y-abs))))
-	   (unless (= y-abs (ash 1 len))
+	   (unless (and (> y-abs 0) (= y-abs (ash 1 len)))
 	     (give-up-ir1-transform))
 	   (let ((shift (- len))
 		 (mask (1- y-abs))
@@ -2683,7 +2706,7 @@
   (let* ((y (lvar-value y))
 	 (y-abs (abs y))
 	 (len (1- (integer-length y-abs))))
-    (unless (= y-abs (ash 1 len))
+    (unless (and (> y-abs 0) (= y-abs (ash 1 len)))
       (give-up-ir1-transform))
     (let ((mask (1- y-abs)))
       (if (minusp y)
@@ -2698,7 +2721,7 @@
   (let* ((y (lvar-value y))
 	 (y-abs (abs y))
 	 (len (1- (integer-length y-abs))))
-    (unless (= y-abs (ash 1 len))
+    (unless (and (> y-abs 0) (= y-abs (ash 1 len)))
       (give-up-ir1-transform))
     (let* ((shift (- len))
 	   (mask (1- y-abs)))
@@ -2720,7 +2743,7 @@
   (let* ((y (lvar-value y))
 	 (y-abs (abs y))
 	 (len (1- (integer-length y-abs))))
-    (unless (= y-abs (ash 1 len))
+    (unless (and (> y-abs 0) (= y-abs (ash 1 len)))
       (give-up-ir1-transform))
     (let ((mask (1- y-abs)))
       `(if (minusp x)
@@ -3285,12 +3308,6 @@
 
 ;;; for compile-time argument count checking.
 ;;;
-;;; FIXME I: this is currently called from DEFTRANSFORMs, the vast
-;;; majority of which are not going to transform the code, but instead
-;;; are going to GIVE-UP-IR1-TRANSFORM unconditionally.  It would be
-;;; nice to make this explicit, maybe by implementing a new
-;;; "optimizer" (say, DEFOPTIMIZER CONSISTENCY-CHECK).
-;;;
 ;;; FIXME II: In some cases, type information could be correlated; for
 ;;; instance, ~{ ... ~} requires a list argument, so if the lvar-type
 ;;; of a corresponding argument is known and does not intersect the
@@ -3307,18 +3324,15 @@
       (let ((nargs (length args)))
 	(cond
 	  ((< nargs min)
-	   (compiler-warn "Too few arguments (~D) to ~S ~S: ~
-                           requires at least ~D."
-			  nargs fun string min))
+	   (warn 'format-too-few-args-warning
+		 :format-control
+		 "Too few arguments (~D) to ~S ~S: requires at least ~D."
+		 :format-arguments (list nargs fun string min)))
 	  ((> nargs max)
-	   (;; to get warned about probably bogus code at
-	    ;; cross-compile time.
-	    #+sb-xc-host compiler-warn
-	    ;; ANSI saith that too many arguments doesn't cause a
-	    ;; run-time error.
-	    #-sb-xc-host compiler-style-warn
-	    "Too many arguments (~D) to ~S ~S: uses at most ~D."
-	    nargs fun string max)))))))
+	   (warn 'format-too-many-args-warning
+		 :format-control
+		 "Too many arguments (~D) to ~S ~S: uses at most ~D."
+		 :format-arguments (list nargs fun string max))))))))
 
 (defoptimizer (format optimizer) ((dest control &rest args))
   (when (constant-lvar-p control)
@@ -3391,18 +3405,19 @@
 		(let ((nargs (length args)))
 		  (cond
 		    ((< nargs (min min1 min2))
-		     (compiler-warn "Too few arguments (~D) to ~S ~S ~S: ~
-                                     requires at least ~D."
-				    nargs 'cerror y x (min min1 min2)))
+		     (warn 'format-too-few-args-warning
+			   :format-control
+			   "Too few arguments (~D) to ~S ~S ~S: ~
+                            requires at least ~D."
+			   :format-arguments
+			   (list nargs 'cerror y x (min min1 min2))))
 		    ((> nargs (max max1 max2))
-		     (;; to get warned about probably bogus code at
-		      ;; cross-compile time.
-		      #+sb-xc-host compiler-warn
-		      ;; ANSI saith that too many arguments doesn't cause a
-		      ;; run-time error.
-		      #-sb-xc-host compiler-style-warn
-		      "Too many arguments (~D) to ~S ~S ~S: uses at most ~D."
-		      nargs 'cerror y x (max max1 max2)))))))))))))
+		     (warn 'format-too-many-args-warning
+			   :format-control
+			   "Too many arguments (~D) to ~S ~S ~S: ~
+                            uses at most ~D."
+			   :format-arguments
+			   (list nargs 'cerror y x (max max1 max2))))))))))))))
 
 (defoptimizer (coerce derive-type) ((value type))
   (cond
@@ -3589,6 +3604,11 @@
 ;;; code has been written from scratch following Chapter 7 of
 ;;; _Introduction to Algorithms_ by Corman, Rivest, and Shamir.
 (define-source-transform sb!impl::sort-vector (vector start end predicate key)
+  ;; Like CMU CL, we use HEAPSORT. However, other than that, this code
+  ;; isn't really related to the CMU CL code, since instead of trying
+  ;; to generalize the CMU CL code to allow START and END values, this
+  ;; code has been written from scratch following Chapter 7 of
+  ;; _Introduction to Algorithms_ by Corman, Rivest, and Shamir.
   `(macrolet ((%index (x) `(truly-the index ,x))
 	      (%parent (i) `(ash ,i -1))
 	      (%left (i) `(%index (ash ,i 1)))