| blob | 67f5873cf6e6431d7a7d7ff6abb918329b03b84e |
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 ATOM) are best tested by letting the
28 ;;;; 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.)
67 expansion)))
69 ;;; If the lvar OBJECT definitely is or isn't of the specified
70 ;;; type, then return T or NIL as appropriate. Otherwise quietly
71 ;;; GIVE-UP-IR1-TRANSFORM.
76 nil)
78 t)
80 nil)
84 ;;; Flush %TYPEP tests whose result is known at compile time.
89 object
92 ;;; This is the IR1 transform for simple type predicates. It checks
93 ;;; whether the single argument is known to (not) be of the
94 ;;; appropriate type, expanding to T or NIL as appropriate.
104 ;;; If FIND-CLASS is called on a constant class, locate the CLASS-CELL
105 ;;; at load time.
111 \f
112 ;;;; standard type predicates, i.e. those defined in package COMMON-LISP,
113 ;;;; plus at least one oddball (%INSTANCEP)
114 ;;;;
115 ;;;; Various other type predicates (e.g. low-level representation
116 ;;;; stuff like SIMPLE-ARRAY-SINGLE-FLOAT-P) are defined elsewhere.
118 ;;; FIXME: This function is only called once, at top level. Why not
119 ;;; just expand all its operations into toplevel code?
122 ; (The ATOM predicate is handled separately as (NOT CONS).)
150 \f
151 ;;;; transforms for type predicates not implemented primitively
152 ;;;;
153 ;;;; See also VM dependent transforms.
157 #!+sb-unicode
160 \f
161 ;;;; TYPEP source transform
163 ;;; Return a form that tests the variable N-OBJECT for being in the
164 ;;; binds specified by TYPE. BASE is the name of the base type, for
165 ;;; declaration. We make SAFETY locally 0 to inhibit any checking of
166 ;;; this assertion.
182 ;;; Do source transformation of a test of a known numeric type. We can
183 ;;; assume that the type doesn't have a corresponding predicate, since
184 ;;; those types have already been picked off. In particular, CLASS
185 ;;; must be specified, since it is unspecified only in NUMBER and
186 ;;; COMPLEX. Similarly, we assume that COMPLEXP is always specified.
187 ;;;
188 ;;; For non-complex types, we just test that the number belongs to the
189 ;;; base type, and then test that it is in bounds. When CLASS is
190 ;;; INTEGER, we check to see whether the range is no bigger than
191 ;;; FIXNUM. If so, we check for FIXNUM instead of INTEGER. This allows
192 ;;; us to use fixnum comparison to test the bounds.
193 ;;;
194 ;;; For complex types, we must test for complex, then do the above on
195 ;;; both the real and imaginary parts. When CLASS is float, we need
196 ;;; only check the type of the realpart, since the format of the
197 ;;; realpart and the imagpart must be the same.
205 type)))
211 (:real
214 (:complex
225 base))))))))))
227 ;;; Do the source transformation for a test of a hairy type. AND,
228 ;;; SATISFIES and NOT are converted into the obvious code. We convert
229 ;;; unknown types to %TYPEP, emitting an efficiency note if
230 ;;; appropriate.
253 ;;; Do source transformation for TYPEP of a known union type. If a
254 ;;; union type contains LIST, then we pull that out and make it into a
255 ;;; single LISTP call. Note that if SYMBOL is in the union, then LIST
256 ;;; will be a subtype even without there being any (member NIL). We
257 ;;; currently just drop through to the general code in this case,
258 ;;; rather than trying to optimize it (but FIXME CSR 2004-04-05: it
259 ;;; wouldn't be hard to optimize it after all).
278 types))))))
280 ;;; Do source transformation for TYPEP of a known intersection type.
287 ;;; If necessary recurse to check the cons type.
316 collect
319 ;;; Return the predicate and type from the most specific entry in
320 ;;; *TYPE-PREDICATES* that is a supertype of TYPE.
334 ;;; Return forms to test that OBJ has the rank and dimensions
335 ;;; specified by TYPE, where STYPE is the type we have checked against
336 ;;; (which is the same but for dimensions and element type).
354 ;;; Return forms to test that OBJ has the element-type specified by
355 ;;; type specified by TYPE, where STYPE is the type we have checked
356 ;;; against (which is the same but for dimensions and element type).
365 ;; KLUDGE: this isn't in fact maximally efficient,
366 ;; because though we know that DATA is a (SIMPLE-ARRAY *
367 ;; (*)), we will still check to see if the lowtag is
368 ;; appropriate.
372 ;;; If we can find a type predicate that tests for the type without
373 ;;; dimensions, then use that predicate and test for dimensions.
374 ;;; Otherwise, just do %TYPEP.
378 ;; (If the element type hasn't been defined yet, it's
379 ;; not safe to assume here that it will eventually
380 ;; have (UPGRADED-ARRAY-ELEMENT-TYPE type)=T, so punt.)
389 ;;; Transform a type test against some instance type. The type test is
390 ;;; flushed if the result is known at compile time. If not properly
391 ;;; named, error. If sealed and has no subclasses, just test for
392 ;;; layout-EQ. If a structure then test for layout-EQ and then a
393 ;;; general test based on layout-inherits. If safety is important,
394 ;;; then we also check whether the layout for the object is invalid
395 ;;; and signal an error if so. Otherwise, look up the indirect
396 ;;; class-cell and call CLASS-CELL-TYPEP at runtime.
405 res
406 nil))))
408 ;; Flush tests whose result is known at compile time.
410 nil)
412 t)
413 ;; If not properly named, error.
416 class:~% ~S"
417 class))
419 ;; Delay the type transform to give type propagation a chance.
422 ;; Otherwise transform the type test.
434 ;; Sealed and has no subclasses.
443 ;; structure type tests; hierarchical layout depths
448 ;; we used to check for invalid layouts here,
449 ;; but in fact that's both unnecessary and
450 ;; wrong; it's unnecessary because structure
451 ;; classes can't be redefined, and it's wrong
452 ;; because it is quite legitimate to pass an
453 ;; object with an invalid layout to a structure
454 ;; type test.
456 t
460 ;; Use DATA-VECTOR-REF directly,
461 ;; since that's what SVREF in a
462 ;; SAFETY 0 lexenv will eventually be
463 ;; transformed to. This can give a
464 ;; large compilation speedup, since
465 ;; %INSTANCE-TYPEPs are frequently
466 ;; created during GENERATE-TYPE-CHECKS,
467 ;; and the normal aref transformation path
468 ;; is pretty heavy.
473 ;; hierarchical layout depths for other things (e.g.
474 ;; CONDITION, STREAM)
484 t
488 ;; See above.
496 object)))))))))
498 ;;; If the specifier argument is a quoted constant, then we consider
499 ;;; converting into a simple predicate or other stuff. If the type is
500 ;;; constant, but we can't transform the call, then we convert to
501 ;;; %TYPEP. We only pass when the type is non-constant. This allows us
502 ;;; to recognize between calls that might later be transformed
503 ;;; successfully when a constant type is discovered. We don't give an
504 ;;; efficiency note when we pass, since the IR1 transform will give
505 ;;; one if necessary and appropriate.
506 ;;;
507 ;;; If the type is TYPE= to a type that has a predicate, then expand
508 ;;; to that predicate. Otherwise, we dispatch off of the type's type.
509 ;;; These transformations can increase space, but it is hard to tell
510 ;;; when, so we ignore policy and always do them.
549 ;; KLUDGE: It looks bad to only do this on explicitly quoted forms,
550 ;; since that would overlook other kinds of constants. But it turns
551 ;; out that the DEFTRANSFORM for TYPEP detects any constant
552 ;; lvar, transforms it into a quoted form, and gives this
553 ;; source transform another chance, so it all works out OK, in a
554 ;; weird roundabout way. -- WHN 2001-03-18
561 \f
562 ;;;; coercion
564 ;;; Constant-folding.
565 ;;;
566 #-sb-xc-host
572 t))))
579 'x
580 ;; Note: The THE here makes sure that specifiers like
581 ;; (SINGLE-FLOAT 0.0 1.0) can raise a TYPE-ERROR.
586 ;; FIXME: #!+long-float (t ,(error "LONG-FLOAT case needed"))
590 ;; Can we avoid checking for dimension issues like
591 ;; (COERCE FOO '(SIMPLE-VECTOR 5)) returning a
592 ;; vector of length 6?
597 x
599 ;; FIXME: other VECTOR types?