From 6e7e59adb6f6c30f84b31695b48cb51e2c519d75 Mon Sep 17 00:00:00 2001 From: William Harold Newman Date: Fri, 1 Feb 2002 15:31:15 +0000 Subject: [PATCH] 0.7.1.4: (still no fix for bug 147) made AS-DEBUG-NAME default DEBUG-NAME over SOURCE-NAME when (EQL SOURCE-NAME .ANONYMOUS.), so it's more logically sound and so that debug names get a little better tweaked *HOST-OBJ-SUFFIX* for bootstrapping under Xanalys Lispworks, as per Lieven Marchand sbcl-devel 2002-02-01 --- BUGS | 16 ++++++++++++++++ src/code/condition.lisp | 4 ++-- src/cold/shared.lisp | 43 +++++++++++++++++++++++++++---------------- src/compiler/ir1opt.lisp | 8 ++++---- src/compiler/ir1report.lisp | 12 ++++++++---- src/compiler/ir1tran.lisp | 3 ++- src/compiler/locall.lisp | 2 +- src/compiler/node.lisp | 4 ++++ version.lisp-expr | 2 +- 9 files changed, 65 insertions(+), 29 deletions(-) diff --git a/BUGS b/BUGS index dbcbeb0..37156e8 100644 --- a/BUGS +++ b/BUGS @@ -1230,6 +1230,22 @@ WORKAROUND: failed in FIND-IN-PHYSENV instead. Fixes in sbcl-0.7.1.3 (not closing over unreferenced variables) made this second test case compile without error, but the original test case still fails. + + Another way to get rid of the DEFTYPE without changing the symptom + of the bug is + (defvar *ch*) + (defun parse-num (string ind) + (flet ((digs () + (let () + (if (and (< ind ind) + (sb-int:memq *ch* '(#\1))) + nil)))))) + In sbcl-0.7.1.3, this fails with + internal error, failed AVER: "(= (LENGTH (BLOCK-SUCC CALL-BLOCK)) 1)" + The problem occurs while the inline expansion of MEMQ, + # + is being LET-converted after having its second REF deleted, leaving + it with only one entry in LEAF-REFS. 148: In sbcl-0.7.1.3 on x86, COMPILE-FILE on this file diff --git a/src/code/condition.lisp b/src/code/condition.lisp index cc7420a..ba29887 100644 --- a/src/code/condition.lisp +++ b/src/code/condition.lisp @@ -767,8 +767,8 @@ alien code or from unsafe Lisp code; or there might be a bug ~ in the OS or hardware that SBCL is running on.) If it seems to ~ be a bug in SBCL itself, the maintainers would like to know ~ - how to exercise the bug so it can be fixed. Bug reports are ~ - welcome on the SBCL mailing lists, which you can find at ~ + about it. Bug reports are welcome on the SBCL ~ + mailing lists, which you can find at ~ .~:@>" '((fmakunbound 'compile)))))) (defun bug (format-control &rest format-arguments) diff --git a/src/cold/shared.lisp b/src/cold/shared.lisp index 5654245..7fcb851 100644 --- a/src/cold/shared.lisp +++ b/src/cold/shared.lisp @@ -36,12 +36,12 @@ (sb-ext:gc-on) (sb-ext:gc)) -;;; FIXME: I'm now inclined to make all the bootstrap stuff run in CL-USER -;;; instead of SB-COLD. If I do so, I should first take care to -;;; UNINTERN any old stuff in CL-USER, since ANSI says (11.1.2.2, "The -;;; COMMON-LISP-USER Package") that CL-USER can have arbitrary symbols in -;;; it. (And of course I should set the USE list to only CL.) +;;; SB-COLD holds stuff used to build the initial SBCL core file +;;; (including not only the final construction of the core file, but +;;; also the preliminary steps like e.g. building the cross-compiler +;;; and running the cross-compiler to produce target FASL files). (defpackage "SB-COLD" (:use "CL")) + (in-package "SB-COLD") ;;; prefixes for filename stems when cross-compiling. These are quite arbitrary @@ -50,20 +50,31 @@ ;;; "host-objects/" or absolute pathnames (e.g. "/tmp/sbcl-xc-host-objects/"). ;;; ;;; The cross-compilation process will force the creation of these directories -;;; by executing CL:ENSURE-DIRECTORIES-EXIST (on the host Common Lisp). +;;; by executing CL:ENSURE-DIRECTORIES-EXIST (on the xc host Common Lisp). (defvar *host-obj-prefix*) (defvar *target-obj-prefix*) -;;; suffixes for filename stems when cross-compiling. Everything -;;; should work fine for any arbitrary string values here. With more -;;; work maybe we could cause these automatically to become the -;;; traditional extensions for whatever host and target architectures -;;; (e.g. ".x86f" or ".axpf") we're currently doing. That would make -;;; it easier for a human looking at the temporary files to figure out -;;; what they're for, but it's not necessary for the compilation -;;; process to work, so we haven't bothered. -(defvar *host-obj-suffix* ".lisp-obj") -(defvar *target-obj-suffix* ".lisp-obj") +;;; suffixes for filename stems when cross-compiling +(defvar *host-obj-suffix* + (or + ;; On some xc hosts, it's impossible to LOAD a fasl file unless it + ;; has the same extension that the host uses for COMPILE-FILE + ;; output, so we have to be careful to use the xc host's preferred + ;; extension. + ;; + ;; FIXME: This is a little ugly and annoying to maintain. And + ;; there's very likely some way to rearrange the build process so + ;; that we never explicitly refer to host object file suffixes, + ;; only to the result of CL:COMPILE-FILE-PATHNAME. + #+lispworks ".ufsl" ; as per Lieven Marchand sbcl-devel 2002-02-01 + ;; On most xc hosts, any old extension works, so we use an + ;; arbitrary one. + ".lisp-obj")) +(defvar *target-obj-suffix* + ;; Target fasl files are LOADed (actually only quasi-LOADed, in + ;; GENESIS) only by SBCL code, and it doesn't care about particular + ;; extensions, so we can use something arbitrary. + ".lisp-obj") ;;; a function of one functional argument, which calls its functional argument ;;; in an environment suitable for compiling the target. (This environment diff --git a/src/compiler/ir1opt.lisp b/src/compiler/ir1opt.lisp index d71be0f..259bc77 100644 --- a/src/compiler/ir1opt.lisp +++ b/src/compiler/ir1opt.lisp @@ -412,7 +412,7 @@ ;;; variable has no references. ;;; ;;; [### For now, don't delete potentially flushable calls when they -;;; have the CALL attribute. Someday we should look at the funcitonal +;;; have the CALL attribute. Someday we should look at the functional ;;; args to determine if they have any side-effects.] (defun flush-dead-code (block) (declare (type cblock block)) @@ -1096,9 +1096,9 @@ (defun transform-call (node res) (declare (type combination node) (list res)) (with-ir1-environment-from-node node - (let ((new-fun (ir1-convert-inline-lambda - res - :debug-name "something inlined in TRANSFORM-CALL")) + (let ((new-fun (ir1-convert-inline-lambda + res + :debug-name "something inlined in TRANSFORM-CALL")) (ref (continuation-use (combination-fun node)))) (change-ref-leaf ref new-fun) (setf (combination-kind node) :full) diff --git a/src/compiler/ir1report.lisp b/src/compiler/ir1report.lisp index 697e7c4..3a81b98 100644 --- a/src/compiler/ir1report.lisp +++ b/src/compiler/ir1report.lisp @@ -220,14 +220,18 @@ ;;; ;;; the problem, part II: The is represented as a pair ;;; of values, SOURCE-NAME and DEBUG-NAME, where SOURCE-NAME is used -;;; if it's not null. +;;; if it's not .ANONYMOUS. (This is parallel to the way that ordinarily +;;; we don't use a value if it's NIL, instead defaulting it. But we +;;; can't safely/comfortably use NIL for that in this context, since +;;; the app programmer can use NIL as a name, so we use the private +;;; symbol .ANONYMOUS. instead.) ;;; ;;; the solution: Use this function to convert whatever it is to a ;;; string, which FORMAT can then splice using "~A". (defun as-debug-name (source-name debug-name) - (if source-name - (debug-namify "~S" source-name) - debug-name)) + (if (eql source-name '.anonymous.) + debug-name + (debug-namify "~S" source-name))) ;;; Return a COMPILER-ERROR-CONTEXT structure describing the current ;;; error context, or NIL if we can't figure anything out. ARGS is a diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp index 6936072..77c5165 100644 --- a/src/compiler/ir1tran.lisp +++ b/src/compiler/ir1tran.lisp @@ -2021,7 +2021,8 @@ (unless (eq (defined-fun-inlinep var) :inline) (setf (defined-fun-inline-expansion var) nil)) (let* ((name (leaf-source-name var)) - (fun (funcall converter lambda :source-name name)) + (fun (funcall converter lambda + :source-name name)) (fun-info (info :function :info name))) (setf (functional-inlinep fun) (defined-fun-inlinep var)) (assert-new-definition var fun) diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp index eb49946..35def44 100644 --- a/src/compiler/locall.lisp +++ b/src/compiler/locall.lisp @@ -363,7 +363,7 @@ ;;; Dispatch to the appropriate function to attempt to convert a call. ;;; REF must be a reference to a FUNCTIONAL. This is called in IR1 -;;; optimize as well as in local call analysis. If the call is is +;;; optimization as well as in local call analysis. If the call is is ;;; already :LOCAL, we do nothing. If the call is already scheduled ;;; for deletion, also do nothing (in addition to saving time, this ;;; also avoids some problems with optimizing collections of functions diff --git a/src/compiler/node.lisp b/src/compiler/node.lisp index 53e9edc..d95ffc9 100644 --- a/src/compiler/node.lisp +++ b/src/compiler/node.lisp @@ -628,6 +628,10 @@ ;; skewed enough (e.g. for macro functions or method functions) that ;; we don't want to have that name affect compilation ;; + ;; (We use .ANONYMOUS. here more or less the way we'd ordinarily use + ;; NIL, but we're afraid to use NIL because it's a symbol which could + ;; be the name of a leaf, if only the constant named NIL.) + ;; ;; The value of this slot in can affect ordinary runtime behavior, ;; e.g. of special variables and known functions, not just debugging. ;; diff --git a/version.lisp-expr b/version.lisp-expr index 2804246..2e69dca 100644 --- a/version.lisp-expr +++ b/version.lisp-expr @@ -18,4 +18,4 @@ ;;; for internal versions, especially for internal versions off the ;;; main CVS branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".) -"0.7.1.3" +"0.7.1.4" -- 1.7.10.4