1 ;;;; miscellaneous types and macros used in writing the compiler
3 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
14 (declaim (special *wild-type* *universal-type* *compiler-error-context*))
16 ;;; An INLINEP value describes how a function is called. The values
17 ;;; have these meanings:
18 ;;; NIL No declaration seen: do whatever you feel like, but don't
19 ;;; dump an inline expansion.
20 ;;; :NOTINLINE NOTINLINE declaration seen: always do full function call.
21 ;;; :INLINE INLINE declaration seen: save expansion, expanding to it
24 ;;; Retain expansion, but only use it opportunistically.
25 (deftype inlinep () '(member :inline :maybe-inline :notinline nil))
27 ;;;; source-hacking defining forms
29 ;;; to be passed to PARSE-DEFMACRO when we want compiler errors
30 ;;; instead of real errors
31 #!-sb-fluid (declaim (inline convert-condition-into-compiler-error))
32 (defun convert-condition-into-compiler-error (datum &rest stuff)
34 (apply #'compiler-error datum stuff)
37 (apply #'make-condition datum stuff)
40 ;;; Parse a DEFMACRO-style lambda-list, setting things up so that a
41 ;;; compiler error happens if the syntax is invalid.
43 ;;; Define a function that converts a special form or other magical
44 ;;; thing into IR1. LAMBDA-LIST is a defmacro style lambda
45 ;;; list. START-VAR, NEXT-VAR and RESULT-VAR are bound to the start and
46 ;;; result continuations for the resulting IR1. KIND is the function
47 ;;; kind to associate with NAME.
48 (defmacro def-ir1-translator (name (lambda-list start-var next-var result-var)
50 (let ((fn-name (symbolicate "IR1-CONVERT-" name))
53 (multiple-value-bind (body decls doc)
54 (parse-defmacro lambda-list n-form body name "special form"
56 :error-fun 'convert-condition-into-compiler-error
59 (declaim (ftype (function (ctran ctran (or lvar null) t) (values))
61 (defun ,fn-name (,start-var ,next-var ,result-var ,n-form)
62 (let ((,n-env *lexenv*))
67 `((setf (fdocumentation ',name 'function) ,doc)))
68 ;; FIXME: Evidently "there can only be one!" -- we overwrite any
69 ;; other :IR1-CONVERT value. This deserves a warning, I think.
70 (setf (info :function :ir1-convert ',name) #',fn-name)
71 ;; FIXME: rename this to SPECIAL-OPERATOR, to update it to
73 (setf (info :function :kind ',name) :special-form)
74 ;; It's nice to do this for error checking in the target
75 ;; SBCL, but it's not nice to do this when we're running in
76 ;; the cross-compilation host Lisp, which owns the
77 ;; SYMBOL-FUNCTION of its COMMON-LISP symbols.
79 (let ((fun (lambda (&rest rest)
80 (declare (ignore rest))
81 (error 'special-form-function :name ',name))))
82 (setf (%simple-fun-arglist fun) ',lambda-list)
83 (setf (symbol-function ',name) fun))
86 ;;; (This is similar to DEF-IR1-TRANSLATOR, except that we pass if the
87 ;;; syntax is invalid.)
89 ;;; Define a macro-like source-to-source transformation for the
90 ;;; function NAME. A source transform may "pass" by returning a
91 ;;; non-nil second value. If the transform passes, then the form is
92 ;;; converted as a normal function call. If the supplied arguments are
93 ;;; not compatible with the specified LAMBDA-LIST, then the transform
94 ;;; automatically passes.
96 ;;; Source transforms may only be defined for functions. Source
97 ;;; transformation is not attempted if the function is declared
98 ;;; NOTINLINE. Source transforms should not examine their arguments.
99 ;;; If it matters how the function is used, then DEFTRANSFORM should
100 ;;; be used to define an IR1 transformation.
102 ;;; If the desirability of the transformation depends on the current
103 ;;; OPTIMIZE parameters, then the POLICY macro should be used to
104 ;;; determine when to pass.
105 (defmacro source-transform-lambda (lambda-list &body body)
106 (let ((n-form (gensym))
109 (multiple-value-bind (body decls)
110 (parse-defmacro lambda-list n-form body "source transform" "form"
112 :error-fun `(lambda (&rest stuff)
113 (declare (ignore stuff))
117 `(lambda (,n-form &aux (,n-env *lexenv*))
121 (defmacro define-source-transform (name lambda-list &body body)
122 `(setf (info :function :source-transform ',name)
123 (source-transform-lambda ,lambda-list ,@body)))
125 ;;;; boolean attribute utilities
127 ;;;; We need to maintain various sets of boolean attributes for known
128 ;;;; functions and VOPs. To save space and allow for quick set
129 ;;;; operations, we represent the attributes as bits in a fixnum.
131 (deftype attributes () 'fixnum)
133 (eval-when (#-sb-xc :compile-toplevel :load-toplevel :execute)
135 ;;; Given a list of attribute names and an alist that translates them
136 ;;; to masks, return the OR of the masks.
137 (defun compute-attribute-mask (names alist)
138 (collect ((res 0 logior))
140 (let ((mask (cdr (assoc name alist))))
142 (error "unknown attribute name: ~S" name))
148 ;;; Define a new class of boolean attributes, with the attributes
149 ;;; having the specified ATTRIBUTE-NAMES. NAME is the name of the
150 ;;; class, which is used to generate some macros to manipulate sets of
153 ;;; NAME-attributep attributes attribute-name*
154 ;;; Return true if one of the named attributes is present, false
155 ;;; otherwise. When set with SETF, updates the place Attributes
156 ;;; setting or clearing the specified attributes.
158 ;;; NAME-attributes attribute-name*
159 ;;; Return a set of the named attributes.
162 (def!macro !def-boolean-attribute (name &rest attribute-names)
164 (let ((translations-name (symbolicate "*" name "-ATTRIBUTE-TRANSLATIONS*"))
165 (test-name (symbolicate name "-ATTRIBUTEP"))
166 (decoder-name (symbolicate "DECODE-" name "-ATTRIBUTES")))
168 (do ((mask 1 (ash mask 1))
169 (names attribute-names (cdr names)))
171 (alist (cons (car names) mask)))
173 (eval-when (:compile-toplevel :load-toplevel :execute)
174 (defparameter ,translations-name ',(alist)))
175 (defmacro ,(symbolicate name "-ATTRIBUTES") (&rest attribute-names)
176 "Automagically generated boolean attribute creation function.
177 See !DEF-BOOLEAN-ATTRIBUTE."
178 (compute-attribute-mask attribute-names ,translations-name))
179 (defmacro ,test-name (attributes &rest attribute-names)
180 "Automagically generated boolean attribute test function.
181 See !DEF-BOOLEAN-ATTRIBUTE."
182 `(logtest ,(compute-attribute-mask attribute-names
184 (the attributes ,attributes)))
185 ;; This definition transforms strangely under UNCROSS, in a
186 ;; way that DEF!MACRO doesn't understand, so we delegate it
187 ;; to a submacro then define the submacro differently when
188 ;; building the xc and when building the target compiler.
189 (!def-boolean-attribute-setter ,test-name
192 (defun ,decoder-name (attributes)
193 (loop for (name . mask) in ,translations-name
194 when (logtest mask attributes)
197 ;; It seems to be difficult to express in DEF!MACRO machinery what
198 ;; to do with target-vs-host GET-SETF-EXPANSION in here, so we just
199 ;; hack it by hand, passing a different GET-SETF-EXPANSION-FUN-NAME
200 ;; in the host DEFMACRO and target DEFMACRO-MUNDANELY cases.
201 (defun guts-of-!def-boolean-attribute-setter (test-name
204 get-setf-expansion-fun-name)
205 `(define-setf-expander ,test-name (place &rest attributes
207 "Automagically generated boolean attribute setter. See
208 !DEF-BOOLEAN-ATTRIBUTE."
209 #-sb-xc-host (declare (type sb!c::lexenv env))
210 ;; FIXME: It would be better if &ENVIRONMENT arguments were
211 ;; automatically declared to have type LEXENV by the
212 ;; hairy-argument-handling code.
213 (multiple-value-bind (temps values stores set get)
214 (,get-setf-expansion-fun-name place env)
216 (error "multiple store variables for ~S" place))
217 (let ((newval (gensym))
219 (mask (compute-attribute-mask attributes ,translations-name)))
220 (values `(,@temps ,n-place)
223 `(let ((,(first stores)
225 (logior ,n-place ,mask)
226 (logand ,n-place ,(lognot mask)))))
229 `(,',test-name ,n-place ,@attributes))))))
230 ;; We define the host version here, and the just-like-it-but-different
231 ;; target version later, after DEFMACRO-MUNDANELY has been defined.
232 (defmacro !def-boolean-attribute-setter (test-name
234 &rest attribute-names)
235 (guts-of-!def-boolean-attribute-setter test-name
238 'get-setf-expansion)))
240 ;;; And now for some gratuitous pseudo-abstraction...
243 ;;; Return the union of all the sets of boolean attributes which are its
245 ;;; ATTRIBUTES-INTERSECTION
246 ;;; Return the intersection of all the sets of boolean attributes which
247 ;;; are its arguments.
249 ;;; True if the attributes present in ATTR1 are identical to
251 (defmacro attributes-union (&rest attributes)
253 (logior ,@(mapcar (lambda (x) `(the attributes ,x)) attributes))))
254 (defmacro attributes-intersection (&rest attributes)
256 (logand ,@(mapcar (lambda (x) `(the attributes ,x)) attributes))))
257 (declaim (ftype (function (attributes attributes) boolean) attributes=))
258 #!-sb-fluid (declaim (inline attributes=))
259 (defun attributes= (attr1 attr2)
262 ;;;; lambda-list parsing utilities
264 ;;;; IR1 transforms, optimizers and type inferencers need to be able
265 ;;;; to parse the IR1 representation of a function call using a
266 ;;;; standard function lambda-list.
268 (eval-when (#-sb-xc :compile-toplevel :load-toplevel :execute)
270 ;;; Given a DEFTRANSFORM-style lambda-list, generate code that parses
271 ;;; the arguments of a combination with respect to that
272 ;;; lambda-list. BODY is the the list of forms which are to be
273 ;;; evaluated within the bindings. ARGS is the variable that holds
274 ;;; list of argument lvars. ERROR-FORM is a form which is evaluated
275 ;;; when the syntax of the supplied arguments is incorrect or a
276 ;;; non-constant argument keyword is supplied. Defaults and other gunk
277 ;;; are ignored. The second value is a list of all the arguments
278 ;;; bound. We make the variables IGNORABLE so that we don't have to
279 ;;; manually declare them Ignore if their only purpose is to make the
281 (defun parse-deftransform (lambda-list body args error-form)
282 (multiple-value-bind (req opt restp rest keyp keys allowp)
283 (parse-lambda-list lambda-list)
284 (let* ((min-args (length req))
285 (max-args (+ min-args (length opt)))
293 (binds `(,arg (nth ,(pos) ,args)))
297 (let ((var (if (atom arg) arg (first arg))))
299 (binds `(,var (nth ,(pos) ,args)))
304 (binds `(,rest (nthcdr ,(pos) ,args))))
307 (if (or (atom spec) (atom (first spec)))
308 (let* ((var (if (atom spec) spec (first spec)))
309 (key (keywordicate var)))
311 (binds `(,var (find-keyword-lvar ,n-keys ,key)))
313 (let* ((head (first spec))
317 (binds `(,var (find-keyword-lvar ,n-keys ,key)))
320 (let ((n-length (gensym))
321 (limited-legal (not (or restp keyp))))
323 `(let ((,n-length (length ,args))
324 ,@(when keyp `((,n-keys (nthcdr ,(pos) ,args)))))
326 ;; FIXME: should be PROPER-LIST-OF-LENGTH-P
328 `(<= ,min-args ,n-length ,max-args)
329 `(<= ,min-args ,n-length))
332 `((check-key-args-constant ,n-keys))
333 `((check-transform-keys ,n-keys ',(keywords))))))
336 (declare (ignorable ,@(vars)))
344 ;;; Define an IR1 transformation for NAME. An IR1 transformation
345 ;;; computes a lambda that replaces the function variable reference
346 ;;; for the call. A transform may pass (decide not to transform the
347 ;;; call) by calling the GIVE-UP-IR1-TRANSFORM function. LAMBDA-LIST
348 ;;; both determines how the current call is parsed and specifies the
349 ;;; LAMBDA-LIST for the resulting lambda.
351 ;;; We parse the call and bind each of the lambda-list variables to
352 ;;; the lvar which represents the value of the argument. When parsing
353 ;;; the call, we ignore the defaults, and always bind the variables
354 ;;; for unsupplied arguments to NIL. If a required argument is
355 ;;; missing, an unknown keyword is supplied, or an argument keyword is
356 ;;; not a constant, then the transform automatically passes. The
357 ;;; DECLARATIONS apply to the bindings made by DEFTRANSFORM at
358 ;;; transformation time, rather than to the variables of the resulting
359 ;;; lambda. Bound-but-not-referenced warnings are suppressed for the
360 ;;; lambda-list variables. The DOC-STRING is used when printing
361 ;;; efficiency notes about the defined transform.
363 ;;; Normally, the body evaluates to a form which becomes the body of
364 ;;; an automatically constructed lambda. We make LAMBDA-LIST the
365 ;;; lambda-list for the lambda, and automatically insert declarations
366 ;;; of the argument and result types. If the second value of the body
367 ;;; is non-null, then it is a list of declarations which are to be
368 ;;; inserted at the head of the lambda. Automatic lambda generation
369 ;;; may be inhibited by explicitly returning a lambda from the body.
371 ;;; The ARG-TYPES and RESULT-TYPE are used to create a function type
372 ;;; which the call must satisfy before transformation is attempted.
373 ;;; The function type specifier is constructed by wrapping (FUNCTION
374 ;;; ...) around these values, so the lack of a restriction may be
375 ;;; specified by omitting the argument or supplying *. The argument
376 ;;; syntax specified in the ARG-TYPES need not be the same as that in
377 ;;; the LAMBDA-LIST, but the transform will never happen if the
378 ;;; syntaxes can't be satisfied simultaneously. If there is an
379 ;;; existing transform for the same function that has the same type,
380 ;;; then it is replaced with the new definition.
382 ;;; These are the legal keyword options:
383 ;;; :RESULT - A variable which is bound to the result lvar.
384 ;;; :NODE - A variable which is bound to the combination node for the call.
385 ;;; :POLICY - A form which is supplied to the POLICY macro to determine
386 ;;; whether this transformation is appropriate. If the result
387 ;;; is false, then the transform automatically gives up.
389 ;;; - The name and argument/result types are actually forms to be
390 ;;; evaluated. Useful for getting closures that transform similar
393 ;;; - Don't actually instantiate a transform, instead just DEFUN
394 ;;; Name with the specified transform definition function. This
395 ;;; may be later instantiated with %DEFTRANSFORM.
397 ;;; - If supplied and non-NIL, note this transform as ``important,''
398 ;;; which means efficiency notes will be generated when this
399 ;;; transform fails even if INHIBIT-WARNINGS=SPEED (but not if
400 ;;; INHIBIT-WARNINGS>SPEED).
401 (defmacro deftransform (name (lambda-list &optional (arg-types '*)
403 &key result policy node defun-only
405 &body body-decls-doc)
406 (when (and eval-name defun-only)
407 (error "can't specify both DEFUN-ONLY and EVAL-NAME"))
408 (multiple-value-bind (body decls doc) (parse-body body-decls-doc)
409 (let ((n-args (gensym))
410 (n-node (or node (gensym)))
413 (decls-body `(,@decls ,@body)))
414 (multiple-value-bind (parsed-form vars)
415 (parse-deftransform lambda-list
417 `((unless (policy ,n-node ,policy)
418 (give-up-ir1-transform))
422 '(give-up-ir1-transform))
425 (let* ((,n-args (basic-combination-args ,n-node))
427 `((,result (node-lvar ,n-node)))))
428 (multiple-value-bind (,n-lambda ,n-decls)
430 (if (and (consp ,n-lambda) (eq (car ,n-lambda) 'lambda))
432 `(lambda ,',lambda-list
433 (declare (ignorable ,@',vars))
437 `(defun ,name ,@(when doc `(,doc)) ,@stuff)
439 ,(if eval-name name `',name)
441 ``(function ,,arg-types ,,result-type)
442 `'(function ,arg-types ,result-type))
445 ,(if important t nil))))))))
447 ;;;; DEFKNOWN and DEFOPTIMIZER
449 ;;; This macro should be the way that all implementation independent
450 ;;; information about functions is made known to the compiler.
452 ;;; FIXME: The comment above suggests that perhaps some of my added
453 ;;; FTYPE declarations are in poor taste. Should I change my
454 ;;; declarations, or change the comment, or what?
456 ;;; FIXME: DEFKNOWN is needed only at build-the-system time. Figure
457 ;;; out some way to keep it from appearing in the target system.
459 ;;; Declare the function NAME to be a known function. We construct a
460 ;;; type specifier for the function by wrapping (FUNCTION ...) around
461 ;;; the ARG-TYPES and RESULT-TYPE. ATTRIBUTES is an unevaluated list
462 ;;; of boolean attributes of the function. See their description in
463 ;;; (!DEF-BOOLEAN-ATTRIBUTE IR1). NAME may also be a list of names, in
464 ;;; which case the same information is given to all the names. The
465 ;;; keywords specify the initial values for various optimizers that
466 ;;; the function might have.
467 (defmacro defknown (name arg-types result-type &optional (attributes '(any))
469 (when (and (intersection attributes '(any call unwind))
470 (intersection attributes '(movable)))
471 (error "function cannot have both good and bad attributes: ~S" attributes))
473 (when (member 'any attributes)
474 (setq attributes (union '(call unsafe unwind) attributes)))
475 (when (member 'flushable attributes)
476 (pushnew 'unsafely-flushable attributes))
478 `(%defknown ',(if (and (consp name)
479 (not (legal-fun-name-p name)))
482 '(sfunction ,arg-types ,result-type)
483 (ir1-attributes ,@attributes)
486 ;;; Create a function which parses combination args according to WHAT
487 ;;; and LAMBDA-LIST, where WHAT is either a function name or a list
488 ;;; (FUN-NAME KIND) and does some KIND of optimization.
490 ;;; The FUN-NAME must name a known function. LAMBDA-LIST is used
491 ;;; to parse the arguments to the combination as in DEFTRANSFORM. If
492 ;;; the argument syntax is invalid or there are non-constant keys,
493 ;;; then we simply return NIL.
495 ;;; The function is DEFUN'ed as FUNCTION-KIND-OPTIMIZER. Possible
496 ;;; kinds are DERIVE-TYPE, OPTIMIZER, LTN-ANNOTATE and IR2-CONVERT. If
497 ;;; a symbol is specified instead of a (FUNCTION KIND) list, then we
498 ;;; just do a DEFUN with the symbol as its name, and don't do anything
499 ;;; with the definition. This is useful for creating optimizers to be
500 ;;; passed by name to DEFKNOWN.
502 ;;; If supplied, NODE-VAR is bound to the combination node being
503 ;;; optimized. If additional VARS are supplied, then they are used as
504 ;;; the rest of the optimizer function's lambda-list. LTN-ANNOTATE
505 ;;; methods are passed an additional POLICY argument, and IR2-CONVERT
506 ;;; methods are passed an additional IR2-BLOCK argument.
507 (defmacro defoptimizer (what (lambda-list &optional (n-node (gensym))
510 (let ((name (if (symbolp what) what
511 (symbolicate (first what) "-" (second what) "-OPTIMIZER"))))
513 (let ((n-args (gensym)))
515 (defun ,name (,n-node ,@vars)
516 (let ((,n-args (basic-combination-args ,n-node)))
517 ,(parse-deftransform lambda-list body n-args
518 `(return-from ,name nil))))
520 `((setf (,(symbolicate "FUN-INFO-" (second what))
521 (fun-info-or-lose ',(first what)))
524 ;;;; IR groveling macros
526 ;;; Iterate over the blocks in a component, binding BLOCK-VAR to each
527 ;;; block in turn. The value of ENDS determines whether to iterate
528 ;;; over dummy head and tail blocks:
529 ;;; NIL -- Skip Head and Tail (the default)
530 ;;; :HEAD -- Do head but skip tail
531 ;;; :TAIL -- Do tail but skip head
532 ;;; :BOTH -- Do both head and tail
534 ;;; If supplied, RESULT-FORM is the value to return.
535 (defmacro do-blocks ((block-var component &optional ends result) &body body)
536 (unless (member ends '(nil :head :tail :both))
537 (error "losing ENDS value: ~S" ends))
538 (let ((n-component (gensym))
540 `(let* ((,n-component ,component)
541 (,n-tail ,(if (member ends '(:both :tail))
543 `(component-tail ,n-component))))
544 (do ((,block-var ,(if (member ends '(:both :head))
545 `(component-head ,n-component)
546 `(block-next (component-head ,n-component)))
547 (block-next ,block-var)))
548 ((eq ,block-var ,n-tail) ,result)
550 ;;; like DO-BLOCKS, only iterating over the blocks in reverse order
551 (defmacro do-blocks-backwards ((block-var component &optional ends result) &body body)
552 (unless (member ends '(nil :head :tail :both))
553 (error "losing ENDS value: ~S" ends))
554 (let ((n-component (gensym))
556 `(let* ((,n-component ,component)
557 (,n-head ,(if (member ends '(:both :head))
559 `(component-head ,n-component))))
560 (do ((,block-var ,(if (member ends '(:both :tail))
561 `(component-tail ,n-component)
562 `(block-prev (component-tail ,n-component)))
563 (block-prev ,block-var)))
564 ((eq ,block-var ,n-head) ,result)
567 ;;; Iterate over the uses of LVAR, binding NODE to each one
570 ;;; XXX Could change it not to replicate the code someday perhaps...
571 (defmacro do-uses ((node-var lvar &optional result) &body body)
572 (with-unique-names (uses)
573 `(let ((,uses (lvar-uses ,lvar)))
575 (dolist (,node-var ,uses ,result)
578 (let ((,node-var ,uses))
581 ;;; Iterate over the nodes in BLOCK, binding NODE-VAR to the each node
582 ;;; and LVAR-VAR to the node's LVAR. The only keyword option is
583 ;;; RESTART-P, which causes iteration to be restarted when a node is
584 ;;; deleted out from under us. (If not supplied, this is an error.)
586 ;;; In the forward case, we terminate when NODE does not have NEXT, so
587 ;;; that we do not have to worry about our termination condition being
588 ;;; changed when new code is added during the iteration. In the
589 ;;; backward case, we do NODE-PREV before evaluating the body so that
590 ;;; we can keep going when the current node is deleted.
592 ;;; When RESTART-P is supplied to DO-NODES, we start iterating over
593 ;;; again at the beginning of the block when we run into a ctran whose
594 ;;; block differs from the one we are trying to iterate over, either
595 ;;; because the block was split, or because a node was deleted out
596 ;;; from under us (hence its block is NIL.) If the block start is
597 ;;; deleted, we just punt. With RESTART-P, we are also more careful
598 ;;; about termination, re-indirecting the BLOCK-LAST each time.
599 (defmacro do-nodes ((node-var lvar-var block &key restart-p)
601 (with-unique-names (n-block n-start)
602 `(do* ((,n-block ,block)
603 (,n-start (block-start ,n-block))
605 (,node-var (ctran-next ,n-start)
607 `(let ((next (node-next ,node-var)))
611 ((eq (ctran-block next) ,n-block)
614 (let ((start (block-start ,n-block)))
615 (unless (eq (ctran-kind start)
618 (ctran-next start)))))
619 `(acond ((node-next ,node-var)
623 `((,lvar-var (when (valued-node-p ,node-var)
624 (node-lvar ,node-var))
625 (when (valued-node-p ,node-var)
626 (node-lvar ,node-var))))))
630 `((when (block-delete-p ,n-block)
633 ;;; Like DO-NODES, only iterating in reverse order. Should be careful
634 ;;; with block being split under us.
635 (defmacro do-nodes-backwards ((node-var lvar block &key restart-p) &body body)
636 (let ((n-block (gensym))
638 `(loop with ,n-block = ,block
639 for ,node-var = (block-last ,n-block) then
641 `(if (eq ,n-block (ctran-block ,n-prev))
643 (block-last ,n-block))
644 `(ctran-use ,n-prev))
645 for ,n-prev = (when ,node-var (node-prev ,node-var))
646 and ,lvar = (when (and ,node-var (valued-node-p ,node-var))
647 (node-lvar ,node-var))
649 `(and ,node-var (not (block-to-be-deleted-p ,n-block)))
654 (defmacro do-nodes-carefully ((node-var block) &body body)
655 (with-unique-names (n-block n-ctran)
656 `(loop with ,n-block = ,block
657 for ,n-ctran = (block-start ,n-block) then (node-next ,node-var)
658 for ,node-var = (and ,n-ctran (ctran-next ,n-ctran))
662 ;;; Bind the IR1 context variables to the values associated with NODE,
663 ;;; so that new, extra IR1 conversion related to NODE can be done
664 ;;; after the original conversion pass has finished.
665 (defmacro with-ir1-environment-from-node (node &rest forms)
666 `(flet ((closure-needing-ir1-environment-from-node ()
668 (%with-ir1-environment-from-node
670 #'closure-needing-ir1-environment-from-node)))
671 (defun %with-ir1-environment-from-node (node fun)
672 (declare (type node node) (type function fun))
673 (let ((*current-component* (node-component node))
674 (*lexenv* (node-lexenv node))
675 (*current-path* (node-source-path node)))
676 (aver-live-component *current-component*)
679 ;;; Bind the hashtables used for keeping track of global variables,
680 ;;; functions, etc. Also establish condition handlers.
681 (defmacro with-ir1-namespace (&body forms)
682 `(let ((*free-vars* (make-hash-table :test 'eq))
683 (*free-funs* (make-hash-table :test 'equal))
684 (*constants* (make-hash-table :test 'equal))
685 (*source-paths* (make-hash-table :test 'eq)))
686 (handler-bind ((compiler-error #'compiler-error-handler)
687 (style-warning #'compiler-style-warning-handler)
688 (warning #'compiler-warning-handler))
691 ;;; Look up NAME in the lexical environment namespace designated by
692 ;;; SLOT, returning the <value, T>, or <NIL, NIL> if no entry. The
693 ;;; :TEST keyword may be used to determine the name equality
695 (defmacro lexenv-find (name slot &key test)
696 (once-only ((n-res `(assoc ,name (,(let ((*package* (symbol-package 'lexenv-funs)))
697 (symbolicate "LEXENV-" slot))
699 :test ,(or test '#'eq))))
701 (values (cdr ,n-res) t)
704 (defmacro with-component-last-block ((component block) &body body)
705 (with-unique-names (old-last-block)
706 (once-only ((component component)
708 `(let ((,old-last-block (component-last-block ,component)))
710 (progn (setf (component-last-block ,component)
713 (setf (component-last-block ,component)
714 ,old-last-block))))))
717 ;;;; the EVENT statistics/trace utility
719 ;;; FIXME: This seems to be useful for troubleshooting and
720 ;;; experimentation, not for ordinary use, so it should probably
721 ;;; become conditional on SB-SHOW.
723 (eval-when (#-sb-xc :compile-toplevel :load-toplevel :execute)
725 (defstruct (event-info (:copier nil))
726 ;; The name of this event.
727 (name (missing-arg) :type symbol)
728 ;; The string rescribing this event.
729 (description (missing-arg) :type string)
730 ;; The name of the variable we stash this in.
731 (var (missing-arg) :type symbol)
732 ;; The number of times this event has happened.
733 (count 0 :type fixnum)
734 ;; The level of significance of this event.
735 (level (missing-arg) :type unsigned-byte)
736 ;; If true, a function that gets called with the node that the event
738 (action nil :type (or function null)))
740 ;;; A hashtable from event names to event-info structures.
741 (defvar *event-info* (make-hash-table :test 'eq))
743 ;;; Return the event info for Name or die trying.
744 (declaim (ftype (function (t) event-info) event-info-or-lose))
745 (defun event-info-or-lose (name)
746 (let ((res (gethash name *event-info*)))
748 (error "~S is not the name of an event." name))
753 ;;; Return the number of times that EVENT has happened.
754 (declaim (ftype (function (symbol) fixnum) event-count))
755 (defun event-count (name)
756 (event-info-count (event-info-or-lose name)))
758 ;;; Return the function that is called when Event happens. If this is
759 ;;; null, there is no action. The function is passed the node to which
760 ;;; the event happened, or NIL if there is no relevant node. This may
761 ;;; be set with SETF.
762 (declaim (ftype (function (symbol) (or function null)) event-action))
763 (defun event-action (name)
764 (event-info-action (event-info-or-lose name)))
765 (declaim (ftype (function (symbol (or function null)) (or function null))
767 (defun %set-event-action (name new-value)
768 (setf (event-info-action (event-info-or-lose name))
770 (defsetf event-action %set-event-action)
772 ;;; Return the non-negative integer which represents the level of
773 ;;; significance of the event Name. This is used to determine whether
774 ;;; to print a message when the event happens. This may be set with
776 (declaim (ftype (function (symbol) unsigned-byte) event-level))
777 (defun event-level (name)
778 (event-info-level (event-info-or-lose name)))
779 (declaim (ftype (function (symbol unsigned-byte) unsigned-byte) %set-event-level))
780 (defun %set-event-level (name new-value)
781 (setf (event-info-level (event-info-or-lose name))
783 (defsetf event-level %set-event-level)
785 ;;; Define a new kind of event. NAME is a symbol which names the event
786 ;;; and DESCRIPTION is a string which describes the event. Level
787 ;;; (default 0) is the level of significance associated with this
788 ;;; event; it is used to determine whether to print a Note when the
790 (defmacro defevent (name description &optional (level 0))
791 (let ((var-name (symbolicate "*" name "-EVENT-INFO*")))
792 `(eval-when (:compile-toplevel :load-toplevel :execute)
794 (make-event-info :name ',name
795 :description ',description
798 (setf (gethash ',name *event-info*) ,var-name)
801 ;;; the lowest level of event that will print a note when it occurs
802 (declaim (type unsigned-byte *event-note-threshold*))
803 (defvar *event-note-threshold* 1)
805 ;;; Note that the event with the specified NAME has happened. NODE is
806 ;;; evaluated to determine the node to which the event happened.
807 (defmacro event (name &optional node)
808 ;; Increment the counter and do any action. Mumble about the event if
810 `(%event ,(event-info-var (event-info-or-lose name)) ,node))
812 ;;; Print a listing of events and their counts, sorted by the count.
813 ;;; Events that happened fewer than Min-Count times will not be
814 ;;; printed. Stream is the stream to write to.
815 (declaim (ftype (function (&optional unsigned-byte stream) (values)) event-statistics))
816 (defun event-statistics (&optional (min-count 1) (stream *standard-output*))
818 (maphash (lambda (k v)
820 (when (>= (event-info-count v) min-count)
823 (dolist (event (sort (info) #'> :key #'event-info-count))
824 (format stream "~6D: ~A~%" (event-info-count event)
825 (event-info-description event)))
829 (declaim (ftype (function nil (values)) clear-event-statistics))
830 (defun clear-event-statistics ()
831 (maphash (lambda (k v)
833 (setf (event-info-count v) 0))
837 ;;;; functions on directly-linked lists (linked through specialized
838 ;;;; NEXT operations)
840 #!-sb-fluid (declaim (inline find-in position-in))
842 ;;; Find ELEMENT in a null-terminated LIST linked by the accessor
843 ;;; function NEXT. KEY, TEST and TEST-NOT are the same as for generic
844 ;;; sequence functions.
851 (test-not #'eql not-p))
852 (declare (type function next key test test-not))
853 (when (and test-p not-p)
854 (error "It's silly to supply both :TEST and :TEST-NOT arguments."))
856 (do ((current list (funcall next current)))
858 (unless (funcall test-not (funcall key current) element)
860 (do ((current list (funcall next current)))
862 (when (funcall test (funcall key current) element)
865 ;;; Return the position of ELEMENT (or NIL if absent) in a
866 ;;; null-terminated LIST linked by the accessor function NEXT. KEY,
867 ;;; TEST and TEST-NOT are the same as for generic sequence functions.
868 (defun position-in (next
874 (test-not #'eql not-p))
875 (declare (type function next key test test-not))
876 (when (and test-p not-p)
877 (error "It's silly to supply both :TEST and :TEST-NOT arguments."))
879 (do ((current list (funcall next current))
882 (unless (funcall test-not (funcall key current) element)
884 (do ((current list (funcall next current))
887 (when (funcall test (funcall key current) element)
891 ;;; KLUDGE: This is expanded out twice, by cut-and-paste, in a
892 ;;; (DEF!MACRO FOO (..) .. CL:GET-SETF-EXPANSION ..)
894 ;;; (SB!XC:DEFMACRO FOO (..) .. SB!XC:GET-SETF-EXPANSION ..)
895 ;;; arrangement, in order to get it to work in cross-compilation. This
896 ;;; duplication should be removed, perhaps by rewriting the macro in a more
897 ;;; cross-compiler-friendly way, or perhaps just by using some (MACROLET ((FROB
898 ;;; ..)) .. FROB .. FROB) form, or perhaps by completely eliminating this macro
899 ;;; and its partner PUSH-IN, but I don't want to do it now, because the system
900 ;;; isn't running yet, so it'd be too hard to check that my changes were
901 ;;; correct -- WHN 19990806
902 (def!macro deletef-in (next place item &environment env)
903 (multiple-value-bind (temps vals stores store access)
904 (get-setf-expansion place env)
906 (error "multiple store variables for ~S" place))
907 (let ((n-item (gensym))
911 `(let* (,@(mapcar #'list temps vals)
914 (if (eq ,n-place ,n-item)
915 (let ((,(first stores) (,next ,n-place)))
917 (do ((,n-prev ,n-place ,n-current)
918 (,n-current (,next ,n-place)
920 ((eq ,n-current ,n-item)
921 (setf (,next ,n-prev)
922 (,next ,n-current)))))
924 ;;; #+SB-XC-HOST SB!XC:DEFMACRO version is in late-macros.lisp. -- WHN 19990806
926 ;;; Push ITEM onto a list linked by the accessor function NEXT that is
929 ;;; KLUDGE: This is expanded out twice, by cut-and-paste, in a
930 ;;; (DEF!MACRO FOO (..) .. CL:GET-SETF-EXPANSION ..)
932 ;;; (SB!XC:DEFMACRO FOO (..) .. SB!XC:GET-SETF-EXPANSION ..)
933 ;;; arrangement, in order to get it to work in cross-compilation. This
934 ;;; duplication should be removed, perhaps by rewriting the macro in a more
935 ;;; cross-compiler-friendly way, or perhaps just by using some (MACROLET ((FROB
936 ;;; ..)) .. FROB .. FROB) form, or perhaps by completely eliminating this macro
937 ;;; and its partner DELETEF-IN, but I don't want to do it now, because the
938 ;;; system isn't running yet, so it'd be too hard to check that my changes were
939 ;;; correct -- WHN 19990806
940 (def!macro push-in (next item place &environment env)
941 (multiple-value-bind (temps vals stores store access)
942 (get-setf-expansion place env)
944 (error "multiple store variables for ~S" place))
945 `(let (,@(mapcar #'list temps vals)
946 (,(first stores) ,item))
947 (setf (,next ,(first stores)) ,access)
950 ;;; #+SB-XC-HOST SB!XC:DEFMACRO version is in late-macros.lisp. -- WHN 19990806
952 (defmacro position-or-lose (&rest args)
953 `(or (position ,@args)
954 (error "shouldn't happen?")))