src/code/cross-type.lisp

   1 ;;;; cross-compiler-only versions of TYPEP, TYPE-OF, and related functions
   2
   3 ;;;; This software is part of the SBCL system. See the README file for
   4 ;;;; more information.
   5 ;;;;
   6 ;;;; This software is derived from the CMU CL system, which was
   7 ;;;; written at Carnegie Mellon University and released into the
   8 ;;;; public domain. The software is in the public domain and is
   9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
  10 ;;;; files for more information.
  11
  12 (in-package "SB!KERNEL")
  13
  14 ;;; Is X a fixnum in the target Lisp?
  15 (defun fixnump (x)
  16   (and (integerp x)
  17        (<= sb!xc:most-negative-fixnum x sb!xc:most-positive-fixnum)))
  18
  19 ;;; (This was a useful warning when trying to get bootstrapping
  20 ;;; to work, but it's mostly irrelevant noise now that the system
  21 ;;; works.)
  22 (define-condition cross-type-style-warning (style-warning)
  23   ((call :initarg :call
  24          :reader cross-type-style-warning-call)
  25    (message :reader cross-type-style-warning-message
  26             #+cmu :initarg #+cmu :message ; (to stop bogus non-STYLE WARNING)
  27             ))
  28   (:report (lambda (c s)
  29              (format
  30               s
  31               "cross-compilation-time type ambiguity (should be OK) in ~S:~%~A"
  32               (cross-type-style-warning-call c)
  33               (cross-type-style-warning-message c)))))
  34
  35 ;;; This warning is issued when giving up on a type calculation where a
  36 ;;; conservative answer is acceptable. Since a conservative answer is
  37 ;;; acceptable, the only downside is lost optimization opportunities.
  38 (define-condition cross-type-giving-up-conservatively
  39     (cross-type-style-warning)
  40   ((message :initform "giving up conservatively"
  41             #+cmu :reader #+cmu #.(gensym) ; (to stop bogus non-STYLE WARNING)
  42             )))
  43
  44 ;;; This warning refers to the flexibility in the ANSI spec with
  45 ;;; regard to run-time distinctions between floating point types.
  46 ;;; (E.g. the cross-compilation host might not even distinguish
  47 ;;; between SINGLE-FLOAT and DOUBLE-FLOAT, so a DOUBLE-FLOAT number
  48 ;;; would test positive as SINGLE-FLOAT.) If the target SBCL does make
  49 ;;; this distinction, then information is lost. It's not too hard to
  50 ;;; contrive situations where this would be a problem. In practice we
  51 ;;; don't tend to run into them because all widely used Common Lisp
  52 ;;; environments do recognize the distinction between SINGLE-FLOAT and
  53 ;;; DOUBLE-FLOAT, and we don't really need the other distinctions
  54 ;;; (e.g. between SHORT-FLOAT and SINGLE-FLOAT), so we call
  55 ;;; WARN-POSSIBLE-CROSS-TYPE-FLOAT-INFO-LOSS to test at runtime
  56 ;;; whether we need to worry about this at all, and not warn unless we
  57 ;;; do. If we *do* have to worry about this at runtime, my (WHN
  58 ;;; 19990808) guess is that the system will break in multiple places,
  59 ;;; so this is a real WARNING, not just a STYLE-WARNING.
  60 ;;;
  61 ;;; KLUDGE: If we ever try to support LONG-FLOAT or SHORT-FLOAT, this
  62 ;;; situation will get a lot more complicated.
  63 (defun warn-possible-cross-type-float-info-loss (call)
  64   (when (or (subtypep 'single-float 'double-float)
  65             (subtypep 'double-float 'single-float))
  66     (warn "possible floating point information loss in ~S" call)))
  67
  68 (defun sb!xc:type-of (object)
  69   (let ((raw-result (type-of object)))
  70     (cond ((or (subtypep raw-result 'float)
  71                (subtypep raw-result 'complex))
  72            (warn-possible-cross-type-float-info-loss
  73             `(sb!xc:type-of ,object))
  74            raw-result)
  75           ((subtypep raw-result 'integer)
  76            (cond ((<= 0 object 1)
  77                   'bit)
  78                  (;; We can't rely on the host's opinion of whether
  79                   ;; it's a FIXNUM, but instead test against target
  80                   ;; MOST-fooITIVE-FIXNUM limits.
  81                   (fixnump object)
  82                   'fixnum)
  83                  (t
  84                   'integer)))
  85           ((subtypep raw-result 'simple-string)
  86            `(simple-base-string ,(length object)))
  87           ((subtypep raw-result 'string) 'base-string)
  88           ((some (lambda (type) (subtypep raw-result type))
  89                  '(array character list symbol))
  90            raw-result)
  91           (t
  92            (error "can't handle TYPE-OF ~S in cross-compilation" object)))))
  93
  94 ;;; Is SYMBOL in the CL package? Note that we're testing this on the
  95 ;;; cross-compilation host, which could do things any old way. In
  96 ;;; particular, it might be in the CL package even though
  97 ;;; SYMBOL-PACKAGE is not (FIND-PACKAGE :CL). So we test things
  98 ;;; another way.
  99 (defun in-cl-package-p (symbol)
 100   (eql (find-symbol (symbol-name symbol) :cl)
 101        symbol))
 102
 103 ;;; This is like TYPEP, except that it asks whether HOST-OBJECT would
 104 ;;; be of TARGET-TYPE when instantiated on the target SBCL. Since this
 105 ;;; is hard to determine in some cases, and since in other cases we
 106 ;;; just haven't bothered to try, it needs to return two values, just
 107 ;;; like SUBTYPEP: the first value for its conservative opinion (never
 108 ;;; T unless it's certain) and the second value to tell whether it's
 109 ;;; certain.
 110 (defun cross-typep (host-object raw-target-type)
 111   (let ((target-type (type-expand raw-target-type)))
 112     (flet ((warn-and-give-up ()
 113            ;; We don't have to keep track of this as long as system
 114            ;; performance is acceptable, since giving up
 115            ;; conservatively is a safe way out.
 116            #+nil
 117            (warn 'cross-type-giving-up-conservatively
 118                  :call `(cross-typep ,host-object ,raw-target-type))
 119            (values nil nil))
 120            (warn-about-possible-float-info-loss ()
 121              (warn-possible-cross-type-float-info-loss
 122                `(cross-typep ,host-object ,raw-target-type)))
 123            ;; a convenient idiom for making more matches to special cases:
 124            ;; Test both forms of target type for membership in LIST.
 125            ;;
 126            ;; (In order to avoid having to use too much deep knowledge
 127            ;; of types, it's sometimes convenient to test RAW-TARGET-TYPE
 128            ;; as well as the expanded type, since we can get matches with
 129            ;; just EQL. E.g. SIMPLE-STRING can be matched with EQL, while
 130            ;; safely matching its expansion,
 131            ;;  (OR (SIMPLE-ARRAY CHARACTER (*)) (SIMPLE-BASE-STRING *))
 132            ;; would require logic clever enough to know that, e.g., OR is
 133            ;; commutative.)
 134            (target-type-is-in (list)
 135              (or (member raw-target-type list)
 136                  (member target-type list))))
 137       (cond (;; Handle various SBCL-specific types which can't exist on
 138              ;; the ANSI cross-compilation host. KLUDGE: This code will
 139              ;; need to be tweaked by hand if the names of these types
 140              ;; ever change, ugh!
 141              (if (consp target-type)
 142                  (member (car target-type)
 143                          '(sb!alien:alien))
 144                  (member target-type
 145                          '(system-area-pointer
 146                            sb!alien-internals:alien-value)))
 147              (values nil t))
 148             (;; special case when TARGET-TYPE isn't a type spec, but
 149              ;; instead a CLASS object.
 150              (typep target-type 'class)
 151              (bug "We don't support CROSS-TYPEP of CLASS type specifiers"))
 152             ((and (symbolp target-type)
 153                   (find-classoid target-type nil)
 154                   (sb!xc:subtypep target-type 'cl:structure-object)
 155                   (typep host-object '(or symbol number list character)))
 156              (values nil t))
 157             ((and (symbolp target-type)
 158                   (find-class target-type nil)
 159                   (subtypep target-type 'sb!kernel::structure!object))
 160              (values (typep host-object target-type) t))
 161             (;; easy cases of arrays and vectors
 162              (target-type-is-in
 163               '(array simple-string simple-vector string vector))
 164              (values (typep host-object target-type) t))
 165             (;; general cases of vectors
 166              (and (not (hairy-type-p (values-specifier-type target-type)))
 167                   (sb!xc:subtypep target-type 'cl:vector))
 168              (if (vectorp host-object)
 169                  (warn-and-give-up) ; general-case vectors being way too hard
 170                  (values nil t))) ; but "obviously not a vector" being easy
 171             (;; general cases of arrays
 172              (and (not (hairy-type-p (values-specifier-type target-type)))
 173                   (sb!xc:subtypep target-type 'cl:array))
 174              (if (arrayp host-object)
 175                  (warn-and-give-up) ; general-case arrays being way too hard
 176                  (values nil t))) ; but "obviously not an array" being easy
 177             ((target-type-is-in '(*))
 178              ;; KLUDGE: SBCL has * as an explicit wild type. While
 179              ;; this is sort of logical (because (e.g. (ARRAY * 1)) is
 180              ;; a valid type) it's not ANSI: looking at the ANSI
 181              ;; definitions of complex types like like ARRAY shows
 182              ;; that they consider * different from other type names.
 183              ;; Someday we should probably get rid of this non-ANSIism
 184              ;; in base SBCL, but until we do, we might as well here
 185              ;; in the cross compiler. And in order to make sure that
 186              ;; we don't continue doing it after we someday patch
 187              ;; SBCL's type system so that * is no longer a type, we
 188              ;; make this assertion. -- WHN 2001-08-08
 189              (aver (typep (values-specifier-type '*) 'named-type))
 190              (values t t))
 191             (;; Many simple types are guaranteed to correspond exactly
 192              ;; between any host ANSI Common Lisp and the target
 193              ;; Common Lisp. (Some array types are too, but they
 194              ;; were picked off earlier.)
 195              (target-type-is-in
 196               '(atom bit character complex cons float function integer keyword
 197                 list nil null number rational real signed-byte symbol t
 198                 unsigned-byte))
 199              (values (typep host-object target-type) t))
 200             (;; Floating point types are guaranteed to correspond,
 201              ;; too, but less exactly.
 202              (target-type-is-in
 203               '(single-float double-float))
 204              (cond ((floatp host-object)
 205                     (warn-about-possible-float-info-loss)
 206                     (values (typep host-object target-type) t))
 207                    (t
 208                     (values nil t))))
 209             (;; Complexes suffer the same kind of problems as arrays
 210              (and (not (hairy-type-p (values-specifier-type target-type)))
 211                   (sb!xc:subtypep target-type 'cl:complex))
 212              (if (complexp host-object)
 213                  (warn-and-give-up) ; general-case complexes being way too hard
 214                  (values nil t))) ; but "obviously not a complex" being easy
 215             ;; Some types require translation between the cross-compilation
 216             ;; host Common Lisp and the target SBCL.
 217             ((target-type-is-in '(classoid))
 218              (values (typep host-object 'classoid) t))
 219             ((target-type-is-in '(fixnum))
 220              (values (fixnump host-object) t))
 221             ;; Some types are too hard to handle in the positive
 222             ;; case, but at least we can be confident in a large
 223             ;; fraction of the negative cases..
 224             ((target-type-is-in
 225               '(base-string simple-base-string simple-string))
 226              (if (stringp host-object)
 227                  (warn-and-give-up)
 228                  (values nil t)))
 229             ((target-type-is-in '(character base-char))
 230              (cond ((typep host-object 'standard-char)
 231                     (values t t))
 232                    ((not (characterp host-object))
 233                     (values nil t))
 234                    (t
 235                     (warn-and-give-up))))
 236             ((target-type-is-in '(stream instance))
 237              ;; Neither target CL:STREAM nor target SB!KERNEL:INSTANCE
 238              ;; is implemented as a STRUCTURE-OBJECT, so they'll fall
 239              ;; through the tests above. We don't want to assume too
 240              ;; much about them here, but at least we know enough
 241              ;; about them to say that neither T nor NIL nor indeed
 242              ;; any other symbol in the cross-compilation host is one.
 243              ;; That knowledge suffices to answer so many of the
 244              ;; questions that the cross-compiler asks that it's well
 245              ;; worth special-casing it here.
 246              (if (symbolp host-object)
 247                  (values nil t)
 248                  (warn-and-give-up)))
 249             ;; various hacks for composite types..
 250             ((consp target-type)
 251              (let ((first (first target-type))
 252                    (rest (rest target-type)))
 253                (case first
 254                  ;; Many complex types are guaranteed to correspond exactly
 255                  ;; between any host ANSI Common Lisp and the target SBCL.
 256                  ((integer member mod rational real signed-byte unsigned-byte)
 257                   (values (typep host-object target-type) t))
 258                  ;; Floating point types are guaranteed to correspond,
 259                  ;; too, but less exactly.
 260                  ((single-float double-float)
 261                   (cond ((floatp host-object)
 262                          (warn-about-possible-float-info-loss)
 263                          (values (typep host-object target-type) t))
 264                         (t
 265                          (values nil t))))
 266                  ;; Some complex types have translations that are less
 267                  ;; trivial.
 268                  (and (every/type #'cross-typep host-object rest))
 269                  (or  (any/type   #'cross-typep host-object rest))
 270                  ;; If we want to work with the KEYWORD type, we need
 271                  ;; to grok (SATISFIES KEYWORDP).
 272                  (satisfies
 273                   (destructuring-bind (predicate-name) rest
 274                     (if (and (in-cl-package-p predicate-name)
 275                              (fboundp predicate-name))
 276                         ;; Many predicates like KEYWORDP, ODDP, PACKAGEP,
 277                         ;; and NULL correspond between host and target.
 278                         ;; But we still need to handle errors, because
 279                         ;; the code which calls us may not understand
 280                         ;; that a type is unreachable. (E.g. when compiling
 281                         ;; (AND STRING (SATISFIES ARRAY-HAS-FILL-POINTER-P))
 282                         ;; CTYPEP may be called on the SATISFIES expression
 283                         ;; even for non-STRINGs.)
 284                         (multiple-value-bind (result error?)
 285                             (ignore-errors (funcall predicate-name
 286                                                     host-object))
 287                           (if error?
 288                               (values nil nil)
 289                               (values result t)))
 290                         ;; For symbols not in the CL package, it's not
 291                         ;; in general clear how things correspond
 292                         ;; between host and target, so we punt.
 293                         (warn-and-give-up))))
 294                  ;; Some complex types are too hard to handle in the
 295                  ;; positive case, but at least we can be confident in
 296                  ;; a large fraction of the negative cases..
 297                  ((base-string simple-base-string simple-string)
 298                   (if (stringp host-object)
 299                       (warn-and-give-up)
 300                       (values nil t)))
 301                  ((vector simple-vector)
 302                   (if (vectorp host-object)
 303                       (warn-and-give-up)
 304                       (values nil t)))
 305                  ((array simple-array)
 306                   (if (arrayp host-object)
 307                       (warn-and-give-up)
 308                       (values nil t)))
 309                  (function
 310                   (if (functionp host-object)
 311                       (warn-and-give-up)
 312                       (values nil t)))
 313                  ;; And the Common Lisp type system is complicated,
 314                  ;; and we don't try to implement everything.
 315                  (otherwise (warn-and-give-up)))))
 316             ;; And the Common Lisp type system is complicated, and
 317             ;; we don't try to implement everything.
 318             (t
 319              (warn-and-give-up))))))
 320
 321 ;;; This is an incomplete TYPEP which runs at cross-compile time to
 322 ;;; tell whether OBJECT is the host Lisp representation of a target
 323 ;;; SBCL type specified by TARGET-TYPE-SPEC. It need make no pretense
 324 ;;; to completeness, since it need only handle the cases which arise
 325 ;;; when building SBCL itself, e.g. testing that range limits FOO and
 326 ;;; BAR in (INTEGER FOO BAR) are INTEGERs.
 327 (defun sb!xc:typep (host-object target-type-spec &optional (env nil env-p))
 328   (declare (ignore env))
 329   (aver (null env-p)) ; 'cause we're too lazy to think about it
 330   (multiple-value-bind (opinion certain-p)
 331       (cross-typep host-object target-type-spec)
 332     ;; A program that calls TYPEP doesn't want uncertainty and
 333     ;; probably can't handle it.
 334     (if certain-p
 335         opinion
 336         (error "uncertain in SB!XC:TYPEP ~S ~S"
 337                host-object
 338                target-type-spec))))
 339
 340 ;;; This is an incomplete, portable implementation for use at
 341 ;;; cross-compile time only.
 342 (defun ctypep (obj ctype)
 343   (check-type ctype ctype)
 344   ;; There is at least one possible endless recursion in the
 345   ;; cross-compiler type system: (SUBTYPEP NULL (OR UNKOWN0 UNKNOWN1)
 346   ;; runs out of stack. The right way would probably be to not
 347   ;; implement CTYPEP in terms of TYPE-SPECIFIER (:UNPARSE, that may
 348   ;; call TYPE=, that in turn may call CTYPEP). Until then, pick a few
 349   ;; cherries off.
 350   (cond ((member-type-p ctype)
 351          (if (member obj (member-type-members ctype))
 352              (values t t)
 353              (values nil t)))
 354         ((union-type-p ctype)
 355          (any/type #'ctypep obj (union-type-types ctype)))
 356         (t
 357          (let ( ;; the Common Lisp type specifier corresponding to CTYPE
 358                (type (type-specifier ctype)))
 359            (check-type type (or symbol cons))
 360            (cross-typep obj type)))))
 361
 362 (defun ctype-of (x)
 363   (typecase x
 364     (function
 365      (if (typep x 'generic-function)
 366          ;; Since at cross-compile time we build a CLOS-free bootstrap
 367          ;; version of SBCL, it's unclear how to explain to it what a
 368          ;; generic function is.
 369          (error "not implemented: cross CTYPE-OF generic function")
 370          ;; There's no ANSI way to find out what the function is
 371          ;; declared to be, so we just return the CTYPE for the
 372          ;; most-general function.
 373          *universal-fun-type*))
 374     (symbol
 375      (make-member-type :members (list x)))
 376     (number
 377      (ctype-of-number x))
 378     (string
 379      (make-array-type :dimensions (array-dimensions x)
 380                       :complexp (not (typep x 'simple-array))
 381                       :element-type (specifier-type 'base-char)
 382                       :specialized-element-type (specifier-type 'base-char)))
 383     (array
 384      (let ((etype (specifier-type (array-element-type x))))
 385        (make-array-type :dimensions (array-dimensions x)
 386                         :complexp (not (typep x 'simple-array))
 387                         :element-type etype
 388                         :specialized-element-type etype)))
 389     (cons (specifier-type 'cons))
 390     (character
 391      (cond ((typep x 'standard-char)
 392             ;; (Note that SBCL doesn't distinguish between BASE-CHAR and
 393             ;; CHARACTER.)
 394             (specifier-type 'base-char))
 395            ((not (characterp x))
 396             nil)
 397            (t
 398             ;; Beyond this, there seems to be no portable correspondence.
 399             (error "can't map host Lisp CHARACTER ~S to target Lisp" x))))
 400     (structure!object
 401      (find-classoid (uncross (class-name (class-of x)))))
 402     (t
 403      ;; There might be more cases which we could handle with
 404      ;; sufficient effort; since all we *need* to handle are enough
 405      ;; cases for bootstrapping, we don't try to be complete here,. If
 406      ;; future maintainers make the bootstrap code more complicated,
 407      ;; they can also add new cases here to handle it. -- WHN 2000-11-11
 408      (error "can't handle ~S in cross CTYPE-OF" x))))