X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fir2tran.lisp;h=275d2dca4c2886cee30e86027f5a84b67620e91e;hb=74cf7a4d01664fbf72a662ba093ad67ca243b524;hp=b10661d2179b4f6bcc012b7d142ec065b98fe95e;hpb=46602bb31b943b1793da732781586c032333c907;p=sbcl.git diff --git a/src/compiler/ir2tran.lisp b/src/compiler/ir2tran.lisp index b10661d..275d2dc 100644 --- a/src/compiler/ir2tran.lisp +++ b/src/compiler/ir2tran.lisp @@ -31,14 +31,16 @@ ;;; If there is any CHECK-xxx template for TYPE, then return it, ;;; otherwise return NIL. +;;; The second value is T if the template needs TYPE to be passed (defun type-check-template (type) (declare (type ctype type)) (multiple-value-bind (check-ptype exact) (primitive-type type) (if exact (primitive-type-check check-ptype) - (let ((name (hairy-type-check-template-name type))) + (multiple-value-bind (name type-needed) + (hairy-type-check-template-name type) (if name - (template-or-lose name) + (values (template-or-lose name) type-needed) nil))))) ;;; Emit code in BLOCK to check that VALUE is of the specified TYPE, @@ -49,7 +51,10 @@ (defun emit-type-check (node block value result type) (declare (type tn value result) (type node node) (type ir2-block block) (type ctype type)) - (emit-move-template node block (type-check-template type) value result) + (multiple-value-bind (template type-needed) (type-check-template type) + (if type-needed + (emit-load-template node block template value result (list type)) + (emit-move-template node block template value result))) (values)) ;;; Allocate an indirect value cell. @@ -178,10 +183,18 @@ (vop fast-symbol-global-value node block name-tn res) (vop symbol-global-value node block name-tn res)))) (:global-function - (let ((fdefn-tn (make-load-time-constant-tn :fdefinition name))) - (if unsafe - (vop fdefn-fun node block fdefn-tn res) - (vop safe-fdefn-fun node block fdefn-tn res))))))) + (cond #-sb-xc-host + ((and (info :function :definition name) + (info :function :info name)) + ;; Known functions can be saved without going through fdefns, + ;; except during cross-compilation + (emit-move node block (make-load-time-constant-tn :known-fun name) + res)) + (t + (let ((fdefn-tn (make-load-time-constant-tn :fdefinition name))) + (if unsafe + (vop fdefn-fun node block fdefn-tn res) + (vop safe-fdefn-fun node block fdefn-tn res))))))))) ;;; some sanity checks for a CLAMBDA passed to IR2-CONVERT-CLOSURE (defun assertions-on-ir2-converted-clambda (clambda) @@ -237,35 +250,39 @@ (type ir2-block ir2-block) (type functional functional) (type tn res)) - (aver (not (eql (functional-kind functional) :deleted))) - (unless (leaf-info functional) - (setf (leaf-info functional) - (make-entry-info :name (functional-debug-name functional)))) - (let ((closure (etypecase functional - (clambda - (assertions-on-ir2-converted-clambda functional) - (physenv-closure (get-lambda-physenv functional))) - (functional - (aver (eq (functional-kind functional) :toplevel-xep)) - nil))) - global-var) - (cond (closure - (let* ((physenv (node-physenv ref)) - (tn (find-in-physenv functional physenv))) - (emit-move ref ir2-block tn res))) - ;; we're about to emit a reference to a "closure" that's actually - ;; an inlinable global function. - ((and (global-var-p (setf global-var - (functional-inline-expanded functional))) - (eq :global-function (global-var-kind global-var))) - (ir2-convert-global-var ref ir2-block global-var res)) - (t - ;; if we're here, we should have either a toplevel-xep (some - ;; global scope function in a different component) or an external - ;; reference to the "closure"'s body. - (aver (memq (functional-kind functional) '(:external :toplevel-xep))) - (let ((entry (make-load-time-constant-tn :entry functional))) - (emit-move ref ir2-block entry res))))) + (flet ((prepare () + (aver (not (eql (functional-kind functional) :deleted))) + (unless (leaf-info functional) + (setf (leaf-info functional) + (make-entry-info :name + (functional-debug-name functional)))))) + (let ((closure (etypecase functional + (clambda + (assertions-on-ir2-converted-clambda functional) + (physenv-closure (get-lambda-physenv functional))) + (functional + (aver (eq (functional-kind functional) :toplevel-xep)) + nil))) + global-var) + (cond (closure + (prepare) + (let* ((physenv (node-physenv ref)) + (tn (find-in-physenv functional physenv))) + (emit-move ref ir2-block tn res))) + ;; we're about to emit a reference to a "closure" that's actually + ;; an inlinable global function. + ((and (global-var-p (setf global-var + (functional-inline-expanded functional))) + (eq :global-function (global-var-kind global-var))) + (ir2-convert-global-var ref ir2-block global-var res)) + (t + ;; if we're here, we should have either a toplevel-xep (some + ;; global scope function in a different component) or an external + ;; reference to the "closure"'s body. + (prepare) + (aver (memq (functional-kind functional) '(:external :toplevel-xep))) + (let ((entry (make-load-time-constant-tn :entry functional))) + (emit-move ref ir2-block entry res)))))) (values)) (defun closure-initial-value (what this-env current-fp) @@ -1818,7 +1835,9 @@ temp (first results)) (move-lvar-result node block results lvar) (return)))))) - (ir2-convert-full-call node block))) + (if (template-p (basic-combination-info node)) + (ir2-convert-template node block) + (ir2-convert-full-call node block)))) ;;; Convert the code in a component into VOPs. (defun ir2-convert (component) @@ -1882,9 +1901,13 @@ ;;; If necessary, emit a terminal unconditional branch to go to the ;;; successor block. If the successor is the component tail, then -;;; there isn't really any successor, but if the end is an unknown, -;;; non-tail call, then we emit an error trap just in case the -;;; function really does return. +;;; there isn't really any successor, but if the end is a non-tail +;;; call to a function that's not *known* to never return, then we +;;; emit an error trap just in case the function really does return. +;;; +;;; Trapping after known calls makes it easier to understand type +;;; derivation bugs at runtime: they show up as nil-fun-returned-error, +;;; rather than the execution of arbitrary code or error traps. (defun finish-ir2-block (block) (declare (type cblock block)) (let* ((2block (block-info block)) @@ -1895,15 +1918,20 @@ (let ((target (first succ))) (cond ((eq target (component-tail (block-component block))) (when (and (basic-combination-p last) - (eq (basic-combination-kind last) :full)) + (or (eq (basic-combination-kind last) :full) + (and (eq (basic-combination-kind last) :known) + (eq (basic-combination-info last) :full)))) (let* ((fun (basic-combination-fun last)) (use (lvar-uses fun)) (name (and (ref-p use) (leaf-has-source-name-p (ref-leaf use)) - (leaf-source-name (ref-leaf use))))) + (leaf-source-name (ref-leaf use)))) + (ftype (and (info :function :info name) ; only use the FTYPE if + (info :function :type name)))) ; NAME was DEFKNOWN (unless (or (node-tail-p last) - (info :function :info name) - (policy last (zerop safety))) + (policy last (zerop safety)) + (and (fun-type-p ftype) + (eq *empty-type* (fun-type-returns ftype)))) (vop nil-fun-returned-error last 2block (if name (emit-constant name)