;;;; part of the backend; different backends can support different
;;;; sets of predicates.
+;;; Establish an association between the type predicate NAME and the
+;;; corresponding TYPE. This causes the type predicate to be
+;;; recognized for purposes of optimization.
(defmacro define-type-predicate (name type)
- #!+sb-doc
- "Define-Type-Predicate Name Type
- Establish an association between the type predicate Name and the
- corresponding Type. This causes the type predicate to be recognized for
- purposes of optimization."
`(%define-type-predicate ',name ',type))
(defun %define-type-predicate (name specifier)
(let ((type (specifier-type specifier)))
(defun ir1-transform-type-predicate (object type)
(declare (type continuation object) (type ctype type))
(let ((otype (continuation-type object)))
- (cond ((not (types-intersect otype type))
- 'nil)
+ (cond ((not (types-equal-or-intersect otype type))
+ nil)
((csubtypep otype type)
- 't)
+ t)
+ ((eq type *empty-type*)
+ nil)
(t
(give-up-ir1-transform)))))
;;; Flush %TYPEP tests whose result is known at compile time.
(deftransform %typep ((object type))
- (unless (constant-continuation-p type) (give-up-ir1-transform))
+ (unless (constant-continuation-p type)
+ (give-up-ir1-transform))
(ir1-transform-type-predicate
object
- (specifier-type (continuation-value type))))
+ (ir1-transform-specifier-type (continuation-value type))))
;;; This is the IR1 transform for simple type predicates. It checks
;;; whether the single argument is known to (not) be of the
;;; appropriate type, expanding to T or NIL as appropriate.
(deftransform fold-type-predicate ((object) * * :node node :defun-only t)
- (let ((ctype (gethash (leaf-name
+ (let ((ctype (gethash (leaf-source-name
(ref-leaf
(continuation-use
(basic-combination-fun node))))
*backend-predicate-types*)))
- (assert ctype)
+ (aver ctype)
(ir1-transform-type-predicate object ctype)))
;;; If FIND-CLASS is called on a constant class, locate the CLASS-CELL
;;; at load time.
-(deftransform find-class ((name) ((constant-argument symbol)) *
- :when :both)
+(deftransform find-classoid ((name) ((constant-arg symbol)) *)
(let* ((name (continuation-value name))
- (cell (find-class-cell name)))
- `(or (class-cell-class ',cell)
+ (cell (find-classoid-cell name)))
+ `(or (classoid-cell-classoid ',cell)
(error "class not yet defined: ~S" name))))
\f
-;;;; standard type predicates
+;;;; standard type predicates, i.e. those defined in package COMMON-LISP,
+;;;; plus at least one oddball (%INSTANCEP)
+;;;;
+;;;; Various other type predicates (e.g. low-level representation
+;;;; stuff like SIMPLE-ARRAY-SINGLE-FLOAT-P) are defined elsewhere.
-;;; FIXME: needed only at cold load time, can be uninterned afterwards;
-;;; or perhaps could just be done at toplevel
-(defun define-standard-type-predicates ()
+;;; FIXME: This function is only called once, at top level. Why not
+;;; just expand all its operations into toplevel code?
+(defun !define-standard-type-predicates ()
(define-type-predicate arrayp array)
; (The ATOM predicate is handled separately as (NOT CONS).)
(define-type-predicate bit-vector-p bit-vector)
(define-type-predicate funcallable-instance-p funcallable-instance)
(define-type-predicate symbolp symbol)
(define-type-predicate vectorp vector))
-
-(define-standard-type-predicates)
+(!define-standard-type-predicates)
\f
;;;; transforms for type predicates not implemented primitively
;;;;
;;;; See also VM dependent transforms.
-(def-source-transform atom (x)
+(define-source-transform atom (x)
`(not (consp ,x)))
\f
;;;; TYPEP source transform
-;;; Return a form that tests the variable N-Object for being in the binds
-;;; specified by Type. Base is the name of the base type, for declaration. We
-;;; make safety locally 0 to inhibit any checking of this assertion.
+;;; Return a form that tests the variable N-OBJECT for being in the
+;;; binds specified by TYPE. BASE is the name of the base type, for
+;;; declaration. We make SAFETY locally 0 to inhibit any checking of
+;;; this assertion.
#!-negative-zero-is-not-zero
(defun transform-numeric-bound-test (n-object type base)
(declare (type numeric-type type))
(declare (type hairy-type type))
(let ((spec (hairy-type-specifier type)))
(cond ((unknown-type-p type)
- (when (policy nil (> speed brevity))
+ (when (policy *lexenv* (> speed inhibit-warnings))
(compiler-note "can't open-code test of unknown type ~S"
(type-specifier type)))
`(%typep ,object ',spec))
(satisfies `(if (funcall #',(second spec) ,object) t nil))
((not and)
(once-only ((n-obj object))
- `(,(first spec) ,@(mapcar #'(lambda (x)
- `(typep ,n-obj ',x))
+ `(,(first spec) ,@(mapcar (lambda (x)
+ `(typep ,n-obj ',x))
(rest spec))))))))))
-;;; Do source transformation for Typep of a known union type. If a
+(defun source-transform-negation-typep (object type)
+ (declare (type negation-type type))
+ (let ((spec (type-specifier (negation-type-type type))))
+ `(not (typep ,object ',spec))))
+
+;;; Do source transformation for TYPEP of a known union type. If a
;;; union type contains LIST, then we pull that out and make it into a
;;; single LISTP call. Note that if SYMBOL is in the union, then LIST
;;; will be a subtype even without there being any (member NIL). We
(let* ((types (union-type-types type))
(ltype (specifier-type 'list))
(mtype (find-if #'member-type-p types)))
- (cond ((and mtype (csubtypep ltype type))
- (let ((members (member-type-members mtype)))
- (once-only ((n-obj object))
- `(if (listp ,n-obj)
- t
- (typep ,n-obj
- '(or ,@(mapcar #'type-specifier
- (remove (specifier-type 'cons)
- (remove mtype types)))
- (member ,@(remove nil members))))))))
- (t
- (once-only ((n-obj object))
- `(or ,@(mapcar #'(lambda (x)
- `(typep ,n-obj ',(type-specifier x)))
- types)))))))
+ (if (and mtype (csubtypep ltype type))
+ (let ((members (member-type-members mtype)))
+ (once-only ((n-obj object))
+ `(or (listp ,n-obj)
+ (typep ,n-obj
+ '(or ,@(mapcar #'type-specifier
+ (remove (specifier-type 'cons)
+ (remove mtype types)))
+ (member ,@(remove nil members)))))))
+ (once-only ((n-obj object))
+ `(or ,@(mapcar (lambda (x)
+ `(typep ,n-obj ',(type-specifier x)))
+ types))))))
-;;; MNA: cons compound-type patch
-;;; FIXIT: all commented out
-; ;;; Source-Transform-Cons-Typep
-; ;;;
-; ;;; If necessary recurse to check the cons type.
-; ;;;
-; (defun source-transform-cons-typep (object type)
-; (let* ((car-type (cons-type-car-type type))
-; (cdr-type (cons-type-cdr-type type)))
-; (let ((car-test-p (not (or (type= car-type *wild-type*)
-; (type= car-type (specifier-type t)))))
-; (cdr-test-p (not (or (type= cdr-type *wild-type*)
-; (type= cdr-type (specifier-type t))))))
-; (if (and (not car-test-p) (not cdr-test-p))
-; `(consp ,object)
-; (once-only ((n-obj object))
-; `(and (consp ,n-obj)
-; ,@(if car-test-p
-; `((typep (car ,n-obj)
-; ',(type-specifier car-type))))
-; ,@(if cdr-test-p
-; `((typep (cdr ,n-obj)
-; ',(type-specifier cdr-type))))))))))
+;;; Do source transformation for TYPEP of a known intersection type.
+(defun source-transform-intersection-typep (object type)
+ (once-only ((n-obj object))
+ `(and ,@(mapcar (lambda (x)
+ `(typep ,n-obj ',(type-specifier x)))
+ (intersection-type-types type)))))
+;;; If necessary recurse to check the cons type.
+(defun source-transform-cons-typep (object type)
+ (let* ((car-type (cons-type-car-type type))
+ (cdr-type (cons-type-cdr-type type)))
+ (let ((car-test-p (not (or (type= car-type *wild-type*)
+ (type= car-type (specifier-type t)))))
+ (cdr-test-p (not (or (type= cdr-type *wild-type*)
+ (type= cdr-type (specifier-type t))))))
+ (if (and (not car-test-p) (not cdr-test-p))
+ `(consp ,object)
+ (once-only ((n-obj object))
+ `(and (consp ,n-obj)
+ ,@(if car-test-p
+ `((typep (car ,n-obj)
+ ',(type-specifier car-type))))
+ ,@(if cdr-test-p
+ `((typep (cdr ,n-obj)
+ ',(type-specifier cdr-type))))))))))
+
;;; Return the predicate and type from the most specific entry in
;;; *TYPE-PREDICATES* that is a supertype of TYPE.
(defun find-supertype-predicate (type)
(res `(= (array-dimension ,obj ,i) ,dim)))))
(res)))))
-;;; If we can find a type predicate that tests for the type w/o
+;;; If we can find a type predicate that tests for the type without
;;; dimensions, then use that predicate and test for dimensions.
;;; Otherwise, just do %TYPEP.
(defun source-transform-array-typep (obj type)
;;; then we also check whether the layout for the object is invalid
;;; and signal an error if so. Otherwise, look up the indirect
;;; class-cell and call CLASS-CELL-TYPEP at runtime.
-;;;
-;;; KLUDGE: The :WHEN :BOTH option here is probably a suboptimal
-;;; solution to the problem of %INSTANCE-TYPEP forms in byte compiled
-;;; code; it'd probably be better just to have %INSTANCE-TYPEP forms
-;;; never be generated in byte compiled code, or maybe to have a DEFUN
-;;; %INSTANCE-TYPEP somewhere to handle them if they are. But it's not
-;;; terribly important because mostly, %INSTANCE-TYPEP forms *aren't*
-;;; generated in byte compiled code. (As of sbcl-0.6.5, they could
-;;; sometimes be generated when byte compiling inline functions, but
-;;; it's quite uncommon.) -- WHN 20000523
-(deftransform %instance-typep ((object spec) * * :when :both)
- (assert (constant-continuation-p spec))
+(deftransform %instance-typep ((object spec) (* *) * :node node)
+ (aver (constant-continuation-p spec))
(let* ((spec (continuation-value spec))
(class (specifier-type spec))
- (name (sb!xc:class-name class))
+ (name (classoid-name class))
(otype (continuation-type object))
(layout (let ((res (info :type :compiler-layout name)))
(if (and res (not (layout-invalid res)))
res
nil))))
- (/noshow "entering DEFTRANSFORM %INSTANCE-TYPEP" otype spec class name layout)
(cond
;; Flush tests whose result is known at compile time.
- ((not (types-intersect otype class))
- (/noshow "flushing constant NIL")
+ ((not (types-equal-or-intersect otype class))
nil)
((csubtypep otype class)
- (/noshow "flushing constant T")
t)
;; If not properly named, error.
- ((not (and name (eq (sb!xc:find-class name) class)))
+ ((not (and name (eq (find-classoid name) class)))
(compiler-error "can't compile TYPEP of anonymous or undefined ~
class:~% ~S"
class))
(t
+ ;; Delay the type transform to give type propagation a chance.
+ (delay-ir1-transform node :constraint)
+
;; Otherwise transform the type test.
(multiple-value-bind (pred get-layout)
(cond
(values '%instancep '%instance-layout))
(t
(values '(lambda (x) (declare (ignore x)) t) 'layout-of)))
- (/noshow pred get-layout)
(cond
- ((and (eq (class-state class) :sealed) layout
- (not (class-subclasses class)))
+ ((and (eq (classoid-state class) :sealed) layout
+ (not (classoid-subclasses class)))
;; Sealed and has no subclasses.
- (/noshow "sealed and has no subclasses")
(let ((n-layout (gensym)))
`(and (,pred object)
(let ((,n-layout (,get-layout object)))
- ,@(when (policy nil (>= safety speed))
+ ,@(when (policy *lexenv* (>= safety speed))
`((when (layout-invalid ,n-layout)
(%layout-invalid-error object ',layout))))
(eq ,n-layout ',layout)))))
- ((and (typep class 'basic-structure-class) layout)
- (/noshow "structure type tests; hierarchical layout depths")
+ ((and (typep class 'basic-structure-classoid) layout)
;; structure type tests; hierarchical layout depths
(let ((depthoid (layout-depthoid layout))
(n-layout (gensym)))
`(and (,pred object)
(let ((,n-layout (,get-layout object)))
- ,@(when (policy nil (>= safety speed))
+ ,@(when (policy *lexenv* (>= safety speed))
`((when (layout-invalid ,n-layout)
(%layout-invalid-error object ',layout))))
(if (eq ,n-layout ',layout)
(eq (svref (layout-inherits ,n-layout)
,depthoid)
',layout))))))))
+ ((and layout (>= (layout-depthoid layout) 0))
+ ;; hierarchical layout depths for other things (e.g.
+ ;; CONDITIONs)
+ (let ((depthoid (layout-depthoid layout))
+ (n-layout (gensym))
+ (n-inherits (gensym)))
+ `(and (,pred object)
+ (let ((,n-layout (,get-layout object)))
+ ,@(when (policy *lexenv* (>= safety speed))
+ `((when (layout-invalid ,n-layout)
+ (%layout-invalid-error object ',layout))))
+ (if (eq ,n-layout ',layout)
+ t
+ (let ((,n-inherits (layout-inherits ,n-layout)))
+ (declare (optimize (safety 0)))
+ (and (> (length ,n-inherits) ,depthoid)
+ (eq (svref ,n-inherits ,depthoid)
+ ',layout))))))))
(t
(/noshow "default case -- ,PRED and CLASS-CELL-TYPEP")
`(and (,pred object)
- (class-cell-typep (,get-layout object)
- ',(find-class-cell name)
- object)))))))))
-
-#|
-;;; Return (VALUES BEST-GUESS EXACT?), where BEST-GUESS is a CTYPE
-;;; which corresponds to the value returned by
-;;; CL:UPGRADED-ARRAY-ELEMENT-TYPE, and EXACT? tells whether that
-;;; result might change when we encounter a DEFTYPE.
-(declaim (maybe-inline upgraded-array-element-ctype-2))
-(defun upgraded-array-element-ctype-2 (spec)
- (let ((ctype (specifier-type `(array ,spec))))
- (values (array-type-specialized-element-type
- (specifier-type `(array ,spec)))
- (not (unknown-type-p (array-type-element-type ctype))))))
-|#
+ (classoid-cell-typep (,get-layout object)
+ ',(find-classoid-cell name)
+ object)))))))))
;;; If the specifier argument is a quoted constant, then we consider
;;; converting into a simple predicate or other stuff. If the type is
;;; If the type is TYPE= to a type that has a predicate, then expand
;;; to that predicate. Otherwise, we dispatch off of the type's type.
;;; These transformations can increase space, but it is hard to tell
-;;; when, so we ignore policy and always do them. When byte-compiling,
-;;; we only do transforms that have potential for control
-;;; simplification. Instance type tests are converted to
-;;; %INSTANCE-TYPEP to allow type propagation.
-(def-source-transform typep (object spec)
+;;; when, so we ignore policy and always do them.
+(define-source-transform typep (object spec)
+ ;; KLUDGE: It looks bad to only do this on explicitly quoted forms,
+ ;; since that would overlook other kinds of constants. But it turns
+ ;; out that the DEFTRANSFORM for TYPEP detects any constant
+ ;; continuation, transforms it into a quoted form, and gives this
+ ;; source transform another chance, so it all works out OK, in a
+ ;; weird roundabout way. -- WHN 2001-03-18
(if (and (consp spec) (eq (car spec) 'quote))
- (let ((type (specifier-type (cadr spec))))
- (or (let ((pred (cdr (assoc type *backend-type-predicates*
+ (let ((type (careful-specifier-type (cadr spec))))
+ (or (when (not type)
+ (compiler-warn "illegal type specifier for TYPEP: ~S"
+ (cadr spec))
+ `(%typep ,object ,spec))
+ (let ((pred (cdr (assoc type *backend-type-predicates*
:test #'type=))))
(when pred `(,pred ,object)))
(typecase type
(hairy-type
(source-transform-hairy-typep object type))
+ (negation-type
+ (source-transform-negation-typep object type))
(union-type
(source-transform-union-typep object type))
+ (intersection-type
+ (source-transform-intersection-typep object type))
(member-type
`(member ,object ',(member-type-members type)))
(args-type
- (compiler-warning "illegal type specifier for TYPEP: ~S"
- (cadr spec))
+ (compiler-warn "illegal type specifier for TYPEP: ~S"
+ (cadr spec))
`(%typep ,object ,spec))
(t nil))
- (and (not (byte-compiling))
- (typecase type
- (numeric-type
- (source-transform-numeric-typep object type))
- (sb!xc:class
- `(%instance-typep ,object ,spec))
- (array-type
- (source-transform-array-typep object type))
- ;; MNA: cons compound-type patch
- ;; FIXIT: all commented
-; (cons-type
-; (source-transform-cons-typep object type))
- (t nil)))
+ (typecase type
+ (numeric-type
+ (source-transform-numeric-typep object type))
+ (classoid
+ `(%instance-typep ,object ,spec))
+ (array-type
+ (source-transform-array-typep object type))
+ (cons-type
+ (source-transform-cons-typep object type))
+ (t nil))
`(%typep ,object ,spec)))
(values nil t)))
\f
;;;; coercion
-;;; old working version
-(deftransform coerce ((x type) (* *) * :when :both)
+(deftransform coerce ((x type) (* *) * :node node)
(unless (constant-continuation-p type)
(give-up-ir1-transform))
- (let ((tspec (specifier-type (continuation-value type))))
+ (let ((tspec (ir1-transform-specifier-type (continuation-value type))))
(if (csubtypep (continuation-type x) tspec)
'x
+ ;; Note: The THE here makes sure that specifiers like
+ ;; (SINGLE-FLOAT 0.0 1.0) can raise a TYPE-ERROR.
`(the ,(continuation-value type)
- ,(cond ((csubtypep tspec (specifier-type 'double-float))
- '(%double-float x))
- ;; FIXME: If LONG-FLOAT is to be supported, we
- ;; need to pick it off here before falling through
- ;; to %SINGLE-FLOAT.
- ((csubtypep tspec (specifier-type 'float))
- '(%single-float x))
- (t
- (give-up-ir1-transform)))))))
+ ,(cond
+ ((csubtypep tspec (specifier-type 'double-float))
+ '(%double-float x))
+ ;; FIXME: #!+long-float (t ,(error "LONG-FLOAT case needed"))
+ ((csubtypep tspec (specifier-type 'float))
+ '(%single-float x))
+ ((and (csubtypep tspec (specifier-type 'simple-vector))
+ (policy node (< safety 3)))
+ `(if (simple-vector-p x)
+ x
+ (replace (make-array (length x)) x)))
+ ;; FIXME: other VECTOR types?
+ (t
+ (give-up-ir1-transform)))))))
-;;; KLUDGE: new broken version -- 20000504
-#+nil
-(deftransform coerce ((x type) (* *) * :when :both)
- (unless (constant-continuation-p type)
- (give-up-ir1-transform))
- (let ((tspec (specifier-type (continuation-value type))))
- (if (csubtypep (continuation-type x) tspec)
- 'x
- `(if #+nil (typep x type) #-nil nil
- x
- (the ,(continuation-value type)
- ,(cond ((csubtypep tspec (specifier-type 'double-float))
- '(%double-float x))
- ;; FIXME: If LONG-FLOAT is to be supported,
- ;; we need to pick it off here before falling
- ;; through to %SINGLE-FLOAT.
- ((csubtypep tspec (specifier-type 'float))
- '(%single-float x))
- #+nil
- ((csubtypep tspec (specifier-type 'list))
- '(coerce-to-list x))
- #+nil
- ((csubtypep tspec (specifier-type 'string))
- '(coerce-to-simple-string x))
- #+nil
- ((csubtypep tspec (specifier-type 'bit-vector))
- '(coerce-to-bit-vector x))
- #+nil
- ((csubtypep tspec (specifier-type 'vector))
- '(coerce-to-vector x type))
- (t
- (give-up-ir1-transform))))))))