| blob | 7dc7a6d19574721c22604b38427579d30b0d4d22 |
1 ;;;; This file contains stuff for maintaining a database of special
2 ;;;; information about functions known to the compiler. This includes
3 ;;;; semantic information such as side effects and type inference
4 ;;;; functions as well as transforms and IR2 translators.
6 ;;;; This software is part of the SBCL system. See the README file for
7 ;;;; more information.
8 ;;;;
9 ;;;; This software is derived from the CMU CL system, which was
10 ;;;; written at Carnegie Mellon University and released into the
11 ;;;; public domain. The software is in the public domain and is
12 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
13 ;;;; files for more information.
19 ;;;; interfaces to defining macros
21 ;;; an IR1 transform
23 ;; the function type which enables this transform.
24 ;;
25 ;; (Note that declaring this :TYPE FUN-TYPE probably wouldn't
26 ;; work because some function types, like (SPECIFIER-TYPE 'FUNCTION0
27 ;; itself, are represented as BUILT-IN-TYPE, and at least as of
28 ;; sbcl-0.pre7.54 or so, that's inconsistent with being a
29 ;; FUN-TYPE.)
31 ;; the transformation function. Takes the COMBINATION node and
32 ;; returns a lambda expression, or throws out.
34 ;; string used in efficiency notes
36 ;; T if we should emit a failure note even if SPEED=INHIBIT-WARNINGS.
41 ;;; Grab the FUN-INFO and enter the function, replacing any old
42 ;;; one with the same type and note.
45 *)
46 %deftransform))
65 name))
67 ;;; Make a FUN-INFO structure with the specified type, attributes
68 ;;; and optimizers.
77 *)
78 %defknown))
80 &key derive-type optimizer destroyed-constant-args result-arg
81 overwrite-fndb-silently
82 foldable-call-check
83 callable-check)
86 :derive-type derive-type
87 :optimizer optimizer
88 :destroyed-constant-args destroyed-constant-args
89 :result-arg result-arg
90 :foldable-call-check foldable-call-check
96 ;; This is handled as an error because it's generally a bad
97 ;; thing to blow away all the old optimization stuff. It's
98 ;; also a potential source of sneaky bugs:
99 ;; DEFKNOWN FOO
100 ;; DEFTRANSFORM FOO
101 ;; DEFKNOWN FOO ; possibly hidden inside some macroexpansion
102 ;; ; Now the DEFTRANSFORM doesn't exist in the target Lisp.
103 ;; However, it's continuable because it might be useful to do
104 ;; it when testing new optimization stuff interactively.
106 "~@<overwriting old FUN-INFO ~2I~_~S ~I~_for ~S~:>"
107 old-fun-info name))))
114 location)
116 names)
118 ;;; Return the FUN-INFO for NAME or die trying. Since this is
119 ;;; used by callers who want to modify the info, and the info may be
120 ;;; shared, we copy it. We don't have to copy the lists, since each
121 ;;; function that has generators or transforms has already been
122 ;;; through here.
123 ;;;
124 ;;; Note that this operation is somewhat garbage-producing in the current
125 ;;; globaldb implementation. Setting a piece of INFO for a name makes
126 ;;; a shallow copy of the name's info-vector. FUN-INFO-OR-LOSE sounds
127 ;;; like a data reader, and you might be disinclined to think that it
128 ;;; copies at all, but:
129 ;;; (TIME (LOOP REPEAT 1000 COUNT (FUN-INFO-OR-LOSE '*)))
130 ;;; 294,160 bytes consed
131 ;;; whereas just copying the info per se is not half as bad:
132 ;;; (LET ((X (INFO :FUNCTION :INFO '*)))
133 ;;; (TIME (LOOP REPEAT 1000 COUNT (COPY-FUN-INFO X))))
134 ;;; 130,992 bytes consed
135 ;;;
141 \f
142 ;;;; generic type inference methods
144 ;;; Derive the type to be the type of the xxx'th arg. This can normally
145 ;;; only be done when the result value is that argument.
155 ;;; Derive the result type according to the float contagion rules, but
156 ;;; always return a float. This is used for irrational functions that
157 ;;; preserve realness of their arguments.
164 ;;; Return a closure usable as a derive-type method for accessing the
165 ;;; N'th argument. If arg is a list, result is a list. If arg is a
166 ;;; vector, result is a vector with the same element type.
178 ltype))))))))
180 ;;; Derive the type to be the type specifier which is the Nth arg.
188 ;;; Derive the type to be the type specifier which is the Nth arg,
189 ;;; with the additional restriptions noted in the CLHS for STRING and
190 ;;; SIMPLE-STRING, defined to specialize on CHARACTER, and for VECTOR
191 ;;; (under the page for MAKE-SEQUENCE).
192 ;;; At present this is used to derive the output type of CONCATENATE,
193 ;;; MAKE-SEQUENCE, and MERGE. Two things seem slightly amiss:
194 ;;; 1. The sequence type actually produced might not be exactly that specified.
195 ;;; (TYPE-OF (MAKE-SEQUENCE '(AND (NOT SIMPLE-ARRAY) (VECTOR BIT)) 9))
196 ;;; => (SIMPLE-BIT-VECTOR 9)
197 ;;; 2. Because we *know* that a hairy array won't be produced,
198 ;;; why does derivation preserve the non-simpleness, if so specified?
209 lspecifier
215 lspecifier
228 ctype)))))))))
235 ;;; FIXME: bad name (first because it uses 1-based indexing; second
236 ;;; because it doesn't get the nth constant arguments)
249 ;;; FIXME: a number of the sequence functions not only do not destroy
250 ;;; their argument if it is empty, but also leave it alone if :start
251 ;;; and :end bound a null sequence, or if :count is 0. This test is a
252 ;;; bit complicated to implement, verging on the impossible, but for
253 ;;; extra points (fill #\1 "abc" :start 0 :end 0) should not cause a
254 ;;; warning.
282 null-type))
283 ;; (READ-elt stream nil <x>) returns (OR (EQL <x>) elt-type)
285 element-type)
286 ;; If eof-error is unsupplied, or was but couldn't be nil
287 element-type)))
290 unexceptional-type))))
294 ;; Could possibly constrain the result more highly if
295 ;; the :start/:end were provided and of known types.
297 ;; This can deal with just enough hair to handle type STRING,
298 ;; but might be made to use GENERIC-ABSTRACT-TYPE-FUNCTION
299 ;; if we really want to be more clever.
306 '*))
310 ;; If type derivation were able to notice that non-simple arrays can
311 ;; be mutated (changing the type), we could safely use LVAR-TYPE on
312 ;; any vector type. But it doesn't notice.
313 ;; We could use LVAR-CONSERVATIVE-TYPE to get a conservative answer.
314 ;; However that's probably not an important use, so the above
315 ;; logic restricts itself to simple arrays.