X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fir1tran.lisp;h=0002cb214aad8fd92288ded92c10fb972d399ad2;hb=96b310113978665980a8d65ad5dd83deab05c28b;hp=59cf7118f5c6085869f5491948d43e80466f05cb;hpb=64a50ee0d70f2e87f3d284d1c7a48a2e0762ea90;p=sbcl.git diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp index 59cf711..0002cb2 100644 --- a/src/compiler/ir1tran.lisp +++ b/src/compiler/ir1tran.lisp @@ -428,8 +428,9 @@ cont form &optional - (proxy ``(error "execution of a form compiled with errors:~% ~S" - ',,form))) + (proxy ``(error 'simple-program-error + :format-control "execution of a form compiled with errors:~% ~S" + :format-arguments (list ',,form)))) &body body) (let ((skip (gensym "SKIP"))) `(block ,skip @@ -543,21 +544,23 @@ ;;; functional instead. (defun reference-leaf (start cont leaf) (declare (type continuation start cont) (type leaf leaf)) - (let* ((leaf (or (and (defined-fun-p leaf) - (not (eq (defined-fun-inlinep leaf) - :notinline)) - (let ((functional (defined-fun-functional leaf))) - (when (and functional - (not (functional-kind functional))) - (maybe-reanalyze-functional functional)))) - leaf)) - (res (make-ref (or (lexenv-find leaf type-restrictions) - (leaf-type leaf)) - leaf))) - (push res (leaf-refs leaf)) - (setf (leaf-ever-used leaf) t) - (link-node-to-previous-continuation res start) - (use-continuation res cont))) + (with-continuation-type-assertion + (cont (or (lexenv-find leaf type-restrictions) *wild-type*) + "in DECLARE") + (let* ((leaf (or (and (defined-fun-p leaf) + (not (eq (defined-fun-inlinep leaf) + :notinline)) + (let ((functional (defined-fun-functional leaf))) + (when (and functional + (not (functional-kind functional))) + (maybe-reanalyze-functional functional)))) + leaf)) + (res (make-ref (leaf-type leaf) + leaf))) + (push res (leaf-refs leaf)) + (setf (leaf-ever-used leaf) t) + (link-node-to-previous-continuation res start) + (use-continuation res cont)))) ;;; Convert a reference to a symbolic constant or variable. If the ;;; symbol is entered in the LEXENV-VARS we use that definition, @@ -585,22 +588,31 @@ (values)) ;;; Convert anything that looks like a special form, global function -;;; or macro call. +;;; or compiler-macro call. (defun ir1-convert-global-functoid (start cont form) (declare (type continuation start cont) (list form)) - (let* ((fun (first form)) - (translator (info :function :ir1-convert fun)) - (cmacro (info :function :compiler-macro-function fun))) - (cond (translator (funcall translator start cont form)) - ((and cmacro - (not (eq (info :function :inlinep fun) - :notinline))) - (let ((res (careful-expand-macro cmacro form))) + (let* ((fun-name (first form)) + (translator (info :function :ir1-convert fun-name)) + (cmacro-fun (sb!xc:compiler-macro-function fun-name *lexenv*))) + (cond (translator + (when cmacro-fun + (compiler-warn "ignoring compiler macro for special form")) + (funcall translator start cont form)) + ((and cmacro-fun + ;; gotcha: If you look up the DEFINE-COMPILER-MACRO + ;; macro in the ANSI spec, you might think that + ;; suppressing compiler-macro expansion when NOTINLINE + ;; is some pre-ANSI hack. However, if you look up the + ;; NOTINLINE declaration, you'll find that ANSI + ;; requires this behavior after all. + (not (eq (info :function :inlinep fun-name) :notinline))) + (let ((res (careful-expand-macro cmacro-fun form))) (if (eq res form) - (ir1-convert-global-functoid-no-cmacro start cont form fun) + (ir1-convert-global-functoid-no-cmacro + start cont form fun-name) (ir1-convert start cont res)))) (t - (ir1-convert-global-functoid-no-cmacro start cont form fun))))) + (ir1-convert-global-functoid-no-cmacro start cont form fun-name))))) ;;; Handle the case of where the call was not a compiler macro, or was ;;; a compiler macro and passed. @@ -746,6 +758,7 @@ (setf (continuation-dest fun-cont) node) (assert-continuation-type fun-cont (specifier-type '(or function symbol))) + (setf (continuation-%externally-checkable-type fun-cont) nil) (collect ((arg-conts)) (let ((this-start fun-cont)) (dolist (arg args) @@ -884,7 +897,7 @@ ;;; macro, we just wrap a THE around the expansion. (defun process-type-decl (decl res vars) (declare (list decl vars) (type lexenv res)) - (let ((type (specifier-type (first decl)))) + (let ((type (compiler-specifier-type (first decl)))) (collect ((restr nil cons) (new-vars nil cons)) (dolist (var-name (rest decl)) @@ -932,7 +945,7 @@ ;;; functions. (defun process-ftype-decl (spec res names fvars) (declare (list spec names fvars) (type lexenv res)) - (let ((type (specifier-type spec))) + (let ((type (compiler-specifier-type spec))) (collect ((res nil cons)) (dolist (name names) (let ((found (find name fvars @@ -1105,7 +1118,7 @@ `(values ,@types)) cont res - 'values)))) + "in VALUES declaration")))) (dynamic-extent (when (policy *lexenv* (> speed inhibit-warnings)) (compiler-note @@ -1223,9 +1236,10 @@ (declaim (ftype (function (list) (values list boolean boolean list list)) make-lambda-vars)) (defun make-lambda-vars (list) - (multiple-value-bind (required optional restp rest keyp keys allowp aux + (multiple-value-bind (required optional restp rest keyp keys allowp auxp aux morep more-context more-count) (parse-lambda-list list) + (declare (ignore auxp)) ; since we just iterate over AUX regardless (collect ((vars) (names-so-far) (aux-vars) @@ -1466,30 +1480,11 @@ (setf (node-lexenv bind) *lexenv*) (let ((cont1 (make-continuation)) - (cont2 (make-continuation)) - (revised-body (if (policy bind - (or (> safety - (max speed space)) - (= safety 3))) - ;; (Stuffing this in at IR1 level like - ;; this is pretty crude. And it's - ;; particularly inefficient to execute - ;; it on *every* LAMBDA, including - ;; LET-converted LAMBDAs. Improvements - ;; are welcome, but meanwhile, when - ;; SAFETY is high, it's still arguably - ;; an improvement over the old CMU CL - ;; approach of doing nothing (waiting - ;; for evolution to breed careful - ;; users:-). -- WHN) - `((%detect-stack-exhaustion) - ,@body) - body))) + (cont2 (make-continuation))) (continuation-starts-block cont1) (link-node-to-previous-continuation bind cont1) (use-continuation bind cont2) - (ir1-convert-special-bindings cont2 result - revised-body + (ir1-convert-special-bindings cont2 result body aux-vars aux-vals (svars))) (let ((block (continuation-block result))) @@ -1500,6 +1495,7 @@ (setf (lambda-tail-set lambda) tail-set) (setf (lambda-return lambda) return) (setf (continuation-dest result) return) + (setf (continuation-%externally-checkable-type result) nil) (setf (block-last block) return) (link-node-to-previous-continuation return result) (use-continuation return dummy)) @@ -1958,7 +1954,7 @@ (multiple-value-bind (vars keyp allow-other-keys aux-vars aux-vals) (make-lambda-vars (cadr form)) - (multiple-value-bind (forms decls) (sb!sys:parse-body (cddr form)) + (multiple-value-bind (forms decls) (parse-body (cddr form)) (let* ((result-cont (make-continuation)) (*lexenv* (process-decls decls (append aux-vars vars) @@ -2006,9 +2002,9 @@ :source-name source-name :debug-name debug-name)))) -;;; Get a DEFINED-FUN object for a function we are about to -;;; define. If the function has been forward referenced, then -;;; substitute for the previous references. +;;; Get a DEFINED-FUN object for a function we are about to define. If +;;; the function has been forward referenced, then substitute for the +;;; previous references. (defun get-defined-fun (name) (proclaim-as-fun-name name) (let ((found (find-free-fun name "shouldn't happen! (defined-fun)"))) @@ -2084,8 +2080,8 @@ (setf (functional-inlinep fun) (defined-fun-inlinep var)) (assert-new-definition var fun) (setf (defined-fun-inline-expansion var) var-expansion) - ;; If definitely not an interpreter stub, then substitute for any - ;; old references. + ;; If definitely not an interpreter stub, then substitute for + ;; any old references. (unless (or (eq (defined-fun-inlinep var) :notinline) (not *block-compile*) (and fun-info