X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fknownfun.lisp;h=c9ec933c472f899a3bfd8a1c7da4ebc301266bb1;hb=390073eee1f9738487bf22c7fd118156899fabbe;hp=cbe6892acf9824106840f69a7d7079f1a3f690b6;hpb=83a96ea32f132597c70b314080d150235ef2944a;p=sbcl.git diff --git a/src/compiler/knownfun.lisp b/src/compiler/knownfun.lisp index cbe6892..c9ec933 100644 --- a/src/compiler/knownfun.lisp +++ b/src/compiler/knownfun.lisp @@ -25,22 +25,29 @@ ;;; 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. +;;; +;;; FIXME: This whole notion of "bad" explicit attributes is bad for +;;; maintenance. How confident are we that we have no defknowns for functions +;;; with functional arguments that are missing the CALL attribute? Much better +;;; to have NO-CALLS, as it is much less likely to break accidentally. (!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. call - ;; may incorporate function or number arguments into the result or - ;; somehow pass them upward. Note that this applies to any argument - ;; that *might* be a function or number, not just the arguments that - ;; always are. - unsafe ;; may fail to return during correct execution. Errors are O.K. + ;; UNUSED, BEWARE OF BITROT. unwind ;; the (default) worst case. Includes all the other bad things, plus ;; any other possible bad thing. If this is present, the above bad ;; attributes will be explicitly present as well. any + ;; all arguments are safe for dynamic extent. + ;; (We used to have an UNSAFE attribute, which was basically the inverse + ;; of this, but it was unused and bitrotted, so when we started making + ;; use of the information we flipped the name and meaning the safe way + ;; around.) + dx-safe ;; may be constant-folded. The function has no side effects, but may ;; be affected by side effects on the arguments. e.g. SVREF, MAPC. ;; Functions that side-effect their arguments are not considered to @@ -61,11 +68,13 @@ ;; 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 + ;; return value is important, and ignoring it is probably a mistake. + ;; Unlike the other attributes, this is used only for style + ;; warnings and has no effect on optimization. + important-result ;; may be moved with impunity. Has no side effects except possibly ;; consing, and is affected only by its arguments. - ;; - ;; Since it is not used now, its distribution in fndb.lisp is - ;; mere random; use with caution. + ;; UNUSED, BEWARE OF BITROT. movable ;; The function is a true predicate likely to be open-coded. Convert ;; any non-conditional uses into (IF T NIL). Not usually @@ -81,7 +90,12 @@ ;; The function does explicit argument type checking, so the ;; declared type should not be asserted when a definition is ;; compiled. - explicit-check) + explicit-check + ;; The function should always be translated by a VOP (i.e. it should + ;; should never be converted into a full call). This is used strictly + ;; as a consistency checking mechanism inside the compiler during IR2 + ;; transformation. + always-translatable) (defstruct (fun-info #-sb-xc-host (:pure t)) ;; boolean attributes of this function. @@ -122,7 +136,10 @@ (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))) + (predicate-type nil :type (or ctype null)) + ;; If non-null, the index of the argument which becomes the result + ;; of the function. + (result-arg nil :type (or index null))) (defprinter (fun-info) (attributes :test (not (zerop attributes)) @@ -173,7 +190,8 @@ (eq (transform-important x) important))) (fun-info-transforms info)))) (cond (old - (style-warn "Overwriting ~S" old) + (style-warn 'sb!kernel:redefinition-with-deftransform + :transform old) (setf (transform-function old) fun (transform-note old) note)) (t @@ -187,16 +205,17 @@ (declaim (ftype (function (list list attributes &key (:derive-type (or function null)) (:optimizer (or function null)) - (:destroyed-constant-args (or function null))) + (:destroyed-constant-args (or function null)) + (:result-arg (or index null))) *) %defknown)) -(defun %defknown (names type attributes &key derive-type optimizer destroyed-constant-args) +(defun %defknown (names type attributes &key derive-type optimizer destroyed-constant-args result-arg) (let ((ctype (specifier-type type)) (info (make-fun-info :attributes attributes :derive-type derive-type :optimizer optimizer - :destroyed-constant-args destroyed-constant-args)) - (target-env *info-environment*)) + :destroyed-constant-args destroyed-constant-args + :result-arg result-arg))) (dolist (name names) (let ((old-fun-info (info :function :info name))) (when old-fun-info @@ -212,10 +231,10 @@ (cerror "Go ahead, overwrite it." "~@" old-fun-info name))) - (setf (info :function :type name target-env) ctype) - (setf (info :function :where-from name target-env) :declared) - (setf (info :function :kind name target-env) :function) - (setf (info :function :info name target-env) info))) + (setf (info :function :type name) ctype) + (setf (info :function :where-from name) :declared) + (setf (info :function :kind name) :function) + (setf (info :function :info name) info))) names) ;;; Return the FUN-INFO for NAME or die trying. Since this is