| blob | 612d2bcc199e1e95e52d32c141e19da67a240122 |
1 ;;;; This file contains stuff that implements the portable IR1
2 ;;;; semantics of type tests and coercion. The main thing we do is
3 ;;;; convert complex type operations into simpler code that can be
4 ;;;; compiled inline.
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.
16 \f
17 ;;;; type predicate translation
18 ;;;;
19 ;;;; We maintain a bidirectional association between type predicates
20 ;;;; and the tested type. The presence of a predicate in this
21 ;;;; association implies that it is desirable to implement tests of
22 ;;;; this type using the predicate. These are either predicates that
23 ;;;; the back end is likely to have special knowledge about, or
24 ;;;; predicates so complex that the only reasonable implentation is
25 ;;;; via function call.
26 ;;;;
27 ;;;; Some standard types (such as SEQUENCE) are best tested by letting
28 ;;;; the TYPEP source transform do its thing with the expansion. These
29 ;;;; types (and corresponding predicates) are not maintained in this
30 ;;;; association. In this case, there need not be any predicate
31 ;;;; function unless it is required by the Common Lisp specification.
32 ;;;;
33 ;;;; The mapping between predicates and type structures is considered
34 ;;;; part of the backend; different backends can support different
35 ;;;; sets of predicates.
37 ;;; Establish an association between the type predicate NAME and the
38 ;;; corresponding TYPE. This causes the type predicate to be
39 ;;; recognized for purposes of optimization.
50 name))
51 \f
52 ;;;; IR1 transforms
54 ;;; If we discover the type argument is constant during IR1
55 ;;; optimization, then give the source transform another chance. The
56 ;;; source transform can't pass, since we give it an explicit
57 ;;; constant. At worst, it will convert to %TYPEP, which will prevent
58 ;;; spurious attempts at transformation (and possible repeated
59 ;;; warnings.)
65 ;;; If the lvar OBJECT definitely is or isn't of the specified
66 ;;; type, then return T or NIL as appropriate. Otherwise quietly
67 ;;; GIVE-UP-IR1-TRANSFORM.
72 nil)
74 t)
76 nil)
80 ;;; Flush %TYPEP tests whose result is known at compile time.
85 object
88 ;;; This is the IR1 transform for simple type predicates. It checks
89 ;;; whether the single argument is known to (not) be of the
90 ;;; appropriate type, expanding to T or NIL as appropriate.
100 ;;; If FIND-CLASS is called on a constant class, locate the CLASS-CELL
101 ;;; at load time.
107 \f
108 ;;;; standard type predicates, i.e. those defined in package COMMON-LISP,
109 ;;;; plus at least one oddball (%INSTANCEP)
110 ;;;;
111 ;;;; Various other type predicates (e.g. low-level representation
112 ;;;; stuff like SIMPLE-ARRAY-SINGLE-FLOAT-P) are defined elsewhere.
114 ;;; FIXME: This function is only called once, at top level. Why not
115 ;;; just expand all its operations into toplevel code?
118 ; (The ATOM predicate is handled separately as (NOT CONS).)
144 \f
145 ;;;; transforms for type predicates not implemented primitively
146 ;;;;
147 ;;;; See also VM dependent transforms.
151 #!+sb-unicode
154 \f
155 ;;;; TYPEP source transform
157 ;;; Return a form that tests the variable N-OBJECT for being in the
158 ;;; binds specified by TYPE. BASE is the name of the base type, for
159 ;;; declaration. We make SAFETY locally 0 to inhibit any checking of
160 ;;; this assertion.
176 ;;; Do source transformation of a test of a known numeric type. We can
177 ;;; assume that the type doesn't have a corresponding predicate, since
178 ;;; those types have already been picked off. In particular, CLASS
179 ;;; must be specified, since it is unspecified only in NUMBER and
180 ;;; COMPLEX. Similarly, we assume that COMPLEXP is always specified.
181 ;;;
182 ;;; For non-complex types, we just test that the number belongs to the
183 ;;; base type, and then test that it is in bounds. When CLASS is
184 ;;; INTEGER, we check to see whether the range is no bigger than
185 ;;; FIXNUM. If so, we check for FIXNUM instead of INTEGER. This allows
186 ;;; us to use fixnum comparison to test the bounds.
187 ;;;
188 ;;; For complex types, we must test for complex, then do the above on
189 ;;; both the real and imaginary parts. When CLASS is float, we need
190 ;;; only check the type of the realpart, since the format of the
191 ;;; realpart and the imagpart must be the same.
199 type)))
205 (:real
208 (:complex
219 base))))))))))
221 ;;; Do the source transformation for a test of a hairy type. AND,
222 ;;; SATISFIES and NOT are converted into the obvious code. We convert
223 ;;; unknown types to %TYPEP, emitting an efficiency note if
224 ;;; appropriate.
247 ;;; Do source transformation for TYPEP of a known union type. If a
248 ;;; union type contains LIST, then we pull that out and make it into a
249 ;;; single LISTP call. Note that if SYMBOL is in the union, then LIST
250 ;;; will be a subtype even without there being any (member NIL). We
251 ;;; currently just drop through to the general code in this case,
252 ;;; rather than trying to optimize it (but FIXME CSR 2004-04-05: it
253 ;;; wouldn't be hard to optimize it after all).
272 types))))))
274 ;;; Do source transformation for TYPEP of a known intersection type.
281 ;;; If necessary recurse to check the cons type.
310 collect
313 ;;; Return the predicate and type from the most specific entry in
314 ;;; *TYPE-PREDICATES* that is a supertype of TYPE.
328 ;;; Return forms to test that OBJ has the rank and dimensions
329 ;;; specified by TYPE, where STYPE is the type we have checked against
330 ;;; (which is the same but for dimensions and element type).
348 ;;; Return forms to test that OBJ has the element-type specified by
349 ;;; type specified by TYPE, where STYPE is the type we have checked
350 ;;; against (which is the same but for dimensions and element type).
359 ;; KLUDGE: this isn't in fact maximally efficient,
360 ;; because though we know that DATA is a (SIMPLE-ARRAY *
361 ;; (*)), we will still check to see if the lowtag is
362 ;; appropriate.
366 ;;; If we can find a type predicate that tests for the type without
367 ;;; dimensions, then use that predicate and test for dimensions.
368 ;;; Otherwise, just do %TYPEP.
372 ;; (If the element type hasn't been defined yet, it's
373 ;; not safe to assume here that it will eventually
374 ;; have (UPGRADED-ARRAY-ELEMENT-TYPE type)=T, so punt.)
383 ;;; Transform a type test against some instance type. The type test is
384 ;;; flushed if the result is known at compile time. If not properly
385 ;;; named, error. If sealed and has no subclasses, just test for
386 ;;; layout-EQ. If a structure then test for layout-EQ and then a
387 ;;; general test based on layout-inherits. If safety is important,
388 ;;; then we also check whether the layout for the object is invalid
389 ;;; and signal an error if so. Otherwise, look up the indirect
390 ;;; class-cell and call CLASS-CELL-TYPEP at runtime.
399 res
400 nil))))
402 ;; Flush tests whose result is known at compile time.
404 nil)
406 t)
407 ;; If not properly named, error.
410 class:~% ~S"
411 class))
413 ;; Delay the type transform to give type propagation a chance.
416 ;; Otherwise transform the type test.
428 ;; Sealed and has no subclasses.
437 ;; structure type tests; hierarchical layout depths
446 t
454 ;; hierarchical layout depths for other things (e.g.
455 ;; CONDITIONs)
465 t
476 object)))))))))
478 ;;; If the specifier argument is a quoted constant, then we consider
479 ;;; converting into a simple predicate or other stuff. If the type is
480 ;;; constant, but we can't transform the call, then we convert to
481 ;;; %TYPEP. We only pass when the type is non-constant. This allows us
482 ;;; to recognize between calls that might later be transformed
483 ;;; successfully when a constant type is discovered. We don't give an
484 ;;; efficiency note when we pass, since the IR1 transform will give
485 ;;; one if necessary and appropriate.
486 ;;;
487 ;;; If the type is TYPE= to a type that has a predicate, then expand
488 ;;; to that predicate. Otherwise, we dispatch off of the type's type.
489 ;;; These transformations can increase space, but it is hard to tell
490 ;;; when, so we ignore policy and always do them.
492 ;; KLUDGE: It looks bad to only do this on explicitly quoted forms,
493 ;; since that would overlook other kinds of constants. But it turns
494 ;; out that the DEFTRANSFORM for TYPEP detects any constant
495 ;; lvar, transforms it into a quoted form, and gives this
496 ;; source transform another chance, so it all works out OK, in a
497 ;; weird roundabout way. -- WHN 2001-03-18
537 \f
538 ;;;; coercion
540 ;;; Constant-folding.
541 ;;;
542 #-sb-xc-host
548 t))))
555 'x
556 ;; Note: The THE here makes sure that specifiers like
557 ;; (SINGLE-FLOAT 0.0 1.0) can raise a TYPE-ERROR.
562 ;; FIXME: #!+long-float (t ,(error "LONG-FLOAT case needed"))
566 ;; Can we avoid checking for dimension issues like
567 ;; (COERCE FOO '(SIMPLE-VECTOR 5)) returning a
568 ;; vector of length 6?
573 x
575 ;; FIXME: other VECTOR types?