Parent Directory | Revision Log
|Links to HEAD:||(view) (annotate)|
|Links to RELEASE_18a:||(view) (annotate)|
Fix headed boilerplate.
In propagate-local-call-args, don't do anything if there is an optional-dispatch specified. The last fixed entry point won't be referenced by the XEP, so we can't count on that providing a T type input.
In PROPAGATE-LOCAL-CALL-ARGS, be prepared the possibility that other refs to the function have no dest (and are going to be deleted.)
Don'e use info function info for dylan-function-var, instead get the info from the dylan-function-var-function-info slot.
In inline expansion, *byte-compiling* => (byte-compiling)
When byte-compiling, don't do any inline expansion, and only do ir1 transforms explicitly annotated as relevant.
Fixed call to CONTINUATION-DERIVED-TYPE to be CONTINUATION-TYPE so that we don't choke on values types in the functional position.
Fixed a bug in type inference which seems to have generally prevented anything from being inferred about function result types.
Fixed VALIDATE-CALL-TYPE to correctly handle calls where there is no function type guarding the call (for example, calls to lambdas). In this case, we still want to call RECOGNIZE-KNOWN-CALL, since it will figure out what leaf we are referencing, and might also do something else interesting: inline expansion, etc.
Fixed FIND-RESULT-TYPE to correctly handle assignment conversion.
Added a hack to IF-IF optimization to hopefully prevent some spurious unreachable code notes.
In IR1-OPTIMIZE-MV-COMBINATION, only call MAYBE-LET-CONVERT if we suceed in local call converting.
Pass inline-ok argument to IR1-CONVERT-LAMBDA-FOR-DEFUN.
Make propagate-from-sets an entry point.
Make PROPAGATE-TO-REFS an entry point.
Added block compilation declarations. Moved some stuff around to get better locality. Substantially revamped known call reoptimization so that more core is sharable with ir1-conversion. Formerly some stuff (like inline expansion) only happend at ir1-conversion time.
Don't try to reconvert calls to SETF functions with inline expansions in RECOGNIZE-KNOWN-CALL, because it won't work. For now, SETF functions are never inline expanded.
In RECOGNIZE-KNOWN-CALL, reconvert the form if it has an inline expansion or source transform, even if there is no function-info.
Do not SUBSTITUTE-SINGLE-USE-CONTINUATION when *BYTE-COMPILING*.
Moved tail-set merging out of IR1-OPTIMIZE-RETURN into LTN. Changed MAYBE-DELETE-EXIT to call MERGE-TAIL-SETS.
Set COMPONENT-REANALYZE in MAYBE-TERMINATE-BLOCK if we do terminate.
Don't substitute out LET variables when the initial value is a reference to a :NOTINLINE functional. The inlinep information must be retained, since we count on :NOTLININE calls never being local call converted.
Changed SUBSTITUTE-SINGLE-USE-CONTINUATION to not substitute if the continuation type assertions conflict.
Added optimization which deletes MV-BINDS when all variables have been deleted.
Flame out when speed>=brevity if the transform is important.
Don't look at the LAMBDA-TAIL-SET of deleted functions to find out the result type, because there isn't any.
In FIND-RESULT-TYPE, don't call MAYBE-CONVERT-TAIL-LOCAL-CALL on MV-combinations.
Do inconsistent derived type warning only when *CHECK-CONSISTENCY* is T. It seems that we do derive inconsistent types in dead code.
Only call maybe-emit-make-load-forms when we are (producing-fasl-file).
Make constant-fold-call call maybe-emit-make-load-forms on the resultant constant so that it gets dumped correctly.
Give a warning in DERIVE-NODE-TYPE when we prove inconsistent types. This is probably always a bug, but I don't want to use ASSERT until all the problems are fixed. Changed RETURN optimization to call MAYBE-CONVERT-TAIL-CALL. Updated for new tail-set semantics. Changed VALUES IR1 transform and SUBSTITUTE-SINGLE-USE-CONTINUATION to clear out the old NODE-DERIVED-TYPE so that the type doesn't spuriously go to NIL.
Fixed the VALUES IR1 transform (which discards unused values forms) to work when there are no values forms.
In MAYBE-TERMINATE-BLOCK, don't try it if either the block is DELETE-P or has already been terminated. In IR1-OPTIMIZE-MV-COMBINATION, don't do MV-LET optimizations on local MV-CALLs that aren't MV-LETs yet.
Made MAYBE-TERMINATE-BLOCK more cautious about using continuation type information, since both the derived and asserted types can independently spuriously be NIL during IR1 conversion. Also, deleted some unnecessary (and wrong) checking of CONTINUATION-REOPTIMIZE in IR1-OPTIMIZE-MV-COMBINATION.
When optimizing combinations, don't do the "efficiency hack" of checking whether any args have reoptimize set. Most calls to IR1-OPTIMIZE-COMBINATION that this inhibits are actually desirable. Deleted assertion in JOIN-SUCCESSOR-IF-POSSIBLE. This really can happen, and DELETE-CONTINUATION should do the right thing. Changed MAYBE-TERMINATE-BLOCK to take an explicit IR1-P flag. Fixed it not to consider deleted continuations to have type NIL. Use DELETE-CONTINUATION on the old continuation if it has no references and we aren't in IR1 conversion.
Added MAYBE-TERMINATE-BLOCK, which looks at a combination node to see if the result type is NIL. If so, it stops the block and links it to the component tail. Changed IR1-OPTIMIZE-BLOCK to call MAYBE-TERMINATE-BLOCK. Changed REOPTIMIZE-CONTINUATION to quietly do nothing when called on an unused continuation.
Changed IR1 transform stuff to use TRANSFORM structures instead of conses so that we can keep track of the transform note.
Inhibit continuation substitution when the let and ref have different policies, so that we don't blow away type checks.
Fixed let var substitution to not attempt to substitute references in different components. This can happen when we close over top-level variables.
Added an assertion in single-use continuation variable substitution.
New file header with RCS stuff.
Weakened assertion in IR1-CONVERT-MV-CALL.
Fixed IR1-OPTIMIZE-MV-CALL not to convert calls with more than one arg, and to convert the call immediately and check if it wins.
Added IR1-OPTIMIZE-MV-COMBINATION, which dispatches to various MV-combination optimizers depending on the kind of call. We convert newly discovered MV-BINDs local :MV-LET calls, and convert MV-CALLs to MV-BINDs if the argument count is known. Also added a VALUES-LIST IR1 optimizer that converts (values-list (list ...)) into (values ...). These changes make inline expansion of functions that have &rest args and do APPLY convert to FUNCALL.
Fixed VALUES IR1 optimizer to do the REOPTIMIZE-CONTINUATION before PROPAGATE-TO-ARGS so that we know that the first arg won't be deleted yet.
Mucho enhancements. If we discover a known call, and that call has a source transform or is a conditional, then we replace the function with a lambda that just calls the function again. This gives IR1 conversion another chance to permute the call. Changed IR1 transforms to test the function type with :STRICT-RESULT T since this is almost always what you want when writing a transform. In constant folding, if the call returns multiple values, change the function to a call to VALUES, rather than just blowing off constant folding. Added DELETE-LET which deletes the bind node for a let when all its variables are deleted. This cleans up the IR1 a great deal, enabling some optimizations. Added an IR1 optimizer for VALUES that converts MV-BIND/VALUES into a LET (as long as the VALUES is the only use of the values continuation.) This helps optimization of the results of IR1 transforms for multiple value functions. Added a IR1 transform for VALUES that discards all but the first value when the context is not a multiple-value receiver.
Fixed REOPTIMIZE-CONTINUATION to set BLOCK-TEST-MODIFIED if the continuation goes to an IF.
Made CONSTANT-REFERENCE-P be an interface in the comment.
Inhibit substitution of let variables whenever the arg variable type is not a subtype of the asserted type, not just when the arg *value* is nota subtype. This is necessary to prevent representation selection from being defeated.
Changed the failed optimization stuff to record one note for each failed transform, instead of just one per call. Also, when a transform quietly gives up, blow away any old note for that transform.
Fixed the proclaim of continuation-type to return a ctype, not a type.
Merged MIPS branch with the trunk.
In PROPAGATE-LET-ARGS, propagate the arg type to the refs before substituting rather than after, since after substituting, there are no refs to propagate to.
Lexenv changes, mostly usage of new block-flags block attributes instead of separate boolean flags.
Added CONSTANT-CONTINUATION-P assertion to CONTINUATION-VALUE so that we don't lose again from people doing it on non-constant continuations.
In SUBSTITUTE-SINGLE-USE-CONTINUATION, we also punt if either continuation has some weird TYPE-CHECK annotation. This prevents us from trashing type check generation.
Fixed JOIN-BLOCKS to combine many optimization flags it was ignoring. Fixed continuation substitution stuff to look at the let's home lambda so that we will sometimes do something.
Enhanced let optimization: Now we substitute for global function variables when the reference isn't :notinline. Also, single-reference let variables can be squeezed out by replacing the ref's value continuation with the argument continuation. The biggest advantage of this is that it allows output type assertions on the reference to be seen by the argument, which helps INCF, PSETQ, etc.
Merged in MV-BIND type inference from the mips branch, and fixed to handle set variables correctly.
Rolled back to 1.2, since there seem to be serious problems with the deleted-contiuation merging.
Fixed JOIN-SUCCESSOR-IF-POSSIBLE a bit in the new case of the first block ending in a deleted continuation.
Changed JOIN-BLOCKS-IF-POSSIBLE to join when the first block's last-cont is deleted.
Fixed TRANSFORM-CALL to return T or NIL to indicate whether to attempt other transforms, and changed IR1-OPTIMIZE-COMBINATION to respect this.
This form allows you to request diffs between any two revisions of this file. For each of the two "sides" of the diff, select a symbolic revision name using the selection box, or choose 'Use Text Field' and enter a numeric revision.
|Powered by ViewVC 1.1.5|