X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fvm-type.lisp;h=4f7c4a770c175fc90857457904b6d494e44cf9f8;hb=c45da820b56cd0bd4bd958b66639fa021054f962;hp=85c1b0b8af7b94b031a66ae7429c36e13e5bb4e3;hpb=a4c3562138e342465826de31fb8c324ae8a4b594;p=sbcl.git

diff --git a/src/compiler/generic/vm-type.lisp b/src/compiler/generic/vm-type.lisp
index 85c1b0b..4f7c4a7 100644
--- a/src/compiler/generic/vm-type.lisp
+++ b/src/compiler/generic/vm-type.lisp
@@ -17,6 +17,8 @@
 ;;;; FIXME: I'm not sure where to put this. -- WHN 19990817
 
 (def!type sb!vm:word () `(unsigned-byte ,sb!vm:n-word-bits))
+(def!type sb!vm:signed-word () `(signed-byte ,sb!vm:n-word-bits))
+
 
 ;;;; implementation-dependent DEFTYPEs
 
@@ -84,14 +86,14 @@
   (collect ((types (list 'or)))
     (dolist (type *specialized-array-element-types*)
       (when (subtypep type '(or integer character float (complex float)))
-	(types `(array ,type ,dims))))
+        (types `(array ,type ,dims))))
     (types)))
 
 (sb!xc:deftype simple-unboxed-array (&optional dims)
   (collect ((types (list 'or)))
     (dolist (type *specialized-array-element-types*)
       (when (subtypep type '(or integer character float (complex float)))
-	(types `(simple-array ,type ,dims))))
+        (types `(simple-array ,type ,dims))))
     (types)))
 
 ;;; Return the symbol that describes the format of FLOAT.
@@ -110,24 +112,24 @@
 (defun specialize-array-type (type)
   (let ((eltype (array-type-element-type type)))
     (setf (array-type-specialized-element-type type)
-	  (if (or (eq eltype *wild-type*)
-		  ;; This is slightly dubious, but not as dubious as
-		  ;; assuming that the upgraded-element-type should be
-		  ;; equal to T, given the way that the AREF
-		  ;; DERIVE-TYPE optimizer works.  -- CSR, 2002-08-19
-		  (unknown-type-p eltype))
-	      *wild-type*
-	      (dolist (stype-name *specialized-array-element-types*
-				  *universal-type*)
-		;; FIXME: Mightn't it be better to have
-		;; *SPECIALIZED-ARRAY-ELEMENT-TYPES* be stored as precalculated
-		;; SPECIFIER-TYPE results, instead of having to calculate
-		;; them on the fly this way? (Call the new array
-		;; *SPECIALIZED-ARRAY-ELEMENT-SPECIFIER-TYPES* or something..)
-		(let ((stype (specifier-type stype-name)))
-		  (aver (not (unknown-type-p stype)))
-		  (when (csubtypep eltype stype)
-		    (return stype))))))
+          (if (or (eq eltype *wild-type*)
+                  ;; This is slightly dubious, but not as dubious as
+                  ;; assuming that the upgraded-element-type should be
+                  ;; equal to T, given the way that the AREF
+                  ;; DERIVE-TYPE optimizer works.  -- CSR, 2002-08-19
+                  (unknown-type-p eltype))
+              *wild-type*
+              (dolist (stype-name *specialized-array-element-types*
+                                  *universal-type*)
+                ;; FIXME: Mightn't it be better to have
+                ;; *SPECIALIZED-ARRAY-ELEMENT-TYPES* be stored as precalculated
+                ;; SPECIFIER-TYPE results, instead of having to calculate
+                ;; them on the fly this way? (Call the new array
+                ;; *SPECIALIZED-ARRAY-ELEMENT-SPECIFIER-TYPES* or something..)
+                (let ((stype (specifier-type stype-name)))
+                  (aver (not (unknown-type-p stype)))
+                  (when (csubtypep eltype stype)
+                    (return stype))))))
     type))
 
 (defun sb!xc:upgraded-array-element-type (spec &optional environment)
@@ -138,7 +140,7 @@
   (if (unknown-type-p (specifier-type spec))
       (error "undefined type: ~S" spec)
       (type-specifier (array-type-specialized-element-type
-		       (specifier-type `(array ,spec))))))
+                       (specifier-type `(array ,spec))))))
 
 (defun sb!xc:upgraded-complex-part-type (spec &optional environment)
   #!+sb-doc
@@ -168,10 +170,10 @@
 ;;; includes the given type.
 (defun containing-integer-type (subtype)
   (dolist (type '(fixnum
-		  (signed-byte 32)
-		  (unsigned-byte 32)
-		  integer)
-		(error "~S isn't an integer type?" subtype))
+                  (signed-byte 32)
+                  (unsigned-byte 32)
+                  integer)
+                (error "~S isn't an integer type?" subtype))
     (when (csubtypep subtype (specifier-type type))
       (return type))))
 
@@ -182,20 +184,28 @@
   (typecase type
     (cons-type
      (if (type= type (specifier-type 'cons))
-	 'sb!c:check-cons
-	 nil))
+         'sb!c:check-cons
+         nil))
     (built-in-classoid
      (if (type= type (specifier-type 'symbol))
-	 'sb!c:check-symbol
-	 nil))
+         'sb!c:check-symbol
+         nil))
     (numeric-type
      (cond ((type= type (specifier-type 'fixnum))
-	    'sb!c:check-fixnum)
-	   ((type= type (specifier-type '(signed-byte 32)))
-	    'sb!c:check-signed-byte-32)
-	   ((type= type (specifier-type '(unsigned-byte 32)))
-	    'sb!c:check-unsigned-byte-32)
-	   (t nil)))
+            'sb!c:check-fixnum)
+           #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+           ((type= type (specifier-type '(signed-byte 32)))
+            'sb!c:check-signed-byte-32)
+           #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+           ((type= type (specifier-type '(unsigned-byte 32)))
+            'sb!c:check-unsigned-byte-32)
+           #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+           ((type= type (specifier-type '(signed-byte 64)))
+            'sb!c:check-signed-byte-64)
+           #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+           ((type= type (specifier-type '(unsigned-byte 64)))
+            'sb!c:check-unsigned-byte-64)
+           (t nil)))
     (fun-type
      'sb!c:check-fun)
     (t