| blob | 98a5a9367655fafd13a44af59336c348963a883a |
1 ;;;; This file implements the IR1 optimization phase of the compiler.
2 ;;;; IR1 optimization is a grab-bag of optimizations that don't make
3 ;;;; major changes to the block-level control flow and don't use flow
4 ;;;; analysis. These optimizations can mostly be classified as
5 ;;;; "meta-evaluation", but there is a sizable top-down component as
6 ;;;; well.
8 ;;;; This software is part of the SBCL system. See the README file for
9 ;;;; more information.
10 ;;;;
11 ;;;; This software is derived from the CMU CL system, which was
12 ;;;; written at Carnegie Mellon University and released into the
13 ;;;; public domain. The software is in the public domain and is
14 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
15 ;;;; files for more information.
18 \f
19 ;;;; interface for obtaining results of constant folding
21 ;;; Return true for an LVAR whose sole use is a reference to a
22 ;;; constant leaf.
29 ;;; Return the constant value for an LVAR whose only use is a constant
30 ;;; node.
35 \f
36 ;;;; interface for obtaining results of type inference
38 ;;; Our best guess for the type of this lvar's value. Note that this
39 ;;; may be VALUES or FUNCTION type, which cannot be passed as an
40 ;;; argument to the normal type operations. See LVAR-TYPE.
41 ;;;
42 ;;; The result value is cached in the LVAR-%DERIVED-TYPE slot. If the
43 ;;; slot is true, just return that value, otherwise recompute and
44 ;;; stash the value there.
58 res))
64 ;;; Return the derived type for LVAR's first value. This is guaranteed
65 ;;; not to be a VALUES or FUNCTION type.
70 ;;; If LVAR is an argument of a function, return a type which the
71 ;;; function checks LVAR for.
80 ;; TODO: MV-COMBINATION
88 ;; FUN-TYPE might be (AND FUNCTION (SATISFIES ...)).
101 dest)))))
107 \f
108 ;;;; interface routines used by optimizers
118 ;;; This function is called by optimizers to indicate that something
119 ;;; interesting has happened to the value of LVAR. Optimizers must
120 ;;; make sure that they don't call for reoptimization when nothing has
121 ;;; happened, since optimization will fail to terminate.
122 ;;;
123 ;;; We clear any cached type for the lvar and set the reoptimize flags
124 ;;; on everything in sight.
134 ;; PREV may be missing.
153 ;;; Annotate NODE to indicate that its result has been proven to be
154 ;;; TYPEP to RTYPE. After IR1 conversion has happened, this is the
155 ;;; only correct way to supply information discovered about a node's
156 ;;; type. If you screw with the NODE-DERIVED-TYPE directly, then
157 ;;; information may be lost and reoptimization may not happen.
158 ;;;
159 ;;; What we do is intersect RTYPE with NODE's DERIVED-TYPE. If the
160 ;;; intersection is different from the old type, then we do a
161 ;;; REOPTIMIZE-LVAR on the NODE-LVAR.
174 "New inferred type ~S conflicts with old type:~
175 ~% ~S~%*** possible internal error? Please report this."
178 ;; If the new type consists of only one object, replace the
179 ;; node with a constant reference.
190 ;;; This is similar to DERIVE-NODE-TYPE, but asserts that it is an
191 ;;; error for LVAR's value not to be TYPEP to TYPE. We implement it
192 ;;; splitting off DEST a new CAST node; old LVAR will deliver values
193 ;;; to CAST. If we improve the assertion, we set TYPE-CHECK and
194 ;;; TYPE-ASSERTED to guarantee that the new assertion will be checked.
205 \f
206 ;;;; IR1-OPTIMIZE
208 ;;; Do one forward pass over COMPONENT, deleting unreachable blocks
209 ;;; and doing IR1 optimizations. We can ignore all blocks that don't
210 ;;; have the REOPTIMIZE flag set. If COMPONENT-REOPTIMIZE is true when
211 ;;; we are done, then another iteration would be beneficial.
217 for last-block = block
220 ;; We delete blocks when there is either no predecessor or the
221 ;; block is in a lambda that has been deleted. These blocks
222 ;; would eventually be deleted by DFO recomputation, but doing
223 ;; it here immediately makes the effect available to IR1
224 ;; optimization.
230 ;; Preserve the BLOCK-SUCC invariant that almost every block has
231 ;; one successor (and a block with DELETE-P set is an acceptable
232 ;; exception).
267 ;;; Loop over the nodes in BLOCK, acting on (and clearing) REOPTIMIZE
268 ;;; flags.
269 ;;;
270 ;;; Note that although they are cleared here, REOPTIMIZE flags might
271 ;;; still be set upon return from this function, meaning that further
272 ;;; optimization is wanted (as a consequence of optimizations we did).
275 ;; We clear the node and block REOPTIMIZE flags before doing the
276 ;; optimization, not after. This ensures that the node or block will
277 ;; be reoptimized if necessary.
281 ;; As above, we clear the node REOPTIMIZE flag before optimizing.
286 ;; With a COMBINATION, we call PROPAGATE-FUN-CHANGE whenever
287 ;; the function changes, and call IR1-OPTIMIZE-COMBINATION if
288 ;; any argument changes.
293 ;; KLUDGE: We leave the NODE-OPTIMIZE flag set going into
294 ;; IR1-OPTIMIZE-RETURN, since IR1-OPTIMIZE-RETURN wants to
295 ;; clear the flag itself. -- WHN 2002-02-02, quoting original
296 ;; CMU CL comments
302 ;; With an EXIT, we derive the node's type from the VALUE's
303 ;; type.
314 ;;; Try to join with a successor block. If we succeed, we return true,
315 ;;; otherwise false.
322 ;; the successor has more than one predecessor;
324 ;; the successor is the current block (infinite loop);
326 ;; the next block has a different cleanup, and thus
327 ;; we may want to insert cleanup code between the
328 ;; two blocks at some point;
331 ;; the next block has a different home lambda, and
332 ;; thus the control transfer is a non-local exit.
335 ;; Stack analysis phase wants ENTRY to start a block...
341 ;; ... and a DX-allocator to end a block.
343 ;; FIXME: This is a partial workaround for bug 303.
345 nil)
348 t)))))
350 ;;; Join together two blocks. The code in BLOCK2 is moved into BLOCK1
351 ;;; and BLOCK2 is deleted from the DFO. We combine the optimize flags
352 ;;; for the two blocks so that any indicated optimization gets done.
385 ;;; Delete any nodes in BLOCK whose value is unused and which have no
386 ;;; side effects. We can delete sets of lexical variables when the set
387 ;;; variable has no references.
403 ;; ### For now, don't delete potentially
404 ;; flushable calls when they have the CALL
405 ;; attribute. Someday we should look at the
406 ;; functional args to determine if they have
407 ;; any side effects.
440 \f
441 ;;;; local call return type propagation
443 ;;; This function is called on RETURN nodes that have their REOPTIMIZE
444 ;;; flag set. It iterates over the uses of the RESULT, looking for
445 ;;; interesting stuff to update the TAIL-SET. If a use isn't a local
446 ;;; call, then we union its type together with the types of other such
447 ;;; uses. We assign to the RETURN-RESULT-TYPE the intersection of this
448 ;;; type with the RESULT's asserted type. We can make this
449 ;;; intersection now (potentially before type checking) because this
450 ;;; assertion on the result will eventually be checked (if
451 ;;; appropriate.)
452 ;;;
453 ;;; We call MAYBE-CONVERT-TAIL-LOCAL-CALL on each local non-MV
454 ;;; combination, which may change the successor of the call to be the
455 ;;; called function, and if so, checks if the call can become an
456 ;;; assignment. If we convert to an assignment, we abort, since the
457 ;;; RETURN has been deleted.
476 ;; (values-type-intersection
477 ;; (continuation-asserted-type result) ; FIXME -- APD, 2002-01-26
479 ;; )
480 ))
482 nil)
484 ;;; Do stuff to realize that something has changed about the value
485 ;;; delivered to a return node. Since we consider the return values of
486 ;;; all functions in the tail set to be equivalent, this amounts to
487 ;;; bringing the entire tail set up to date. We iterate over the
488 ;;; returns for all the functions in the tail set, reanalyzing them
489 ;;; all (not treating NODE specially.)
490 ;;;
491 ;;; When we are done, we check whether the new type is different from
492 ;;; the old TAIL-SET-TYPE. If so, we set the type and also reoptimize
493 ;;; all the lvars for references to functions in the tail set. This
494 ;;; will cause IR1-OPTIMIZE-COMBINATION to derive the new type as the
495 ;;; results of the calls.
499 :restart
519 \f
520 ;;;; IF optimization
522 ;;; If the test has multiple uses, replicate the node when possible.
523 ;;; Also check whether the predicate is known to be true or false,
524 ;;; deleting the IF node in favor of the appropriate branch when this
525 ;;; is the case.
556 ;;; Create a new copy of an IF node that tests the value of the node
557 ;;; USE. The test must have >1 use, and must be immediately used by
558 ;;; USE. NODE must be the only node in its block (implying that
559 ;;; block-start = if-test).
560 ;;;
561 ;;; This optimization has an effect semantically similar to the
562 ;;; source-to-source transformation:
563 ;;; (IF (IF A B C) D E) ==>
564 ;;; (IF A (IF B D E) (IF C D E))
565 ;;;
566 ;;; We clobber the NODE-SOURCE-PATH of both the original and the new
567 ;;; node so that dead code deletion notes will definitely not consider
568 ;;; either node to be part of the original source. One node might
569 ;;; become unreachable, resulting in a spurious note.
581 :consequent cblock
603 \f
604 ;;;; exit IR1 optimization
606 ;;; This function attempts to delete an exit node, returning true if
607 ;;; it deletes the block as a consequence:
608 ;;; -- If the exit is degenerate (has no ENTRY), then we don't do
609 ;;; anything, since there is nothing to be done.
610 ;;; -- If the exit node and its ENTRY have the same home lambda then
611 ;;; we know the exit is local, and can delete the exit. We change
612 ;;; uses of the Exit-Value to be uses of the original lvar,
613 ;;; then unlink the node. If the exit is to a TR context, then we
614 ;;; must do MERGE-TAIL-SETS on any local calls which delivered
615 ;;; their value to this exit.
616 ;;; -- If there is no value (as in a GO), then we skip the value
617 ;;; semantics.
618 ;;;
619 ;;; This function is also called by environment analysis, since it
620 ;;; wants all exits to be optimized even if normal optimization was
621 ;;; omitted.
633 \f
634 ;;;; combination IR1 optimization
636 ;;; Report as we try each transform?
637 #!+sb-show
645 "The return value of ~A should not be discarded."
648 ;;; Do IR1 optimizations on a COMBINATION node.
658 (:local
663 (:error
667 (:full
689 (:known
697 ;; If somebody is really sure that they want to modify
698 ;; constants, let them.
711 ;; KLUDGE: The next test could be made more sensitive,
712 ;; only suppressing constant-folding of functions with
713 ;; CALL attributes when they're actually passed
714 ;; function arguments. -- WHN 19990918
730 ;; First give the VM a peek at the call
734 (:direct
735 ;; The VM knows how to handle this.
736 )
737 (:transform
738 ;; The VM mostly knows how to handle this. We need
739 ;; to massage the call slightly, though.
741 (:default
742 ;; Let transforms have a crack at it.
744 #!+sb-show
750 #!+sb-show
757 ;;; If NODE doesn't return (i.e. return type is NIL), then terminate
758 ;;; the block there, and link it to the component tail.
759 ;;;
760 ;;; Except when called during IR1 convertion, we delete the
761 ;;; continuation if it has no other uses. (If it does have other uses,
762 ;;; we reoptimize.)
763 ;;;
764 ;;; Termination on the basis of a continuation type is
765 ;;; inhibited when:
766 ;;; -- The continuation is deleted (hence the assertion is spurious), or
767 ;;; -- We are in IR1 conversion (where THE assertions are subject to
768 ;;; weakening.) FIXME: Now THE assertions are not weakened, but new
769 ;;; uses can(?) be added later. -- APD, 2003-07-17
770 ;;;
771 ;;; Why do we need to consider LVAR type? -- APD, 2003-07-30
807 t))))
809 ;;; This is called both by IR1 conversion and IR1 optimization when
810 ;;; they have verified the type signature for the call, and are
811 ;;; wondering if something should be done to special-case the call. If
812 ;;; CALL is a call to a global function, then see whether it defined
813 ;;; or known:
814 ;;; -- If a DEFINED-FUN should be inline expanded, then convert
815 ;;; the expansion and change the call to call it. Expansion is
816 ;;; enabled if :INLINE or if SPACE=0. If the FUNCTIONAL slot is
817 ;;; true, we never expand, since this function has already been
818 ;;; converted. Local call analysis will duplicate the definition
819 ;;; if necessary. We claim that the parent form is LABELS for
820 ;;; context declarations, since we don't want it to be considered
821 ;;; a real global function.
822 ;;; -- If it is a known function, mark it as such by setting the KIND.
823 ;;;
824 ;;; We return the leaf referenced (NIL if not a leaf) and the
825 ;;; FUN-INFO assigned.
853 ;; called semi-inlining? A more descriptive name would
854 ;; be nice. -- WHN 2002-01-07
858 name
860 leaf
861 inlinep
863 ;; allow backward references to this function from
864 ;; following top level forms
874 nil))
884 ;;; Check whether CALL satisfies TYPE. If so, apply the type to the
885 ;;; call, and do MAYBE-TERMINATE-BLOCK and return the values of
886 ;;; RECOGNIZE-KNOWN-CALL. If an error, set the combination kind and
887 ;;; return NIL, NIL. If the type is just FUNCTION, then skip the
888 ;;; syntax check, arg/result type processing, but still call
889 ;;; RECOGNIZE-KNOWN-CALL, since the call might be to a known lambda,
890 ;;; and that checking is done by local call analysis.
900 :result-test nil
901 ;; KLUDGE: Common Lisp is such a dynamic
902 ;; language that all we can do here in
903 ;; general is issue a STYLE-WARNING. It
904 ;; would be nice to issue a full WARNING
905 ;; in the special case of of type
906 ;; mismatches within a compilation unit
907 ;; (as in section 3.2.2.3 of the spec)
908 ;; but at least as of sbcl-0.6.11, we
909 ;; don't keep track of whether the
910 ;; mismatched data came from the same
911 ;; compilation unit, so we can't do that.
912 ;; -- WHN 2001-02-11
913 ;;
914 ;; FIXME: Actually, I think we could
915 ;; issue a full WARNING if the call
916 ;; violates a DECLAIM FTYPE.
926 ;;; This is called by IR1-OPTIMIZE when the function for a call has
927 ;;; changed. If the call is local, we try to LET-convert it, and
928 ;;; derive the result type. If it is a :FULL call, we validate it
929 ;;; against the type, which recognizes known calls, does inline
930 ;;; expansion, etc. If a call to a predicate in a non-conditional
931 ;;; position or to a function with a source transform, then we
932 ;;; reconvert the form to give IR1 another chance.
939 (:local
944 (:full
950 call))
958 predicate)
972 \f
973 ;;;; known function optimization
975 ;;; Add a failed optimization note to FAILED-OPTIMZATIONS for NODE,
976 ;;; FUN and ARGS. If there is already a note for NODE and TRANSFORM,
977 ;;; replace it, otherwise add a new one.
988 ;;; Attempt to transform NODE using TRANSFORM-FUNCTION, subject to the
989 ;;; call type constraint TRANSFORM-TYPE. If we are inhibited from
990 ;;; doing the transform for some reason and FLAME is true, then we
991 ;;; make a note of the message in FAILED-OPTIMIZATIONS for IR1
992 ;;; finalize to pick up. We return true if the transform failed, and
993 ;;; thus further transformation should be attempted. We return false
994 ;;; if either the transform succeeded or was aborted.
1014 (:none
1016 nil)
1017 (:aborted
1022 nil)
1023 (:failure
1029 t)
1030 (:delayed
1032 nil))))
1035 type
1039 t)
1041 t))))
1043 ;;; When we don't like an IR1 transform, we throw the severity/reason
1044 ;;; and args.
1045 ;;;
1046 ;;; GIVE-UP-IR1-TRANSFORM is used to throw out of an IR1 transform,
1047 ;;; aborting this attempt to transform the call, but admitting the
1048 ;;; possibility that this or some other transform will later succeed.
1049 ;;; If arguments are supplied, they are format arguments for an
1050 ;;; efficiency note.
1051 ;;;
1052 ;;; ABORT-IR1-TRANSFORM is used to throw out of an IR1 transform and
1053 ;;; force a normal call to the function at run time. No further
1054 ;;; optimizations will be attempted.
1055 ;;;
1056 ;;; DELAY-IR1-TRANSFORM is used to throw out of an IR1 transform, and
1057 ;;; delay the transform on the node until later. REASONS specifies
1058 ;;; when the transform will be later retried. The :OPTIMIZE reason
1059 ;;; causes the transform to be delayed until after the current IR1
1060 ;;; optimization pass. The :CONSTRAINT reason causes the transform to
1061 ;;; be delayed until after constraint propagation.
1062 ;;;
1063 ;;; FIXME: Now (0.6.11.44) that there are 4 variants of this (GIVE-UP,
1064 ;;; ABORT, DELAY/:OPTIMIZE, DELAY/:CONSTRAINT) and we're starting to
1065 ;;; do CASE operations on the various REASON values, it might be a
1066 ;;; good idea to go OO, representing the reasons by objects, using
1067 ;;; CLOS methods on the objects instead of CASE, and (possibly) using
1068 ;;; SIGNAL instead of THROW.
1085 ;;; Clear any delayed transform with no reasons - these should have
1086 ;;; been tried in the last pass. Then remove the reason from the
1087 ;;; delayed transform reasons, and if any become empty then set
1088 ;;; reoptimize flags for the node. Return true if any transforms are
1089 ;;; to be retried.
1105 reoptimize))
1107 ;;; Take the lambda-expression RES, IR1 convert it in the proper
1108 ;;; environment, and then install it as the function for the call
1109 ;;; NODE. We do local call analysis so that the new function is
1110 ;;; integrated into the control flow.
1111 ;;;
1112 ;;; We require the original function source name in order to generate
1113 ;;; a meaningful debug name for the lambda we set up. (It'd be
1114 ;;; possible to do this starting from debug names as well as source
1115 ;;; names, but as of sbcl-0.7.1.5, there was no need for this
1116 ;;; generality, since source names are always known to our callers.)
1122 ;; The internal variables of a transform are not going to be
1123 ;; interesting to the debugger, so there's no sense in
1124 ;; suppressing the substitution of variables with only one use
1125 ;; (the extra variables can slow down constraint propagation).
1126 ;;
1127 ;; This needs to be done before the WITH-IR1-ENVIRONMENT-FROM-NODE,
1128 ;; so that it will bind *LEXENV* to the right environment.
1141 res
1150 ;;; Replace a call to a foldable function of constant arguments with
1151 ;;; the result of evaluating the form. If there is an error during the
1152 ;;; evaluation, we give a warning and leave the call alone, making the
1153 ;;; call a :ERROR call.
1154 ;;;
1155 ;;; If there is more than one value, then we transform the call into a
1156 ;;; VALUES form.
1162 args
1163 call
1164 ;; Note: CMU CL had COMPILER-WARN here, and that
1165 ;; seems more natural, but it's probably not.
1166 ;;
1167 ;; It's especially not while bug 173 exists:
1168 ;; Expressions like
1169 ;; (COND (END
1170 ;; (UNLESS (OR UNSAFE? (<= END SIZE)))
1171 ;; ...))
1172 ;; can cause constant-folding TYPE-ERRORs (in
1173 ;; #'<=) when END can be proved to be NIL, even
1174 ;; though the code is perfectly legal and safe
1175 ;; because a NIL value of END means that the
1176 ;; #'<= will never be executed.
1177 ;;
1178 ;; Moreover, even without bug 173,
1179 ;; quite-possibly-valid code like
1180 ;; (COND ((NONINLINED-PREDICATE END)
1181 ;; (UNLESS (<= END SIZE))
1182 ;; ...))
1183 ;; (where NONINLINED-PREDICATE is something the
1184 ;; compiler can't do at compile time, but which
1185 ;; turns out to make the #'<= expression
1186 ;; unreachable when END=NIL) could cause errors
1187 ;; when the compiler tries to constant-fold (<=
1188 ;; END SIZE).
1189 ;;
1190 ;; So, with or without bug 173, it'd be
1191 ;; unnecessarily evil to do a full
1192 ;; COMPILER-WARNING (and thus return FAILURE-P=T
1193 ;; from COMPILE-FILE) for legal code, so we we
1194 ;; use a wimpier COMPILE-STYLE-WARNING instead.
1196 ;; On the other hand, for code we control, we
1197 ;; should be able to work around any bug
1198 ;; 173-related problems, and in particular we
1199 ;; want to be alerted to calls to our own
1200 ;; functions which aren't being folded away; a
1201 ;; COMPILER-WARNING is butch enough to stop the
1202 ;; SBCL build itself in its tracks.
1222 call
1226 fun-name))))))
1228 \f
1229 ;;;; local call optimization
1231 ;;; Propagate TYPE to LEAF and its REFS, marking things changed. If
1232 ;;; the leaf type is a function type, then just leave it alone, since
1233 ;;; TYPE is never going to be more specific than that (and
1234 ;;; TYPE-INTERSECTION would choke.)
1244 ;; KLUDGE: LET var substitution
1250 ;;; Iteration variable: exactly one SETQ of the form:
1251 ;;;
1252 ;;; (let ((var initial))
1253 ;;; ...
1254 ;;; (setq var (+ var step))
1255 ;;; ...)
1281 ;; Detect cases like (LOOP FOR 1.0 to 5.0 ...), where
1282 ;; the initial and the step are of different types,
1283 ;; and the step is less contagious.
1286 step-type))))
1325 :low low
1326 :high high
1329 "check for iteration variable reoptimization"
1339 ;;; Figure out the type of a LET variable that has sets. We compute
1340 ;;; the union of the INITIAL-TYPE and the types of all the set
1341 ;;; values and to a PROPAGATE-TO-REFS with this type.
1356 ;;; If a LET variable, find the initial value's type and do
1357 ;;; PROPAGATE-FROM-SETS. We also derive the VALUE's type as the node's
1358 ;;; type.
1374 ;;; Return true if the value of REF will always be the same (and is
1375 ;;; thus legal to substitute.)
1387 (:global-function
1394 ;;; If we have a non-set LET var with a single use, then (if possible)
1395 ;;; replace the variable reference's LVAR with the arg lvar.
1396 ;;;
1397 ;;; We change the REF to be a reference to NIL with unused value, and
1398 ;;; let it be flushed as dead code. A side effect of this substitution
1399 ;;; is to delete the variable.
1406 ;; Think about (LET ((A ...)) (IF ... A ...)): two
1407 ;; LVAR-USEs should not be met on one path. Another problem
1408 ;; is with dynamic-extent.
1412 ;; we should not change lifetime of unknown values lvars
1424 ;; While CRETURN and EXIT nodes may be known-values,
1425 ;; they have their own complications, such as
1426 ;; substitution into CRETURN may create new tail calls.
1427 nil)
1430 t))
1436 ;; Really it is (EQ (LVAR-USES LVAR) REF):
1437 t)
1442 ;; KLUDGE: it should be (TYPE-CHECK 0)
1446 ;; FIXME
1447 t)
1455 t)))
1457 ;;; Delete a LET, removing the call and bind nodes, and warning about
1458 ;;; any unreferenced variables. Note that FLUSH-DEAD-CODE will come
1459 ;;; along right away and delete the REF and then the lambda, since we
1460 ;;; flush the FUN lvar.
1475 ;;; This function is called when one of the arguments to a LET
1476 ;;; changes. We look at each changed argument. If the corresponding
1477 ;;; variable is set, then we call PROPAGATE-FROM-SETS. Otherwise, we
1478 ;;; consider substituting for the variable, and also propagate
1479 ;;; derived-type information for the arg to all the VAR's refs.
1480 ;;;
1481 ;;; Substitution is inhibited when the arg leaf's derived type isn't a
1482 ;;; subtype of the argument's leaf type. This prevents type checking
1483 ;;; from being defeated, and also ensures that the best representation
1484 ;;; for the variable can be used.
1485 ;;;
1486 ;;; Substitution of individual references is inhibited if the
1487 ;;; reference is in a different component from the home. This can only
1488 ;;; happen with closures over top level lambda vars. In such cases,
1489 ;;; the references may have already been compiled, and thus can't be
1490 ;;; retroactively modified.
1491 ;;;
1492 ;;; If all of the variables are deleted (have no references) when we
1493 ;;; are done, then we delete the LET.
1494 ;;;
1495 ;;; Note that we are responsible for clearing the LVAR-REOPTIMIZE
1496 ;;; flags.
1511 ;; (NODE-DERIVED-TYPE USE) would
1512 ;; be better -- APD, 2003-05-15
1519 t)
1522 nil)))
1523 leaf var)))
1524 t)))))
1526 ;; Don't substitute single-ref variables on high-debug /
1527 ;; low speed, to improve the debugging experience.
1538 ;;; This function is called when one of the args to a non-LET local
1539 ;;; call changes. For each changed argument corresponding to an unset
1540 ;;; variable, we compute the union of the types across all calls and
1541 ;;; propagate this type information to the var's refs.
1542 ;;;
1543 ;;; If the function has an XEP, then we don't do anything, since we
1544 ;;; won't discover anything.
1545 ;;;
1546 ;;; We can clear the LVAR-REOPTIMIZE flags for arguments in all calls
1547 ;;; corresponding to changed arguments in CALL, since the only use in
1548 ;;; IR1 optimization of the REOPTIMIZE flag for local call args is
1549 ;;; right here.
1562 vars))
1578 union)))))
1581 and type in union
1585 \f
1586 ;;;; multiple values optimization
1588 ;;; Do stuff to notice a change to a MV combination node. There are
1589 ;;; two main branches here:
1590 ;;; -- If the call is local, then it is already a MV let, or should
1591 ;;; become one. Note that although all :LOCAL MV calls must eventually
1592 ;;; be converted to :MV-LETs, there can be a window when the call
1593 ;;; is local, but has not been LET converted yet. This is because
1594 ;;; the entry-point lambdas may have stray references (in other
1595 ;;; entry points) that have not been deleted yet.
1596 ;;; -- The call is full. This case is somewhat similar to the non-MV
1597 ;;; combination optimization: we propagate return type information and
1598 ;;; notice non-returning calls. We also have an optimization
1599 ;;; which tries to convert MV-CALLs into MV-binds.
1602 (:local
1611 (:full
1634 ;;; Propagate derived type info from the values lvar to the vars.
1641 n-vars)))
1643 and type in types
1650 ;;; If possible, convert a general MV call to an MV-BIND. We can do
1651 ;;; this if:
1652 ;;; -- The call has only one argument, and
1653 ;;; -- The function has a known fixed number of arguments, or
1654 ;;; -- The argument yields a known fixed number of values.
1655 ;;;
1656 ;;; What we do is change the function in the MV-CALL to be a lambda
1657 ;;; that "looks like an MV bind", which allows
1658 ;;; IR1-OPTIMIZE-MV-COMBINATION to notice that this call can be
1659 ;;; converted (the next time around.) This new lambda just calls the
1660 ;;; actual function with the MV-BIND variables as arguments. Note that
1661 ;;; this new MV bind is not let-converted immediately, as there are
1662 ;;; going to be stray references from the entry-point functions until
1663 ;;; they get deleted.
1664 ;;;
1665 ;;; In order to avoid loss of argument count checking, we only do the
1666 ;;; transformation according to a known number of expected argument if
1667 ;;; safety is unimportant. We can always convert if we know the number
1668 ;;; of actual values, since the normal call that we build will still
1669 ;;; do any appropriate argument count checking.
1670 ;;;
1671 ;;; We only attempt the transformation if the called function is a
1672 ;;; constant reference. This allows us to just splice the leaf into
1673 ;;; the new function, instead of trying to somehow bind the function
1674 ;;; expression. The leaf must be constant because we are evaluating it
1675 ;;; again in a different place. This also has the effect of squelching
1676 ;;; multiple warnings when there is an argument count error.
1698 "MULTIPLE-VALUE-CALL with ~R values when the function expects ~
1699 at least ~R."
1700 total-nvals min)
1705 "MULTIPLE-VALUE-CALL with ~R values when the function expects ~
1706 at most ~R."
1707 total-nvals max)
1714 min)
1730 ;;; If we see:
1731 ;;; (multiple-value-bind
1732 ;;; (x y)
1733 ;;; (values xx yy)
1734 ;;; ...)
1735 ;;; Convert to:
1736 ;;; (let ((x xx)
1737 ;;; (y yy))
1738 ;;; ...)
1739 ;;;
1740 ;;; What we actually do is convert the VALUES combination into a
1741 ;;; normal LET combination calling the original :MV-LET lambda. If
1742 ;;; there are extra args to VALUES, discard the corresponding
1743 ;;; lvars. If there are insufficient args, insert references to NIL.
1766 for prev = node-prev then ctran
1772 use ctran))
1788 t)))
1790 ;;; If we see:
1791 ;;; (values-list (list x y z))
1792 ;;;
1793 ;;; Convert to:
1794 ;;; (values x y z)
1795 ;;;
1796 ;;; In implementation, this is somewhat similar to
1797 ;;; CONVERT-MV-BIND-TO-LET. We grab the args of LIST and make them
1798 ;;; args of the VALUES-LIST call, flushing the old argument lvar
1799 ;;; (allowing the LIST to be flushed.)
1800 ;;;
1801 ;;; FIXME: Thus we lose possible type assertions on (LIST ...).
1808 ;; FIXME: VALUES might not satisfy an assertion on NODE-LVAR.
1819 t)))
1821 ;;; If VALUES appears in a non-MV context, then effectively convert it
1822 ;;; to a PROG1. This allows the computation of the additional values
1823 ;;; to become dead code.
1835 val))
1836 nil))
1838 ;;; TODO:
1839 ;;; - CAST chains;
1863 lvar)
1864 ;; Pathwise removing of CAST
1867 next-block)
1895 ;; FIXME: Do it in one step.
1897 value
1903 ;; FIXME: Derived type.
1907 ;; KLUDGE: FILTER-LVAR does not work for non-returning
1908 ;; functions, so we declare the return type of
1909 ;; %COMPILE-TIME-TYPE-ERROR to be * and derive the real type
1910 ;; here.
1914 ;; FIXME: Is it necessary?