X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fsrctran.lisp;h=869f6842cd2aea287da93aeacb3f3ac667aa22ff;hb=e73a30c901ab234291aefc9f1e73507650628892;hp=6ba54f858372a38ae03a204bd43b378909a7748b;hpb=20b2378572cf7378f3f267e2234c4234dacfbdc9;p=sbcl.git

diff --git a/src/compiler/srctran.lisp b/src/compiler/srctran.lisp
index 6ba54f8..869f684 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)))
@@ -2121,7 +2125,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 +2158,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 +2198,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 +2237,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 +2249,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 +2553,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)))
@@ -3285,12 +3301,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 +3317,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 +3398,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
@@ -3583,7 +3591,17 @@
 	    (t
 	     *universal-type*)))))
 
+;;; 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.
 (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)))
@@ -3617,15 +3635,16 @@
 				      (%elt largest) i-elt
 				      i largest)))))))))
 	      (%sort-vector (keyfun &optional (vtype 'vector))
-	       `(macrolet (;; KLUDGE: In SBCL ca. 0.6.10, I had trouble getting
-			   ;; type inference to propagate all the way
-			   ;; through this tangled mess of
-			   ;; inlining. The TRULY-THE here works
-			   ;; around that. -- WHN
+	       `(macrolet (;; KLUDGE: In SBCL ca. 0.6.10, I had
+			   ;; trouble getting type inference to
+			   ;; propagate all the way through this
+			   ;; tangled mess of inlining. The TRULY-THE
+			   ;; here works around that. -- WHN
 			   (%elt (i)
 			    `(aref (truly-the ,',vtype ,',',vector)
 			      (%index (+ (%index ,i) start-1)))))
-		 (let ((start-1 (1- ,',start)) ; Heaps prefer 1-based addressing.
+		 (let (;; Heaps prefer 1-based addressing.
+		       (start-1 (1- ,',start)) 
 		       (current-heap-size (- ,',end ,',start))
 		       (keyfun ,keyfun))
 		   (declare (type (integer -1 #.(1- most-positive-fixnum))