From 3a1b73b5544d52afbb90a8d751a4892e2bc01834 Mon Sep 17 00:00:00 2001 From: ram <ram> Date: Mon, 17 Dec 1990 19:19:43 +0000 Subject: [PATCH] Initial revision --- compiler/c.log | 2048 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2048 insertions(+) create mode 100644 compiler/c.log diff --git a/compiler/c.log b/compiler/c.log new file mode 100644 index 000000000..a304fda24 --- /dev/null +++ b/compiler/c.log @@ -0,0 +1,2048 @@ +/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. -- GitLab