X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=OPTIMIZATIONS;h=51fcb32f0e2a426469ae07f97796e3b2d1685a19;hb=5a2b6553fbbbb62fa789350facd0d56bb136045f;hp=2b2d63b5b69e118fd53ef28c2f876758fefc5a7f;hpb=c5c178ceac9f34b2c3580557fec1ffe15073ac99;p=sbcl.git

diff --git a/OPTIMIZATIONS b/OPTIMIZATIONS
index 2b2d63b..51fcb32 100644
--- a/OPTIMIZATIONS
+++ b/OPTIMIZATIONS
@@ -11,9 +11,6 @@
 
 * On X86 I is represented as a tagged integer.
 
-* EQL uses "CMP reg,reg" instead of "CMP reg,im". This causes
-  allocation of an extra register and an extra move.
-
 * Unnecessary move:
   3: SLOT S!11[EDX] {SB-C::VECTOR-LENGTH 1 7} => t23[EAX]
   4: MOVE t23[EAX] => t24[EBX]
@@ -65,11 +62,6 @@ VOP DATA-VECTOR-SET/SIMPLE-STRING V2!14[EDI] t32[EAX] t30[S2]>t33[CL]
 
 * And why two moves?
 --------------------------------------------------------------------------------
-#5
-(loop repeat 1.5)
-
-uses generic arithmetic
---------------------------------------------------------------------------------
 #6
 09:49:05 <jtra> I have found a case in those where suboptimal code is
   generate with nested loops, it might be moderately easy to fix that
@@ -80,7 +72,6 @@ uses generic arithmetic
   memory location for iteration variable
 
 ;;; -*- mode: lisp -*-
-;;; $Id$
 ;;; http://www.bagley.org/~doug/shootout/
 ;;; from Friedrich Dominicus
 
@@ -99,21 +90,14 @@ uses generic arithmetic
                 (incf x)))))))
    (format t "~A~%" x)))
 --------------------------------------------------------------------------------
-#7
-(defun foo (x)
-  (declare (optimize speed (debug 0)))
-  (if (< x 0) x (foo (1- x))))
-
-SBCL generates a full call of FOO (but CMUCL does not).
---------------------------------------------------------------------------------
 #8
 (defun foo (d)
   (declare (optimize (speed 3) (safety 0) (debug 0)))
   (declare (type (double-float 0d0 1d0) d))
   (loop for i fixnum from 1 to 5
-     for x1 double-float = (sin d) ;;; !!!
-     do (loop for j fixnum from 1 to 4
-             sum x1 double-float)))
+        for x1 double-float = (sin d) ;;; !!!
+        do (loop for j fixnum from 1 to 4
+                 sum x1 double-float)))
 
 Without the marked declaration Python will use boxed representation for X1.
 
@@ -128,7 +112,7 @@ The initial binding is effectless, and without it X is of type
 DOUBLE-FLOAT. Unhopefully, IR1 does not optimize away effectless
 SETs/bindings, and IR2 does not perform type inference.
 --------------------------------------------------------------------------------
-#9
+#9 "Multi-path constant folding"
 (defun foo (x)
   (if (= (cond ((irgh x) 0)
                ((buh x) 1)
@@ -144,28 +128,31 @@ This code could be optimized to
         ((buh x) :no)
         (t :no)))
 --------------------------------------------------------------------------------
-#10
-Reported by Robert E. Brown on sbcl-devel 2003-01-21:
+#11
+(inverted variant of #9)
 
-(defstruct trace-info
-  (foo nil :type (or null function)))
+(lambda (x)
+  (let ((y (sap-alien x c-string)))
+    (list (alien-sap y)
+          (alien-sap y))))
 
-(defun bad (x)
-  (declare (optimize (speed 3) (safety 0)))
-  (let ((wow (trace-info-foo x)))
-    (or (not wow) (funcall wow 1 2 3))))
+It could be optimized to
 
-Python does not derive that FUNCALL is applied to FUNCTION.
+(lambda (x) (list x x))
 
-(OR ...) is equivalent to
-
-(LET ((G2407 (NOT WOW)))
-  (IF G2407 G2407 (FUNCALL WOW 1 2 3)))
-
-or to
-
-(LET ((G2407 (IF WOW NIL T)))
-  (IF G2407 G2407 (FUNCALL WOW 1 2 3)))
+(if Y were used only once, the current compiler would optimize it)
+--------------------------------------------------------------------------------
+#12
+(typep (truly-the (simple-array * (*)) x) 'simple-vector)
 
-so this is similar to #9.
+tests lowtag.
+--------------------------------------------------------------------------------
+#13
+FAST-+/FIXNUM and similar should accept unboxed arguments in interests
+of representation selection. Problem: inter-TN dependencies.
+--------------------------------------------------------------------------------
+#14
+The derived type of (/ (THE (DOUBLE-FLOAT (0D0)) X) (THE (DOUBLE-FLOAT
+1D0) Y)) is (DOUBLE-FLOAT 0.0d0). While it might be reasonable, it is
+better to derive (DOUBLE-FLOAT (-0.0d0)).
 --------------------------------------------------------------------------------