0.8.2.55:

[sbcl.git] / BUGS

diff --git a/BUGS b/BUGS
index 44aa72d..84357b1 100644 (file)
--- a/BUGS
+++ b/BUGS
@@ -170,12 +170,6 @@ WORKAROUND:
 45:
   a slew of floating-point-related errors reported by Peter Van Eynde
   on July 25, 2000:
 45:
   a slew of floating-point-related errors reported by Peter Van Eynde
   on July 25, 2000:

-       b: SBCL's value for LEAST-POSITIVE-SHORT-FLOAT on the x86 is 
-          bogus, and should probably be 1.4012985e-45. In SBCL,
-          (/ LEAST-POSITIVE-SHORT-FLOAT 2) returns a number smaller
-          than LEAST-POSITIVE-SHORT-FLOAT. Similar problems 
-          exist for LEAST-NEGATIVE-SHORT-FLOAT, LEAST-POSITIVE-LONG-FLOAT,
-          and LEAST-NEGATIVE-LONG-FLOAT.

        c: Many expressions generate floating infinity on x86/Linux:
                (/ 1 0.0)
                (/ 1 0.0d0)
        c: Many expressions generate floating infinity on x86/Linux:
                (/ 1 0.0)
                (/ 1 0.0d0)

@@ -223,12 +217,6 @@ WORKAROUND:
   crashes SBCL. In general tracing anything which is used in the 
   implementation of TRACE is likely to have the same problem.
 
   crashes SBCL. In general tracing anything which is used in the 
   implementation of TRACE is likely to have the same problem.
 

-75:
-  As reported by Martin Atzmueller on sbcl-devel 26 Dec 2000,
-  ANSI says that WITH-OUTPUT-TO-STRING should have a keyword
-  :ELEMENT-TYPE, but in sbcl-0.6.9 this is not defined for
-  WITH-OUTPUT-TO-STRING.
-

 78:
   ANSI says in one place that type declarations can be abbreviated even
   when the type name is not a symbol, e.g.
 78:
   ANSI says in one place that type declarations can be abbreviated even
   when the type name is not a symbol, e.g.

@@ -276,34 +264,6 @@ WORKAROUND:
   holding... * is not equivalent to T in many cases, such as 
     (VECTOR *) /= (VECTOR T).
 
   holding... * is not equivalent to T in many cases, such as 
     (VECTOR *) /= (VECTOR T).
 

-94a: 
-  Inconsistencies between derived and declared VALUES return types for
-  DEFUN aren't checked very well. E.g. the logic which successfully
-  catches problems like
-    (declaim (ftype (function (fixnum) float) foo))
-    (defun foo (x)
-      (declare (type integer x))
-      (values x)) ; wrong return type, detected, gives warning, good!
-  fails to catch
-    (declaim (ftype (function (t) (values t t)) bar))
-    (defun bar (x)
-      (values x)) ; wrong number of return values, no warning, bad!
-  The cause of this is seems to be that (1) the internal function 
-  VALUES-TYPES-EQUAL-OR-INTERSECT used to make the check handles its
-  arguments symmetrically, and (2) when the type checking code was
-  written back when when SBCL's code was still CMU CL, the intent
-  was that this case
-    (declaim (ftype (function (t) t) bar))
-    (defun bar (x)
-      (values x x)) ; wrong number of return values; should give warning?
-  not be warned for, because a two-valued return value is considered
-  to be compatible with callers who expects a single value to be
-  returned. That intent is probably not appropriate for modern ANSI
-  Common Lisp, but fixing this might be complicated because of other
-  divergences between auld-style and new-style handling of
-  multiple-VALUES types. (Some issues related to this were discussed
-  on cmucl-imp at some length sometime in 2000.)
-

 95:
   The facility for dumping a running Lisp image to disk gets confused
   when run without the PURIFY option, and creates an unnecessarily large
 95:
   The facility for dumping a running Lisp image to disk gets confused
   when run without the PURIFY option, and creates an unnecessarily large

@@ -530,6 +490,7 @@ WORKAROUND:
   it took more than two minutes (but less than five) for me.
 
 145:
   it took more than two minutes (but less than five) for me.
 
 145:

+  a.

   ANSI allows types `(COMPLEX ,FOO) to use very hairy values for
   FOO, e.g. (COMPLEX (AND REAL (SATISFIES ODDP))). The old CMU CL
   COMPLEX implementation didn't deal with this, and hasn't been
   ANSI allows types `(COMPLEX ,FOO) to use very hairy values for
   FOO, e.g. (COMPLEX (AND REAL (SATISFIES ODDP))). The old CMU CL
   COMPLEX implementation didn't deal with this, and hasn't been

@@ -537,6 +498,18 @@ WORKAROUND:
   conformance problem, since seems hard to construct useful code
   where it matters.)
 
   conformance problem, since seems hard to construct useful code
   where it matters.)
 

+  b.
+  * (defun foo (x)
+      (declare (type (double-float -0d0) x))
+      (declare (optimize speed))
+      (+ x (sqrt (log (random 1d0)))))
+  debugger invoked on condition of type SIMPLE-ERROR:
+    bad thing to be a type specifier: ((COMPLEX
+                                        (DOUBLE-FLOAT 0.0d0
+                                                      #.SB-EXT:DOUBLE-FLOAT-POSITIVE-INFINITY))
+                                       #C(0.0d0 #.SB-EXT:DOUBLE-FLOAT-POSITIVE-INFINITY)
+                                       #C(0.0d0 #.SB-EXT:DOUBLE-FLOAT-POSITIVE-INFINITY))
+

 146:
   Floating point errors are reported poorly. E.g. on x86 OpenBSD
   with sbcl-0.7.1, 
 146:
   Floating point errors are reported poorly. E.g. on x86 OpenBSD
   with sbcl-0.7.1, 

@@ -846,22 +819,7 @@ WORKAROUND:
    Then (FOO #\1 *STANDARD-OUTPUT*) signals type error.
 
   (In 0.7.9.1 the result type is (FUNCTION * *), so Python does not
    Then (FOO #\1 *STANDARD-OUTPUT*) signals type error.
 
   (In 0.7.9.1 the result type is (FUNCTION * *), so Python does not

-  produce invalid code, but type checking is not accurate. Similar
-  problems exist with VALUES-TYPE-INTERSECTION.)
-
-220:
-  Sbcl 0.7.9 fails to compile
-
-  (multiple-value-call #'list
-    (the integer (helper))
-    nil)
-
-  Type check for INTEGER, the result of which serves as the first
-  argument of M-V-C, is inserted after evaluation of NIL. So arguments
-  of M-V-C are pushed in the wrong order. As a temporary workaround
-  type checking was disabled for M-V-Cs in 0.7.9.13. A better solution
-  would be to put the check between evaluation of arguments, but it
-  could be tricky to check result types of PROG1, IF etc.
+  produce invalid code, but type checking is not accurate.)

 
 233: bugs in constraint propagation
   a.
 
 233: bugs in constraint propagation
   a.

@@ -1067,31 +1025,6 @@ WORKAROUND:
 
   Urgh... It's time to write IR1-copier.
 
 
   Urgh... It's time to write IR1-copier.
 

-262:
-  In 0.8.1.32:
-
-    * (ensure-generic-function 'foo)
-    #<STANDARD-GENERIC-FUNCTION FOO (0)>
-    * (defmethod foo (x) x)
-    debugger invoked on condition of type SIMPLE-ERROR:
-      The generic function #<STANDARD-GENERIC-FUNCTION FOO (0)> takes 0 required
-      arguments; was asked to find a method with specializers (#<BUILT-IN-CLASS T>)
-
-  AMOP seems to say that it should work (first ADD-METHOD initializes
-  GF lambda list).
-
-264:
-  (reported by <dsk> on #lisp 2003-07-16)
-
-    (progv '(foo) '(1)
-      (eval '(symbol-macrolet ((foo 3))
-               (declare (special foo))
-               foo)))
-
-  does not signal an error.
-
-  (fixed in 0.8.1.37)
-

 265:
   SB-EXT:RUN-PROGRAM is currently non-functional on Linux/PPC;
   attempting to use it leads to segmentation violations.  This is
 265:
   SB-EXT:RUN-PROGRAM is currently non-functional on Linux/PPC;
   attempting to use it leads to segmentation violations.  This is

@@ -1107,15 +1040,72 @@ WORKAROUND:
   be nice to understand why the first patch caused problems, and to
   fix the cause if possible.
 
   be nice to understand why the first patch caused problems, and to
   fix the cause if possible.
 

-267:
-  In
-    (defun fact (x i)
-      (if (= x 0)
-          i
-          (fact (1- x) (* x i))))
-  sbcl does not convert the self-recursive call to a jump, though it
-  is allowed to by CLHS 3.2.2.3.  CMUCL, however, does perform this
-  optimization.
+268: "wrong free declaration scope"
+  The following code must signal type error:
+
+    (locally (declare (optimize (safety 3)))
+      (flet ((foo (x &optional (y (car x)))
+               (declare (optimize (safety 0)))
+               (list x y)))
+        (funcall (eval #'foo) 1)))
+
+269:
+  SCALE-FLOAT should accept any integer for its second argument.
+
+270:
+  In the following function constraint propagator optimizes nothing:
+
+    (defun foo (x)
+      (declare (integer x))
+      (declare (optimize speed))
+      (typecase x
+        (fixnum "hala")
+        (fixnum "buba")
+        (bignum "hip")
+        (t "zuz")))
+
+272:
+  All forms of GC hooks (including notifiers and finalisers) are currently
+  (since 0.8.0) broken for gencgc (i.e. x86) users 
+
+273:
+  Compilation of the following two forms causes "X is unbound" error:
+
+    (symbol-macrolet ((x pi))
+      (macrolet ((foo (y) (+ x y)))
+        (declaim (inline bar))
+        (defun bar (z)
+          (* z (foo 4)))))
+    (defun quux (z)
+      (bar z))
+
+  (See (COERCE (CDR X) 'FUNCTION) in IR1-CONVERT-INLINE-LAMBDA.)
+
+274:
+  CLHS says that type declaration of a symbol macro should not affect
+  its expansion, but in SBCL it does.
+
+275:
+  The following code (taken from CLOCC) takes a lot of time to compile:
+
+    (defun foo (n)
+      (declare (type (integer 0 #.large-constant) n))
+      (expt 1/10 n))
+
+  (fixed in 0.8.2.51, but a test case would be good)
+
+276:
+    (defmethod fee ((x fixnum))
+      (setq x (/ x 2))
+      x)
+    (fee 1) => type error
+
+  (taken from CLOCC)
+
+277:
+  IGNORE/IGNORABLE declarations should be acceptable for symbol
+  macros.
+

 
 DEFUNCT CATEGORIES OF BUGS
   IR1-#:
 
 DEFUNCT CATEGORIES OF BUGS
   IR1-#: