0.7.12.12:

[sbcl.git] / src / compiler / knownfun.lisp

diff --git a/src/compiler/knownfun.lisp b/src/compiler/knownfun.lisp
index c5fa533..86f4b85 100644 (file)
--- a/src/compiler/knownfun.lisp
+++ b/src/compiler/knownfun.lisp
@@ -25,7 +25,7 @@
 ;;; breakdown of side effects, since we do very little code motion on
 ;;; IR1. We are interested in some deeper semantic properties such as
 ;;; whether it is safe to pass stack closures to.
-(def-boolean-attribute ir1
+(!def-boolean-attribute ir1
   ;; may call functions that are passed as arguments. In order to
   ;; determine what other effects are present, we must find the
   ;; effects of all arguments that may be functions.
@@ -49,15 +49,26 @@
   ;; mark these functions as foldable in this database.
   foldable
   ;; may be eliminated if value is unused. The function has no side
-  ;; effects except possibly CONS. If a function is defined to signal
-  ;; errors, then it is not flushable even if it is movable or
-  ;; foldable.
+  ;; effects except possibly cons. If a function might signal errors,
+  ;; then it is not flushable even if it is movable, foldable or
+  ;; unsafely-flushable. Implies UNSAFELY-FLUSHABLE. (In safe code
+  ;; type checking of arguments is always performed by the caller, so
+  ;; a function which SHOULD signal an error if arguments are not of
+  ;; declared types may be FLUSHABLE.)
   flushable
+  ;; unsafe call may be eliminated if value is unused. The function
+  ;; has no side effects except possibly cons and signalling an error
+  ;; in the safe code. If a function MUST signal errors, then it is
+  ;; not unsafely-flushable even if it is movable or foldable.
+  unsafely-flushable
   ;; may be moved with impunity. Has no side effects except possibly
   ;; consing, and is affected only by its arguments.
   movable
   ;; The function is a true predicate likely to be open-coded. Convert
-  ;; any non-conditional uses into (IF <pred> T NIL).
+  ;; any non-conditional uses into (IF <pred> T NIL). Not usually
+  ;; specified to DEFKNOWN, since this is implementation dependent,
+  ;; and is usually automatically set by the DEFINE-VOP :CONDITIONAL
+  ;; option.
   predicate
   ;; Inhibit any warning for compiling a recursive definition.
   ;; (Normally the compiler warns when compiling a recursive
@@ -89,23 +100,20 @@
   ;; If true, a special-case LTN annotation method that is used in
   ;; place of the standard type/policy template selection. It may use
   ;; arbitrary code to choose a template, decide to do a full call, or
-  ;; conspire with the IR2-Convert method to do almost anything. The
-  ;; Combination node is passed as the argument.
+  ;; conspire with the IR2-CONVERT method to do almost anything. The
+  ;; COMBINATION node is passed as the argument.
   (ltn-annotate nil :type (or function null))
   ;; If true, the special-case IR2 conversion method for this
   ;; function. This deals with funny functions, and anything else that
   ;; can't be handled using the template mechanism. The Combination
-  ;; node and the IR2-Block are passed as arguments.
+  ;; node and the IR2-BLOCK are passed as arguments.
   (ir2-convert nil :type (or function null))
   ;; all the templates that could be used to translate this function
   ;; into IR2, sorted by increasing cost.
   (templates nil :type list)
   ;; If non-null, then this function is a unary type predicate for
   ;; this type.
-  (predicate-type nil :type (or ctype null))
-  ;; If non-null, use this function to annotate the known call for the
-  ;; byte compiler. If it returns NIL, then change the call to :full.
-  (byte-annotate nil :type (or function null)))
+  (predicate-type nil :type (or ctype null)))
 
 (defprinter (fun-info)
   (transforms :test transforms)
@@ -114,8 +122,7 @@
   (ltn-annotate :test ltn-annotate)
   (ir2-convert :test ir2-convert)
   (templates :test templates)
-  (predicate-type :test predicate-type)
-  (byte-annotate :test byte-annotate))
+  (predicate-type :test predicate-type))
 \f
 ;;;; interfaces to defining macros
 
@@ -172,8 +179,8 @@
 (defun %defknown (names type attributes &key derive-type optimizer)
   (let ((ctype (specifier-type type))
        (info (make-fun-info :attributes attributes
-                                 :derive-type derive-type
-                                 :optimizer optimizer))
+                             :derive-type derive-type
+                             :optimizer optimizer))
        (target-env *info-environment*))
     (dolist (name names)
       (let ((old-fun-info (info :function :info name)))
@@ -257,6 +264,6 @@
     (declare (type combination call))
     (let ((cont (nth (1- n) (combination-args call))))
       (when (and cont (constant-continuation-p cont))
-       (specifier-type (continuation-value cont))))))
+       (careful-specifier-type (continuation-value cont))))))
 
 (/show0 "knownfun.lisp end of file")