;; problems: hidden references should not be established to
;; lambdas of kind NIL should not have (otherwise the compiler
;; might let-convert or delete them) and to variables.
- (let ((name (or debug-name source-name))
- (defaults (if supplied-p (list default nil) (list default))))
+ (let ((name (or debug-name source-name)))
(if (or force
supplied-p-p ; this entry will be of kind NIL
(and (lambda-p ep) (eq (lambda-kind ep) nil)))
(convert-optional-entry ep
default-vars default-vals
- defaults
+ (if supplied-p (list default nil) (list default))
name)
- (delay
- (register-entry-point
- (convert-optional-entry (force ep)
- default-vars default-vals
- defaults
- name)
- res))))))
+ (let* ((default `',(constant-form-value default))
+ (defaults (if supplied-p (list default nil) (list default))))
+ ;; DEFAULT can contain a reference to a
+ ;; to-be-optimized-away function/block/tag, so better to
+ ;; reduce code now (but we possibly lose syntax checking
+ ;; in an unreachable code).
+ (delay
+ (register-entry-point
+ (convert-optional-entry (force ep)
+ default-vars default-vals
+ defaults
+ name)
+ res)))))))
;;; Create the MORE-ENTRY function for the OPTIONAL-DISPATCH RES.
;;; ENTRY-VARS and ENTRY-VALS describe the fixed arguments. REST is
(arg-vals n-context)
(arg-vals n-count))
+ ;; The reason for all the noise with
+ ;; STACK-GROWS-DOWNWARD-NOT-UPWARD is to enable generation of
+ ;; slightly more efficient code on x86oid processors. (We can
+ ;; hoist the negation of the index outside the main parsing loop
+ ;; and take advantage of the base+index+displacement addressing
+ ;; mode on x86oids.)
(when (optional-dispatch-keyp res)
(let ((n-index (gensym "N-INDEX-"))
(n-key (gensym "N-KEY-"))
(policy *lexenv* (zerop safety))))
(found-allow-p nil))
- (temps `(,n-index (1- ,n-count)) n-key n-value-temp)
- (body `(declare (fixnum ,n-index) (ignorable ,n-key ,n-value-temp)))
+ (temps #!-stack-grows-downward-not-upward
+ `(,n-index (1- ,n-count))
+ #!+stack-grows-downward-not-upward
+ `(,n-index (- (1- ,n-count)))
+ #!-stack-grows-downward-not-upward n-value-temp
+ #!-stack-grows-downward-not-upward n-key)
+ (body `(declare (fixnum ,n-index)
+ #!-stack-grows-downward-not-upward
+ (ignorable ,n-value-temp ,n-key)))
(collect ((tests))
(dolist (key keys)
(%odd-key-args-error)))
(body
+ #!-stack-grows-downward-not-upward
`(locally
(declare (optimize (safety 0)))
(loop
(decf ,n-index)
(setq ,n-key (%more-arg ,n-context ,n-index))
(decf ,n-index)
- (cond ,@(tests)))))
+ (cond ,@(tests))))
+ #!+stack-grows-downward-not-upward
+ `(locally (declare (optimize (safety 0)))
+ (loop
+ (when (plusp ,n-index) (return))
+ (multiple-value-bind (,n-value-temp ,n-key)
+ (%more-kw-arg ,n-context ,n-index)
+ (declare (ignorable ,n-value-temp ,n-key))
+ (incf ,n-index 2)
+ (cond ,@(tests))))))
(unless allowp
(body `(when (and ,n-losep (not ,n-allowp))
(n-val (make-symbol (format nil
"~A-DEFAULTING-TEMP"
(leaf-source-name key))))
- (key-type (leaf-type key))
- (val-temp (make-lambda-var
- :%source-name n-val
- :type (if hairy-default
- (type-union key-type (specifier-type 'null))
- key-type))))
+ (val-temp (make-lambda-var :%source-name n-val)))
(main-vars val-temp)
(bind-vars key)
(cond ((or hairy-default supplied-p)
(declare (type optional-dispatch res)
(list default-vars default-vals entry-vars entry-vals vars body
aux-vars aux-vals))
+ (aver (or debug-name (neq '.anonymous. source-name)))
(cond ((not vars)
(if (optional-dispatch-keyp res)
;; Handle &KEY with no keys...
;;; call IR1-CONVERT-HAIRY-ARGS to do the work. When it is done, we
;;; figure out the MIN-ARGS and MAX-ARGS.
(defun ir1-convert-hairy-lambda (body vars keyp allowp aux-vars aux-vals
- &key
- post-binding-lexenv
- (source-name '.anonymous.)
- (debug-name
- (debug-name '&optional-dispatch vars)))
+ &key post-binding-lexenv
+ (source-name '.anonymous.)
+ debug-name)
(declare (list body vars aux-vars aux-vals))
+ (aver (or debug-name (neq '.anonymous. source-name)))
(let ((res (make-optional-dispatch :arglist vars
:allowp allowp
:keyp keyp
;;; Convert a LAMBDA form into a LAMBDA leaf or an OPTIONAL-DISPATCH leaf.
(defun ir1-convert-lambda (form &key (source-name '.anonymous.)
- debug-name)
+ debug-name maybe-add-debug-catch)
(unless (consp form)
(compiler-error "A ~S was found when expecting a lambda expression:~% ~S"
(type-of form)
(compiler-error
"The lambda expression has a missing or non-list lambda list:~% ~S"
form))
-
+ (unless (or debug-name (neq '.anonymous. source-name))
+ (setf debug-name (name-lambdalike form)))
(multiple-value-bind (vars keyp allow-other-keys aux-vars aux-vals)
(make-lambda-vars (cadr form))
(multiple-value-bind (forms decls) (parse-body (cddr form))
(binding* (((*lexenv* result-type post-binding-lexenv)
(process-decls decls (append aux-vars vars) nil
:binding-form-p t))
- (forms (if (and *allow-instrumenting*
- (policy *lexenv* (>= insert-debug-catch 2)))
- `((catch (locally
- (declare (optimize (insert-step-conditions 0)))
- ;; Using MAKE-SYMBOL would lead
- ;; to recursive disaster.
- (%make-symbol "SB-DEBUG-CATCH-TAG"))
- ,@forms))
+ (debug-catch-p (and maybe-add-debug-catch
+ *allow-instrumenting*
+ (policy *lexenv*
+ (>= insert-debug-catch 2))))
+ (forms (if debug-catch-p
+ (wrap-forms-in-debug-catch forms)
forms))
(forms (if (eq result-type *wild-type*)
forms
:debug-name debug-name))))
(setf (functional-inline-expansion res) form)
(setf (functional-arg-documentation res) (cadr form))
+ (when (boundp '*lambda-conversions*)
+ ;; KLUDGE: Not counting TL-XEPs is a lie, of course, but
+ ;; keeps things less confusing to users of TIME, where this
+ ;; count gets used.
+ (unless (and (consp debug-name) (eq 'tl-xep (car debug-name)))
+ (incf *lambda-conversions*)))
res))))
+(defun wrap-forms-in-debug-catch (forms)
+ #!+unwind-to-frame-and-call-vop
+ `((multiple-value-prog1
+ (progn
+ ,@forms)
+ ;; Just ensure that there won't be any tail-calls, IR2 magic will
+ ;; handle the rest.
+ (values)))
+ #!-unwind-to-frame-and-call-vop
+ `( ;; Normally, we'll return from this block with the below RETURN-FROM.
+ (block
+ return-value-tag
+ ;; If DEBUG-CATCH-TAG is thrown (with a thunk as the value) the
+ ;; RETURN-FROM is elided and we funcall the thunk instead. That
+ ;; thunk might either return a value (for a RETURN-FROM-FRAME)
+ ;; or call this same function again (for a RESTART-FRAME).
+ ;; -- JES, 2007-01-09
+ (funcall
+ (the function
+ ;; Use a constant catch tag instead of consing a new one for every
+ ;; entry to this block. The uniquencess of the catch tags is
+ ;; ensured when the tag is throw by the debugger. It'll allocate a
+ ;; new tag, and modify the reference this tag in the proper
+ ;; catch-block structure to refer to that new tag. This
+ ;; significantly decreases the runtime cost of high debug levels.
+ ;; -- JES, 2007-01-09
+ (catch 'debug-catch-tag
+ (return-from return-value-tag
+ (progn
+ ,@forms))))))))
+
;;; helper for LAMBDA-like things, to massage them into a form
;;; suitable for IR1-CONVERT-LAMBDA.
(defun ir1-convert-lambdalike (thing
&key
(source-name '.anonymous.)
debug-name)
+ (when (and (not debug-name) (eq '.anonymous. source-name))
+ (setf debug-name (name-lambdalike thing)))
(ecase (car thing)
((lambda)
(ir1-convert-lambda thing
+ :maybe-add-debug-catch t
:source-name source-name
:debug-name debug-name))
((instance-lambda)
((named-lambda)
(let ((name (cadr thing))
(lambda-expression `(lambda ,@(cddr thing))))
- (if (legal-fun-name-p name)
+ (if (and name (legal-fun-name-p name))
(let ((defined-fun-res (get-defined-fun name))
(res (ir1-convert-lambda lambda-expression
+ :maybe-add-debug-catch t
:source-name name)))
(assert-global-function-definition-type name res)
(setf (defined-fun-functional defined-fun-res) res)
(policy ref (> recognize-self-calls 0)))
res defined-fun-res))
res)
- (ir1-convert-lambda lambda-expression :debug-name name))))
+ (ir1-convert-lambda lambda-expression
+ :maybe-add-debug-catch t
+ :debug-name
+ (or name (name-lambdalike thing))))))
((lambda-with-lexenv)
(ir1-convert-inline-lambda thing
:source-name source-name
;;; current compilation policy. Note that FUN may be a
;;; LAMBDA-WITH-LEXENV, so we may have to augment the environment to
;;; reflect the state at the definition site.
-(defun ir1-convert-inline-lambda (fun &key
- (source-name '.anonymous.)
- debug-name)
+(defun ir1-convert-inline-lambda (fun
+ &key
+ (source-name '.anonymous.)
+ debug-name
+ system-lambda)
+ (when (and (not debug-name) (eq '.anonymous. source-name))
+ (setf debug-name (name-lambdalike fun)))
(destructuring-bind (decls macros symbol-macros &rest body)
- (if (eq (car fun) 'lambda-with-lexenv)
- (cdr fun)
- `(() () () . ,(cdr fun)))
- (let ((*lexenv* (make-lexenv
- :default (process-decls decls nil nil
- :lexenv (make-null-lexenv))
- :vars (copy-list symbol-macros)
- :funs (mapcar (lambda (x)
- `(,(car x) .
- (macro . ,(coerce (cdr x) 'function))))
- macros)
- :policy (lexenv-policy *lexenv*))))
- (ir1-convert-lambda `(lambda ,@body)
- :source-name source-name
- :debug-name debug-name))))
+ (if (eq (car fun) 'lambda-with-lexenv)
+ (cdr fun)
+ `(() () () . ,(cdr fun)))
+ (let* ((*lexenv* (make-lexenv
+ :default (process-decls decls nil nil
+ :lexenv (make-null-lexenv))
+ :vars (copy-list symbol-macros)
+ :funs (mapcar (lambda (x)
+ `(,(car x) .
+ (macro . ,(coerce (cdr x) 'function))))
+ macros)
+ ;; Inherit MUFFLE-CONDITIONS from the call-site lexenv
+ ;; rather than the definition-site lexenv, since it seems
+ ;; like a much more common case.
+ :handled-conditions (lexenv-handled-conditions *lexenv*)
+ :policy (lexenv-policy *lexenv*)))
+ (*allow-instrumenting* (and (not system-lambda)
+ *allow-instrumenting*))
+ (clambda (ir1-convert-lambda `(lambda ,@body)
+ :source-name source-name
+ :debug-name debug-name)))
+ (setf (functional-inline-expanded clambda) t)
+ clambda)))
;;; 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 declaration"
"previous definition"))))
-;;; Convert a lambda doing all the basic stuff we would do if we were
-;;; converting a DEFUN. In the old CMU CL system, this was used both
-;;; by the %DEFUN translator and for global inline expansion, but
-;;; since sbcl-0.pre7.something %DEFUN does things differently.
-;;; FIXME: And now it's probably worth rethinking whether this
-;;; function is a good idea.
-;;;
-;;; Unless a :INLINE function, we temporarily clobber the inline
-;;; expansion. This prevents recursive inline expansion of
-;;; opportunistic pseudo-inlines.
-(defun ir1-convert-lambda-for-defun (lambda var expansion converter)
- (declare (cons lambda) (function converter) (type defined-fun var))
- (let ((var-expansion (defined-fun-inline-expansion var)))
- (unless (eq (defined-fun-inlinep var) :inline)
- (setf (defined-fun-inline-expansion var) nil))
- (let* ((name (leaf-source-name var))
- (fun (funcall converter lambda
- :source-name name))
- (fun-info (info :function :info name)))
- (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.
- (unless (or (eq (defined-fun-inlinep var) :notinline)
- (not *block-compile*)
- (and fun-info
- (or (fun-info-transforms fun-info)
- (fun-info-templates fun-info)
- (fun-info-ir2-convert fun-info))))
- (substitute-leaf fun var)
- ;; If in a simple environment, then we can allow backward
- ;; references to this function from following top level forms.
- (when expansion (setf (defined-fun-functional var) fun)))
- fun)))
+;;; Used for global inline expansion. Earlier something like this was
+;;; used by %DEFUN too. FIXME: And now it's probably worth rethinking
+;;; whether this function is a good idea at all.
+(defun ir1-convert-inline-expansion (name expansion var inlinep info)
+ ;; Unless a :INLINE function, we temporarily clobber the inline
+ ;; expansion. This prevents recursive inline expansion of
+ ;; opportunistic pseudo-inlines.
+ (unless (eq inlinep :inline)
+ (setf (defined-fun-inline-expansion var) nil))
+ (let ((fun (ir1-convert-inline-lambda expansion
+ :source-name name
+ ;; prevent instrumentation of
+ ;; known function expansions
+ :system-lambda (and info t))))
+ (setf (functional-inlinep fun) inlinep)
+ (assert-new-definition var fun)
+ (setf (defined-fun-inline-expansion var) expansion)
+ ;; substitute for any old references
+ (unless (or (not *block-compile*)
+ (and info
+ (or (fun-info-transforms info)
+ (fun-info-templates info)
+ (fun-info-ir2-convert info))))
+ (substitute-leaf fun var))
+ fun))
;;; the even-at-compile-time part of DEFUN
;;;
projects / sbcl.git / blobdiff