0.8.13.47:

	The quest for a real 64-bit port continues:

	* add logic for 64-bit friendly specialized array types (although
	  the appropriate getter and setter VOPs may not be written);
	* add widetags for the same and attempt to preserve binary
	  compatibility by not moving around the widetags for existing
	  32-bit ports;
	* modify bits of the garbage collector to handle the same, mostly
	  in scavenging and friends.  The garbage collector has not been
	  reviewed (yet) for 64-bit cleanness;
	* export symbols for 64-bit friendly specialized array types
	  from appropriate packages (but note KLUDGE in package-data-list);
	* export several Lisp-determined constants in SB!VM to C-land.
	  Since they are no longer hard-coded in the C source files,
	  rearrange headers to #include sbcl.h as the first user-defined
	  header to ensure constants are recognized in other header files;
	* remove 32-bit assumptions from NWORDS in the garbage collector
	  and remove duplicate definitions from various places.

package-data-list.lisp-expr

@@ -1278,15 +1278,38 @@ is a good idea, but see SB-SYS re. blurring of boundaries."
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-15-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-16-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-2-ERROR"
+                       ;; KLUDGE: 32-bit and 64-bit ports implement a
+                       ;; different set of specialized array types.
+                       ;; Various bits of code in SBCL assume that
+                       ;; symbols connected to the specialized array
+                       ;; types are exported.  But there's not a good
+                       ;; way at this point to know whether the port
+                       ;; for which we're building is 32-bit or 64-bit.
+                       ;; Granted, we could hardcode the particulars
+                       ;; (or even come up with a special :64BIT feature),
+                       ;; but that seems a little inelegant.  For now,
+                       ;; we brute-force the issue by always exporting
+                       ;; all the names required for both 32-bit and 64-bit
+                       ;; ports.  Other bits connected to the same issue
+                       ;; are noted throughout the code below with the
+                       ;; tag "32/64-bit issues".  --njf, 2004-08-09
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-29-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-31-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-32-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-4-ERROR"
+                       ;; FIXME: 32/64-bit issues
+		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-60-ERROR"
+		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-63-ERROR"
+		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-64-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-7-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-UNSIGNED-BYTE-8-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-SIGNED-BYTE-16-ERROR"
+                       ;; FIXME: 32/64-bit issues
 		       "OBJECT-NOT-SIMPLE-ARRAY-SIGNED-BYTE-30-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-SIGNED-BYTE-32-ERROR"
+                       ;; FIXME: 32/64-bit issues
+		       "OBJECT-NOT-SIMPLE-ARRAY-SIGNED-BYTE-61-ERROR"
+		       "OBJECT-NOT-SIMPLE-ARRAY-SIGNED-BYTE-64-ERROR"
 		       "OBJECT-NOT-SIMPLE-ARRAY-SIGNED-BYTE-8-ERROR"
 		       "OBJECT-NOT-SIMPLE-BIT-VECTOR-ERROR"
 		       "OBJECT-NOT-SIMPLE-BASE-STRING-ERROR"
@@ -1329,15 +1352,23 @@ is a good idea, but see SB-SYS re. blurring of boundaries."
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-15-P"
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-16-P"
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-2-P"
+                       ;; FIXME: 32/64-bit issues
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-29-P"
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-31-P"
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-32-P"
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-4-P"
+                       ;; FIXME: 32/64-bit issues
+                       "SIMPLE-ARRAY-UNSIGNED-BYTE-60-P"
+                       "SIMPLE-ARRAY-UNSIGNED-BYTE-63-P"
+                       "SIMPLE-ARRAY-UNSIGNED-BYTE-64-P"
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-7-P"
 		       "SIMPLE-ARRAY-UNSIGNED-BYTE-8-P"
 		       "SIMPLE-ARRAY-SIGNED-BYTE-16-P"
 		       "SIMPLE-ARRAY-SIGNED-BYTE-30-P"
 		       "SIMPLE-ARRAY-SIGNED-BYTE-32-P"
+                       ;; FIXME: 32/64-bit issues
+		       "SIMPLE-ARRAY-SIGNED-BYTE-61-P"
+		       "SIMPLE-ARRAY-SIGNED-BYTE-64-P"
 		       "SIMPLE-ARRAY-SIGNED-BYTE-8-P"
 		       "SIMPLE-BASE-STRING-P"
 		       "SIMPLE-PACKAGE-ERROR"
@@ -2074,8 +2105,13 @@ structure representations"
 					"OBJECT-NOT-LIST-TRAP" "OBJECT-NOT-INSTANCE-TRAP"
 					"OCFP-SAVE-OFFSET"
 					"ODD-FIXNUM-LOWTAG"
-					"OFFSET-STATIC-SYMBOL" "OTHER-IMMEDIATE-0-LOWTAG"
-					"OTHER-IMMEDIATE-1-LOWTAG" "OTHER-POINTER-LOWTAG"
+					"OFFSET-STATIC-SYMBOL"
+                                        "OTHER-IMMEDIATE-0-LOWTAG"
+					"OTHER-IMMEDIATE-1-LOWTAG"
+                                        ;; FIXME: 32/64-bit issues
+                                        "OTHER-IMMEDIATE-2-LOWTAG"
+                                        "OTHER-IMMEDIATE-3-LOWTAG"
+                                        "OTHER-POINTER-LOWTAG"
 					"PAD-DATA-BLOCK" "PENDING-INTERRUPT-TRAP"
 					"PRIMITIVE-OBJECT" "PRIMITIVE-OBJECT-WIDETAG"
 					"PRIMITIVE-OBJECT-LOWTAG" "PRIMITIVE-OBJECT-NAME"
@@ -2107,15 +2143,24 @@ structure representations"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-15-WIDETAG"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-16-WIDETAG"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-2-WIDETAG"
+                                        ;; FIXME: 32/64-bit issues
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-29-WIDETAG"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-31-WIDETAG"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-32-WIDETAG"
+                                        ;; FIXME: 32/64-bit issues
+					"SIMPLE-ARRAY-UNSIGNED-BYTE-60-WIDETAG"
+					"SIMPLE-ARRAY-UNSIGNED-BYTE-63-WIDETAG"
+					"SIMPLE-ARRAY-UNSIGNED-BYTE-64-WIDETAG"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-4-WIDETAG"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-7-WIDETAG"
 					"SIMPLE-ARRAY-UNSIGNED-BYTE-8-WIDETAG"
 					"SIMPLE-ARRAY-SIGNED-BYTE-16-WIDETAG"
-					"SIMPLE-ARRAY-SIGNED-BYTE-30-WIDETAG"
+                                        ;; FIXME: 32/64-bit issues
+                                        "SIMPLE-ARRAY-SIGNED-BYTE-30-WIDETAG"
 					"SIMPLE-ARRAY-SIGNED-BYTE-32-WIDETAG"
+                                        ;; FIXME: 32/64-bit issues
+					"SIMPLE-ARRAY-SIGNED-BYTE-61-WIDETAG"
+					"SIMPLE-ARRAY-SIGNED-BYTE-64-WIDETAG"
 					"SIMPLE-ARRAY-SIGNED-BYTE-8-WIDETAG"
 					"SIMPLE-BIT-VECTOR-WIDETAG"
 					"SIMPLE-BASE-STRING-WIDETAG"

src/code/class.lisp

@@ -1024,8 +1024,7 @@
       :translation (and integer (not fixnum))
       :inherits (integer rational real number)
       :codes (#.sb!vm:bignum-widetag)
-      ;; FIXME: wrong for 64-bit!
-      :prototype-form (expt 2 42))
+      :prototype-form (expt 2 #.(* sb!vm:n-word-bits (/ 3 2))))
 
      (array :translation array :codes (#.sb!vm:complex-array-widetag)
             :hierarchical-p nil
@@ -1091,6 +1090,7 @@
       :direct-superclasses (vector simple-array)
       :inherits (vector simple-array array sequence)
       :prototype-form (make-array 0 :element-type '(unsigned-byte 16)))
+     #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
      (simple-array-unsigned-byte-29
       :translation (simple-array (unsigned-byte 29) (*))
       :codes (#.sb!vm:simple-array-unsigned-byte-29-widetag)
@@ -1109,6 +1109,27 @@
       :direct-superclasses (vector simple-array)
       :inherits (vector simple-array array sequence)
       :prototype-form (make-array 0 :element-type '(unsigned-byte 32)))
+     #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+     (simple-array-unsigned-byte-60
+      :translation (simple-array (unsigned-byte 60) (*))
+      :codes (#.sb!vm:simple-array-unsigned-byte-60-widetag)
+      :direct-superclasses (vector simple-array)
+      :inherits (vector simple-array array sequence)
+      :prototype-form (make-array 0 :element-type '(unsigned-byte 60)))
+     #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+     (simple-array-unsigned-byte-63
+      :translation (simple-array (unsigned-byte 63) (*))
+      :codes (#.sb!vm:simple-array-unsigned-byte-63-widetag)
+      :direct-superclasses (vector simple-array)
+      :inherits (vector simple-array array sequence)
+      :prototype-form (make-array 0 :element-type '(unsigned-byte 63)))
+     #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+     (simple-array-unsigned-byte-64
+      :translation (simple-array (unsigned-byte 64) (*))
+      :codes (#.sb!vm:simple-array-unsigned-byte-64-widetag)
+      :direct-superclasses (vector simple-array)
+      :inherits (vector simple-array array sequence)
+      :prototype-form (make-array 0 :element-type '(unsigned-byte 64)))
      (simple-array-signed-byte-8
       :translation (simple-array (signed-byte 8) (*))
       :codes (#.sb!vm:simple-array-signed-byte-8-widetag)
@@ -1121,6 +1142,7 @@
       :direct-superclasses (vector simple-array)
       :inherits (vector simple-array array sequence)
       :prototype-form (make-array 0 :element-type '(signed-byte 16)))
+     #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
      (simple-array-signed-byte-30
       :translation (simple-array (signed-byte 30) (*))
       :codes (#.sb!vm:simple-array-signed-byte-30-widetag)
@@ -1133,6 +1155,20 @@
       :direct-superclasses (vector simple-array)
       :inherits (vector simple-array array sequence)
       :prototype-form (make-array 0 :element-type '(signed-byte 32)))
+     #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+     (simple-array-signed-byte-61
+      :translation (simple-array (signed-byte 61) (*))
+      :codes (#.sb!vm:simple-array-signed-byte-61-widetag)
+      :direct-superclasses (vector simple-array)
+      :inherits (vector simple-array array sequence)
+      :prototype-form (make-array 0 :element-type '(signed-byte 61)))
+     #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+     (simple-array-signed-byte-64
+      :translation (simple-array (signed-byte 64) (*))
+      :codes (#.sb!vm:simple-array-signed-byte-64-widetag)
+      :direct-superclasses (vector simple-array)
+      :inherits (vector simple-array array sequence)
+      :prototype-form (make-array 0 :element-type '(signed-byte 64)))
      (simple-array-single-float
       :translation (simple-array single-float (*))
       :codes (#.sb!vm:simple-array-single-float-widetag)

src/compiler/generic/early-objdef.lisp

@@ -110,8 +110,15 @@
 ;;;
 ;;; rather than two separate tests and jumps 
 (defenum (:suffix -widetag
+          ;; The first widetag must be greater than SB!VM:LOWTAG-LIMIT
+          ;; otherwise code in generic/early-type-vops will suffer
+          ;; a long, horrible death.  --njf, 2004-08-09
 	  :start (+ (ash 1 n-lowtag-bits) other-immediate-0-lowtag)
 	  :step 4)
+  ;; NOTE: the binary numbers off to the side are only valid for 32-bit
+  ;; ports; add #x1000 if you want to know the values for 64-bit ports.
+  ;; And note that the numbers get a little scrambled further down.
+  ;;   --njf, 2004-08-09
   bignum                            ; 00001010
   ratio                             ; 00001110
   single-float                      ; 00010010
@@ -146,8 +153,10 @@
   unused07                          ; 01110110
   unused08                          ; 01111010
   unused09                          ; 01111110
-
+
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   unused10                          ; 10000010
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   unused11                          ; 10000110
 
   simple-array-unsigned-byte-2      ; 10001010
@@ -160,13 +169,25 @@
   simple-base-string                ; 10100110
   simple-bit-vector                 ; 10101010
   simple-vector                     ; 10101110
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   simple-array-unsigned-byte-29     ; 10110010
   simple-array-unsigned-byte-31     ; 10110110
   simple-array-unsigned-byte-32     ; 10111010
+  #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+  simple-array-unsigned-byte-60
+  #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+  simple-array-unsigned-byte-63
+  #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+  simple-array-unsigned-byte-64
   simple-array-signed-byte-8        ; 10111110
   simple-array-signed-byte-16       ; 11000010
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   simple-array-signed-byte-30       ; 11000110
   simple-array-signed-byte-32       ; 11001010
+  #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+  simple-array-signed-byte-61
+  #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+  simple-array-signed-byte-64
   simple-array-single-float         ; 11001110
   simple-array-double-float         ; 11010010
   simple-array-complex-single-float ; 11010110
@@ -178,8 +199,11 @@
   complex-vector                    ; 11101110
   complex-array                     ; 11110010
 
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   unused12                          ; 11110110
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   unused13                          ; 11111010
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   unused14                          ; 11111110
 )
 

src/compiler/generic/genesis.lisp

@@ -308,7 +308,11 @@
 			   (- unsigned #x40000000)
 			   unsigned))))
 	    ((or (= lowtag sb!vm:other-immediate-0-lowtag)
-		 (= lowtag sb!vm:other-immediate-1-lowtag))
+		 (= lowtag sb!vm:other-immediate-1-lowtag)
+                 #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+                 (= lowtag sb!vm:other-immediate-2-lowtag)
+                 #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+                 (= lowtag sb!vm:other-immediate-3-lowtag))
 	     (format stream
 		     "for other immediate: #X~X, type #b~8,'0B"
 		     (ash (descriptor-bits des) (- sb!vm:n-widetag-bits))
@@ -364,15 +368,15 @@
 (defun descriptor-fixnum (des)
   (let ((bits (descriptor-bits des)))
     (if (logbitp (1- sb!vm:n-word-bits) bits)
-      ;; KLUDGE: The (- SB!VM:N-WORD-BITS 2) term here looks right to
-      ;; me, and it works, but in CMU CL it was (1- SB!VM:N-WORD-BITS),
-      ;; and although that doesn't make sense for me, or work for me,
-      ;; it's hard to see how it could have been wrong, since CMU CL
-      ;; genesis worked. It would be nice to understand how this came
-      ;; to be.. -- WHN 19990901
-      (logior (ash bits (- 1 sb!vm:n-lowtag-bits)) 
-	      (ash -1 (- sb!vm:n-word-bits (1- sb!vm:n-lowtag-bits))))
-      (ash bits  (- 1 sb!vm:n-lowtag-bits)))))
+        ;; KLUDGE: The (- SB!VM:N-WORD-BITS 2) term here looks right to
+        ;; me, and it works, but in CMU CL it was (1- SB!VM:N-WORD-BITS),
+        ;; and although that doesn't make sense for me, or work for me,
+        ;; it's hard to see how it could have been wrong, since CMU CL
+        ;; genesis worked. It would be nice to understand how this came
+        ;; to be.. -- WHN 19990901
+        (logior (ash bits (- 1 sb!vm:n-lowtag-bits))
+                (ash -1 (1+ sb!vm:n-positive-fixnum-bits)))
+        (ash bits (- 1 sb!vm:n-lowtag-bits)))))
 
 ;;; common idioms
 (defun descriptor-bytes (des)
@@ -1833,7 +1837,7 @@
 	      (note-load-time-code-fixup code-object
 					 after-header
 					 value
-					 kind)))))) ))
+					 kind))))))))
   (values))
 
 (defun resolve-assembler-fixups ()
@@ -2136,6 +2140,11 @@
 		 (31 (prog1 sb!vm:simple-array-unsigned-byte-31-widetag
 		       (setf sizebits 32)))
 		 (32 sb!vm:simple-array-unsigned-byte-32-widetag)
+                 #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+                 (63 (prog1 sb!vm:simple-array-unsigned-byte-63-widetag
+                       (setf sizebits 64)))
+                 #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+                 (64 (sb!vm:simple-array-unsigned-byte-64-widetag))
 		 (t (error "losing element size: ~W" sizebits))))
 	 (result (allocate-vector-object *dynamic* sizebits len type))
 	 (start (+ (descriptor-byte-offset result)
@@ -2631,6 +2640,22 @@
               (maybe-record-with-translated-name '("-START" "-END") 6)
               (maybe-record-with-translated-name '("-CORE-ENTRY-TYPE-CODE") 7)
               (maybe-record-with-translated-name '("-CORE-SPACE-ID") 8))))))
+    ;; KLUDGE: these constants are sort of important, but there's no
+    ;; pleasing way to inform the code above about them.  So we fake
+    ;; it for now.  nikodemus on #lisp (2004-08-09) suggested simply
+    ;; exporting every numeric constant from SB!VM; that would work,
+    ;; but the C runtime would have to be altered to use Lisp-like names
+    ;; rather than the munged names currently exported.  --njf, 2004-08-09
+    (dolist (c '(sb!vm:n-word-bits sb!vm:n-word-bytes
+                 sb!vm:n-lowtag-bits sb!vm:lowtag-mask
+                 sb!vm:n-widetag-bits sb!vm:widetag-mask
+                 sb!vm:n-fixnum-tag-bits sb!vm:fixnum-tag-mask))
+      (push (list (substitute #\_ #\- (symbol-name c))
+                  -1                    ; invent a new priority
+                  (symbol-value c)
+                  nil)
+            constants))
+
     (setf constants
 	  (sort constants
 		(lambda (const1 const2)

src/compiler/generic/vm-array.lisp

@@ -99,23 +99,41 @@
 	  :importance 12)
 	 ((unsigned-byte 16) 0 16 simple-array-unsigned-byte-16
 	  :importance 12)
+         #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
 	 ((unsigned-byte 29) 0 32 simple-array-unsigned-byte-29
 	  :importance 8)
 	 ((unsigned-byte 31) 0 32 simple-array-unsigned-byte-31
 	  :importance 11)
 	 ((unsigned-byte 32) 0 32 simple-array-unsigned-byte-32
 	  :importance 11)
+         #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+         ((unsigned-byte 60) 0 64 simple-array-unsigned-byte-60
+          :importance 8)
+         #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+         ((unsigned-byte 63) 0 64 simple-array-unsigned-byte-63
+          :importance 9)
+         #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+         ((unsigned-byte 64) 0 64 simple-array-unsigned-byte-64
+          :importance 9)
 	 ((signed-byte 8) 0 8 simple-array-signed-byte-8
 	  :importance 10)
 	 ((signed-byte 16) 0 16 simple-array-signed-byte-16
 	  :importance 9)
 	 ;; KLUDGE: See the comment in PRIMITIVE-TYPE-AUX,
 	 ;; compiler/generic/primtype.lisp, for why this is FIXNUM and
 	 ;; not (SIGNED-BYTE 30)
+         #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
 	 (fixnum 0 32 simple-array-signed-byte-30
 	  :importance 8)
 	 ((signed-byte 32) 0 32 simple-array-signed-byte-32
 	  :importance 7)
+         ;; KLUDGE: see above KLUDGE for the 32-bit case
+         #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+         (fixnum 0 64 simple-array-signed-byte-61
+          :importance 8)
+         #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+         ((signed-byte 64) 0 64 simple-array-signed-byte-64
+          :importance 7)
 	 ((complex single-float) #C(0.0f0 0.0f0) 64
 	  simple-array-complex-single-float
 	  :importance 3)

src/compiler/generic/vm-fndb.lisp

@@ -27,11 +27,25 @@
 	   simple-array-unsigned-byte-2-p
 	   simple-array-unsigned-byte-4-p simple-array-unsigned-byte-7-p
 	   simple-array-unsigned-byte-8-p simple-array-unsigned-byte-15-p
-	   simple-array-unsigned-byte-16-p simple-array-unsigned-byte-29-p
+	   simple-array-unsigned-byte-16-p
+           #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+           simple-array-unsigned-byte-29-p
 	   simple-array-unsigned-byte-31-p
 	   simple-array-unsigned-byte-32-p
+           #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+           simple-array-unsigned-byte-60-p
+           #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+           simple-array-unsigned-byte-63-p
+           #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+           simple-array-unsigned-byte-64-p
 	   simple-array-signed-byte-8-p simple-array-signed-byte-16-p
-	   simple-array-signed-byte-30-p simple-array-signed-byte-32-p
+           #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+	   simple-array-signed-byte-30-p
+           simple-array-signed-byte-32-p
+           #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+           simple-array-signed-byte-61-p
+           #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+           simple-array-signed-byte-64-p
 	   simple-array-single-float-p simple-array-double-float-p
 	   #!+long-float simple-array-long-float-p
 	   simple-array-complex-single-float-p