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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- a/src/code/late-type.lisp
+++ b/src/code/late-type.lisp
@@ -2132,6 +2132,41 @@
 \f
 ;;;; 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 #<BUILT-IN-CLASS FUNCTION>;
+          ;; 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
+          ;; #<BUILT-IN-CLASS FUNCTION>, 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 (file)
--- 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))
 \f
 ;;;; 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
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 <name>) 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 (file)
--- 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 (file)
--- 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 "~@<The previously declared FTYPE~2I ~_~S~I ~_~
+                              conflicts with the definition type ~2I~_~S~:>"
+                            (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 (file)
--- 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))))
 \f
 ;;;; 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 (file)
--- 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)))
 \f
 ;;;; flow/DFO/component hackery
 

diff --git a/src/compiler/lexenv.lisp b/src/compiler/lexenv.lisp
index 7d95e9f..299eda9 100644 (file)
--- 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 . <function>) (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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
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 (file)
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 (file)
--- 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 <<EOF ; tenfour
+               (compile-file "$f")
+               (progn (load *) (sb-ext:quit :unix-status 104))
+EOF
+    fi
+done
+
+# *.impure-cload.lisp files want to be compiled, then loaded. They
+# can have side effects, so each one should be done in a separate
+# invocation of Lisp so that they don't interfere.
+echo //running '*.impure-cload.lisp' tests
+for f in *.impure-cload.lisp; do
     if [ -f $f ]; then
        echo //running $f test
        $sbcl <<EOF ; tenfour

diff --git a/version.lisp-expr b/version.lisp-expr
index 298d226..9b8f48c 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -15,4 +15,4 @@
 ;;; versions, and a string like "0.6.5.12" is used for versions which
 ;;; aren't released but correspond only to CVS tags or snapshots.
 
-"0.6.11.33"
+"0.6.11.34"