1.0.24.7: CHAR-CODE type derivation

[sbcl.git] / OPTIMIZATIONS

diff --git a/OPTIMIZATIONS b/OPTIMIZATIONS
index 45b5463..55f86c4 100644 (file)
--- a/OPTIMIZATIONS
+++ b/OPTIMIZATIONS
@@ -162,15 +162,6 @@ through TYPEP UNBOXED-ARRAY, within the compiler itself.
 rather than either constant-folding or manipulating NIL-VALUE or
 NULL-TN directly.
 --------------------------------------------------------------------------------
-#19
-  (let ((dx (if (foo)
-                (list x)
-                (list y z))))
-    (declare (dynamic-extent dx))
-    ...)
-
-DX is not allocated on stack.
---------------------------------------------------------------------------------
 #20
 (defun-with-dx foo (x)
   (flet ((make (x)
@@ -182,23 +173,11 @@ DX is not allocated on stack.
       (declare (dynamic-extent l))
       (mapc #'print l))))
 
-Result of MAKE is not stack allocated, which means that
-stack-allocation of structures is impossible.
---------------------------------------------------------------------------------
-#21
-(defun-with-dx foo ()
-  (let ((dx (list (list 1 2) (list 3 4))))
-    (declare (dynamic-extent dx))
-    ...))
-
-External list in DX is allocated on stack, but internal are not.
+Result of MAKE is not stack allocated.
 --------------------------------------------------------------------------------
 #22
 IR2 does not perform unused code flushing.
 --------------------------------------------------------------------------------
-#23
-Python does not know that &REST lists are LISTs (and cannot derive it).
---------------------------------------------------------------------------------
 #24
 a. Iterations on &REST lists, returning them as VALUES could be
    rewritten with &MORE vectors.
@@ -328,32 +307,6 @@ using the x86 FP stack.  It would be nice if SBCL included an SSE2-based
 floating point backend with a compile-time option to switch between the
 two.
 --------------------------------------------------------------------------------
-#34
-Compiling
-
-(defun foo (x y)
-  (declare (type (integer 0 45) x y))
-  (+ x y))
-
-results in the following error trapping code for type-checking the
-arguments:
-
-;      424: L0:   8B058CE31812     MOV EAX, [#x1218E38C]      ; '(MOD 46)
-;      42A:       0F0B0A           BREAK 10                   ; error trap
-;      42D:       05               BYTE #X05
-;      42E:       1F               BYTE #X1F                  ; OBJECT-NOT-TYPE-ERROR
-;      42F:       FECE01           BYTE #XFE, #XCE, #X01      ; EDI
-;      432:       0E               BYTE #X0E                  ; EAX
-;      433: L1:   8B0590E31812     MOV EAX, [#x1218E390]      ; '(MOD 46)
-;      439:       0F0B0A           BREAK 10                   ; error trap
-;      43C:       03               BYTE #X03
-;      43D:       1F               BYTE #X1F                  ; OBJECT-NOT-TYPE-ERROR
-;      43E:       8E               BYTE #X8E                  ; EDX
-;      43F:       0E               BYTE #X0E                  ; EAX
-
-Notice that '(MOD 46) has two entries in the constant vector.  Having
-one would be preferable.
---------------------------------------------------------------------------------
 #35
 Compiling
 
@@ -411,12 +364,6 @@ all three comparisons or b) eliminated the necessity of the MOV(s)
 altogether.  The former option is probably easier than the latter.
 
 --------------------------------------------------------------------------------
-#37
-
-Dynamic extent allocation doesn't currently work for one-element lists,
-since there's a source transform from (LIST X) to (CONS X NIL).
-
---------------------------------------------------------------------------------
 #38
 
 (setf (subseq s1 start1 end1) (subseq s2 start2 end1))
@@ -439,3 +386,18 @@ currently compiles to code that ensures the TLS index at runtime, which
 is both a decently large chunk of code and unnecessary, as we could ensure
 the TLS index at load-time as well.
 
+--------------------------------------------------------------------------------
+#40
+
+When FTYPE is declared -- to say (function (t t t t t) t), and
+function has a compiler-macro,
+
+  (apply #'foo 'x1 x2 'x3 more)
+
+can be transformed into
+
+  (apply (lambda (x2 x4 x5) (foo 'x1 x2 'x3 x4 x5)) x2 more)
+
+which allows compiler-macro-expansion for FOO. (Only constant
+arguments can be moved inside the new lambda -- otherwise evaluation
+order is altered.)