X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fearly-objdef.lisp;h=ef6563c42057e7d11a7660a38833c5e560d8243a;hb=cd875f8c1fb306067521330fbf84411713b7c20d;hp=b40ee3a75fdd2f3763263ffd20d54fddadb36163;hpb=f143939b1dbaf38ebd4f92c851fbc4ecddf37af1;p=sbcl.git diff --git a/src/compiler/generic/early-objdef.lisp b/src/compiler/generic/early-objdef.lisp index b40ee3a..ef6563c 100644 --- a/src/compiler/generic/early-objdef.lisp +++ b/src/compiler/generic/early-objdef.lisp @@ -14,21 +14,37 @@ ;;; FIXME: It's clever using :SUFFIX -TYPE for these things, but it's ;;; a pain for people just learning to find their way around the code ;;; who want to use lexical search to figure out where things like -;;; EVEN-FIXNUM-TYPE are defined. Remove the :SUFFIXes and just expand -;;; out the full names. Or even define them in DEF-FROB EVEN-FIXNUM-TYPE -;;; style so searches like 'def.*even-fixnum-type' can find them. +;;; EVEN-FIXNUM-LOWTAG are defined. Remove the :SUFFIXes and just expand +;;; out the full names. Or even define them in DEF EVEN-FIXNUM-LOWTAG +;;; style so searches like 'def.*even-fixnum-lowtag' can find them. -;;; the main types. These types are represented by the low three bits -;;; of the pointer or immediate object. +;;; Tags for the main low-level types are stored in the low three +;;; 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 + 4 = 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, +;;; which uses bit 2 of the ALLOC register to indicate that +;;; PSEUDO-ATOMIC is on, doesn't strip the low bits of reg_ALLOC +;;; before ORing in OTHER-POINTER-LOWTAG within a PSEUDO-ATOMIC +;;; section. +;;; (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 +;;; inventive abstraction-phobic maintainers.:-) (eval-when (:compile-toplevel :load-toplevel :execute) ;; The EVAL-WHEN is necessary (at least for Lispworks), because the - ;; second DEFENUM uses the value of OTHER-IMMEDIATE-0-TYPE, which is + ;; second DEFENUM uses the value of OTHER-IMMEDIATE-0-LOWTAG, which is ;; defined in the first DEFENUM. -- AL 20000216 - (defenum (:suffix -type) + (defenum (:suffix -lowtag) even-fixnum - ;; Note: CMU CL, and SBCL < 0.pre7.39, had FUN-POINTER-TYPE - ;; here. We swapped FUN-POINTER-TYPE and - ;; INSTANCE-POINTER-TYPE in sbcl-0.pre7.39 in order to help with a + ;; Note: CMU CL, and SBCL < 0.pre7.39, had FUN-POINTER-LOWTAG + ;; here. We swapped FUN-POINTER-LOWTAG and + ;; INSTANCE-POINTER-LOWTAG in sbcl-0.pre7.39 in order to help with a ;; low-level pun in the function call sequence on the PPC port. ;; For more information, see the PPC port code. -- WHN 2001-10-03 instance-pointer @@ -39,11 +55,47 @@ other-immediate-1 other-pointer)) -;;; the heap types. Each of these types is in the header of objects in -;;; the heap. -(defenum (:suffix -type - :start (+ (ash 1 lowtag-bits) other-immediate-0-type) - :step (ash 1 (1- lowtag-bits))) +;;; the heap types, stored in 8 bits of the header of an object on the +;;; heap, to identify the type of the heap object (which'll be at +;;; least two machine words, often more) +;;; +;;; Note: the order specified here is not critical for correctness, +;;; but (FIXME) with %TEST-HEADERS as currently defined, BIGNUM must +;;; be first, and COMPLEX-ARRAY must be last. +;;; +;;; However, for efficiency, we prefer contiguous sets of widetags for +;;; "similar" objects, so that type checking can be done with a range +;;; check, rather than several individual checks. +;;; +;;; * BIGNUM + RATIO (+ FIXNUM) = RATIONAL +;;; +;;; * SINGLE-FLOAT + DOUBLE-FLOAT + LONG-FLOAT = FLOAT +;;; +;;; * RATIONAL + FLOAT = REAL +;;; +;;; * (FIXME: COMPLEX example, which needs fixing anyway -- see +;;; UPGRADED-COMPLEX-PART-TYPE) +;;; +;;; * SIMPLE-ARRAY-* = (SIMPLE-ARRAY * (*)) +;;; +;;; * SIMPLE-ARRAY-NIL + SIMPLE-BASE-STRING = SIMPLE-STRING +;;; +;;; * SIMPLE-ARRAY + COMPLEX-ARRAYOID = (SATISFIES ARRAY-HEADER-P) +;;; +;;; In addition, with +;;; sufficient care we can cause extra combinations to appear with +;;; differences in only one bit, permitting a more efficient type +;;; test. As an example, if SIMPLE-BASE-STRING = 0xA6 and +;;; COMPLEX-BASE-STRING = 0xE6, then the type test for BASE-STRING is +;;; +;;; AND tag, ~0x40, tag +;;; ANDcc tag, 0xA6, tag +;;; JNE tag, label +;;; +;;; rather than two separate tests and jumps +(defenum (:suffix -widetag + :start (+ (ash 1 n-lowtag-bits) other-immediate-0-lowtag) + :step (ash 1 (1- n-lowtag-bits))) bignum ratio single-float @@ -54,14 +106,49 @@ complex-double-float #!+long-float complex-long-float - simple-array - simple-string - simple-bit-vector - simple-vector + code-header + simple-fun-header + closure-header + funcallable-instance-header + + return-pc-header + value-cell-header + symbol-header + base-char + sap + unbound-marker + weak-pointer + instance-header + fdefn + + unused00 + unused01 + unused02 + unused03 + unused04 + unused05 + unused06 + unused07 + #!-long-float unused08 + #!-long-float unused09 + + #!+long-float simple-array-long-float + #!+long-float simple-array-complex-long-float + #!-long-float unused10 + #!-long-float unused11 + simple-array-unsigned-byte-2 simple-array-unsigned-byte-4 + simple-array-unsigned-byte-7 simple-array-unsigned-byte-8 + simple-array-unsigned-byte-15 simple-array-unsigned-byte-16 + simple-array-nil + simple-base-string + simple-bit-vector + simple-vector + simple-array-unsigned-byte-29 + simple-array-unsigned-byte-31 simple-array-unsigned-byte-32 simple-array-signed-byte-8 simple-array-signed-byte-16 @@ -69,30 +156,15 @@ simple-array-signed-byte-32 simple-array-single-float simple-array-double-float - #!+long-float simple-array-long-float simple-array-complex-single-float simple-array-complex-double-float - #!+long-float simple-array-complex-long-float - complex-string + simple-array + complex-vector-nil + complex-base-string complex-bit-vector complex-vector complex-array - - code-header - simple-fun-header - closure-header - funcallable-instance-header - closure-fun-header - - return-pc-header - value-cell-header - symbol-header - base-char - sap - unbound-marker - weak-pointer - instance-header - fdefn) +) ;;; the different vector subtypes (defenum (:prefix vector- :suffix -subtype)