(let ((arg (car args))
(var (car vars)))
(cond ((leaf-refs var)
- (assert-continuation-type arg (leaf-type var)))
+ (assert-continuation-type arg (leaf-type var)
+ (lexenv-policy (node-lexenv call))))
(t
(flush-dest arg)
(setf (car args) nil)))))
(temps (make-gensym-list (length (lambda-vars fun)))))
`(lambda (,n-supplied ,@temps)
(declare (type index ,n-supplied))
- ,(if (policy *lexenv* (zerop safety))
+ ,(if (policy *lexenv* (zerop verify-arg-count))
`(declare (ignore ,n-supplied))
`(%verify-arg-count ,n-supplied ,nargs))
(locally
- ;; KLUDGE: The intent here is to enable tail recursion
- ;; optimization, since leaving frames for wrapper
- ;; functions like this on the stack is actually more
- ;; annoying than helpful for debugging. Unfortunately
- ;; trying to express this by messing with the
- ;; ANSI-standard declarations is a little awkward, since
- ;; no matter how we do it we'll tend to have side-effects
- ;; on things like SPEED-vs.-SAFETY comparisons. Perhaps
- ;; it'd be better to define a new SB-EXT:TAIL-RECURSIVELY
- ;; declaration and use that? -- WHN 2002-07-08
- (declare (optimize (speed 2) (debug 1)))
+ (declare (optimize (merge-tail-calls 3)))
(%funcall ,fun ,@temps)))))
(optional-dispatch
(let* ((min (optional-dispatch-min-args fun))
`(multiple-value-bind (,n-context ,n-count)
(%more-arg-context ,n-supplied ,max)
(locally
- ;; KLUDGE: As above, we're trying to
- ;; enable tail recursion optimization and
- ;; any other effects of this declaration
- ;; are accidental. -- WHN 2002-07-08
- (declare (optimize (speed 2) (debug 1)))
+ (declare (optimize (merge-tail-calls 3)))
(%funcall ,more ,@temps ,n-context ,n-count)))))))
(t
(%arg-count-error ,n-supplied)))))))))
(assert-continuation-type
(first (basic-combination-args call))
(make-values-type :optional (mapcar #'leaf-type (lambda-vars ep))
- :rest *universal-type*))))
+ :rest *universal-type*)
+ (lexenv-policy (node-lexenv call)))))
(values))
;;; Attempt to convert a call to a lambda. If the number of args is
(with-ir1-environment-from-node call
(ir1-convert-lambda
`(lambda ,vars
- (declare (ignorable . ,ignores))
- (%funcall ,entry . ,args))
+ (declare (ignorable ,@ignores))
+ (%funcall ,entry ,@args))
:debug-name (debug-namify "hairy function entry ~S"
(continuation-fun-name
(basic-combination-fun call)))))))
;; information.
(setf (tail-set-info (lambda-tail-set clambda)) nil))
-;;; Handle the environment semantics of LET conversion. We add CLAMBDA
-;;; and its LETs to LETs for the CALL's home function. We merge the
-;;; calls for CLAMBDA with the calls for the home function, removing
-;;; CLAMBDA in the process. We also merge the ENTRIES.
+;;; Handle the PHYSENV semantics of LET conversion. We add CLAMBDA and
+;;; its LETs to LETs for the CALL's home function. We merge the calls
+;;; for CLAMBDA with the calls for the home function, removing CLAMBDA
+;;; in the process. We also merge the ENTRIES.
;;;
;;; We also unlink the function head from the component head and set
;;; COMPONENT-REANALYZE to true to indicate that the DFO should be
(depart-from-tail-set clambda)
(let* ((home (node-home-lambda call))
- (home-env (lambda-physenv home)))
+ (home-physenv (lambda-physenv home)))
(aver (not (eq home clambda)))
;; CLAMBDA belongs to HOME now.
(push clambda (lambda-lets home))
(setf (lambda-home clambda) home)
- (setf (lambda-physenv clambda) home-env)
+ (setf (lambda-physenv clambda) home-physenv)
;; All of CLAMBDA's LETs belong to HOME now.
(let ((lets (lambda-lets clambda)))
(dolist (let lets)
(setf (lambda-home let) home)
- (setf (lambda-physenv let) home-env))
+ (setf (lambda-physenv let) home-physenv))
(setf (lambda-lets home) (nconc lets (lambda-lets home))))
;; CLAMBDA no longer has an independent existence as an entity
;; which has LETs.
(cont (node-cont call))
(call-type (node-derived-type call)))
(when (eq (continuation-use cont) call)
- (assert-continuation-type cont (continuation-asserted-type result)))
+ (set-continuation-type-assertion
+ cont
+ (continuation-asserted-type result)
+ (continuation-type-to-check result)))
(unless (eq call-type *wild-type*)
(do-uses (use result)
(derive-node-type use call-type)))
;; From the user's point of view, LET-converting something that
;; has a name is inlining it. (The user can't see what we're doing
;; with anonymous things, and suppressing inlining
- ;; for such things can easily give Python acute indigestion, so
+ ;; for such things can easily give Python acute indigestion, so
;; we don't.)
(when (leaf-has-source-name-p clambda)
;; ANSI requires that explicit NOTINLINE be respected.
(or (eq (lambda-inlinep clambda) :notinline)
- ;; If (> DEBUG SPEED) we can guess that inlining generally
- ;; won't be appreciated, but if the user specifically requests
- ;; inlining, that takes precedence over our general guess.
- (and (policy clambda (> debug speed))
+ ;; If (= LET-CONVERTION 0) we can guess that inlining
+ ;; generally won't be appreciated, but if the user
+ ;; specifically requests inlining, that takes precedence over
+ ;; our general guess.
+ (and (policy clambda (= let-convertion 0))
(not (eq (lambda-inlinep clambda) :inline))))))
;;; We also don't convert calls to named functions which appear in the
projects / sbcl.git / blobdiff