X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=BUGS;h=4c64490f99abbe41f3d21bbdd262e5b923c64aa4;hb=b4c650bad5478d99132fdf0e219d63cf07d0a5f8;hp=f97463edf4ea0c4b3ced64b2c01b99add72aefd2;hpb=6487794d94ba4804624e9c8b23870dffb61088c2;p=sbcl.git diff --git a/BUGS b/BUGS index f97463e..4c64490 100644 --- a/BUGS +++ b/BUGS @@ -84,12 +84,6 @@ WORKAROUND: d: (fixed in 0.8.1.5) -27: - Sometimes (SB-EXT:QUIT) fails with - Argh! maximum interrupt nesting depth (4096) exceeded, exiting - Process inferior-lisp exited abnormally with code 1 - I haven't noticed a repeatable case of this yet. - 33: And as long as we're wishing, it would be awfully nice if INSPECT could also report on closures, telling about the values of the bound variables. @@ -174,6 +168,9 @@ WORKAROUND: e-mail on cmucl-help@cons.org on 2001-01-16 and 2001-01-17 from WHN and Pierre Mai.) + (Actually this has changed changed since, and types as above are + now supported. This may be a bug.) + 83: RANDOM-INTEGER-EXTRA-BITS=10 may not be large enough for the RANDOM RNG to be high quality near RANDOM-FIXNUM-MAX; it looks as though @@ -252,20 +249,17 @@ WORKAROUND: comfortable merging the patches in the CVS version of SBCL. 108: - (TIME (ROOM T)) reports more than 200 Mbytes consed even for - a clean, just-started SBCL system. And it seems to be right: - (ROOM T) can bring a small computer to its knees for a *long* - time trying to GC afterwards. Surely there's some more economical - way to implement (ROOM T). + ROOM issues: - Daniel Barlow doesn't know what fixed this, but observes that it - doesn't seem to be the case in 0.8.7.3 any more. Instead, (ROOM T) - in a fresh SBCL causes + a) ROOM works by walking over the heap linearly, instead of + following the object graph. Hence, it report garbage objects that + are unreachable. (Maybe this is a feature and not a bug?) - debugger invoked on a SB-INT:BUG in thread 5911: - failed AVER: "(SAP= CURRENT END)" - - unless a GC has happened beforehand. + b) ROOM uses MAP-ALLOCATED-OBJECTS to walk the heap, which doesn't + check all pointers as well as it should, and can hence become + confused, leading to aver failures. As of 1.0.13.21 these (the + SAP= aver in particular) should be mostly under control, but push + ROOM hard enough and it still might croak. 117: When the compiler inline expands functions, it may be that different @@ -732,11 +726,7 @@ WORKAROUND: a. (lambda () (svref (make-array 8 :adjustable t) 1)) - b. (lambda (x) - (list (let ((y (the real x))) - (unless (floatp y) (error "")) - y) - (integer-length x))) + b. (fixed at some point before 1.0.4.10) c. (lambda (x) (declare (optimize (debug 0))) @@ -1476,18 +1466,6 @@ WORKAROUND: tries to find and remove a method with an incompatible lambda list from the unrelated generic function. -381: incautious calls to EQUAL in fasl dumping - Compiling - (frob #(#1=(a #1#))) - (frob #(#1=(b #1#))) - (frob #(#1=(a #1#))) - in sbcl-0.9.0 causes CONTROL-STACK-EXHAUSTED. My (WHN) impression - is that this follows from the use of (MAKE-HASH-TABLE :TEST 'EQUAL) - to detect sharing, in which case fixing it might require either - getting less ambitious about detecting shared list structure, or - implementing the moral equivalent of EQUAL hash tables in a - cycle-tolerant way. - 382: externalization unexpectedly changes array simplicity COMPILE-FILE and LOAD (defun foo () @@ -1634,22 +1612,6 @@ WORKAROUND: For some more details see comments for (define-alien-type-method (c-string :deport-gen) ...) in host-c-call.lisp. -402: "DECLAIM DECLARATION does not inform the PCL code-walker" - reported by Vincent Arkesteijn: - - (declaim (declaration foo)) - (defgeneric bar (x)) - (defmethod bar (x) - (declare (foo x)) - x) - - ==> WARNING: The declaration FOO is not understood by - SB-PCL::SPLIT-DECLARATIONS. - Please put FOO on one of the lists SB-PCL::*NON-VAR-DECLARATIONS*, - SB-PCL::*VAR-DECLARATIONS-WITH-ARG*, or - SB-PCL::*VAR-DECLARATIONS-WITHOUT-ARG*. - (Assuming it is a variable declaration without argument). - 403: FORMAT/PPRINT-LOGICAL-BLOCK of CONDITIONs ignoring *PRINT-CIRCLE* In sbcl-0.9.13.34, (defparameter *c* @@ -1751,6 +1713,10 @@ WORKAROUND: 3: (SB-C::BOUND-FUNC ...) 4: (SB-C::%SINGLE-FLOAT-DERIVE-TYPE-AUX ...) + These are now fixed, but (COERCE HUGE 'SINGLE-FLOAT) still signals a + type-error at runtime. The question is, should it instead signal a + floating-point overflow, or return an infinity? + 408: SUBTYPEP confusion re. OR of SATISFIES of not-yet-defined predicate As reported by Levente M\'{e}sz\'{a}ros sbcl-devel 2006-02-20, (aver (equal (multiple-value-list @@ -1806,3 +1772,114 @@ WORKAROUND: This gives a type error (#:G1 is not a (NOT SYMBOL)) because of the implementation of read circularity, using a symbol as a marker for the previously-referenced object. + +415: Issues creating large arrays on x86-64/Linux and x86/Darwin + + (make-array (1- array-dimension-limit)) + + causes a GC invariant violation on x86-64/Linux, and + an unhandled SIGILL on x86/Darwin. + +416: backtrace confusion + + (defun foo (x) + (let ((v "foo")) + (flet ((bar (z) + (oops v z) + (oops z v))) + (bar x) + (bar v)))) + (foo 13) + + gives the correct error, but the backtrace shows + 1: (SB-KERNEL:FDEFINITION-OBJECT 13 NIL) + as the second frame. + +418: SUBSEQ on lists doesn't support bignum indexes + + LIST-SUBSEQ* now has all the works necessary to support bignum indexes, + but it needs to be verified that changing the DEFKNOWN doesn't kill + performance elsewhere. + + Other generic sequence functions have this problem as well. + +419: stack-allocated indirect closure variables are not popped + + (locally (declare (optimize speed (safety 0))) + (defun bug419 (x) + (multiple-value-call #'list + (eval '(values 1 2 3)) + (let ((x x)) + (declare (dynamic-extent x)) + (flet ((mget (y) + (+ x y)) + (mset (z) + (incf x z))) + (declare (dynamic-extent #'mget #'mset)) + ((lambda (f g) (eval `(progn ,f ,g (values 4 5 6)))) #'mget #'mset)))))) + + (ASSERT (EQUAL (BUG419) '(1 2 3 4 5 6))) => failure + +420: The MISC.556 test from gcl/ansi-tests/misc.lsp fails hard. + +In sbcl-1.0.13 on Linux/x86, executing + (FUNCALL + (COMPILE NIL + '(LAMBDA (P1 P2) + (DECLARE + (OPTIMIZE (SPEED 1) (SAFETY 0) (DEBUG 0) (SPACE 0)) + (TYPE (MEMBER 8174.8604) P1) (TYPE (MEMBER -95195347) P2)) + (FLOOR P1 P2))) + 8174.8604 -95195347) +interactively causes + SB-SYS:MEMORY-FAULT-ERROR: Unhandled memory fault at #x8. +The gcl/ansi-tests/doit.lisp program terminates prematurely shortly after +MISC.556 by falling into gdb with + fatal error encountered in SBCL pid 2827: Unhandled SIGILL +unless the MISC.556 test is commented out. + +Analysis: + and a number of other arithmetic functions exhibit the +same behaviour. Here's the underlying problem: On x86 we perform +single-float + integer normally using double-precision, and then +coerce the result back to single-float. (The FILD instruction always +gives us a double-float, and unless we do MOVE-FROM-SINGLE it remains +one. Or so it seems to me, and that would also explain the observed +behaviour below.) + +During IR1 we derive the types for both + + (+ ) ; uses double-precision + (+ (FLOAT )) ; uses single-precision + +and get a mismatch for a number of unlucky arguments. This leads to +derived result type NIL, and ends up flushing the whole whole +operation -- and finally we generate code without a return sequence, +and fall through to whatever. + +The use of double-precision in the first case appears to be an +(un)happy accident -- interval arithmetic gives us the +double-precision result because that's what the backend does. + + (+ 8172.0 (coerce -95195347 'single-float)) ; => -9.518717e7 + (+ 8172.0 -95195347) ; => -9.5187176e7 + (coerce (+ 8172.0 (coerce -95195347 'double-float)) 'single-float) + ; => -9.5187176e7 + +Which should be fixed, the IR1, or the backend? + +421: READ-CHAR-NO-HANG misbehaviour on Windows Console: + + It seems that on Windows READ-CHAR-NO-HANG hangs if the user + has pressed a key, but not yet enter (ie. SYSREAD-MAY-BLOCK-P + seems to lie if the OS is buffering input for us on Console.) + + reported by Elliot Slaughter on sbcl-devel 2008/1/10. + +422: out-of-extent return not checked in safe code + + (declaim (optimize safety)) + (funcall (catch 't (block nil (throw 't (lambda () (return)))))) + +behaves ...erratically. Reported by Kevin Reid on sbcl-devel +2007-07-06. (We don't _have_ to check things like this, but we +generally try to check returns in safe code, so we should here too.)