From: William Harold Newman Date: Sat, 7 Apr 2001 17:23:13 +0000 (+0000) Subject: 0.6.11.34: X-Git-Url: http://repo.macrolet.net/gitweb/?a=commitdiff_plain;h=6c765578c8dc4bcc7798e37c9918715f198b30da;p=sbcl.git 0.6.11.34: eliminated distinction between ordinary optimization policy and *INTERFACE-POLICY* eliminated *INTERFACE-POLICY* stuff, including INTERFACE flags to IR1-CONVERT-AUX-BINDINGS, IR1-CONVERT-LAMBDA-BODY, IR1-CONVERT-SPECIAL-BINDINGS converted &OPTIONAL args in IR1-CONVERT-LAMBDA-BODY to &KEY *POLICY-BASIC-QUALITIES* becomes *POLICY-QUALITIES* merged redundant OPTIMIZATION-QUALITY-P and POLICY-QUALITY-NAME-P (Bug 87 was fixed by getting rid of interface policy stuff.) merged nearly-irrelevant SB-INSPECT package into SB-IMPL rearranged new function definition vs. declaration type checking, so that the compiler won't die when (DECLAIM (FTYPE FUNCTION F)) (DEFUN F ..) removed src/compiler/c.log (>10-year-old log file) added *.impure-cload.lisp category of tests, and moved compiler-1.impure.lisp to that category so that it's compiled as it should be --- diff --git a/NEWS b/NEWS index 9af23ae..63f6ec5 100644 --- a/NEWS +++ b/NEWS @@ -682,6 +682,12 @@ changes in sbcl-0.6.11 relative to sbcl-0.6.10: as per Daniel Barlow's suggestion and Martin Atzmueller's patch changes in sbcl-0.6.12 relative to sbcl-0.6.11: +* incompatible change: The old SB-EXT:OPTIMIZE-INTERFACE declaration + is no longer recognized. I apologize for this, because it was + listed in SB-EXT as a supported extension, but I found that + its existing behavior was poorly specified, as well as incorrectly + specified, and it looked like too much of a mess to straighten it + out. I have enough on my hands trying to get ANSI stuff to work.. * many patches ported from CMU CL by Martin Atzmueller, with half a dozen bug fixes in pretty-printing and the debugger, and half a dozen others elsewhere @@ -723,3 +729,6 @@ planned incompatible changes in 0.7.x: ANSI Common Lisp standard, may change to their ASCII symbolic names: #\Nul, #\Soh, #\Stx, etc. * INTERNAL-TIME-UNITS-PER-SECOND might increase, e.g. to 1000. +* MAYBE-INLINE will probably go away at some point, maybe 0.7.x, + maybe later, in favor of the ANSI-recommended idiom for making + a function optionally inline. diff --git a/package-data-list.lisp-expr b/package-data-list.lisp-expr index 9446fad..499c353 100644 --- a/package-data-list.lisp-expr +++ b/package-data-list.lisp-expr @@ -512,7 +512,7 @@ like *STACK-TOP-HINT*" ;; extended declarations.. "FREEZE-TYPE" "INHIBIT-WARNINGS" - "MAYBE-INLINE" "OPTIMIZE-INTERFACE" + "MAYBE-INLINE" ;; ..and variables to control compiler policy "*INLINE-EXPANSION-LIMIT*" @@ -601,16 +601,6 @@ Lisp extension proposal by David N. Gray" "STREAM-START-LINE-P" "STREAM-TERPRI" "STREAM-UNREAD-CHAR" "STREAM-WRITE-BYTE" "STREAM-WRITE-CHAR" "STREAM-WRITE-STRING")) - ;; FIXME: It looks as though it's no longer important to have INSPECT be - ;; a separate package. INSPECT functionality is in the ANSI spec, and we - ;; might as well implement it with everything else. - #s(sb-cold:package-data - :name "SB!INSPECT" - :doc "private: implementation of INSPECT" - :use ("CL" "SB!KERNEL" "SB!EXT" "SB!INT") - :export ("*INTERFACE-STYLE*" "REMOVE-ALL-DISPLAYS" - "REMOVE-OBJECT-DISPLAY" "SHOW-OBJECT")) - #s(sb-cold:package-data :name "SB!INT" :doc @@ -933,7 +923,9 @@ is a good idea, but see SB-SYS for blurring of boundaries." "CSUBTYPEP" "CTYPE" "TYPE-HASH-VALUE" "CTYPE-OF" "CTYPE-P" "CTYPEP" "CURRENT-FP" "CURRENT-SP" "DATA-VECTOR-REF" "DATA-VECTOR-SET" "DECODE-DOUBLE-FLOAT" - "DECODE-LONG-FLOAT" "DECODE-SINGLE-FLOAT" "DESCEND-INTO" + "DECODE-LONG-FLOAT" "DECODE-SINGLE-FLOAT" + "DEFINED-FTYPE-MATCHES-DECLARED-FTYPE-P" + "DESCEND-INTO" "DIVISION-BY-ZERO-ERROR" "DOUBLE-FLOAT-EXPONENT" "DOUBLE-FLOAT-HIGH-BITS" "DOUBLE-FLOAT-INT-EXPONENT" "DOUBLE-FLOAT-LOW-BITS" diff --git a/src/code/early-type.lisp b/src/code/early-type.lisp index 5276a35..2c19b75 100644 --- a/src/code/early-type.lisp +++ b/src/code/early-type.lisp @@ -118,7 +118,7 @@ ;; Lists of the type for each required and optional argument. (required nil :type list) (optional nil :type list) - ;; The type for the rest arg. NIL if there is no rest arg. + ;; The type for the rest arg. NIL if there is no &REST arg. (rest nil :type (or ctype null)) ;; true if &KEY arguments are specified (keyp nil :type boolean) diff --git a/src/code/inspect.lisp b/src/code/inspect.lisp index 294c7c0..52f08e3 100644 --- a/src/code/inspect.lisp +++ b/src/code/inspect.lisp @@ -9,7 +9,7 @@ ;;;; provided with absolutely no warranty. See the COPYING and CREDITS ;;;; files for more information. -(in-package "SB-INSPECT") +(in-package "SB-IMPL") ;;; The inspector views LISP objects as being composed of parts. A ;;; list, for example, would be divided into its members, and a @@ -46,8 +46,8 @@ (input-loop object (describe-parts object) *standard-output*) (setf *inspect-object-stack* nil))) -;;; When *ILLEGAL-OBJECT-MARKER* occurs in a parts list, it indicates that that -;;; slot is unbound. +;;; When *ILLEGAL-OBJECT-MARKER* occurs in a parts list, it indicates +;;; that that slot is unbound. (defvar *illegal-object-marker* (cons nil nil)) (defun input-loop (object parts s) @@ -56,7 +56,8 @@ (format s "~&> ") (force-output) (let ((command (read)) - ;; Use 2 less than length because first 2 elements are bookkeeping. + ;; Use 2 less than the length because the first 2 elements + ;; are bookkeeping. (parts-len-2 (- (length parts) 2))) (typecase command (integer diff --git a/src/code/late-type.lisp b/src/code/late-type.lisp index 5d05e7b..523f792 100644 --- a/src/code/late-type.lisp +++ b/src/code/late-type.lisp @@ -2132,6 +2132,41 @@ ;;;; utilities shared between cross-compiler and target system +;;; Does the type derived from compilation of an actual function +;;; definition satisfy declarations of a function's type? +(defun defined-ftype-matches-declared-ftype-p (defined-ftype declared-ftype) + (declare (type ctype defined-ftype declared-ftype)) + (flet ((is-built-in-class-function-p (ctype) + (and (built-in-class-p ctype) + (eq (built-in-class-%name ctype) 'function)))) + (cond (;; DECLARED-FTYPE could certainly be #; + ;; that's what happens when we (DECLAIM (FTYPE FUNCTION FOO)). + (is-built-in-class-function-p declared-ftype) + ;; In that case, any definition satisfies the declaration. + t) + (;; It's not clear whether or how DEFINED-FTYPE might be + ;; #, but it's not obviously + ;; invalid, so let's handle that case too, just in case. + (is-built-in-class-function-p defined-ftype) + ;; No matter what DECLARED-FTYPE might be, we can't prove + ;; that an object of type FUNCTION doesn't satisfy it, so + ;; we return success no matter what. + t) + (;; Otherwise both of them must be FUNCTION-TYPE objects. + t + ;; FIXME: For now we only check compatibility of the return + ;; type, not argument types, and we don't even check the + ;; return type very precisely (as per bug 94a). It would be + ;; good to do a better job. Perhaps to check the + ;; compatibility of the arguments, we should (1) redo + ;; VALUES-TYPES-EQUAL-OR-INTERSECT as + ;; ARGS-TYPES-EQUAL-OR-INTERSECT, and then (2) apply it to + ;; the ARGS-TYPE slices of the FUNCTION-TYPEs. (ARGS-TYPE + ;; is a base class both of VALUES-TYPE and of FUNCTION-TYPE.) + (values-types-equal-or-intersect + (function-type-returns defined-ftype) + (function-type-returns declared-ftype)))))) + ;;; This messy case of CTYPE for NUMBER is shared between the ;;; cross-compiler and the target system. (defun ctype-of-number (x) diff --git a/src/code/list.lisp b/src/code/list.lisp index 734fd50..4dea431 100644 --- a/src/code/list.lisp +++ b/src/code/list.lisp @@ -506,8 +506,8 @@ ;; KLUDGE: This declaration is a hack to make the closure ignore ;; all its arguments without consing a &REST list or anything. ;; Perhaps once DYNAMIC-EXTENT is implemented we won't need to - ;; screw around with this kind of thing. - (declare (optimize-interface (speed 3) (safety 0))) + ;; screw around with this kind of thing. -- WHN 2001-04-06 + (declare (optimize (speed 3) (safety 0))) value)) ;;;; macros for (&KEY (KEY #'IDENTITY) (TEST #'EQL TESTP) (TEST-NOT NIL NOTP)) diff --git a/src/code/primordial-extensions.lisp b/src/code/primordial-extensions.lisp index 9e7eb47..6d9e4f2 100644 --- a/src/code/primordial-extensions.lisp +++ b/src/code/primordial-extensions.lisp @@ -42,8 +42,8 @@ ;;; now we just don't worry about it. If for some reason it becomes ;;; worrisome and the magic value needs replacement: ;;; * The replacement value needs to be LOADable with EQL preserved, -;;; so that macroexpansion for WITH-HASH-TABLE-ITERATOR will work -;;; when compiled into a file and loaded back into SBCL. +;;; so that the macroexpansion for WITH-HASH-TABLE-ITERATOR will +;;; work when compiled into a file and loaded back into SBCL. ;;; (Thus, just uninterning %EMPTY-HT-SLOT% doesn't work.) ;;; * The replacement value needs to be acceptable to the ;;; low-level gencgc.lisp hash table scavenging code. @@ -62,13 +62,13 @@ (label-2 (gensym))) ;; Check for illegal old-style DO. (when (or (not (listp varlist)) (atom endlist)) - (error "Ill-formed ~S -- possibly illegal old style DO?" name)) + (error "ill-formed ~S -- possibly illegal old style DO?" name)) ;; Parse VARLIST to get R-INITS and R-STEPS. (dolist (v varlist) - (flet (;; (We avoid using CL:PUSH here so that CL:PUSH can be defined - ;; in terms of CL:SETF, and CL:SETF can be defined in terms of - ;; CL:DO, and CL:DO can be defined in terms of the current - ;; function.) + (flet (;; (We avoid using CL:PUSH here so that CL:PUSH can be + ;; defined in terms of CL:SETF, and CL:SETF can be + ;; defined in terms of CL:DO, and CL:DO can be defined + ;; in terms of the current function.) (push-on-r-inits (x) (setq r-inits (cons x r-inits))) ;; common error-handling @@ -81,10 +81,10 @@ name (first v))) (let ((lv (length v))) - ;; (We avoid using CL:CASE here so that CL:CASE can be - ;; defined in terms of CL:SETF, and CL:SETF can be defined - ;; in terms of CL:DO, and CL:DO can be defined in terms of - ;; the current function.) + ;; (We avoid using CL:CASE here so that CL:CASE can + ;; be defined in terms of CL:SETF, and CL:SETF can + ;; be defined in terms of CL:DO, and CL:DO can be + ;; defined in terms of the current function.) (cond ((= lv 1) (push-on-r-inits (first v))) ((= lv 2) diff --git a/src/code/target-alieneval.lisp b/src/code/target-alieneval.lisp index 87b7f68..091841f 100644 --- a/src/code/target-alieneval.lisp +++ b/src/code/target-alieneval.lisp @@ -242,15 +242,16 @@ ;;; system area pointer to it. #!-sb-fluid (declaim (inline %make-alien)) (defun %make-alien (bits) - (declare (type index bits) (optimize-interface (safety 2))) - (alien-funcall (extern-alien "malloc" (function system-area-pointer unsigned)) + (declare (type index bits)) + (alien-funcall (extern-alien "malloc" + (function system-area-pointer unsigned)) (ash (the index (+ bits 7)) -3))) #!-sb-fluid (declaim (inline free-alien)) (defun free-alien (alien) #!+sb-doc "Dispose of the storage pointed to by ALIEN. ALIEN must have been allocated - by MAKE-ALIEN or ``malloc''." + by MAKE-ALIEN or malloc(3)." (alien-funcall (extern-alien "free" (function (values) system-area-pointer)) (alien-sap alien)) nil) @@ -482,7 +483,7 @@ (defun %cast (alien target-type) (declare (type alien-value alien) (type alien-type target-type) - (optimize-interface (safety 2)) + (optimize (safety 2)) (optimize (inhibit-warnings 3))) (if (or (alien-pointer-type-p target-type) (alien-array-type-p target-type) diff --git a/src/code/target-load.lisp b/src/code/target-load.lisp index 5f23533..25eb0ba 100644 --- a/src/code/target-load.lisp +++ b/src/code/target-load.lisp @@ -170,11 +170,19 @@ source, the result of evaluating each top-level form is printed. The default is *LOAD-PRINT*." - (let ((sb!c::*policy* sb!c::*policy*) - (sb!c::*interface-policy* sb!c::*interface-policy*) + (let ((*load-depth* (1+ *load-depth*)) + ;; KLUDGE: I can't find in the ANSI spec where it says that + ;; DECLAIM/PROCLAIM of optimization policy should have file + ;; scope. CMU CL did this, and it seems reasonable, but it + ;; might not be right; after all, things like (PROCLAIM '(TYPE + ;; ..)) don't have file scope, and I can't find anything under + ;; PROCLAIM or COMPILE-FILE or LOAD or OPTIMIZE which + ;; justifies this behavior. Hmm. -- WHN 2001-04-06 + (sb!c::*policy* sb!c::*policy*) + ;; The ANSI spec for LOAD says "LOAD binds *READTABLE* and + ;; *PACKAGE* to the values they held before loading the file." (*package* (sane-package)) (*readtable* *readtable*) - (*load-depth* (1+ *load-depth*)) ;; The old CMU CL LOAD function used an IF-DOES-NOT-EXIST argument of ;; (MEMBER :ERROR NIL) type. ANSI constrains us to accept a generalized ;; boolean argument value for this externally-visible function, but the diff --git a/src/compiler/c.log b/src/compiler/c.log deleted file mode 100644 index a304fda..0000000 --- a/src/compiler/c.log +++ /dev/null @@ -1,2048 +0,0 @@ -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval.lisp -05-Feb-90 20:45:20, Edit by Ram. - Fixed MAKE-INTERPRETED-FUNCTION to specify the LAMBDA slot when creating the - function so that it is avaliable to INTERPRETED-FUNCTION-LAMBDA-EXPRESSION. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/sset.lisp -05-Feb-90 12:07:12, Edit by Ram. - Fixed a problem in SSET-UNION-OF-DIFFERENCE. It was using (>= num2 num3) in - two places where it should have been using <=. Probably due to incorrect - modification of the original SSET-DIFFERENCE code into this function. The - original function had the inner loop over the second arg, rather than the - first. This effectively resulted in the difference aspect usually not - happening, so the KILL set in constraint propagation never took effect, - resulting in some over-zealous type propagation. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -04-Feb-90 10:11:51, Edit by Ram. - Oops... Fixed * transform so that multiplication by 8 doesn't really - multiply by 256, etc. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -04-Feb-90 09:48:09, Edit by Ram. - Wrote CLOSE-SOURCE-INFO, and made COMPILE-FILE, ADVANCE-SOURCE-FILE and - COMPILE-FROM-STREAM call it. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/fndb.lisp -04-Feb-90 08:09:06, Edit by Ram. - Added definition for %SP-STRING-COMPARE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/seqtran.lisp -04-Feb-90 08:01:21, Edit by Ram. - Fixed STRING<>=-BODY a bit. In addition to some query replace lossage, there - was also a genuine ancestral bug in computation of the result in the = case - of = ops. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ctype.lisp -03-Feb-90 20:44:39, Edit by Ram. - Made VALID-FUNCTION-USE and VALID-APPROXIMATE-TYPE return NIL, NIL when - uncertainty is encountered, rather than T, NIL. Everybody was expecting this - to be a conservative test (and only looking at the first value.) This caused - spurious transforms to happen. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -02-Feb-90 14:08:09, Edit by Ram. - Added NTH, NTHCDR transforms for the constant index case. Added * transform - for the power-of-2 case. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/seqtran.lisp -02-Feb-90 13:00:15, Edit by Ram. - Added string transforms, derived from CLC sources. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -02-Feb-90 13:25:40, Edit by Ram. - Added FORMAT transform derived from CLC sources. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/type.lisp -02-Feb-90 11:23:26, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -02-Feb-90 11:23:15, Edit by Ram. - Defined TYPE/= and made the "anything changed" tests use it instead of TYPE= - so as to be conservative in the presence of hairy types. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -02-Feb-90 10:29:54, Edit by Ram. - Changed REOPTIMIZE-CONTINUATION to set BLOCK-TYPE-CHECK in the use blocks so - that new derived-type information will also cause type checking to be redone. - This mainly handles the case where new type information causes us to want to - negate a check that was previously simple. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -02-Feb-90 10:12:24, Edit by Ram. - Fixed CONTINUATION-%DERIVED-TYPE to call CONTINUATION-%TYPE-CHECK instead of - CONTINUATION-TYPE-CHECK so that it won't recurse indefinitely. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -01-Feb-90 14:46:13, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -01-Feb-90 14:43:26, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/knownfun.lisp -01-Feb-90 14:40:22, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -01-Feb-90 14:42:19, Edit by Ram. - Flushed *FUNCTION-INFO* in favor of (INFO FUNCTION INFO ...). Added - FUNCTION-INFO-PREDICATE-TYPE slot. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -01-Feb-90 14:09:42, Edit by Ram. - Changed ASSERT-CONTINUATION-TYPE to set BLOCK-TYPE-ASSERTED in the use - blocks. Also, moved fixed the setting of BLOCK-TYPE-CHECK to be on the use - blocks rather than the CONTINUATION-BLOCK, since type check generation uses - DO-NODES, and thus ignores the BLOCK-START. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/node.lisp -01-Feb-90 13:37:14, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/checkgen.lisp -01-Feb-90 13:41:46, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -01-Feb-90 13:41:48, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -01-Feb-90 13:42:05, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -01-Feb-90 13:42:29, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -01-Feb-90 13:43:07, Edit by Ram. - Renamed the CONTINUATION TYPE-CHECK slot to %TYPE-CHECK, which is filtered by - the new CONTINUATION-TYPE-CHECK function to make sure that it has been - computed recently. Changed setters of TYPE-CHECK to %TYPE-CHECK, and flushed - the now unnecessary calls to CONTINUATION-DERIVED-TYPE (which explicitly did - the recomputation.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -01-Feb-90 12:56:50, Edit by Ram. - Changed %CONTINUATION-DERIVED-TYPE to not set TYPE-CHECK when the assertion - is T or there is no DEST. In the first case, this just avoids waste motion. - In the second case, this prevents constraint analysis from being tricked into - believing such a check will be done, when in fact no checks are done on - unused values. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -01-Feb-90 12:51:41, Edit by Ram. - Made DELETE-CONTINUATION, FLUSH-DEST, NODE-ENDS-BLOCK and UNLINK-NODE set the - BLOCK-TYPE-ASSERTED and BLOCK-TEST-CHANGED flags. At least for the former, - this has to be done in more places than I thought, and also must be done for - correctness, rather than just to ensure new assertions are seen. This is - because if a block is split, or code needing an assertion is deleted, then we - must recompute the block's set of constraints or it will contain incorrect - constraints. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/sset.lisp -01-Feb-90 11:33:28, Edit by Ram. - Fixed SSET-INTERSECTION to blow away any extra elements in SET1 that are - larger than the greatest element in SET2. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/node.lisp -01-Feb-90 10:34:17, Edit by Ram. - Changed initial values for TYPE-ASSERTED and TEST-MODIFIED to be T rather - than NIL. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/vop.lisp -30-Jan-90 16:10:06, Edit by Ram. - Added IR2-ENVIRONMENT-KEEP-AROUND-TNS and IR2-COMPONENT-PRE-PACKED-SAVE-TNS - so that we won't have to recompile to add these features later on. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval.lisp -30-Jan-90 14:54:58, Edit by Ram. - Added the MAKE-INTERPRETED-FUNCTION interface which allows lazy conversion of - functions and features bounded IR1 memory usage through a LRU cache that is - partially flushed on GC. Added INTERPRETED-FUNCTION-NAME, - INTERPRETED-FUNCTION-ARGLIST and setf functions. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -30-Jan-90 10:08:19, Edit by Ram. - Now that %DEFMACRO is passed #'(lambda ... for benefit for the interpreter, - we don't want to unquote the definition using EVAL. Use SECOND instead. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -29-Jan-90 14:17:06, Edit by Ram. - Changed FIND-COMPONENT-NAME to bind *PRINT-LEVEL* and *PRINT-PRETTY* so as to - prevent huge component names. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/life.lisp -29-Jan-90 13:43:23, Edit by Ram. - Fixed CONFLICT-ANALYZE-BLOCK in the dead read case to do FROB-MORE-TNS on - NOTE-CONFLICTS as well as the addition to the live set. This was the fix to - the long-procrastinated-about :MORE TN bug (first noticed in fall 88.) Also, - changed FROB-MORE-TNS to return whether it did anything, rather than sleazily - hacking on the loop variable to get the loop to exit. I must have been - having a Pascal flashback when I wrote that code... - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval.lisp -29-Jan-90 13:24:23, Edit by Ram. - Fixed LEAF-VALUE to use FDEFINITION rather than SYMBOL-FUNCTION when the name - isn't a symbol. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -29-Jan-90 10:46:23, Edit by Ram. - Changed COMPILE-FIX-FUNCTION-NAME to substitute for old uses of the name so - that recursive calls get converted. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -29-Jan-90 10:13:18, Edit by Ram. - But for the want of a single character... So that's why no functions were - being inline expanded! In %DEFUN the ir1 translator, I was looking at the - INLINEP value for the NAME in the same LET that was eval'ing the name to - unquote it. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/debug-dump.lisp -27-Jan-90 18:05:15, Edit by Ram. - Made DEBUG-SOURCE-FOR-INFO handle the incremental compilation cases. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -27-Jan-90 17:46:09, Edit by Ram. - Wrote COMPILE and UNCOMPILE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval.lisp -27-Jan-90 17:07:17, Edit by Ram. - Added the interfaces INTERPRETED-FUNCTION-LAMBDA-EXPRESSION and - INTERPRETED-FUNCTION-CLOSURE. These use the new FIND-IF-IN-CLOSURE operation - pick apart the closure that is an interpreted function. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -26-Jan-90 16:35:51, Edit by Ram. - Moved a bunch of stuff from COMPILE-FILE to SUB-COMPILE-FILE. Wrote - MAKE-LISP-SOURCE-INFO and MAKE-STREAM-SOURCE-INFO. Wrote - COMPILE-FROM-STREAM, and added appropriate uses of the in-core compilation - interface to various functions. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -26-Jan-90 16:09:30, Edit by Ram. - Made the CACHE-NAME slot be duplicated in both kinds of environment rather - than inherited from INFO-ENV so that the inline type checks for the slot - access will win, allowing bootstrapping to work. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval-comp.lisp -26-Jan-90 13:12:09, Edit by Ram. - Changed COMPILE-FOR-EVAL to call the new MAKE-LISP-SOURCE-INFO, rather than - rolling its own. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -26-Jan-90 11:59:58, Edit by Ram. - Added code to cache the last name looked up, since we commonly consecutively - look up several types of info for the same name. [Maybe even some types more - than once!] - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -26-Jan-90 09:30:59, Edit by Ram. - Fixed PROCESS-TYPE-PROCLAMATION to not try to call TYPES-INTERSECT on - function types so that we don't flame out. This was probably what I was - really trying to fix in the last change to PROCESS-TYPE-DECLARATION. Really - both were broken. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -25-Jan-90 10:58:43, Edit by Ram. - Added transform for ARRAY-DIMENSION that converts to LENGTH when possible. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/typetran.lisp -25-Jan-90 10:46:00, Edit by Ram. - Moved array typep code here from vm-type-tran, since it turned out not to be - VM dependent after all. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/typetran.lisp -23-Jan-90 15:31:32, Edit by Ram. - Transformed array type tests to %ARRAY-TYPEP so that clever - implementation-dependent things can be done. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -23-Jan-90 18:45:14, Edit by Ram. - Fixed up some messed up backquote stuff in DO-MACROLET-STUFF where it was - trying to coerce the lambda to a function. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/envanal.lisp -23-Jan-90 13:06:41, Edit by Ram. - Don't annotate as TAIL-P nodes whose DERIVED-TYPE is NIL, so that we don't - tail-call functions such as ERROR. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -23-Jan-90 12:44:28, Edit by Ram. - Fixed %DEFUN translator to record an inline expansion when the INLINEP value - is :MAYBE-INLINE as well as :INLINE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -23-Jan-90 08:49:50, Edit by Ram. - Changed PUSH-IN and DELETEF-IN to only call FOO-GET-SETF-METHOD when - CLC::*IN-THE-COMPILER* is true, so that we can still use these macros in the - old compiler. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/seqtran.lisp -22-Jan-90 16:11:28, Edit by Ram. - Added a transform for MEMBER where the list is a constant argument (primarily - to help MEMBER type tests.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval.lisp -22-Jan-90 15:20:27, Edit by Ram. - Replaced all uses of COMBINATION- accessors with BASIC-COMBINATION- accessors - so that MV combinations will work. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval.lisp -22-Jan-90 15:08:07, Edit by Ram. - Put a couple of macros in EVAL-WHEN (COMPILE LOAD EVAL) so that they are - avaliable to SETF in the bootstrap environment. Also, changed %SP-[UN]BIND - to the appropriate %PRIMITIVE calls. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/fndb.lisp -20-Jan-90 20:21:34, Edit by Ram. - Fixed up FBOUNDP & stuff to correspond to the FUNCTION-NAME cleanup. Now - FBOUNDP can take a list as well as a symbol. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -20-Jan-90 09:56:43, Edit by Ram. - In #+NEW-COMPILER, made DO-MACROLET-STUFF coerce the lambda expression to a - function. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval-comp.lisp -20-Jan-90 09:52:20, Edit by Ram. - Added bind of *FENV* to () in COMPILE-FOR-EVAL. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -20-Jan-90 09:50:59, Edit by Ram. - And made IR1-TOP-LEVEL *not* bind *FENV* to () so that top-level MACROLETs - will be recognized... - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -20-Jan-90 09:47:19, Edit by Ram. - Added binding of *FENV* to () in SUB-COMPILE-FILE so that MACROLET processing - won't flame out. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/macros.lisp -19-Jan-90 22:25:15, Edit by Ram. - Made WITH-IR1-ENVIRONMENT bind a bunch more variables. *fenv*, etc. Wrote - WITH-IR1-NAMESPACE, which allocates the gloabal namespace hashtables. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval-comp.lisp -19-Jan-90 22:35:44, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -19-Jan-90 22:34:20, Edit by Ram. - Flushed IR1-TOP-LEVEL-FOR-EVAL and changed IR1-TOP-LEVEL to take a FOR-VALUE - flag so that it can do the same thing. Added use of WITH-IR1-NAMESPACE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -19-Jan-90 21:43:20, Edit by Ram. - Made SUB-COMPILE-FILE bind *CURRENT-COOKIE* so that people can randomly call - (POLICY NIL ...) to get at the current policy, and will never see any - leftover local policy from a dynamically enclosing IR1 conversion. - ### Maybe this should really be bound somewhere else, like COMPILE-COMPONENT. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -19-Jan-90 22:00:35, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/node.lisp -19-Jan-90 22:01:47, Edit by Ram. - Added a keyword constructor for CBLOCK, and changed all MAKE-BLOCK calls - outside of IR1 conversion to use this new constructor, specifying all the - values that would otherwise be defaulted from specials. This is necessary to - make stuff properly reentrant. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -19-Jan-90 17:26:17, Edit by Ram. - In FIND-FREE-VARIABLE, flushed the assertion that non-constant variables - never have constant values. This isn't really right, but it is better. - ### Really, the implementation of "constant but value unknown" variables - should be either flushed or redone. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval-comp.lisp -19-Jan-90 15:31:33, Edit by Ram. - New file from Chiles. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/eval.lisp -19-Jan-90 15:30:03, Edit by Ram. - New file from chiles. Changed MY-EVAL to INTERNAL-EVAL and made it frob - *ALREADY-EVALED-THIS*. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -19-Jan-90 14:53:28, Edit by Ram. - Made IR1 conversion reentrant by having IR1-TOP-LEVEL bind all of the state - variables. Removed DEFVAR initial values for variables that should never be - referenced outside of IR1 conversion. Rather than always making four new - hashtables every time, I kept around the global values, allowing them to be - used on the outermost call. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -19-Jan-90 11:06:50, Edit by Ram. - Changed PROPAGATE-TO-REFS to do nothing when the variable type is a function - type so that we don't lose specific function type information, and also so - that TYPE-INTERSECTION doesn't gag. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -19-Jan-90 11:24:07, Edit by Ram. - Changed PROCESS-TYPE-DECLARATION to quietly set the var type when either the - old or new type is a function type, rather than losing trying to do - TYPE-INTERSECTION. - ### Someday when we have a incompatible-redefinition detection capability, we - might want to hook it in here. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -18-Jan-90 16:45:20, Edit by Ram. - In %DEFMACRO IR1 convert, when #+NEW-COMPILER, coerce the expander to a - function before sticking it in the MACRO-FUNCTION. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -18-Jan-90 14:11:44, Edit by Ram. - Changed %DEFUN translator to dump an inline expanion when appropriate. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/fndb.lisp -18-Jan-90 12:33:17, Edit by Ram. - Added %STANDARD-CHAR-P and %STRING-CHAR-P to the imports list. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -18-Jan-90 12:24:34, Edit by Ram. - In #+NEW-COMPILER, added info type defaults that get information from the - environment. This only affected functions and constant values, since - everything else is already stored in the global database. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -18-Jan-90 11:51:45, Edit by Ram. - In COMPILE-FILE, fixed FROB to always pathnamify the thing so that - OPEN-FASL-FILE won't choke. Also, this way any syntax error always happens - in COMPILE-FILE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/life.lisp -18-Jan-90 10:44:11, Edit by Ram. - And also in NOTE-CONFLICTS, fixed the declaration for Live-List to be - (OR TN NULL) rather than TN. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/life.lisp -18-Jan-90 10:39:41, Edit by Ram. - In NOTE-CONFLICTS, fixed the type for Live-Bits to be LOCAL-TN-BIT-VECTOR, - not SC-BIT-VECTOR. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -17-Jan-90 20:47:37, Edit by Ram. - Fixed IR2-CONVERT-NORMAL-LOCAL-CALL to set up the argument pointer. It - seems this was only happening in tail calls, so stack arguments did not in - general work in local calls. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -17-Jan-90 16:20:28, Edit by Ram. - Changed FIND-TEMPLATE to guard the unsafe policy "trusting" result test by a - check for any non-null value of TYPE-CHECK, rather than just T or :ERROR. - This since the value might have also been :NO-CHECK, this was usually - preventing us from believing the assertion. - - This was resulting in the rather baffling efficiency note that output type - assertions can't be trusted in a safe policy, when the policy wasn't safe... - I added an assertion that the policy really is safe when we emit that note. - Although it should always be the case, lossage in either VALID-FUNCTION-USE - or template selection could cause us to end up in that branch. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -16-Jan-90 21:25:42, Edit by Ram. - Renamed the types ENTRY-INFO and ENTRIES-INDEX to be COMPACT-INFO-ENTRY and - COMPACT-INFO-ENTRIES-INDEX. We already had a structure called ENTRY-INFO. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/proclaim.lisp -16-Jan-90 11:23:51, Edit by Ram. - Set the symbol-function of PROCLAIM to the definition of %PROCLAIM. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -16-Jan-90 11:15:56, Edit by Ram. - Fixed DEFMACRO ir1 convert to unquote the original arglist before setting the - FUNCTIONAL-ARG-DOCUMENTATION. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/codegen.lisp -15-Jan-90 13:04:59, Edit by Ram. - Oops... I seem to have broken codegen when I changed to it give each block a - label, sometimes emitting a label more than once. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -13-Jan-90 13:09:05, Edit by Ram. - Changed DELETEF-IN and PUSH-IN to use FOO-GET-SETF-METHOD rather than - GET-SETF-METHOD so that they will expand correctly in the bootstrapping - environment. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -13-Jan-90 12:27:12, Edit by Ram. - Fixed a CDR circularity detection in FIND-SOURCE-PATHS a bit. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -13-Jan-90 11:49:48, Edit by Ram. - In addition to initializing *INFO-CLASSES* in GLOBALDB-INIT for benefit of - bootstrapping, we must also init *TYPE-COUNTER* and *TYPE-NUMBERS*. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -12-Jan-90 16:15:25, Edit by Ram. - Changed to use a special FIND-TYPE-INFO function instead of FIND, since the - slot accessor TYPE-INFO-NAME isn't avaliable for use as a funarg before - top-level forms run. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -11-Jan-90 11:14:44, Edit by Ram. - I'm sooo embarrassed... I got the rehashing algorithm wrong in compact - environments. The second hash could be 0, resulting in infinite looping. - [b.t.w., this is a new largely rewritten version of globaldb that uses - special hashtables instead of standard hashtables. There are two kinds of - environments: volatile and compact. Volatile environments can be modified, - but are not especially compact (comparable to the old hashtable - implementation, but faster.) Compact environments are not modifiable, but - reduce memory usage by at least half.] - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -10-Jan-90 12:04:33, Edit by Ram. - Rather than asserting that (INFO FUNCTION WHERE-FROM ) is :ASSUMED - whenever the LEAF-WHERE-FROM is assumed, we just quietly skip the unknown - function warning code when the name no longer names an assumed function. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -10-Jan-90 11:27:03, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -10-Jan-90 11:24:07, Edit by Ram. - Added special-case top-level form processing of EVAL-WHEN, PROGN and MACROLET - so that we don't get huge compilations when these forms enclose lots of code - at top-level. To do this, I split off the environment manipulation code in - EVAL-WHEN and MACROLET. - ### Probably should expand macros to see if they turn into a magic form - ### before just compiling the thing. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -09-Jan-90 13:23:41, Edit by Ram. - Wrote a version of PROGV. This IR1 translator is in IR2tran because it goes - directly from syntax to shallow-binding primitives. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -08-Jan-90 14:39:46, Edit by Ram. - Made FIND-SOURCE-PATHS hack circular source code. CAR circularities are - detected by noticing that the cons is already in the source paths hashtable. - CDR circularities are detected using the two-phase trailing pointer hack. - This support is necessary as long as circular constants are allowed (which is - strongly implied by the presence of the #=/## read syntax.) Of course if - there is circular evaluated code, bad things will still happen... - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -08-Jan-90 13:36:03, Edit by Ram. - Made PRINT-SUMMARY print information about compilation units that were - aborted, and inhibited printing of unknown function warnings when the warning - compilation unit is unwound. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -08-Jan-90 10:58:02, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -08-Jan-90 10:49:04, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/node.lisp -08-Jan-90 10:28:23, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1final.lisp -08-Jan-90 10:40:20, Edit by Ram. - Changed *UNKNOWN-FUNCTIONS* a bit. Now it is a list of UNKNOWN-FUNCTION - structures. This was done primarily to allow the number of warnings to be - limited in IR1-CONVERT-OK-COMBINATION-FER-SHER rather than in PRINT-SUMMARY. - It turns out that recording hundreds of error locations for tents of - functions can suck down a large amount of memory. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -05-Jan-90 16:24:40, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -05-Jan-90 15:58:34, Edit by Ram. - Changed *UNKNOWN-FUNCTIONS* to be an alist with one entry for each name, with - the value being a list of all the error contexts for the calls. Made - PRINT-SUMMARY print the undefined function warnings sorted by name, limiting - the number of warnings per function to *UNKNOWN-FUNCTION-WARNING-LIMIT*. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -05-Jan-90 15:51:31, Edit by Ram. - Changed PRINT-SUMMARY to print a warning for each unknown function. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -05-Jan-90 15:46:02, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1final.lisp -05-Jan-90 15:45:49, Edit by Ram. - Moved detection of unknown function calls to - IR1-CONVERT-OK-COMBINATION-FER-SHER so that we can conveniently note the - error context each time around. *UNKNOWN-FUNCTIONS* is now a list of conses - (Name . Compiler-Error-Context), with entries for each call to an unknown - function. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -05-Jan-90 15:22:04, Edit by Ram. - Split off error context determination from error printing by introducing the - COMPILER-ERROR-CONTEXT structure. The current error context can now be saved - for future use by calling FIND-ERROR-CONTEXT. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/debug-dump.lisp -04-Jan-90 10:56:42, Edit by Ram. - New file. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -04-Jan-90 10:39:31, Edit by Ram. - Put in hooks for dumping debug info. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/entry.lisp -03-Jan-90 15:04:07, Edit by Ram. - Added code to dump the arg documentation. For now, we do pretty much what - the old compiler did, i.e. printing it to a string. - ### Eventually, we may want to put in code to flush package qualifiers on the - variable names and omit complex default forms. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/node.lisp -03-Jan-90 14:44:54, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -03-Jan-90 14:50:15, Edit by Ram. - Added FUNCTIONAL-ARG-DOCUMENTATION slot and made IR1 conversion set it. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/node.lisp -03-Jan-90 14:34:44, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -03-Jan-90 14:34:27, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/debug.lisp -03-Jan-90 14:40:06, Edit by Ram. - Added LAMBDA-OPTIONAL-DISPATCH and made IR1 conversion set it in :OPTIONAL - lambdas. Made consistency checker allow this. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -03-Jan-90 14:07:30, Edit by Ram. - In DELETE-OPTIONAL-DISPATCH, don't clear the ENTRY-FUNCTION in the :OPTIONAL - lambdas. This info is now kept in the LAMBDA-OPTIONAL-DISPATCH slot, and is - not cleared when the lambda stops being an entry point. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/dfo.lisp -03-Jan-90 10:35:50, Edit by Ram. - But we still want to compute the component name in such components... - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/dfo.lisp -03-Jan-90 09:27:51, Edit by Ram. - Changed FIND-INITIAL-DFO to move all components containing a top-level lambda - to the end of the compilation order, even if there are XEPs. This does a - better job of ensuring that environment analysis is done before we compile - the top-level component which does cross-component references. - ### This probably still loses in some pathological case. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -02-Jan-90 17:01:46, Edit by Ram. - Fixed CLEAR-IR2-INFO to check whether there is a tail set before attempting - to clear its INFO. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -02-Jan-90 14:51:46, Edit by Ram. - Changed IR2-CONVERT-CLOSURE to not use the IR2-ENVIRONMENT-ENVIRONMENT, since - this is now blown away after the component is compiled. Instead we use the - ENVIRONMENT-CLOSURE, which is just as good. Actually, this should only - happen with references in XEPs, since that is the only kind of function that - can reference functions across component boundaries. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -17-Dec-89 15:30:10, Edit by Ram. - Wrote CLEAR-IR2-INFO and made COMPILE-TOP-LEVEL call it after it was done - with the IR2 for each component. This should allow the IR2 data structures - to be reclaimed after each component is compiled, even in a multi-component - compilation. - - ### Eventually it should be possible for the IR1 to be reclaimed after the - component is compiled, but there currently cross-component links that inhibit - this. It would also cause problems with IR1 consistency checking, since we - currently need to check all components together. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -15-Dec-89 13:33:44, Edit by Ram. - In IR1-CONVERT-VARIABLE, when we find a CT-A-VAL, we convert an ALIEN-VALUE - form rather than referencing the CT-A-VAL as a leaf. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1final.lisp -13-Dec-89 13:38:51, Edit by Ram. - In NOTE-FAILED-OPTIMIZATION, also inhibit any attempt to give a note if the - combination is no longer a known call. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/gtn.lisp -12-Dec-89 12:25:57, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -12-Dec-89 12:36:38, Edit by Ram. - To avoid having to fix this right right now, changed all passing locations to - be *ANY-PRIMITIVE-TYPE* and added code to do necessary coercions to/from the - actual variable representation. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/type.lisp -12-Dec-89 10:21:15, Edit by Ram. - Fixed a bunch of declarations that were calling things TYPEs instead of - CTYPEs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -11-Dec-89 10:11:31, Edit by Ram. - Changed default fasl file extension from "fasl" to "nfasl", at least for now. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/fndb.lisp -11-Dec-89 08:15:47, Edit by Ram. - Changed most uses of the FUNCTION type to CALLABLE, now that FUNCTION doesn't - encompass SYMBOL but we can still call them. Also fixed some lossage where - someone believed that the SUBSTITUTE/NSUBSTITUTE family of functions had the - same arguments as the DELETE/REMOVE family. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -10-Dec-89 20:33:05, Edit by Ram. - Oops... (fifth x) /==> (nth 5 x), is really (nth 4 x). So that's why - PACKAGE-INIT was losing... - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/macros.lisp -10-Dec-89 09:23:47, Edit by Ram. - Fixed DO-NODES-BACKWARDS to work when the current node is deleted now that - UNLINK-NODE blasts the PREV. Also fixed two bugs in this macro that seem not - to have affected the sole use in FLUSH-DEAD-CODE. One was that it randomly - referenced the variable CONT in one place, rather than commaing in the - appropriate argument. The other was that it did an extra iteration binding - CONT to the block start and NODE to whatever its USE was (often NIL.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -09-Dec-89 13:31:24, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1final.lisp -09-Dec-89 13:30:52, Edit by Ram. - Wrote NODE-DELETED and made NOTE-FAILED-OPTIMIZATION call it so that we won't - gag trying to look at deleted code. This also prevents bogus efficiency - notes about code that was actually optimized away. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -09-Dec-89 13:22:39, Edit by Ram. - Made UNLINK-NODE set the NODE-PREV of the deleted node to NIL so that we can - recognize deleted nodes. Also, fixed the degenerate exit branch to add a use - by EXIT rather than NODE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/checkgen.lisp -08-Dec-89 11:28:54, Edit by Ram. - Changed CONVERT-TYPE-CHECK to call LOCAL-CALL-ANALYZE now that this is not - being done in COMPILE-COMPONENT. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -08-Dec-89 11:24:13, Edit by Ram. - Fixed PROPAGATE-FUNCTION-CHANGE to call MAYBE-LET-CONVERT in addition to - COMVERT-CALL-IF-POSSIBLE so that IR1 optimize will let convert calls that it - discovers can be local. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/vop.lisp -08-Dec-89 10:58:23, Edit by Ram. - Looks like when I made OLD-CONT and RETURN-PC environment TNs (and requiring - the IR2-ENVIRONMENT-SLOTS to be initialized after the environment was - created), I modified the wrong slots to allow NIL. Only detected now because - I was running with safe defstruct accessors. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/debug.lisp -08-Dec-89 09:58:33, Edit by Ram. - IR1 invariants now a bit different: :DELETED continuations can only be - received by blocks with DELETE-P set, and blocks with DELETE-P set can have - no successors. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/locall.lisp -08-Dec-89 09:51:24, Edit by Ram. - Don't attempt to let-convert when the REF is in a block with DELETE-P set - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -08-Dec-89 09:50:13, Edit by Ram. - Don't attempt to do IR1 optimizations when the block has DELETE-P set, just - delete it instead. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -08-Dec-89 09:46:20, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/node.lisp -08-Dec-89 09:51:26, Edit by Ram. - Added BLOCK-DELETE-P and made DELETE-CONTINUATION set it in the DEST block - and its predecessors. Changed most uses of DELETE-CONTINUATION to assert - that there isn't a DEST. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -07-Dec-89 22:08:35, Edit by Ram. - In IR1-OPTIMIZE-IF, set COMPONENT-REANALYZE before UNLINK-NODE so that there - is still a component in the block. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -07-Dec-89 21:17:43, Edit by Ram. - In IR1-CONVERT-OK-COMBINATION-FER-SHER, set the CONTINUATION-%DERIVED-TYPE - and CONTINUATION-TYPE-CHECK of the fun cont in addition to setting - CONTINUATION-REOPTIMIZE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -07-Dec-89 21:08:09, Edit by Ram. - Moved definitions of the arithmetic & logic functions %LDB et al. here from - eval.lisp, since we need them in the bootstrapping environment. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -07-Dec-89 19:17:48, Edit by Ram. - Changed USE-CONTINUATION not to set the CONTINUATION-%DERIVED-TYPE, as this - inhibits CONTINUATION-DERIVED-TYPE from seeing whether the assertion needs to - be intersected, etc. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -07-Dec-89 18:55:32, Edit by Ram. - Changed IR1-OPTIMIZE to more explicitly ignore a block when it is directly - deleted due to :DELETED kind or no predecessors. The old code should have - realized not to optimize a deleted block, but in a rather obscure way. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -07-Dec-89 13:25:38, Edit by Ram. - Changed IR1-OPTIMIZE-UNTIL-DONE to count the number of iterations that didn't - introduce any new code (set COMPONENT-REANALYZE) rather than just the total - number of iterations. Reduced MAX-OPTIMIZE-ITERATIONS to 3, since we now - don't have to worry so much about the results of transforms being adequately - optimized. Changed IR1-PHASES to call GENERATE-TYPE-CHECKS where it was - calling CHECK-TYPES. Flushed old call to GENERATE-TYPE-CHECKS in - COMPILE-COMPONENT. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -07-Dec-89 13:24:20, Edit by Ram. - Changed IR1-OPTIMIZE-IF to set COMPONENT-REANALYZE if it does anything. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/checkgen.lisp -07-Dec-89 12:56:18, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -07-Dec-89 12:28:19, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -07-Dec-89 13:01:31, Edit by Ram. - Changed type checking around a bunch, fixing some bugs and inefficiencies. - The old CHECK-TYPES phase is gone. The determination of - CONTINUATION-TYPE-CHECK is now done on the fly by CONTINUATION-DERIVED-TYPE. - The compile-time type error detection has been moved into type check - generation. Type check generation is now driven by BLOCK-TYPE-CHECK, so it - doesn't have to look at everything on repeat iterations. Made - ASSERT-CONTINUATION-TYPE set BLOCK-TYPE-CHECK when there is a new assertion. - - There are two new values of TYPE-CHECK: :ERROR and :NO-CHECK. These are used - by check generation to comminicate with itself and the back end. :ERROR - indicates a compile-time type error, which always causes a type check to be - emitted, regardless of policy. :NO-CHECK indicates that a check is needed, - but expected not to be generated due to policy or a safe implementation. - This inhibits LTN from choosing an unsafe implementation based on results of - new type information from the post-type-check optimization pass. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/type.lisp -07-Dec-89 10:01:23, Edit by Ram. - Yep, that combined with a bug in how I hooked CTYPEP into TYPES-INTERSECT. - That function should return (VALUES T NIL) in the uncertain case, not - (VALUES NIL NIL). - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/type.lisp -07-Dec-89 09:54:44, Edit by Ram. - Fixed CTYPEP to return the second value T when it calls TYPEP. Is this what - is causing all hell to break loose? It shouldn't, since it should just - result in increased type uncertainty. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/proclaim.lisp -06-Dec-89 21:24:00, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/macros.lisp -06-Dec-89 21:26:24, Edit by Ram. - Added support for the DEBUG-INFO optimization quality (DEBUG for short). - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/type.lisp -06-Dec-89 11:25:36, Edit by Ram. - Made CTYPEP return a second value indicating whether it was able to determine - the relationship. Made all callers look at the second value and propagate - the uncertainty. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/proclaim.lisp -06-Dec-89 11:11:06, Edit by Ram. - Moved the actual establishing of the type definition to %%COMPILER-DEFSTRUCT - from %DEFSTRUCT. Part of this was actually duplicated both places. Now it - is only here. Hopefully this won't cause any initialization problems. Also, - made structure redefinition preserve the INCLUDED-BY list so that existing - structures won't suddenly be broken when the supertype is compiled. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -06-Dec-89 10:43:21, Edit by Ram. - Changed PROCESS-TYPE-PROCLAMATION to call SINGLE-VALUE-TYPE so that we don't - try to call TYPE-INTERSECTION on a hairy function type (or make the type of a - variable, for all that matter.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -05-Dec-89 13:42:19, Edit by Ram. - Made NCOMPILE-FILE frob *DEFAULT-COOKIE* so as to make optimize proclamations - affect only the file that they appear in (and any compilations dynamically - enclosed in that file.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -04-Dec-89 09:38:18, Edit by Ram. - Flushed :SEMI-INLINE and :ALWAYS-INLINE values for INLINEP. Added - :MAYBE-INLINE, which is interpreted in a more advisory manner. Changed - IR1-CONVERT-GLOBAL-INLINE so that it does something like the old - :SEMI-INLINE case for all inline calls so that recursive functions can be - INLINE. - - Fixed this code so that you really can have recursive inline functions. This - was supposedly supported for :SEMI-INLINE functions, but did not in fact - work. We do a hack similar to LABELS: we enter a dummy FUNCTIONAL in the - *FREE-FUNCTIONS* to prevent repeated attempts to convert the expansion. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -03-Dec-89 15:03:48, Edit by Ram. - Defined SAME-LEAF-REF-P and made transforms for EQ, EQL, < and > use it to - see if both args are references to the same variable or functional or - whatever. Also use the EQ transform for CHAR= and EQUAL. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -02-Dec-89 09:26:12, Edit by Ram. - Made MAX-OPTIMIZE-ITERATIONS be a ceiling on the number of times that - IR1-OPTIMIZE-UNTIL-DONE will iterate. If exceeded, we clear a bunch of - REOPTIMIZE flags and punt. This was made necessary by the addition of type - inference on set variables, which may take arbitrarily long to converge. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -01-Dec-89 14:05:10, Edit by Ram. - Added code to compute the type of set LET variables as the union of the types - of the initial value and the set values. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/checkgen.lisp -01-Dec-89 12:11:57, Edit by Ram. - Added code to check to see if it is cheaper to check against the difference - between the proven type and the assertion. If so, emit a check against the - negation of this difference. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -01-Dec-89 09:04:37, Edit by Ram. - Wrote IR1 transforms for < and > that attempt to statically determine the - relationship using type information. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/type.lisp -01-Dec-89 10:06:56, Edit by Ram. - Wrote TYPE-DIFFERENCE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -30-Nov-89 12:04:24, Edit by Ram. - Marked the error signalling funny functions as not returning by using - TRULY-THE NIL. Formerly this was subverting type inference, since the - primitive was considered to return *. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -30-Nov-89 11:52:27, Edit by Ram. - Made SUBSTITUTE-CONTINUATION-USES do a REOPTIMIZE-CONTINUATION on the New - continuation so that we realize we need to recompute its type, etc. This was - seriously crippling type inference. It probably came unglued in let - conversion when we changed over to using the general substitute function. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -30-Nov-89 11:31:00, Edit by Ram. - Changed FIND-FREE-VARIABLE to find the type of constants having values with - CTYPE-OF, rather than using INFO VARIABLE TYPE. This way we find a good type - for all constants, without interacting with the vagaries of environment query. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -30-Nov-89 10:50:37, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/locall.lisp -29-Nov-89 13:14:40, Edit by Ram. - Moved merging of tail sets from CONVERT-CALL to IR1-OPTIMIZE-RETURN. The old - code wasn't working because IR1 optimizations (such as deleting local EXITs) - could cause a local call to be tail-recursive yet the function would never - get added to the tail set because it had already been converted. - - Inaccurate computation of the tail sets resulted in bad code problems, since - functions were returning in ways not expected by their callers. - - ### This code still isn't quite right, since IR1 optimization is supposed to - be optional. One possible fix would be to do tail annotation in IR1 - optimization, but then you would have to run IR1 optimize to get proper tail - recursion. This might not be much of an issue, since we will probably always - want to do at least some IR1 optimization. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -27-Nov-89 12:35:17, Edit by Ram. - Fixed a braino in mask computation in the %DPB, %MASK-FIELD and - %DEPOSIT-FIELD transforms. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/fndb.lisp -26-Nov-89 15:28:27, Edit by Ram. - Fixed MACRO-FUNCTION def to specify a result type of (OR FUNCTION NULL), - rather than just FUNCTION. This was disabling the use of this function as a - predicate to test whether a symbol names a macro. Also fixed the argument - order to REPLACE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -25-Nov-89 22:44:32, Edit by Ram. - Fixed RPLACx transforms to return the right value. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/type.lisp -22-Nov-89 19:27:58, Edit by Ram. - Fixed the definition of STRING-CHAR so that it wouldn't seem to be a subtype - of STANDARD-CHAR. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/seqtran.lisp -22-Nov-89 14:31:40, Edit by Ram. - In MAPPER-TRANSFORM, I seem to have inverted the sense of the exit test when - converting from CONSP to ENDP. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -21-Nov-89 16:51:31, Edit by Ram. - Moved GTN before control analysis so that the IR2-Environment is allocated by - the time that control analysis runs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/control.lisp -21-Nov-89 16:38:24, Edit by Ram. - Moved to ADD-TO-EMIT-ORDER the adding of IR2-Blocks to the - IR2-ENVIRONMENT-BLOCKS. This way, overflow blocks created by conflict - analysis will appear in this list. TNs only live in overflow blocks were - being considered not to conflict with :ENVIRONMENT TNs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/stack.lisp -21-Nov-89 16:34:05, Edit by Ram. - Made DISCARD-UNUSED-VALUES make an IR2 block for the cleanup block and call - ADD-TO-EMIT-ORDER on it. I think that if this code ever ran, it would have - died. This code was tested at one point, so it was probably broken by the - move of control analysis to before all the other IR2 pre-passes. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/tn.lisp -21-Nov-89 14:43:29, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/gtn.lisp -21-Nov-89 14:51:36, Edit by Ram. - Wrote MAKE-WIRED-ENVIRONMENT-TN so that the save TNs for old-cont and - return-pc could be made environment-live. Made ASSIGN-IR2-ENVIRONMENT pass - the environment to MAKE-xxx-SAVE-TN so that they could make environment-live - TNs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/assembler.lisp -20-Nov-89 08:58:31, Edit by Ram. - In NEW-LOGIOR-ARGUMENT, added code to check that the SB for :REGISTER - operands is really REGISTERS. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -20-Nov-89 08:29:42, Edit by Ram. - In EMIT-MOVE, added code to emit a type error when moving between - incompatible TNs. It seems that this can happen with functions (especially - funny functions) that don't return. This seems like a good fix until we can - figure out how to hack the flow graph when there is a non-returning function. - [Incompatible moves may also happen if there is a compile-time type error and - the check is deleted due to unsafe policy, etc.] - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/fndb.lisp -17-Nov-89 15:06:51, Edit by Ram. - Changed %PUT's IR1 attributes from (FLUSHABLE) to (UNSAFE). - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -17-Nov-89 10:12:48, Edit by Ram. - Fixed some missing commas in SOURCE-TRANSFORM-TRANSITIVE that only affected - LOGEQV. Good thing nobody uses it... - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/vmdef.lisp -16-Nov-89 09:42:37, Edit by Ram. - Fixed previous fix to work when there is a more result. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/vmdef.lisp -15-Nov-89 13:57:36, Edit by Ram. - In TEMPLATE-TYPE-SPECIFIER, if we use a values type for the result, make it - &REST T to represent the vagueness of values count matching. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -15-Nov-89 09:57:48, Edit by Ram. - Added missing source transform for LOGEQV, which was missed in the previous - pass. This required changing SOURCE-TRANSFORM-TRANSTIVE, since that was - already a source transform for LOGEQV. It's a good thing I left in *both* - checks for broken interpreter stubs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -14-Nov-89 10:41:51, Edit by Ram. - Added source transforms for zillions of trivial logic operations that were - missing. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -14-Nov-89 10:43:24, Edit by Ram. - In %DEFUN, added the presence of an IR2-CONVERT methods to the list of things - that inhibits substitution of the actual definition for existing references. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/srctran.lisp -13-Nov-89 12:21:52, Edit by Ram. - Added source transforms for RPLACA, RPLACD. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -13-Nov-89 12:17:32, Edit by Ram. - Moved the test of NODE-REOPTIMIZE out of FIND-RESULT-TYPE and into - IR1-OPTIMIZE-RETURN. This fixes a bug that was introduced when the clearing - of NODE-REOPTIMIZE was moved to the start of the loop in IR1-OPTIMIZE-BLOCK. - We were never recomputing the RETURN-RESULT-TYPE, since REOPTIMIZE was never - set when we got to IR1-OPTIMIZE-RETURN. With this fix, the previous change - should detect broken interpreter stubs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1final.lisp -12-Nov-89 13:05:49, Edit by Ram. - Made CHECK-FREE-FUNCTION give a note when it sees a function that doesn't - return (return type is NIL.) I thought that this would detect broken - interpreter stubs. It turns out not to, but still seems like a useful - feature. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -13-Nov-89 11:47:30, Edit by Ram. - Made LTN-ANALYZE-KNOWN-CALL give a warning when we are unable to find a - template for a known call where there call is to the current function. This - should tell result in a warning when we compile an interpreter stub for a - function that the code sources assume is implemented primitively, but the - compiler doesn't recognize. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -12-Nov-89 10:54:25, Edit by Ram. - Oops... When doing unsafe global function references, use - FAST-SYMBOL-FUNCTION, not FAST-SYMBOL-VALUE. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/main.lisp -10-Nov-89 13:37:15, Edit by Ram. - Oops... Have to dump package frobbing forms specially for cold load. This - might want to be on a switch someday. Instead of actually compiling them, we - dump them as lists so that Genesis can eval them. The normal top-level form - compilation must be suppressed, since the package system isn't initialized at - the time that top-level forms run. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/dfo.lisp -05-Nov-89 13:45:11, Edit by Ram. - Changed FIND-INITIAL-DFO to return top-level components at the end of the - list so that in a block compilation all the functions will be compiled before - we compile any of the top-level references to them. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/envanal.lisp -01-Nov-89 11:57:58, Edit by Ram. - Changed Find-Non-Local-Exits back to a loop over all the blocks in the - component, rather than trying to find the exits from the Lambda-Entries. - Unfortunately, the latter is not possible, since the exit continuation may - become deleted if it isn't used. A possible way to avoid this search would - be to make the Entry node have a list of all the Exit nodes, rather than the - continuations. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/vop.lisp -31-Oct-89 12:45:20, Edit by Ram. - Allow (SETF xxx) for the Entry-Info-Name, in addition to strings and symbols. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -31-Oct-89 12:53:37, Edit by Ram. - In Find-Source-Context, only take the car of list first args to DEFxxx forms - when the form name is in a special list. This list initially only contains - DEFSTRUCT. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -31-Oct-89 12:23:57, Edit by Ram. - In Convert-More-Entry, made the temporaries for the keyword and value - ignorable so that we don't get "defined but never read" warnings when there - aren't any keywords specified. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -31-Oct-89 12:11:24, Edit by Ram. - Fixed Process-Declarations to correctly deal with pervasive special - declarations. Previously, a warning would be given if the varible was only - locally declared, and not globally known. Also an assertion failure would - have resulted (rather than a Compiler-Error) when a constant was declared - pervasively special. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -31-Oct-89 11:39:54, Edit by Ram. - Changed Reference-Constant so that it doesn't call Reference-Leaf anymore, - and made the source be an explicit argument. Changed Reference-Leaf to just - use the Leaf-Name as source, rather than (sometime incorrectly) inferring the - source for constants. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -20-Oct-89 15:56:56, Edit by Ram. - In the :UNKNOWN and :UNUSED cases of CONTINUATION-RESULT-TNS, always return - TNs of the specified result types, rather than sometimes returing T TNs. - This is some sort of compensation for our new belief that VOPS returining - non-T results need not be prepared to accept T TNs. How many other places - does this need to be fixed? - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/stack.lisp -17-Oct-89 12:36:38, Edit by Ram. - In FIND-PUSHED-CONTINUATIONS, fix the check for pushes coming before pops. - You can compare nodes and continuations all day without finding any that are - EQ. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/macros.lisp -17-Oct-89 11:44:40, Edit by Ram. - Flushed the code in DEFTRANSFORM that was creating a THE out of the CONT's - asserted type. This should be unnecessary, and was made incorrect by the - continuation representation change. If the node was the last in a block and - the value wasn't used, then the value would be asserted to be of the NIL - type, resulting in a warning. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -17-Oct-89 10:51:27, Edit by Ram. - Changed Compiler-Mumble to tell whether an error message precedes from - *last-format-string*, rather than *last-source-context*, since the last - message might not have had a source context. Made *compiler-error-output* be - globally bound to a synonym stream for *error-output* so that calls to - Compiler-Error outside of the compiler will more or less work. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/checkgen.lisp -16-Oct-89 15:23:13, Edit by Ram. - In Convert-Type-Check, set the start & end cleanups of the new block to the - *start* cleanup of the Dest's block, and not the end cleanup. Not sure this - is really more correct, but it fixes one case. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/pack.lisp -12-Oct-89 14:05:43, Edit by Ram. - Added a before-GC hook that flushes the per-SB conflict data structure - whenever they aren't being used. This should prevent megabyte-plus conflicts - information from persisting after it is needed, and also reduce the cost of - Init-SB-Vectors, since the vectors will stay smaller. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -11-Oct-89 11:37:16, Edit by Ram. - Made Propagate-Function-Change ignore references that are :Notinline. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -10-Oct-89 23:28:33, Edit by Ram. - In Print-Error-Message, use the *Current-Form* as the source form whenever if - is non-NIL, even if there is a node in *Compiler-Error-Context*. This way, - messages during IR1 conversion of a transform will be more useful. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -10-Oct-89 22:47:56, Edit by Ram. - Now Delete-Optional-Dispatch must be prepared for the main entry to be a let - rather than just being deleted or a normal function, since let conversion is - being triggered here. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/locall.lisp -09-Oct-89 17:56:35, Edit by Ram. - Fixed Convert-Call to change the combination kind before changing the ref - leaf so that the call will appear local at that time. This allows let - conversion to happen when we replace a optional dispatch with one of its EPs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -09-Oct-89 17:34:42, Edit by Ram. - Fixed Delete-Optional-Dispatch to call Maybe-Let-Convert if we notice that a - former EP lambda has exactly one reference. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -04-Oct-89 19:05:16, Edit by Ram. - In IR1-Optimize-Combination, we must be prepared for the derive-type method - to return NIL. This will happen if the arglist is incompatible with the - call (and if the optimizer explicitly returns NIL.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/macros.lisp -04-Oct-89 19:22:17, Edit by Ram. - Check-Transform-Keys and Check-Keywords-Constant were checking the second - (value) part of the key/value pair, so optimizers would never run if any - keywords were supplied. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -04-Oct-89 15:39:27, Edit by Ram. - When I changed Propagate-Local-Call-Args to clear the Continuation-Reoptimize - flags, I forgot that a local call continuation can be NIL (for an unused - argument.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -04-Oct-89 11:05:48, Edit by Ram. - Oops... In Propagate-Function-Change, we have to use - Continuation-Derived-Type rather than Continuation-Type now that the latter - changes function types to FUNCTION. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/globaldb.lisp -27-Sep-89 14:24:04, Edit by Ram. - Exported basic interface (but not environment vars, pending some abstract - interface to environment manipulation.) Changed class and type names to be - represented as strings at run time to avoid package lossage. Changed names - to be arbitrary equal objects (to allow setf functions). - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -21-Sep-89 10:12:38, Edit by Ram. - Changed OK-Result-TN to indicate need for a coercion if the result is unboxed - and the TN is boxed. This prevents load-TN packing from getting confused due - to there being no intersection between the SC restriction and the types - allowed by the SC. This would happen when the result was restricted to a - non-descriptor SC. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -21-Sep-89 10:39:04, Edit by Ram. - Changed Restrict-Descriptor-Args to restrict the argument only when a - coercion was required. This allows immediate objects to be passed to - templates in unboxed registers. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -30-Aug-89 14:37:36, Edit by Ram. - Changed Change-Leaf-Ref (and hence Substitute-Leaf) to use Derive-Node-Type - on the Ref with the Leaf-Type so that substituting a variable causes the new - type to be noticed. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -30-Aug-89 14:30:44, Edit by Ram. - Changed IR1-Optimize-Block and all the combination optimization code to clear - optimize flags *before* optimizing rather than after, so that a node will be - reoptimized if necessary. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/vmdef.lisp -29-Aug-89 09:20:18, Edit by Ram. - Made Template-Type-Specifier hack *'s in operand type restrictions. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -24-Aug-89 13:55:04, Edit by Ram. - In LTN-Analyze-MV-Call, have to annotate the continuations in reverse order, - now that the IR2-Block-Popped isn't built in reverse order. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -24-Aug-89 13:25:14, Edit by Ram. - In LTN-Analyze, eliminated assertion that the block containing the use of a - unknown-values continuation is not already in the - IR2-Component-Values-Generators. It is possible for a single block to - contain uses of several MV continuations that have their DEST in a different - block. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/dfo.lisp -22-Aug-89 12:12:49, Edit by Ram. - Made Find-Initial-DFO-Aux call Walk-Home-Call-Graph on each block before - walking the successors. Walk-Home-Call-Graph is a new function that looks at - the current block's home lambda's bind block to see if it is in a different - component. We need to do this to ensure that all code in a given environment - ends up in the same component, since any successor might be a non-local exit - (into a different environment.) - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -18-Aug-89 15:46:51, Edit by Ram. - Flushed the (locally (declare (optimize (safety 0))) ...) around the body of - Unwind-Protect's expansion. I think that this was trying to suppress some - type checking of the MV-Bind, but it was also causing unsafe compilation of - the protected form. If we really need this, it must be but back some other - way. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -18-Aug-89 15:11:13, Edit by Ram. - Oops... We can't use Label-Offset in the generators for Make-Catch-Block, - &c. Instead, we use a :Label load-time constant. The target argument to the - VOPs is now a normal integer argument, rather than a label in the - codegen-info. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -18-Aug-89 14:13:51, Edit by Ram. - In LTN-Analyze-Return, don't annotate NLX continuations as :Unused so that - the NLX entry code doesn't have to worry about this case. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -18-Aug-89 13:45:19, Edit by Ram. - In Reoptimize-Continuation, don't do anything if the continuation is deleted. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1util.lisp -17-Aug-89 11:17:13, Edit by Ram. - Oops... In Node-Ends-Block, have to set the Block-Start-Uses, now that it is - always supposed to hold the uses of block starts. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -10-Aug-89 10:49:01, Edit by Ram. - Changed Find-Template to intersect the Node-Derived-Type with the - Continuation-Asserted-Type rather than using the Continuation-Derived-Type in - the case where we are allowed to use the result type assertion. This works - better when the continuation has multiple uses. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/typetran.lisp -24-Jul-89 14:25:09, Edit by Ram. - Fixed Source-Transform-Union-Typep to check that there really is a MEMBER - type in the union, instead of assuming there is whenever LIST is a subtype. - This was losing on (OR SYMBOL CONS). - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/assembler.lisp -19-Jul-89 14:36:10, Edit by Ram. - Made Init-Assembler nil out the Info slots in all the fixups so that the - fixup freelist doesn't hold onto the entire IR. More storage allocation - lossage has been caused by the explicit freelists in the assembler than - anything else. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/macros.lisp -12-Jul-89 15:34:09, Edit by Ram. - Changed defining macros to stick the actual function object into the - Function-Info &c to be compatible with the new definition of the Function - type. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -12-Jul-89 12:57:24, Edit by Ram. - Fixed goof in IR2-Convert-Local-Unknown call, where it was converting the - result TN list to TN-refs twice. For some reason, this was dying with a - highly mysterious error in Reference-TN-List. Perhaps this file was last - compiled with an unsafe policy? - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/life.lisp -11-Jul-89 19:29:05, Edit by Ram. - In Propagate-Live-TNs, when we convert a :Read-Only conflict to :Live, we - null the entry in the local TNs to represent the elimination of local - conflict information. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -11-Jul-89 18:46:17, Edit by Ram. - Changed %Defun to only substitute the functional when it isn't notinline and - isn't known to have any templates or transforms. The latter constraint fixes - big problems with interpreter stubs. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1tran.lisp -05-Jul-89 22:11:10, Edit by Ram. - In Return-From, put back code that made Cont start a block so that Cont will - have a block assigned before IR1-Convert. So that's why that was there. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -05-Jul-89 18:07:48, Edit by Ram. - In Annotate-Unknown-Values-Continuation, make a safety note when we delete a - check and the policy is safe. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir1opt.lisp -05-Jul-89 17:43:18, Edit by Ram. - In IR1-Optimize-Exit, don't propagate Cont's type to the Value, since this - moves checking of the assertion to the Exit, which is a bad place. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -05-Jul-89 15:10:34, Edit by Ram. - In Emit-Return-For-Locs, changed the test for when to use known return - convention from External-Entry-Point-P to *not* External-Entry-Point-P. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ir2tran.lisp -05-Jul-89 14:41:55, Edit by Ram. - Oops... We need a UWP-Entry VOP for Unwind-Protect entries to force random - live TNs onto the stack. It doesn't actually do anything, but specifies the - passing locations as results so that they aren't forced to the stack. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/ltn.lisp -03-Jul-89 16:46:09, Edit by Ram. -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/stack.lisp -03-Jul-89 16:39:53, Edit by Ram. - Changed unknown values hackery to ignore non-local exits. We don't record - NLX uses of unknown-values continuations as generators, and we stop - our graph walk when we hit the component root. These changes were - necessitated by the decision to make %NLX-Entry no longer use the values - continuation. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/pack.lisp -03-Jul-89 11:31:36, Edit by Ram. - Fixed one-off error in Pack-Wired-TN's determination of when we have to grow - the SB, and fixed it to handle SC-Element-Size /= 1 while I was at it. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/locall.lisp -29-Jun-89 12:02:16, Edit by Ram. - In Local-Call-Analyze-1, moved the test for the reference being by the - Basic-Combination-Fun to around the entire branch that attempts to convert, - rather than immediately around the call to Convert-Call-If-Possible. Before, - a closure arg to a local function wouldn't get an XEP. - - Also, changed Reference-Entry-Point to ignore references to :Cleanup and - :Escape functions. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/envanal.lisp -28-Jun-89 16:57:12, Edit by Ram. - In Emit-Cleanups, if we find there is no cleanup code, then do nothing, - instead of inserting a cleanup block holding NIL. This was causing blocks - with no non-local uses to inhibit tail-recursion. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/checkgen.lisp -28-Jun-89 14:03:45, Edit by Ram. - It finally happened. A paren error that resulted in mysterious lossage. In - this case, the body of the loop in Make-Type-Check-Form was moved out of the - loop, and always executed once. The meant that only one value would ever be - checked or propagated on to the original receiver. - -/afs/cs.cmu.edu/project/clisp/new-compiler/compiler/pack.lisp -28-Jun-89 13:20:59, Edit by Ram. - Oops... I introduced a bug in the previously correct argument case of - Load-TN-Conflicts-In-SB. We terminate the loop when we reach the first - reference, not the first argument. This caused conflicts with temporaries - with lives beginning at :Load to be ignored. - -/usr1/lisp/compiler/pack.lisp, 23-Jun-89 15:54:32, Edit by Ram. - Fixed logic in Load-TN-Conflicts-In-SB. We weren't recognizing conflicts - with other argument/result TNs that had already been packed. This bug would - only show up with multiple result load TNs. The argument case was actually - correct, but was asymmetrical with the result case, and only worked becase - argument load TNs were packed in evaluation order. - -/usr1/lisp/compiler/locall.lisp, 20-Jun-89 14:53:51, Edit by Ram. - In Merge-Tail-Sets, quietly do nothing if the called function has no tail set - (doesn't return), rather than dying. - -/usr1/lisp/compiler/globaldb.lisp, 14-Jun-89 10:14:04, Edit by Ram. - Flushed Top-Level-P attribute. - -/usr1/lisp/compiler/macros.lisp, 14-Jun-89 10:14:03, Edit by Ram. - Allow a doc string in Def-IR1-Translator (made the FUNCTION documentation). - Removed support for Top-Level-P attribute. - -/usr1/lisp/compiler/ir1opt.lisp, 22-May-89 15:30:59, Edit by Ram. -/usr1/lisp/compiler/ir1util.lisp, 22-May-89 15:22:17, Edit by Ram. - Undid last change to Node-Ends-Block and Join-Blocks. This was fucking up - big time, since it messed with the continuation even when it was a block - start. - -/usr1/lisp/compiler/locall.lisp, 22-May-89 13:24:48, Edit by Ram. - Changed Local-Call-Analyze to maintain the Component-New-Functions exactly up - to date, only popping a function off exactly as it analyzes it. This way, a - lambda is always referenced either in the Lambdas or New-Functions (except - during a brief window), so we can do consistency checking during local call - analysis. - -/usr1/lisp/compiler/ir1util.lisp, 19-May-89 10:05:28, Edit by Ram. -/usr1/lisp/compiler/ir1opt.lisp, 19-May-89 10:05:27, Edit by Ram. - In Flush-Dest and Reoptimize-Continuation, take care not to assume that the - Continuation-Block is an undeleted block. Instead, we pick up the component - to reoptimize from the uses or Dest. - -/usr1/lisp/compiler/ir2tran.lisp, 17-May-89 12:48:35, Edit by Ram. - In Move-Results-Coerced and Move-Results-Checked, subtract Nsrc from Ndest, - rather than the other way around. - -/usr1/lisp/compiler/control.lisp, 15-May-89 11:53:36, Edit by Ram. - Made Control-Analyze walk XEPs first to eliminate the idiocy of never getting - the drop-through in components with only one EP. - -/usr1/lisp/compiler/ir1util.lisp, 13-May-89 15:23:28, Edit by Ram. - And similarly, in Node-Ends-Block, move the last continuation to the new - block when its block is the old block. - -/usr1/lisp/compiler/ir1opt.lisp, 13-May-89 15:02:31, Edit by Ram. - In Join-Blocks, move the Cont of the Last to Block1 when it's block is - currently Block2. This way, the continuation isn't left pointing at some - random deleted block. - -/usr1/lisp/compiler/ir1util.lisp, 14-Mar-89 10:12:04, Edit by Ram. - Also, in Delete-Block, when we delete a bind, call Delete-Lambda, rather - than trying to roll our own. - -/usr1/lisp/compiler/ir1util.lisp, 14-Mar-89 10:07:01, Edit by Ram. - In Delete-Lambda, we must remove a let from its home's lets. - -/usr1/lisp/compiler/ir1util.lisp, 14-Mar-89 09:34:54, Edit by Ram. - In Unlink-Node, the assertion that the start and end cleanups are the same - must use Find-Enclosing-Cleanup, rather than just comparing the values - directly. - -/usr1/lisp/compiler/ir2tran.lisp, 14-Mar-89 08:26:04, Edit by Ram. - Wrote Flush-Tail-Transfer and made people who do TR stuff use it. This - function deletes the link between the blocks for a TR node and the block - containing the return node. We have to do this so that lifetime analysis - doesn't get confused when there are TNs live at the return node, but some - predecessors of the return don't write the TNs because the return some other - way. - -/usr1/lisp/compiler/srctran.lisp, 10-Mar-89 19:11:51, Edit by Ram. - Made the transforms into %typep always pass until we do type predicates for - real. - -/usr1/lisp/compiler/assembler.lisp, 10-Mar-89 18:56:45, Edit by Ram. - Fixed Macrolet of Emit-Label in Def-Branch to have a paren in the right - place. As written, it expanded into its argument, and didn't enclose any - code anyway. But I think this would only affect instructions that both were - a branch and had a load-time fixup. - -/usr1/lisp/compiler/assembler.lisp, 10-Mar-89 18:47:50, Edit by Ram. - Added code to Def-Branch in the choose function that calls - Undefined-Label-Error when the the label isn't defined. This function uses - the *assembler-nodes* source info and the branch instruction location to - print the source node responsible for generating the bogus branch. - -/usr1/lisp/compiler/assembler.lisp, 10-Mar-89 17:59:51, Edit by Ram. - Made Gen-Label initalize the Elsewhere-P slot to :Undecided. Also made - Merge-Code-Vectors ignore labels whose Elsewhere-P is undecided. The theory - is that it should be o.k. to make labels that aren't emitted as long as you - don't reference them. Of course, I will probably find that the losing labels - are referenced. Renamed the Location slot in Label to %Location, and defined - Label-Location to filter out undefined labels. - -/usr1/lisp/compiler/ltn.lisp, 10-Mar-89 17:43:39, Edit by Ram. - In LTN-Analyze-Return, we must check for the Return-Info-Count being :Unknown - rather than null when we want to know if a fixed number of values are - returned. - -/usr1/lisp/compiler/ir2tran.lisp, 07-Mar-89 18:13:12, Edit by Ram. - In the Values-List IR2 convert method, we must also handle :Unused - continuations, only punting when the continuation is :Fixed. When called - with a TR result continuation, we have to emit the unknown-values return - ourself. Otherwise, there isn't any way to write the Values-List function. - -/usr1/lisp/compiler/ir2tran.lisp, 06-Mar-89 21:25:12, Edit by Ram. - Make-Closure takes the number of closure vars and the function-entry, rather - than the other way around. - -/usr1/lisp/compiler/ir2tran.lisp, 06-Mar-89 20:48:29, Edit by Ram. - And always pass 1 as the number of symbols to Unbind, rather than 0. - -/usr1/lisp/compiler/ir2tran.lisp, 06-Mar-89 20:43:47, Edit by Ram. - Args to the Bind miscop are (Value, Symbol), and not the other way around. - -/usr1/lisp/compiler/ir2tran.lisp, 06-Mar-89 19:09:16, Edit by Ram. - In IR2-Convert-IF, we have to negate the sense of the test when using an EQ - NIL check. Made IR2-Convert-Conditional take an additional not-p argument. - -/usr1/lisp/compiler/ctype.lisp, 06-Mar-89 17:22:40, Edit by Ram. - In Definition-Type, when we make the Function-Type, include the list of - keyword info that we have built. - -/usr1/lisp/compiler/ir2tran.lisp, 02-Mar-89 18:16:40, Edit by Ram. - In Init-XEP-Environment, when we are checking for whether there is a more - arg, look at the entry-function rather than the XEP. - -/usr1/lisp/compiler/main.lisp, 01-Mar-89 15:58:32, Edit by Ram. - Made Clear-Stuff clear the Finite-SB-Live-TNs in all SBs. Maybe this will - nuke some garbage. - -/usr1/lisp/compiler/pack.lisp, 01-Mar-89 15:50:41, Edit by Ram. - In Grow-SC, fill the Finite-SB-Live-TNs vector with NILs before we lose it so - that if it is statically allocated, it won't hold onto garbage. But this - shouldn't make any difference, since we never use the Live-TNs in unbounded - SBs. - -/usr1/lisp/compiler/locall.lisp, 01-Mar-89 01:15:22, Edit by Ram. - In Make-XEP-Lambda, in the lambda case, we now include an ignore declaration - for the nargs var when policy suppresses the argument count check. - -/usr1/lisp/compiler/ir1util.lisp, 28-Feb-89 19:39:56, Edit by Ram. - Also clear :Optional kind for the Main-Entry in Delete-Optional-Dispatch. - -/usr1/lisp/compiler/locall.lisp, 28-Feb-89 19:31:07, Edit by Ram. - Changed Local-Call-Analyze so that it pushes new lambdas on the - Component-Lambdas before it does any call analysis or let conversion. This - gets the normal consistency maintenance code to handle removal of deleted - and let lambdas. Before, there was a local list of new lambdas that could - become inconsistent. - -/usr1/lisp/compiler/ir1tran.lisp, 28-Feb-89 18:12:15, Edit by Ram. - Instead of trying to set the :Optional kind everywhere that hairy lambda - conversion creates a lambda, we wait until we are done and set the kind only - the lambdas that are actually e-ps. This was causing internal lambdas that - weren't e-ps to be marked as optional. The fix is also clearer, and causes - less complication in the already-hairy code. - -/usr1/lisp/compiler/ir1tran.lisp, 24-Feb-89 15:26:29, Edit by Ram. - Changed Optional-Dispatch stuff to set the Functional-Entry-Function of the - :Optional lambdas to the result Optional-Dispatch structure. - -/usr1/lisp/compiler/ir1opt.lisp, 24-Feb-89 14:46:57, Edit by Ram. - In IR1-Optimize, changed test for being in a deleted lambda to just look at - the block-lambda, rather than at it's home. The result should be the same. - -/usr1/lisp/compiler/entry.lisp, 24-Feb-89 14:30:37, Edit by Ram. - Changed Compute-Entry-Info to use the XEP's environment to determine whether - the function is a closure. The result should be the same, but is more easily - obtained. - -/usr1/lisp/compiler/ir1util.lisp, 24-Feb-89 14:26:58, Edit by Ram. - Deleted definition of Find-XEP-Call, since this doesn't make sense anymore. - -/usr1/lisp/compiler/debug.lisp, 24-Feb-89 14:21:09, Edit by Ram. - Flushed permission of random wired live TNs at the start of an XEP. - -/usr1/lisp/compiler/debug.lisp, 24-Feb-89 14:18:01, Edit by Ram. - In Check-Block-Successors, flushed permission of random successor count in - XEPs. - -/usr1/lisp/compiler/ir2tran.lisp, 24-Feb-89 14:14:12, Edit by Ram. - Flushed check for being the bind block for an XEP that inhibited emission of - a block-finishing branch in Finish-IR2-Block. Control flow is now normal in - XEPs, so we don't want to randomly flush branches. - -/usr1/lisp/compiler/ir1opt.lisp, 24-Feb-89 14:07:52, Edit by Ram. - Flushed check for being in an XEP in Join-Successor-If-Possible. Now that - argument count dispatching is done explicitly, there is no need to force the - call to a block boundry (for easy location). Also, we are getting more - complex code in the XEP, making block merging a desirable optimization. - -/usr1/lisp/compiler/ir1util.lisp, 24-Feb-89 14:03:35, Edit by Ram. - Fixed code in Delete-Lambda that was trying to notice when we are deleting - the the XEP for an optional dispatch. The test was right, but the action was - wrong: it was setting the Functional-Entry-Function for all the e-p's to NIL, - yet they were already NIL. Instead, we call Delete-Optional-Dispatch, which - deletes the unreferenced e-p's. - -/usr1/lisp/compiler/ir1tran.lisp, 23-Feb-89 20:17:21, Edit by Ram. - Wrapped a (locally (declare (optimize (safety 0))) ...) around the body of - the loop created in Convert-More-Entry so that no type checking is done on - the fixnum arithmetic. - -/usr1/lisp/compiler/ir2tran.lisp, 23-Feb-89 14:34:49, Edit by Ram. - Flushed most of the hair associated with the %Function-Entry funny function. - What remains is now in Init-XEP-Environment, which is called by - IR2-Convert-Bind when the lambda is an XEP. - -/usr1/lisp/compiler/gtn.lisp, 23-Feb-89 14:24:20, Edit by Ram. - Flushed some special-casing of XEPs that is no longer needed now that XEP's - have args. Also, allocation of argument passing locations in XEPs is now - more similar to the non-XEP case: we don't allocate passing locations for - unused arguments. - -/usr1/lisp/compiler/locall.lisp, 22-Feb-89 15:26:50, Edit by Ram. - Change handling of XEPs. Most of the action in XEPs is now represented by - explicit IR1 in the XEP: argument dispatching is done by a COND, etc. - Instead of using funny functions such as %XEP-ARG to access the passed - arguments, NARGS and all the positional arguments are passed as arguments to - the XEP (with garbage defaults for unsupplied args). The code in the XEP - just references these variables. - - This simplifies creation of the XEP, since we can just cons up a lambda form - and convert it, instead of creating each XEP call by hand. It also moves - complexity out of IR2 conversion, since argument dispatching has already been - implemented. - -/usr1/lisp/compiler/ir2tran.lisp, 16-Feb-89 15:12:17, Edit by Ram. - Fixed %XEP-Arg to use Move-Argument rather than just Move. - -/usr1/lisp/compiler/node.lisp, 15-Feb-89 00:36:30, Edit by Ram. - Made Functional specify :Defined and Function as the defaults for the - Where-From and Type slots so that we know defined functions are in fact - functions. - -/usr1/lisp/compiler/ir1tran.lisp, 14-Feb-89 23:48:37, Edit by Ram. - In %Defun translator, fixed the test for being at top level (and thus o.k. to - substitute). The sense was negated, but it was also broken so that it was - always false, so the normal top-level thing happened anyway. - -/usr1/lisp/compiler/ir1tran.lisp, 14-Feb-89 15:02:14, Edit by Ram. - Wrote Leaf-Inlinep and changed uses to (cdr (assoc leaf *inlines*)) with the - new function. This means that global declarations will now affect function - references. - -/usr1/lisp/compiler/main.lisp, 13-Feb-89 12:19:39, Edit by Ram. - Call Init-Assembler *before* Entry-Analyze so that we don't emit labels when - the assembler isn't initialized. - -/usr1/lisp/compiler/ltn.lisp, 02-Feb-89 15:41:40, Edit by Ram. - Changed Annotate-Function-Continuation not to clear Type-Check unless the - policy is unsafe. Changed LTN-Default-Call to take a policy argument and - pass it through. - -/usr1/lisp/compiler/ir1tran.lisp, 02-Feb-89 15:16:32, Edit by Ram. - Changed IR1-Convert-Combination-Args and the translator for - Multiple-Value-Call to assert that the function continuation yeilds a value - of type Function. - -/usr1/lisp/compiler/assembler.lisp, 31-Jan-89 14:13:54, Edit by Ram. -/usr1/lisp/compiler/codegen.lisp, 31-Jan-89 14:13:53, Edit by Ram. - Added a function version of Emit-Label that can be called outside of - Assemble. Used this in Generate-Code so that we don't have to worry about - faking the current node for Assemble, when we aren't emitting any code - anyway. - -/usr1/lisp/compiler/assembler.lisp, 31-Jan-89 13:56:08, Edit by Ram. - In Init-Assembler, Null out the Assembler-Node-Names in *Assembler-Nodes* so - that we don't hold onto old garbage. Also zero the code vectors so that - unitialized bytes always come up zero. - -/usr1/lisp/compiler/ir2tran.lisp, 31-Jan-89 12:37:21, Edit by Ram. - Fixed IR2-Convert-Local-Unknown-Call to use Standard-Value-TNs to get the - result TNs, rather than calling incorrectly calling Make-Standard-Value-TNs - on a continuation. - -/usr1/lisp/compiler/ir1opt.lisp, 30-Jan-89 23:28:08, Edit by Ram. - Changed Check-Types to not set Type-Check when the asserted type is T and the - derived type is *. - -/usr1/lisp/compiler/ir1util.lisp, 30-Jan-89 19:36:09, Edit by Ram. - Changed Delete-Ref not to call Delete-Lambda or Delete-Optional-Dispatch when - the functional is already deleted. - -/usr1/lisp/compiler/locall.lisp, 30-Jan-89 19:23:26, Edit by Ram. - Convert-MV-Call must add the ep to the Lambda-Calls for the home lambda (as - in Convert-Call) so that DFO can detect the control transfer implicit in - local call. - -/usr1/lisp/compiler/ir1util.lisp, 30-Jan-89 18:30:27, Edit by Ram. - Changed Delete-Optional-Dispatch to call Delete-Lambda on all entry points - with no references. - -/usr1/lisp/compiler/ir1util.lisp, 30-Jan-89 17:04:33, Edit by Ram. - Changed Delete-Lambda to mark the Lambda's lets as :Deleted as well, - guaranteeing that all code in the environment of a deleted lambda is deleted - (without having to do flow analysis). - -/usr1/lisp/compiler/locall.lisp, 30-Jan-89 16:37:31, Edit by Ram. - Changed Convert-MV-Call not to call Let-Convert, since the last entry may - have spurious references due to optional defaulting code that hasn't been - deleted yet. Changed Maybe-Let-Convert to set the Functional-Kind of the - lambda to :Let or :MV-Let, depending on the combination type. - -/usr1/lisp/compiler/locall.lisp, 30-Jan-89 15:35:52, Edit by Ram. - Changed Merge-Cleanups-And-Lets to use Find-Enclosing-Cleanup to determine - whether there is any cleanup in effect at the call site, rather than directly - using the Block-End-Cleanup. - -/usr1/lisp/compiler/ir1util.lisp, 30-Jan-89 15:12:51, Edit by Ram. - Changed Node-Ends-Block to set the start and end cleanups of the *new* block - (not the old) to the ending cleanup of the old block. This is clearly more - right, but may not be totally right. - -/usr1/lisp/compiler/life.lisp, 27-Jan-89 17:09:01, Edit by Ram. - Make Clear-Lifetime-Info always set the TN-Local slot for local TNs, using - some other referencing block when there there are global conflicts. - -/usr1/lisp/compiler/pack.lisp, 10-Jan-89 15:27:21, Edit by Ram. - Fixed Select-Location not to infinite loop when Finite-Sb-Last-Offset is 0. - -/usr0/ram/compiler/ir2tran.lisp, 30-Jun-88 13:57:12, Edit by Ram. - Fixed IR2-Convert-Bind to ignore vars with no Refs. - -/usr0/ram/compiler/gtn.lisp, 30-Jun-88 13:54:51, Edit by Ram. - Fixed Assign-Lambda-Var-TNs and Assign-IR2-Environment to ignore vars with no - Refs. - -/usr0/ram/compiler/life.lisp, 02-Mar-88 17:06:18, Edit by Ram. - Aaaargh! When clearing the Packed-TN-Local in Clear-Lifetime-Info, iterate - up to Local-TN-Limit, not SC-Number-Limit. - -/usr0/ram/compiler/ir1util.lisp, 20-Feb-88 22:00:37, Edit by Ram. - Made Substitute-Leaf and Change-Ref-Leaf do an Up-Tick-Node on the changed - Refs. - -/usr0/ram/compiler/ltn.lisp, 20-Feb-88 16:25:11, Edit by Ram. - Changed Find-Template to deal with output assertions correctly once again. - Instead of assuming that the Node-Derived-Type is true, we look at the - Type-Check flag in the continuation. If the continuation type is being - checked, then we only use a template when it doesn't have an output - restriction. - - In Find-Template-For-Policy, use safe templates as a last resort, even when - policy is :Small or :Fast. A safe template is surely faster and smaller than - a full call. - - In Ltn-Analyze, clear the Type-Check flags on all continuations when our - policy is unsafe. - -/usr0/ram/compiler/debug.lisp, 18-Feb-88 17:17:19, Edit by Ram. - And fixed Check-VOP-Refs to ensure that the temporary write comes before - (which is after in the reversed VOP-Refs) the read, rather than vice-versa... - -/usr0/ram/compiler/vmdef.lisp, 18-Feb-88 17:10:35, Edit by Ram. - Fixed Compute-Reference-Order to begin temporary lifetimes with the write - rather than the read. - -/usr0/ram/compiler/gtn.lisp, 18-Feb-88 16:06:41, Edit by Ram. - Have to fetch the Equated-Returns inside the loop in Find-Equivalence - classes, since Equate-Return-Info will change the returns for the current - environment. This used to work, since Equate-Return-Info used to be - destructive. - -/usr0/ram/compiler/ir1opt.lisp, 14-Feb-88 14:30:47, Edit by Ram. - Oops. Fixed the test in Propagate-From-Calls for being a call to the - function concerned. Now that this optimization can actually happen, who - knows? - -/usr0/ram/compiler/ltn.lisp, 11-Feb-88 18:01:38, Edit by Ram. - Made Annotate-1-Value-Continuation delay global function references to - functions that aren't notinline. Made LTN-Default-Call, - LTN-Analyze-Full-Call and LTN-Analyze-MV-Call annotate their function - continuation. - -/usr0/ram/compiler/flowsimp.lisp, 11-Feb-88 16:44:48, Edit by Ram. - Now that returns aren't being picked off in flow-graph-simplify, we have to - fix join-block-if-possible not to attempt to join the XEP return to the - component tail... - -/usr0/ram/compiler/ir1util.lisp, 11-Feb-88 16:14:52, Edit by Ram. - Made Delete-Ref call Maybe-Let-Convert when deleting the second-to-last - reference to a lambda. - -/usr0/ram/compiler/flowsimp.lisp, 10-Feb-88 16:46:56, Edit by Ram. -/usr0/ram/compiler/locall.lisp, 11-Feb-88 13:24:04, Edit by Ram. - Moved let-conversion to locall from flowsimp, and made it be triggered by - Maybe-Let-Convert. This is called on each new lambda after local call - analysis, and can also be called whenever there is some reason to believe - that a lambda might be eligible for let-conversion. We clear any :Optional - function kinds since the entry functions can be treated as normal functions - after local call analysis. - - This change was made to solve problems with lambdas not being let-converted - when the return node was deleted due to being unreachable. This is important - now that being a let has major environment significance. Originally let - conversion was regarded as a way to delete a return, and thus made some kind - of sense to have it be a flow graph optimization. Now that a let can have - only one reference, we can trigger let conversion by noticing when references - are deleted. - -/usr0/ram/compiler/node.lisp, 11-Feb-88 13:12:38, Edit by Ram. -/usr0/ram/compiler/ir1tran.lisp, 11-Feb-88 13:12:47, Edit by Ram. - Added :Optional Functional-Kind that is initially specified for the - entry-point lambdas in optional-dispatches so that we know there may be - references to the function through the optional dispatch. - -/usr0/ram/compiler/ir1util.lisp, 11-Feb-88 12:23:11, Edit by Ram. - Changed assertion in Control-Equate to allow an existing value-equate to the - same continuation. - -/usr0/ram/compiler/ir1tran.lisp, 25-Jan-88 19:27:57, Edit by Ram. - Changed the default policy to be all 1's, and modified calls to Policy in all - files so that they do "the right thing" when compared qualities are equal. - The default action should be chosen so as to minimize mystification and - annoyance to non-wizards. In general, the default should be chosen according - to the ordering: safety > brevity > speed > space > cspeed. Checks for 0 and - 3 meaning "totally unimportant" and "ultimately important" are also o.k. - -/usr0/ram/compiler/gtn.lisp, 24-Jan-88 11:20:37, Edit by Ram. - Changed Equate-Return-Info so that it effectively ignores the Count and Types - in :Unused continuations, yet still combines the Entry-P and Tail-P values. - -/usr0/ram/compiler/locall.lisp, 23-Jan-88 21:41:28, Edit by Ram. - Make Convert-XEP-Call set the Return-Point too... - -/usr0/ram/compiler/ir1util.lisp, 22-Jan-88 16:17:38, Edit by Ram. - Made Immediately-Used-P special-case local calls by using - Basic-Combination-Return-Point. - -/usr0/ram/compiler/locall.lisp, 22-Jan-88 16:13:32, Edit by Ram. -/usr0/ram/compiler/node.lisp, 22-Jan-88 16:12:03, Edit by Ram. - Added a Basic-Combination-Return-Point slot so that local calls can rebember - where they are supposed to return to. - -/usr0/ram/compiler/gtn.lisp, 22-Jan-88 10:03:37, Edit by Ram. - Fixed Assign-Lambda-Vars to set the TN-Leaf. - -/usr0/ram/compiler/flowsimp.lisp, 22-Jan-88 10:22:53, Edit by Ram. - Made Convert-To-Let do an Intersect-Continuation-Asserted-Type on the actual - continuation with the dummy's assertion when the let call is the only use of - the actual continuation. - -/usr0/ram/compiler/ir1tran.lisp, 22-Jan-88 09:42:49, Edit by Ram. - Tack NIL on the end of the forms that we convert so that no top-level form is - in a for-value context. - -/usr0/ram/compiler/ir1opt.lisp, 21-Jan-88 17:50:52, Edit by Ram. - Made Check-Types intersect the new type with the Node-Derived-Type for all - the continuation uses so that IR1Opt doesn't go and change the type right - back. - -/usr0/ram/compiler/main.lisp, 21-Jan-88 17:31:57, Edit by Ram. -/usr0/ram/compiler/ir1opt.lisp, 21-Jan-88 17:30:31, Edit by Ram. - Type checking was being done wrong. We need to check types even if IR1Opt - doesn't do anything, and we need to give IR1Opt a second chance if type check - does anything. Made Check-Types return whether it did anything. - -/usr0/ram/compiler/ir1tran.lisp, 21-Jan-88 17:14:13, Edit by Ram. - Fixed IR1 translator for THE to use Find-Uses to find whether the - continuation is used, rather than incorrectly doing it itself (using an old - interpretation of Continuation-Use). - -/usr0/ram/compiler/ir1tran.lisp, 16-Nov-87 15:58:39, Edit by Ram. - Made %proclaim (and hence proclaim) return (undefined-value) rather than - arbitrary randomness. - -/usr1/ram/compiler/flowsimp.lisp, 23-Aug-87 22:00:39, Edit by Ram - Changed Flow-Graph-Simplify not to merge blocks unless the cleanups for the - two blocks are identical. The is a sub-optimal (but conservative) way to - ensure that cleanups are only done on block boundaries. - -/usr1/ram/compiler/ir1opt.lisp, 23-Aug-87 21:26:53, Edit by Ram - Just look for the :Let functional kind in Top-Down-Optimize, instead of - figuring out from first principles. - -/usr1/ram/compiler/ir1util.lisp, 20-Aug-87 22:12:45, Edit by Ram - The only worthwhile use for the functional nesting was in Delete-Ref, where - it would walk all the inferiors, marking them as deleted as well. But I - think that just marking the outer function as deleted will eventually cause - all the inner functions to be deleted. As it stands, Delete-Ref is a lot - simpler. If there are problems with deleted-but-somehow-undeletable - references holding onto functions, we may want to look at all references in - Delete-Ref and see if some enclosing function is deleted. - -/usr1/ram/compiler/ir1tran.lisp, 22-Aug-87 15:38:50, Edit by Ram - Changed stuff to use the new Functional and Cleanup structures. Mostly - involves flushing stuff. - -/usr1/ram/compiler/locall.lisp, 21-Aug-87 14:24:32, Edit by Ram -/usr1/ram/compiler/ir1opt.lisp, 20-Aug-87 22:05:33, Edit by Ram - Changed Local-Call-Analyze to just take a component and analyze the - New-Functions. This simplifies (and optimizes) the late uses in IR1 - optimize. Also changed convert-call-if-possible to know to try to convert - the call to the real function rather than the XEP. - -/usr1/ram/compiler/node.lisp, 23-Aug-87 20:12:58, Edit by Ram - Flushed bogus hierarchical information in the Functional, Environment and - Cleanup structures. Now that I've taken a stab at implementing the IR2 - conversion passes, it is obvious that this information is useless and - difficult to maintain. - - We do need a way to iterate over all the functions in a component, but doing - a tree walk is bogus. Instead, we have a list of all the lambdas in each - component. When functions are initially converted, they are placed on the - component New-Functions list. Local call analysis moves analyzed lambdas - into the Lambdas list. We don't bother to remove lambdas from this list when - they are deleted. - - A change needed in the cleanup stuff to make it work is to have continuations - with no immediately enclosing cleanup point have their lambda as the cleanup. - Then when we convert the lambda to a let, we set the Cleanup slot in the - lambda to any cleanup enclosing the call so that we realize stuff needs to be - cleaned up. - -/usr1/ram/compiler/flowsimp.lisp, 23-Aug-87 20:49:36, Edit by Ram - Changed Find-Initial-DFO to build the Lambdas lists for the components. At - the same time, we also use XEP references to (correctly) merge components - with potential environment inter-dependencies, rather than attempting to use - the lambda nesting. Changed Join-Components to combine the Lambdas and - New-Functions lists. - - Changed Delete-Return to convert to a let only when there is a single call, - and also to mark the lambda with the :Let functional kind. This makes - let-calls exactly correspond to the functions that IR1 optimize can - substitute for. This also solves problems with cleanups, since it is - trivially true that all calls are in the same dynamic environment. - -/usr1/ram/compiler/ir1tran.lisp, 18-Aug-87 15:25:18, Edit by Ram - In IR1-Convert, if the function is not a symbol, but doesn't look even - vaguely like a lambda, then complain about an illegal function call, - rather than having IR1-Convert-Lambda say it is an illegal lambda. - -/usr1/ram/compiler/numacs.lisp, 16-Aug-87 13:48:11, Edit by Ram - Added a Defvar that doesn't use OR (and create a LET and freak out IR1 - conversion.) - -/usr1/ram/compiler/ir1util.lisp, 16-Aug-87 18:14:10, Edit by Ram -/usr1/ram/compiler/debug.lisp, 16-Aug-87 15:19:47, Edit by Ram -/usr1/ram/compiler/flowsimp.lisp, 16-Aug-87 15:19:13, Edit by Ram -/usr1/ram/compiler/ir1opt.lisp, 16-Aug-87 15:18:47, Edit by Ram -/usr1/ram/compiler/node.lisp, 16-Aug-87 19:58:30, Edit by Ram -/usr1/ram/compiler/ir1tran.lisp, 16-Aug-87 20:29:36, Edit by Ram -/usr1/ram/compiler/locall.lisp, 16-Aug-87 20:22:28, Edit by Ram - Changed stuff for new explicit external entry point concept. The external - entry point is now a real function containing local calls to the entry - points. This represents reality better, making lots of things previously - special-cased automatically happen in our favor. We really needed this for - environment analysis and IR2 conversion to work. - - Functional-Entry-Kind is replaced by Functional-Kind and - Functional-Entry-Function. The Kind is kind of like the old Entry-Kind. The - Entry-Function is the XEP (or a back-pointer in an XEP). Uses of Entry-Kind - were replaced with Kind or Entry-Function or flushed, as appropriate. - - Note-Entry-Point has been flushed. %Defun doesn't need to do anything to - cause the function to be an entry point. The top-level lambda is no longer - a real entry-point: instead we just directly link it to the component head - and tail. - - The more-arg XEP creates a more-arg cleanup. The local-call case still needs - to be fixed. - -/usr1/ram/compiler/fndb.lisp, 16-Aug-87 20:37:28, Edit by Ram - Added some definitions for %mumble magic compiler functions. - -/usr1/ram/compiler/ir1tran.lisp, 16-Aug-87 20:29:36, Edit by Ram - Changed uses of the two-arg Arg for more-arg hackery into %More-Arg, since - this isn't the user-level functionality we will ultimately want for - more-args. - -/usr1/ram/compiler/main.lisp, 16-Aug-87 18:35:29, Edit by Ram - Changed Compile-Component not to do any IR1 passes on the top-level component - except for Type-Check. These optimizations are unlikely to have any useful - effect on top-level code, and they might want to inject illegal stuff into - the top-level component. - -/usr1/ram/compiler/macros.lisp, 16-Aug-87 18:26:19, Edit by Ram - Changed With-IR1-Environment to bind *Converting-Top-Level*. Currently you'd - better not use this on top-level code unless you are sure you won't emit - anything that can't go in top-level, since IR1-Convert-Lambda will bogue out - because there is no *Initial-Component* to switch to. - -/usr1/ram/compiler/macros.lisp, 13-Aug-87 20:16:47, Edit by Ram -/usr1/ram/compiler/node.lisp, 13-Aug-87 22:24:30, Edit by Ram -/usr1/ram/compiler/main.lisp, 13-Aug-87 22:35:11, Edit by Ram -/usr1/ram/compiler/globaldb.lisp, 13-Aug-87 20:21:12, Edit by Ram -/usr1/ram/compiler/locall.lisp, 13-Aug-87 22:57:54, Edit by Ram -/usr1/ram/compiler/flowsimp.lisp, 13-Aug-87 22:52:01, Edit by Ram -/usr1/ram/compiler/ir1opt.lisp, 13-Aug-87 22:59:11, Edit by Ram -/usr1/ram/compiler/ir1tran.lisp, 13-Aug-87 23:06:03, Edit by Ram - Changed stuff to support having separate top-level and initial components. - Whenver we see a lambda or anything hairy, we switch over to the initial - component. Hairyness of special-forms is determined by the :Top-Level-P - keyword to Def-IR1-Translator. - - We make appropriate special forms hairy to guarantee that the top-level - component doesn't contain any stuff that would make life hard for IR2 - conversion. In particular, it contains no variables, no functions other than - the top-level lambda and no non-local exit targets. - - Local call analysis refuses to convert calls appearing in the top-level - component. In other files, stuff related to Functional-Top-Level-P was - ripped out. - -/usr1/ram/compiler/ir1opt.lisp, 13-Aug-87 17:58:37, Edit by Ram - Changed propagate-from-calls to punt if any use is a mv-combination. Changed - Top-Down-Optimize not to Substitute-Let-Vars unless the only use is not a - MV-Combination. Un-commented-out the substituion of functionals for non-set - let vars. - -/usr1/ram/compiler/locall.lisp, 13-Aug-87 18:31:24, Edit by Ram - Frobbed Find-Top-Level-Code to recognize DEFUNs with no calls as - non-top-level. The entire concept is probably wrong, though. - -/usr1/ram/compiler/ir1tran.lisp, 13-Aug-87 19:07:22, Edit by Ram - Changed IR1-Convert-OK-Combination to look at the leaf-type of the leaf - rather than the derived type for the function continuation. This allows - known calls to be recognized again (I'm sure that worked at one point. - Perhaps before they were becoming known later on somehow?). This is all not - really right anyway, given the broken interpretation of function types - currently used in IR1. - -/usr/ram/compiler/ir1tran.slisp, 12-Jan-87 11:48:32, Edit by Ram - Fixed Find-Source-Paths to use a DO with ATOM test rather than a dolist, so - that it won't blow up on dotted lists. - -/usr/ram/compiler/ir1util.slisp, 12-Jan-87 10:28:07, Edit by Ram - Fixed Delete-Block to null out the DEST for the continuations belonging to - each node as we delete the node, so we don't try to deliver a result to a - node that doesn't exist anymore. diff --git a/src/compiler/early-c.lisp b/src/compiler/early-c.lisp index 62b7329..c707b51 100644 --- a/src/compiler/early-c.lisp +++ b/src/compiler/early-c.lisp @@ -78,7 +78,6 @@ (defvar *current-path*) (defvar *current-component*) (defvar *policy*) -(defvar *interface-policy*) (defvar *dynamic-counts-tn*) (defvar *elsewhere*) (defvar *event-info*) diff --git a/src/compiler/ir1final.lisp b/src/compiler/ir1final.lisp index 8f8cb16..c843505 100644 --- a/src/compiler/ir1final.lisp +++ b/src/compiler/ir1final.lisp @@ -58,8 +58,8 @@ (defun finalize-xep-definition (fun) (let* ((leaf (functional-entry-function fun)) (name (leaf-name leaf)) - (dtype (definition-type leaf))) - (setf (leaf-type leaf) dtype) + (defined-ftype (definition-type leaf))) + (setf (leaf-type leaf) defined-ftype) (when (or (and name (symbolp name)) (and (consp name) (eq (car name) 'setf))) (let* ((where (info :function :where-from name)) @@ -72,34 +72,28 @@ (ecase where (:assumed (let ((approx-type (info :function :assumed-type name))) - (when (and approx-type (function-type-p dtype)) - (valid-approximate-type approx-type dtype)) - (setf (info :function :type name) dtype) + (when (and approx-type (function-type-p defined-ftype)) + (valid-approximate-type approx-type defined-ftype)) + (setf (info :function :type name) defined-ftype) (setf (info :function :assumed-type name) nil)) (setf (info :function :where-from name) :defined)) (:declared - ;; Check that derived type matches declared type. - (let ((type (info :function :type name))) - (when (and type (function-type-p dtype)) - (let ((type-returns (function-type-returns type)) - (dtype-returns (function-type-returns dtype)) - (*error-function* #'compiler-warning)) - (unless (values-types-equal-or-intersect type-returns - dtype-returns) - (note-lossage "The result type from previous declaration:~% ~S~@ - conflicts with the result type:~% ~S" - (type-specifier type-returns) - (type-specifier dtype-returns)))))) - ;; (Regardless of what happens, we keep the declared type.) - ) + (let ((declared-ftype (info :function :type name))) + (unless (defined-ftype-matches-declared-ftype-p + defined-ftype declared-ftype) + (note-lossage "~@" + (type-specifier declared-ftype) + (type-specifier defined-ftype))))) (:defined (when global-p - (setf (info :function :type name) dtype))))))) + (setf (info :function :type name) defined-ftype))))))) (values)) -;;; Find all calls in Component to assumed functions and update the assumed -;;; type information. This is delayed until now so that we have the best -;;; possible information about the actual argument types. +;;; Find all calls in COMPONENT to assumed functions and update the +;;; assumed type information. This is delayed until now so that we +;;; have the best possible information about the actual argument +;;; types. (defun note-assumed-types (component name var) (when (and (eq (leaf-where-from var) :assumed) (not (and (defined-function-p var) @@ -115,8 +109,8 @@ (setq atype (note-function-use dest atype))))) (setf (info :function :assumed-type name) atype)))) -;;; Do miscellaneous things that we want to do once all optimization has -;;; been done: +;;; Do miscellaneous things that we want to do once all optimization +;;; has been done: ;;; -- Record the derived result type before the back-end trashes the ;;; flow graph. ;;; -- Note definition of any entry points. diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp index ae66986..27a7497 100644 --- a/src/compiler/ir1tran.lisp +++ b/src/compiler/ir1tran.lisp @@ -1018,12 +1018,6 @@ (make-lexenv :default res :policy (process-optimize-decl spec (lexenv-policy res)))) - (optimize-interface - (make-lexenv - :default res - :interface-policy (process-optimize-decl - spec - (lexenv-interface-policy res)))) (type (process-type-decl (cdr spec) res vars)) (values @@ -1274,26 +1268,18 @@ ;;; sequentially bind each AUX-VAR to the corresponding AUX-VAL before ;;; converting the body. If there are no bindings, just convert the ;;; body, otherwise do one binding and recurse on the rest. -;;; -;;; If INTERFACE is true, then we convert bindings with the interface -;;; policy. For real &AUX bindings, and for implicit aux bindings -;;; introduced by keyword bindings, this is always true. It is only -;;; false when LET* directly calls this function. -(defun ir1-convert-aux-bindings (start cont body aux-vars aux-vals interface) +(defun ir1-convert-aux-bindings (start cont body aux-vars aux-vals) (declare (type continuation start cont) (list body aux-vars aux-vals)) (if (null aux-vars) (ir1-convert-progn-body start cont body) (let ((fun-cont (make-continuation)) - (fun (ir1-convert-lambda-body body (list (first aux-vars)) - (rest aux-vars) (rest aux-vals) - interface))) + (fun (ir1-convert-lambda-body body + (list (first aux-vars)) + :aux-vars (rest aux-vars) + :aux-vals (rest aux-vals)))) (reference-leaf start fun-cont fun) - (let ((*lexenv* (if interface - (make-lexenv - :policy (make-interface-policy *lexenv*)) - *lexenv*))) - (ir1-convert-combination-args fun-cont cont - (list (first aux-vals)))))) + (ir1-convert-combination-args fun-cont cont + (list (first aux-vals))))) (values)) ;;; This is similar to IR1-CONVERT-PROGN-BODY except that code to bind @@ -1307,13 +1293,12 @@ ;;; will end up being the innermost one. We force CONT to start a ;;; block outside of this cleanup, causing cleanup code to be emitted ;;; when the scope is exited. -(defun ir1-convert-special-bindings (start cont body aux-vars aux-vals - interface svars) +(defun ir1-convert-special-bindings (start cont body aux-vars aux-vals svars) (declare (type continuation start cont) (list body aux-vars aux-vals svars)) (cond ((null svars) - (ir1-convert-aux-bindings start cont body aux-vars aux-vals interface)) + (ir1-convert-aux-bindings start cont body aux-vars aux-vals)) (t (continuation-starts-block cont) (let ((cleanup (make-cleanup :kind :special-bind)) @@ -1326,7 +1311,7 @@ (let ((*lexenv* (make-lexenv :cleanup cleanup))) (ir1-convert next-cont nnext-cont '(%cleanup-point)) (ir1-convert-special-bindings nnext-cont cont body aux-vars aux-vals - interface (rest svars)))))) + (rest svars)))))) (values)) ;;; Create a lambda node out of some code, returning the result. The @@ -1345,11 +1330,8 @@ ;;; ;;; AUX-VARS is a list of VAR structures for variables that are to be ;;; sequentially bound. Each AUX-VAL is a form that is to be evaluated -;;; to get the initial value for the corresponding AUX-VAR. Interface -;;; is a flag as T when there are real aux values (see LET* and -;;; IR1-CONVERT-AUX-BINDINGS.) -(defun ir1-convert-lambda-body (body vars &optional aux-vars aux-vals - interface result) +;;; to get the initial value for the corresponding AUX-VAR. +(defun ir1-convert-lambda-body (body vars &key aux-vars aux-vals result) (declare (list body vars aux-vars aux-vals) (type (or continuation null) result)) (let* ((bind (make-bind)) @@ -1381,7 +1363,7 @@ (prev-link bind cont1) (use-continuation bind cont2) (ir1-convert-special-bindings cont2 result body aux-vars aux-vals - interface (svars))) + (svars))) (let ((block (continuation-block result))) (when block @@ -1409,8 +1391,6 @@ ;;; then we mark the corresponding var as EVER-USED to inhibit ;;; "defined but not read" warnings for arguments that are only used ;;; by default forms. -;;; -;;; We bind *LEXENV* to change the policy to the interface policy. (defun convert-optional-entry (fun vars vals defaults) (declare (type clambda fun) (list vars vals defaults)) (let* ((fvars (reverse vars)) @@ -1423,14 +1403,14 @@ :where-from (leaf-where-from var) :specvar (lambda-var-specvar var))) fvars)) - (*lexenv* (make-lexenv :policy (make-interface-policy *lexenv*))) (fun - (ir1-convert-lambda-body - `((%funcall ,fun ,@(reverse vals) ,@defaults)) - arg-vars))) - (mapc #'(lambda (var arg-var) - (when (cdr (leaf-refs arg-var)) - (setf (leaf-ever-used var) t))) + (ir1-convert-lambda-body `((%funcall ,fun + ,@(reverse vals) + ,@defaults)) + arg-vars))) + (mapc (lambda (var arg-var) + (when (cdr (leaf-refs arg-var)) + (setf (leaf-ever-used var) t))) fvars arg-vars) fun)) @@ -1497,10 +1477,6 @@ ;;; ;;; We deal with :ALLOW-OTHER-KEYS by delaying unknown keyword errors ;;; until we have scanned all the keywords. -;;; -;;; When converting the function, we bind *LEXENV* to change the -;;; compilation policy over to the interface policy, so that keyword -;;; args will be checked even when type checking isn't on in general. (defun convert-more-entry (res entry-vars entry-vals rest morep keys) (declare (type optional-dispatch res) (list entry-vars entry-vals keys)) (collect ((arg-vars) @@ -1517,8 +1493,7 @@ (context-temp (make-lambda-var :name n-context)) (n-count (gensym "N-COUNT-")) (count-temp (make-lambda-var :name n-count - :type (specifier-type 'index))) - (*lexenv* (make-lexenv :policy (make-interface-policy *lexenv*)))) + :type (specifier-type 'index)))) (arg-vars context-temp count-temp) @@ -1670,11 +1645,11 @@ (main-vals (arg-info-default info)) (bind-vals n-val))))) - (let* ((main-entry (ir1-convert-lambda-body body (main-vars) - (append (bind-vars) aux-vars) - (append (bind-vals) aux-vals) - t - cont)) + (let* ((main-entry (ir1-convert-lambda-body + body (main-vars) + :aux-vars (append (bind-vars) aux-vars) + :aux-vals (append (bind-vals) aux-vals) + :result cont)) (last-entry (convert-optional-entry main-entry default-vars (main-vals) ()))) (setf (optional-dispatch-main-entry res) main-entry) @@ -1734,7 +1709,9 @@ nil nil nil vars supplied-p-p body aux-vars aux-vals cont) (let ((fun (ir1-convert-lambda-body body (reverse default-vars) - aux-vars aux-vals t cont))) + :aux-vars aux-vars + :aux-vals aux-vals + :result cont))) (setf (optional-dispatch-main-entry res) fun) (push (if supplied-p-p (convert-optional-entry fun entry-vars entry-vals ()) @@ -1781,7 +1758,7 @@ ;;; This function deals with the case where we have to make an ;;; Optional-Dispatch to represent a lambda. We cons up the result and -;;; call IR1-Convert-Hairy-Args to do the work. When it is done, we +;;; call IR1-CONVERT-HAIRY-ARGS to do the work. When it is done, we ;;; figure out the min-args and max-args. (defun ir1-convert-hairy-lambda (body vars keyp allowp aux-vars aux-vals cont) (declare (list body vars aux-vars aux-vals) (type continuation cont)) @@ -1834,8 +1811,10 @@ (ir1-convert-hairy-lambda forms vars keyp allow-other-keys aux-vars aux-vals cont) - (ir1-convert-lambda-body forms vars aux-vars aux-vals - t cont)))) + (ir1-convert-lambda-body forms vars + :aux-vars aux-vars + :aux-vals aux-vals + :result cont)))) (setf (functional-inline-expansion res) form) (setf (functional-arg-documentation res) (cadr form)) (setf (leaf-name res) name) @@ -2453,7 +2432,7 @@ (multiple-value-bind (forms decls) (sb!sys:parse-body body nil) (multiple-value-bind (vars values) (extract-let-variables bindings 'let*) (let ((*lexenv* (process-decls decls vars nil cont))) - (ir1-convert-aux-bindings start cont forms vars values nil))))) + (ir1-convert-aux-bindings start cont forms vars values))))) ;;; This is a lot like a LET* with no bindings. Unlike LET*, LOCALLY ;;; has to preserves top-level-formness, but we don't need to worry @@ -2469,7 +2448,7 @@ the Forms are also processed as top-level forms." (multiple-value-bind (forms decls) (sb!sys:parse-body body nil) (let ((*lexenv* (process-decls decls nil nil cont))) - (ir1-convert-aux-bindings start cont forms nil nil nil)))) + (ir1-convert-aux-bindings start cont forms nil nil)))) ;;;; FLET and LABELS @@ -3019,8 +2998,7 @@ `(,(car x) . (macro . ,(coerce (cdr x) 'function)))) macros) - :policy (lexenv-policy *lexenv*) - :interface-policy (lexenv-interface-policy *lexenv*)))) + :policy (lexenv-policy *lexenv*)))) (ir1-convert-lambda `(lambda ,@body) name)))) ;;; Return a lambda that has been "closed" with respect to ENV, diff --git a/src/compiler/ir1util.lisp b/src/compiler/ir1util.lisp index 6d3a1a0..7bb508d 100644 --- a/src/compiler/ir1util.lisp +++ b/src/compiler/ir1util.lisp @@ -323,8 +323,7 @@ options (lambda (lexenv-lambda default)) (cleanup (lexenv-cleanup default)) - (policy (lexenv-policy default)) - (interface-policy (lexenv-interface-policy default))) + (policy (lexenv-policy default))) (macrolet ((frob (var slot) `(let ((old (,slot default))) (if ,var @@ -336,21 +335,8 @@ (frob blocks lexenv-blocks) (frob tags lexenv-tags) (frob type-restrictions lexenv-type-restrictions) - lambda cleanup policy interface-policy + lambda cleanup policy (frob options lexenv-options)))) - -;;; Return a POLICY that defaults any unsupplied optimize qualities in -;;; the INTERFACE-POLICY with the corresponding ones from the POLICY. -(defun make-interface-policy (lexenv) - (declare (type lexenv lexenv)) - (let ((ipolicy (lexenv-interface-policy lexenv)) - (policy (lexenv-policy lexenv))) - (let ((result policy)) - (dolist (quality '(speed safety space)) - (let ((iquality-entry (assoc quality ipolicy))) - (when iquality-entry - (push iquality-entry result)))) - result))) ;;;; flow/DFO/component hackery diff --git a/src/compiler/lexenv.lisp b/src/compiler/lexenv.lisp index 7d95e9f..299eda9 100644 --- a/src/compiler/lexenv.lisp +++ b/src/compiler/lexenv.lisp @@ -22,8 +22,7 @@ (:constructor make-null-lexenv ()) (:constructor internal-make-lexenv (functions variables blocks tags type-restrictions - lambda cleanup policy - interface-policy options))) + lambda cleanup policy options))) ;; Alist (NAME . WHAT), where WHAT is either a Functional (a local function), ;; a DEFINED-FUNCTION, representing an INLINE/NOTINLINE declaration, or ;; a list (MACRO . ) (a local macro, with the specifier @@ -63,10 +62,6 @@ (cleanup nil) ;; the current OPTIMIZE policy (policy *policy* :type policy) - ;; the policy that takes effect in XEPs and related syntax parsing - ;; functions. Slots in this policy may be null to indicate that the - ;; normal value in effect. - (interface-policy *interface-policy* :type policy) ;; an alist of miscellaneous options that are associated with the ;; lexical environment (options nil :type list)) diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp index 155afd1..8c18432 100644 --- a/src/compiler/locall.lisp +++ b/src/compiler/locall.lisp @@ -168,8 +168,7 @@ ;;; then associate this lambda with FUN as its XEP. After the ;;; conversion, we iterate over the function's associated lambdas, ;;; redoing local call analysis so that the XEP calls will get -;;; converted. We also bind *LEXENV* to change the compilation policy -;;; over to the interface policy. +;;; converted. ;;; ;;; We set REANALYZE and REOPTIMIZE in the component, just in case we ;;; discover an XEP after the initial local call analyze pass. @@ -177,14 +176,13 @@ (declare (type functional fun)) (aver (not (functional-entry-function fun))) (with-ir1-environment (lambda-bind (main-entry fun)) - (let* ((*lexenv* (make-lexenv :policy (make-interface-policy *lexenv*))) - (res (ir1-convert-lambda (make-xep-lambda fun)))) - (setf (functional-kind res) :external) - (setf (leaf-ever-used res) t) - (setf (functional-entry-function res) fun) - (setf (functional-entry-function fun) res) - (setf (component-reanalyze *current-component*) t) - (setf (component-reoptimize *current-component*) t) + (let ((res (ir1-convert-lambda (make-xep-lambda fun)))) + (setf (functional-kind res) :external + (leaf-ever-used res) t + (functional-entry-function res) fun + (functional-entry-function fun) res + (component-reanalyze *current-component*) t + (component-reoptimize *current-component*) t) (etypecase fun (clambda (local-call-analyze-1 fun)) (optional-dispatch diff --git a/src/compiler/main.lisp b/src/compiler/main.lisp index 0f0f7de..4bdeb1e 100644 --- a/src/compiler/main.lisp +++ b/src/compiler/main.lisp @@ -917,8 +917,7 @@ ;;; *TOP-LEVEL-LAMBDAS* instead. (defun convert-and-maybe-compile (form path) (declare (list path)) - (let* ((*lexenv* (make-lexenv :policy *policy* - :interface-policy *interface-policy*)) + (let* ((*lexenv* (make-lexenv :policy *policy*)) (tll (ir1-top-level form path nil))) (cond ((eq *block-compile* t) (push tll *top-level-lambdas*)) (t (compile-top-level (list tll) nil))))) @@ -945,7 +944,7 @@ (multiple-value-bind (forms decls) (sb!sys:parse-body (cdr form) nil) (let* ((*lexenv* (process-decls decls nil nil (make-continuation))) - ;; Binding *xxx-POLICY* is pretty much of a hack, since it + ;; Binding *POLICY* is pretty much of a hack, since it ;; causes LOCALLY to "capture" enclosed proclamations. It ;; is necessary because CONVERT-AND-MAYBE-COMPILE uses the ;; value of *POLICY* as the policy. The need for this hack @@ -954,8 +953,7 @@ ;; FIXME: Ideally, something should be done so that DECLAIM ;; inside LOCALLY works OK. Failing that, at least we could ;; issue a warning instead of silently screwing up. - (*policy* (lexenv-policy *lexenv*)) - (*interface-policy* (lexenv-interface-policy *lexenv*))) + (*policy* (lexenv-policy *lexenv*))) (process-top-level-progn forms path)))) ;;; Force any pending top-level forms to be compiled and dumped so @@ -1381,7 +1379,6 @@ (*block-compile* *block-compile-argument*) (*package* (sane-package)) (*policy* *policy*) - (*interface-policy* *interface-policy*) (*lexenv* (make-null-lexenv)) (*converting-for-interpreter* nil) (*source-info* info) diff --git a/src/compiler/policy.lisp b/src/compiler/policy.lisp index 9cd204a..40998b1 100644 --- a/src/compiler/policy.lisp +++ b/src/compiler/policy.lisp @@ -22,41 +22,26 @@ ;;; alists instead. (def!type policy () 'list) -;;; names of recognized optimization qualities which don't have -;;; special defaulting behavior -(defvar *policy-basic-qualities*) ; (initialized at cold init) +;;; names of recognized optimization policy qualities +(defvar *policy-qualities*) ; (initialized at cold init) -;;; FIXME: I'd like to get rid of DECLAIM OPTIMIZE-INTERFACE in favor -;;; of e.g. (DECLAIM (OPTIMIZE (INTERFACE-SPEED 2) (INTERFACE-SAFETY 3))). -#| -;;; a list of conses (DEFAULTING-QUALITY . DEFAULT-QUALITY) of qualities -;;; which default to other qualities when undefined, e.g. interface -;;; speed defaulting to basic speed -(defvar *policy-defaulting-qualities*) -|# - -(defun optimization-quality-p (name) - (or (member name *policy-basic-qualities*) - ;; FIXME: Uncomment this when OPTIMIZE-INTERFACE goes away. - #|(member name *policy-defaulting-qualities* :key #'car)|#)) +;;; Is X the name of an optimization quality? +(defun policy-quality-name-p (x) + (memq x *policy-qualities*)) ;;; *POLICY* holds the current global compiler policy information, as ;;; an alist mapping from optimization quality name to quality value. ;;; Inside the scope of declarations, new entries are added at the ;;; head of the alist. -;;; -;;; *INTERFACE-POLICY* holds global interface policy, represented the -;;; same way as in *DEFAULT-POLICY*. -(declaim (type policy *policy* *interface-policy*)) +(declaim (type policy *policy*)) (defvar *policy*) ; initialized in cold init -(defvar *interface-policy*) ; initialized in cold init ;;; This is to be called early in cold init to set things up, and may ;;; also be called again later in cold init in order to reset default ;;; optimization policy back to default values after toplevel PROCLAIM ;;; OPTIMIZE forms have messed with it. (defun !policy-cold-init-or-resanify () - (setf *policy-basic-qualities* + (setf *policy-qualities* '(;; ANSI standard qualities compilation-speed debug @@ -72,28 +57,17 @@ ;; behavior, and should probably become the exact behavior. ;; Perhaps INHIBIT-NOTES? inhibit-warnings)) - #| - (setf *policy-defaulting-qualities* - '((interface-speed . speed) - (interface-safety . safety))) - |# (setf *policy* (mapcar (lambda (name) ;; CMU CL didn't use 1 as the default for everything, ;; but since ANSI says 1 is the ordinary value, we do. (cons name 1)) - *policy-basic-qualities*)) - (setf *interface-policy* - *policy*)) + *policy-qualities*))) ;;; On the cross-compilation host, we initialize immediately (not ;;; waiting for "cold init", since cold init doesn't exist on ;;; cross-compilation host). #+sb-xc-host (!policy-cold-init-or-resanify) -;;; Is X the name of an optimization quality? -(defun policy-quality-name-p (x) - (memq x *policy-basic-qualities*)) - ;;; Look up a named optimization quality in POLICY. This is only ;;; called by compiler code for known-valid QUALITY-NAMEs, e.g. SPEED; ;;; it's an error if it's called for a quality which isn't defined. diff --git a/src/compiler/proclaim.lisp b/src/compiler/proclaim.lisp index 39e494c..3c94f2f 100644 --- a/src/compiler/proclaim.lisp +++ b/src/compiler/proclaim.lisp @@ -219,9 +219,6 @@ (setf (class-state subclass) :sealed)))))))) (optimize (setq *policy* (process-optimize-decl form *policy*))) - (optimize-interface - (setq *interface-policy* - (process-optimize-decl form *interface-policy*))) ((inline notinline maybe-inline) (dolist (name args) (proclaim-as-function-name name) diff --git a/tests/compiler-1.impure-cload.lisp b/tests/compiler-1.impure-cload.lisp new file mode 100644 index 0000000..5a9c05b --- /dev/null +++ b/tests/compiler-1.impure-cload.lisp @@ -0,0 +1,70 @@ +;;;; miscellaneous compiler tests with side-effects (e.g. DEFUN +;;;; changing FDEFINITIONs and globaldb stuff) + +;;;; This software is part of the SBCL system. See the README file for +;;;; more information. +;;;; +;;;; While most of SBCL is derived from the CMU CL system, the test +;;;; files (like this one) were written from scratch after the fork +;;;; from CMU CL. +;;;; +;;;; This software is in the public domain and is provided with +;;;; absolutely no warranty. See the COPYING and CREDITS files for +;;;; more information. + +(cl:in-package :cl-user) + +(declaim (optimize (debug 3) (speed 2) (space 1))) + +;;; Until version 0.6.9 or so, SBCL's version of Python couldn't do +;;; this correctly, due to the bug patched by Rob MacLachlan on the +;;; cmucl-imp list 2000-06-21, and applied to SBCL by Martin Atzmueller. +;;; (The effectiveness of the test also depends on the implicit +;;; function typing of Python (where DEFUN is like DECLAIM FTYPE), +;;; which violates the ANSI spec, and should be fixed. Once that +;;; unrelated bug is fixed, this code will no longer test the type +;;; inference behavior it's intended to test.) +(defun emptyvalues (&rest rest) (declare (ignore rest)) (values)) +(defstruct foo x y) +(defun bar () + (let ((res (emptyvalues))) + (unless (typep res 'foo) + 'expected-value))) +(assert (eq (bar) 'expected-value)) + +(declaim (ftype (function (real) (values integer single-float)) valuesify)) +(defun valuesify (x) + (values (round x) + (coerce x 'single-float))) +(defun exercise-valuesify (x) + (multiple-value-bind (i f) (valuesify x) + (declare (type integer i)) + (declare (type single-float f)) + (+ i f))) +(assert (= (exercise-valuesify 1.25) 2.25)) + +;;; Don Geddis reported this test case 25 December 1999 on a CMU CL +;;; mailing list: dumping circular lists caused an infinite loop. +;;; Douglas Crosher reported a patch 27 Dec 1999. The patch was tested +;;; on SBCL by Martin Atzmueller 2 Nov 2000, and merged in +;;; sbcl-0.6.8.11. +(defun q-dg1999-1 () (dolist (x '#1=("A" "B" . #1#)) x)) +(defun q-dg1999-2 () (dolist (x '#1=("C" "D" . #1#)) x)) +(defun q-dg1999-3 () (dolist (x '#1=("E" "F" . #1#)) x)) +(defun q-dg1999-4 () (dolist (x '#1=("C" "D" . #1#)) x)) +(defun useful-dg1999 (keys) + (declare (type list keys)) + (loop + for c in '#1=("Red" "Blue" . #1#) + for key in keys )) + +;;; An early version (sbcl-0.6.11.33) of code to check FTYPEs from DEFUN +;;; against DECLAIMed FTYPEs blew up when an FTYPE was DECLAIMed +;;; to be pure FUNCTION, because the internal representation of +;;; FUNCTION itself (as opposed to subtypes of FUNCTION, such as +;;; (FUNCTION () T)) is a BUILT-IN-CLASS object, not a FUNCTION-TYPE +;;; object. +(declaim (ftype function i-am-just-a-function)) +(defun i-am-just-a-function (x y) (+ x y 1)) + +(sb-ext:quit :unix-status 104) ; success diff --git a/tests/compiler-1.impure.lisp b/tests/compiler-1.impure.lisp deleted file mode 100644 index 7ce2b21..0000000 --- a/tests/compiler-1.impure.lisp +++ /dev/null @@ -1,63 +0,0 @@ -;;;; miscellaneous compiler tests with side-effects (e.g. DEFUN -;;;; changing FDEFINITIONs and globaldb stuff) - -;;;; This software is part of the SBCL system. See the README file for -;;;; more information. -;;;; -;;;; While most of SBCL is derived from the CMU CL system, the test -;;;; files (like this one) were written from scratch after the fork -;;;; from CMU CL. -;;;; -;;;; This software is in the public domain and is provided with -;;;; absolutely no warranty. See the COPYING and CREDITS files for -;;;; more information. - -(cl:in-package :cl-user) - -(declaim (optimize (debug 3) (speed 2) (space 1))) - -;;; Until version 0.6.9 or so, SBCL's version of Python couldn't this -;;; correctly, due to the bug patched by Rob MacLachlan on the -;;; cmucl-imp list 2000-06-21, and apply to SBCL by Martin Atzmueller. -;;; (The effectiveness of the test also depends on the implicit -;;; function typing of Python (where DEFUN is like DECLAIM FTYPE), -;;; which violates the ANSI spec, and should be fixed. Once that -;;; unrelated bug is fixed, this code will no longer test the type -;;; inference behavior it's intended to test.) -(defun emptyvalues (&rest rest) (declare (ignore rest)) (values)) -(defstruct foo x y) -(defun bar () - (let ((res (emptyvalues))) - (unless (typep res 'foo) - 'expected-value))) -(assert (eq (bar) 'expected-value)) - -(declaim (ftype (function (real) (values integer single-float)) valuesify)) -(defun valuesify (x) - (values (round x) - (coerce x 'single-float))) -(defun exercise-valuesify (x) - (multiple-value-bind (i f) (valuesify x) - (declare (type integer i)) - (declare (type single-float f)) - (+ i f))) -(assert (= (exercise-valuesify 1.25) 2.25)) - - -;;; Don Geddis reported this test case 25 December 1999 on a CMU CL -;;; mailing list: dumping circular lists caused an infinite loop. -;;; Douglas Crosher reported a patch 27 Dec 1999. The patch was tested -;;; on SBCL by Martin Atzmueller 2 Nov 2000, and merged in -;;; sbcl-0.6.8.11. -(defun q1 () (dolist (x '#1=("A" "B" . #1#)) x)) -(defun q2 () (dolist (x '#1=("C" "D" . #1#)) x)) -(defun q3 () (dolist (x '#1=("E" "F" . #1#)) x)) -(defun q4 () (dolist (x '#1=("C" "D" . #1#)) x)) -(defun never5 ()) -(defun useful (keys) - (declare (type list keys)) - (loop - for c in '#1=("Red" "Blue" . #1#) - for key in keys )) - -(sb-ext:quit :unix-status 104) ; success diff --git a/tests/run-tests.sh b/tests/run-tests.sh index a0881b7..7eeaf51 100644 --- a/tests/run-tests.sh +++ b/tests/run-tests.sh @@ -47,9 +47,11 @@ done echo " (sb-ext:quit :unix-status 104)) ; Return status=success." ) | $sbcl ; tenfour -# *.impure.lisp files are Lisp code with side effects (e.g. doing DEFSTRUCT -# or DEFTYPE or DEFVAR). Each one needs to be run as a separate -# invocation of Lisp. +# *.impure.lisp files are Lisp code with side effects (e.g. doing +# DEFSTRUCT or DEFTYPE or DEFVAR, or messing with the read table). +# Each one should be LOADed in a separate invocation of Lisp, so +# that we don't need to worry about them interfering with each +# other. echo //running '*.impure.lisp' tests for f in *.impure.lisp; do if [ -f $f ]; then @@ -58,8 +60,8 @@ for f in *.impure.lisp; do fi done -# *.test.sh files are scripts to test stuff, typically stuff which can't -# so easily be tested within Lisp itself. A file foo.test.sh +# *.test.sh files are scripts to test stuff, typically stuff which +# can't so easily be tested within Lisp itself. A file foo.test.sh # may be associated with other files foo*, e.g. foo.lisp, foo-1.lisp, # or foo.pl. echo //running '*.test.sh' tests @@ -84,6 +86,23 @@ done # can all be done in the same invocation of Lisp. echo //running '*.pure-cload.lisp' tests for f in *.pure-cload.lisp; do + # (Actually here we LOAD each one into a separate invocation + # of Lisp just because I haven't figured out a concise way + # to LOAD them all into the same Lisp.) + if [ -f $f ]; then + echo //running $f test + $sbcl <