0.9.4.5:

[sbcl.git] / src / compiler / generic / early-objdef.lisp

diff --git a/src/compiler/generic/early-objdef.lisp b/src/compiler/generic/early-objdef.lisp
index a3ca7fb..46bd930 100644 (file)
--- a/src/compiler/generic/early-objdef.lisp
+++ b/src/compiler/generic/early-objdef.lisp
@@ -20,12 +20,12 @@
 ;;; 'def.*even-fixnum-lowtag' can find them.
 
 ;;; Tags for the main low-level types are stored in the low n (usually three)
-;;; bits to identify the type of a machine word.  Certain constraints 
+;;; bits to identify the type of a machine word.  Certain constraints
 ;;; apply:
 ;;;   * EVEN-FIXNUM-LOWTAG and ODD-FIXNUM-LOWTAG must be 0 and 4: code
 ;;;     which shifts left two places to convert raw integers to tagged
 ;;;     fixnums is ubiquitous.
-;;;   * LIST-POINTER-LOWTAG + N-WORD-BYTES = OTHER-POINTER-LOWTAG: NIL 
+;;;   * LIST-POINTER-LOWTAG + N-WORD-BYTES = OTHER-POINTER-LOWTAG: NIL
 ;;;     is both a cons and a symbol (at the same address) and depends on this.
 ;;;     See the definition of SYMBOL in objdef.lisp
 ;;;   * OTHER-POINTER-LOWTAG > 4: Some code in the SPARC backend,
@@ -33,8 +33,10 @@
 ;;;     PSEUDO-ATOMIC is on, doesn't strip the low bits of reg_ALLOC
 ;;;     before ORing in OTHER-POINTER-LOWTAG within a PSEUDO-ATOMIC
 ;;;     section.
-;;;   * OTHER-IMMEDIATE-0-LOWTAG are spaced 4 apart: various code wants to 
+;;;   * OTHER-IMMEDIATE-0-LOWTAG are spaced 4 apart: various code wants to
 ;;;     iterate through these
+;;;   * Allocation code on Alpha wants lowtags for heap-allocated
+;;;     objects to be odd.
 ;;; (These are just the ones we know about as of sbcl-0.7.1.22. There
 ;;; might easily be more, since these values have stayed highly
 ;;; constrained for more than a decade, an inviting target for
@@ -108,15 +110,15 @@
 ;;;   ANDcc tag,  0xA6, tag
 ;;;   JNE   tag, label
 ;;;
-;;; rather than two separate tests and jumps 
+;;; 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)
+          :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.
+  ;; ports; add #b1000 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
@@ -136,14 +138,14 @@
   return-pc-header                  ; 00110110
   value-cell-header                 ; 00111010
   symbol-header                     ; 00111110
-  base-char                         ; 01000010
+  character                         ; 01000010
   sap                               ; 01000110
   unbound-marker                    ; 01001010
   weak-pointer                      ; 01001110
   instance-header                   ; 01010010
   fdefn                             ; 01010110
 
-  unused00                          ; 01011010
+  no-tls-value-marker               ; 01011010
   unused01                          ; 01011110
   unused02                          ; 01100010
   unused03                          ; 01100110
@@ -151,7 +153,9 @@
   unused05                          ; 01101110
   unused06                          ; 01110010
   unused07                          ; 01110110
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   unused08                          ; 01111010
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   unused09                          ; 01111110
 
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
@@ -167,6 +171,7 @@
   simple-array-unsigned-byte-16     ; 10011110
   simple-array-nil                  ; 10100010
   simple-base-string                ; 10100110
+  #!+sb-unicode simple-character-string
   simple-bit-vector                 ; 10101010
   simple-vector                     ; 10101110
   #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
@@ -195,15 +200,18 @@
   simple-array                      ; 11011110
   complex-vector-nil                ; 11100010
   complex-base-string               ; 11100110
+  #!+sb-unicode complex-character-string
   complex-bit-vector                ; 11101010
   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))
+  #!+(and #.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+          (not sb-unicode))
   unused13                          ; 11111010
-  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+  #!+(and #.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+          (not sb-unicode))
   unused14                          ; 11111110
 )