a baby step where angels fear to tread.. I'm still heading for a

system where all address constants are defined in one place. I've been
wandering around in a morass of increasingly broken systems (not just
broken s/w -- a flaky graphics adaptor contributed h/w flakiness too)
for quite a while. This version is starting over again with a small
step forward from the last known working state of the system.

diff --git a/package-data-list.lisp-expr b/package-data-list.lisp-expr
index 35ffdee..85027d6 100644 (file)
--- a/package-data-list.lisp-expr
+++ b/package-data-list.lisp-expr
@@ -357,7 +357,7 @@ like *STACK-TOP-HINT*"
  #s(sb-cold:package-data
     :name "SB!DI"
     :doc "private: primitives used to write debuggers"
  #s(sb-cold:package-data
     :name "SB!DI"
     :doc "private: primitives used to write debuggers"

-    :use ("CL" "SB!EXT" "SB!INT" "SB!KERNEL" "SB!SYS")
+    :use ("CL" "SB!EXT" "SB!INT" "SB!KERNEL" "SB!SYS" "SB!VM")

     :import-from (("SB!C"
                    "DEBUG-SOURCE-FROM" "DEBUG-SOURCE-NAME"
                    "DEBUG-SOURCE-CREATED" "DEBUG-SOURCE-COMPILED"
     :import-from (("SB!C"
                    "DEBUG-SOURCE-FROM" "DEBUG-SOURCE-NAME"
                    "DEBUG-SOURCE-CREATED" "DEBUG-SOURCE-COMPILED"

@@ -1694,7 +1694,7 @@ structure representations"
              "TARGET-FASL-CODE-FORMAT" "TARGET-FASL-FILE-TYPE"
              "TARGET-HEAP-ADDRESS-SPACE" "*TARGET-MOST-NEGATIVE-FIXNUM*"
              "*TARGET-MOST-POSITIVE-FIXNUM*" "*READ-ONLY-SPACE-START*"
              "TARGET-FASL-CODE-FORMAT" "TARGET-FASL-FILE-TYPE"
              "TARGET-HEAP-ADDRESS-SPACE" "*TARGET-MOST-NEGATIVE-FIXNUM*"
              "*TARGET-MOST-POSITIVE-FIXNUM*" "*READ-ONLY-SPACE-START*"

-             "*STATIC-SPACE-START*" "TRACE-TABLE-CALL-SITE"
+             "STATIC-SPACE-START" "TRACE-TABLE-CALL-SITE"

              "TRACE-TABLE-FUNCTION-EPILOGUE" "TRACE-TABLE-FUNCTION-PROLOGUE"
              "TRACE-TABLE-NORMAL" "TYPE-BITS" "TYPE-MASK" "UNBOUND-MARKER-TYPE"
              "UNSIGNED-IMMEDIATE-SC-NUMBER"
              "TRACE-TABLE-FUNCTION-EPILOGUE" "TRACE-TABLE-FUNCTION-PROLOGUE"
              "TRACE-TABLE-NORMAL" "TYPE-BITS" "TYPE-MASK" "UNBOUND-MARKER-TYPE"
              "UNSIGNED-IMMEDIATE-SC-NUMBER"

diff --git a/src/assembly/x86/arith.lisp b/src/assembly/x86/arith.lisp
index 55e86e0..59d1edf 100644 (file)
--- a/src/assembly/x86/arith.lisp
+++ b/src/assembly/x86/arith.lisp
@@ -52,7 +52,7 @@
                (inst mov ecx (fixnumize 2)) ; arg count
                (inst jmp
                      (make-ea :dword
                (inst mov ecx (fixnumize 2)) ; arg count
                (inst jmp
                      (make-ea :dword

-                              :disp (+ *nil-value*
+                              :disp (+ nil-value

                                        (static-function-offset
                                         ',(symbolicate "TWO-ARG-" fun)))))
 
                                        (static-function-offset
                                         ',(symbolicate "TWO-ARG-" fun)))))
 

@@ -147,7 +147,7 @@
   (inst push eax)
   (inst mov ecx (fixnumize 1))   ; arg count
   (inst jmp (make-ea :dword
   (inst push eax)
   (inst mov ecx (fixnumize 1))   ; arg count
   (inst jmp (make-ea :dword

-                    :disp (+ *nil-value* (static-function-offset '%negate))))
+                    :disp (+ nil-value (static-function-offset '%negate))))

 
   FIXNUM
   (move res x)
 
   FIXNUM
   (move res x)

@@ -198,14 +198,14 @@
                                        ; SINGLE-FLOAT-BITS are parallel,
                                        ; should be named parallelly.
                (inst jmp (make-ea :dword
                                        ; SINGLE-FLOAT-BITS are parallel,
                                        ; should be named parallelly.
                (inst jmp (make-ea :dword

-                                  :disp (+ *nil-value*
+                                  :disp (+ nil-value

                                            (static-function-offset
                                             ',static-fn))))
 
                INLINE-FIXNUM-COMPARE
                (inst cmp x y)
                (inst jmp ,test RETURN-TRUE)
                                            (static-function-offset
                                             ',static-fn))))
 
                INLINE-FIXNUM-COMPARE
                (inst cmp x y)
                (inst jmp ,test RETURN-TRUE)

-               (inst mov res *nil-value*)
+               (inst mov res nil-value)

                ;; FIXME: A note explaining this return convention, or a
                ;; symbolic name for it, would be nice. (It looks as though we
                ;; should be hand-crafting the same return sequence as would be
                ;; FIXME: A note explaining this return convention, or a
                ;; symbolic name for it, would be nice. (It looks as though we
                ;; should be hand-crafting the same return sequence as would be

@@ -243,7 +243,7 @@
   (inst jmp :nz DO-STATIC-FN)
 
   RETURN-NIL
   (inst jmp :nz DO-STATIC-FN)
 
   RETURN-NIL

-  (inst mov res *nil-value*)
+  (inst mov res nil-value)

   (inst pop eax)
   (inst add eax 2)
   (inst jmp eax)
   (inst pop eax)
   (inst add eax 2)
   (inst jmp eax)

@@ -256,7 +256,7 @@
   (inst push eax)
   (inst mov ecx (fixnumize 2))
   (inst jmp (make-ea :dword
   (inst push eax)
   (inst mov ecx (fixnumize 2))
   (inst jmp (make-ea :dword

-                    :disp (+ *nil-value* (static-function-offset 'eql))))
+                    :disp (+ nil-value (static-function-offset 'eql))))

 
   RETURN-T
   (load-symbol res t)
 
   RETURN-T
   (load-symbol res t)

@@ -278,13 +278,13 @@
                          (:temp ecx unsigned-reg ecx-offset)
                          )
   (inst test x 3)                     ; descriptor?
                          (:temp ecx unsigned-reg ecx-offset)
                          )
   (inst test x 3)                     ; descriptor?

-  (inst jmp :nz DO-STATIC-FN)     ; yes do it here
+  (inst jmp :nz DO-STATIC-FN)          ; yes, do it here

   (inst test y 3)                     ; descriptor?
   (inst jmp :nz DO-STATIC-FN)
   (inst cmp x y)
   (inst jmp :e RETURN-T)               ; ok
 
   (inst test y 3)                     ; descriptor?
   (inst jmp :nz DO-STATIC-FN)
   (inst cmp x y)
   (inst jmp :e RETURN-T)               ; ok
 

-  (inst mov res *nil-value*)
+  (inst mov res nil-value)

   (inst pop eax)
   (inst add eax 2)
   (inst jmp eax)
   (inst pop eax)
   (inst add eax 2)
   (inst jmp eax)

@@ -297,7 +297,7 @@
   (inst push eax)
   (inst mov ecx (fixnumize 2))
   (inst jmp (make-ea :dword
   (inst push eax)
   (inst mov ecx (fixnumize 2))
   (inst jmp (make-ea :dword

-                    :disp (+ *nil-value* (static-function-offset 'two-arg-=))))
+                    :disp (+ nil-value (static-function-offset 'two-arg-=))))

 
   RETURN-T
   (load-symbol res t))
 
   RETURN-T
   (load-symbol res t))

diff --git a/src/assembly/x86/assem-rtns.lisp b/src/assembly/x86/assem-rtns.lisp
index 4fedbd7..65e50b1 100644 (file)
--- a/src/assembly/x86/assem-rtns.lisp
+++ b/src/assembly/x86/assem-rtns.lisp
@@ -74,7 +74,7 @@
   ;; Handle the register arg cases.
   ZERO-VALUES
   (move esp-tn ebx)
   ;; Handle the register arg cases.
   ZERO-VALUES
   (move esp-tn ebx)

-  (inst mov edx *nil-value*)
+  (inst mov edx nil-value)

   (inst mov edi edx)
   (inst mov esi edx)
   (inst jmp eax)
   (inst mov edi edx)
   (inst mov esi edx)
   (inst jmp eax)

@@ -89,7 +89,7 @@
   TWO-VALUES
   (loadw edx esi -1)
   (loadw edi esi -2)
   TWO-VALUES
   (loadw edx esi -1)
   (loadw edi esi -2)

-  (inst mov esi *nil-value*)
+  (inst mov esi nil-value)

   (inst lea esp-tn (make-ea :dword :base ebx :disp (* -2 word-bytes)))
   (inst jmp eax)
 
   (inst lea esp-tn (make-ea :dword :base ebx :disp (* -2 word-bytes)))
   (inst jmp eax)
 

diff --git a/src/code/bit-bash.lisp b/src/code/bit-bash.lisp
index 1df58ce..64cd344 100644 (file)
--- a/src/code/bit-bash.lisp
+++ b/src/code/bit-bash.lisp
@@ -213,7 +213,7 @@
        ;; care.
        (cond
         ((zerop length)
        ;; care.
        (cond
         ((zerop length)

-         ;; Actually, we aren't even writing one word. This is real easy.
+         ;; Actually, we aren't even writing one word. This is really easy.

          )
         ((= length unit-bits)
          ;; DST-BIT-OFFSET must be equal to zero, or we would be writing
          )
         ((= length unit-bits)
          ;; DST-BIT-OFFSET must be equal to zero, or we would be writing

diff --git a/src/code/debug-int.lisp b/src/code/debug-int.lisp
index b06b89c..e8f9ef5 100644 (file)
--- a/src/code/debug-int.lisp
+++ b/src/code/debug-int.lisp
@@ -2477,7 +2477,7 @@
            (or (< sb!vm:*read-only-space-start* val
                   (* sb!vm:*read-only-space-free-pointer*
                      sb!vm:word-bytes))
            (or (< sb!vm:*read-only-space-start* val
                   (* sb!vm:*read-only-space-free-pointer*
                      sb!vm:word-bytes))

-               (< sb!vm::*static-space-start* val
+               (< sb!vm::static-space-start val

                   (* sb!vm:*static-space-free-pointer*
                      sb!vm:word-bytes))
                (< (sb!vm:current-dynamic-space-start) val
                   (* sb!vm:*static-space-free-pointer*
                      sb!vm:word-bytes))
                (< (sb!vm:current-dynamic-space-start) val

diff --git a/src/code/gc.lisp b/src/code/gc.lisp
index 7921d48..45a8a36 100644 (file)
--- a/src/code/gc.lisp
+++ b/src/code/gc.lisp
@@ -42,7 +42,7 @@
 
 (defun static-space-usage ()
   (- (* sb!vm:*static-space-free-pointer* sb!vm:word-bytes)
 
 (defun static-space-usage ()
   (- (* sb!vm:*static-space-free-pointer* sb!vm:word-bytes)

-     sb!vm:*static-space-start*))
+     sb!vm:static-space-start))

 
 (defun read-only-space-usage ()
   (- (* sb!vm::*read-only-space-free-pointer* sb!vm:word-bytes)
 
 (defun read-only-space-usage ()
   (- (* sb!vm::*read-only-space-free-pointer* sb!vm:word-bytes)

diff --git a/src/code/room.lisp b/src/code/room.lisp
index 9827be8..7f01e04 100644 (file)
--- a/src/code/room.lisp
+++ b/src/code/room.lisp
@@ -120,7 +120,7 @@
   (declare (type spaces space))
   (ecase space
     (:static
   (declare (type spaces space))
   (ecase space
     (:static

-     (values (int-sap *static-space-start*)
+     (values (int-sap static-space-start)

             (int-sap (* *static-space-free-pointer* word-bytes))))
     (:read-only
      (values (int-sap *read-only-space-start*)
             (int-sap (* *static-space-free-pointer* word-bytes))))
     (:read-only
      (values (int-sap *read-only-space-start*)

diff --git a/src/compiler/byte-comp.lisp b/src/compiler/byte-comp.lisp
index 55185a6..b428064 100644 (file)
--- a/src/compiler/byte-comp.lisp
+++ b/src/compiler/byte-comp.lisp
@@ -1217,7 +1217,7 @@
                 found
                 name))))
         ((eql values 0)
                 found
                 name))))
         ((eql values 0)

-         ;; Real easy!
+         ;; really easy!

          nil)
         (t
          (etypecase leaf
          nil)
         (t
          (etypecase leaf

diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp
index 277f0c6..5123b7a 100644 (file)
--- a/src/compiler/generic/genesis.lisp
+++ b/src/compiler/generic/genesis.lisp
@@ -2639,7 +2639,7 @@
              ;; We actually ran GENESIS, use the real value.
              (descriptor-bits (cold-intern symbol))
              ;; We didn't run GENESIS, so guess at the address.
              ;; We actually ran GENESIS, use the real value.
              (descriptor-bits (cold-intern symbol))
              ;; We didn't run GENESIS, so guess at the address.

-             (+ sb!vm:*static-space-start*
+             (+ sb!vm:static-space-start

                 sb!vm:word-bytes
                 sb!vm:other-pointer-type
                 (if symbol (sb!vm:static-symbol-offset symbol) 0)))))
                 sb!vm:word-bytes
                 sb!vm:other-pointer-type
                 (if symbol (sb!vm:static-symbol-offset symbol) 0)))))

@@ -2943,7 +2943,7 @@ initially undefined function references:~2%")
                                     sb!vm:*read-only-space-start*))
           (*static*    (make-gspace :static
                                     static-space-id
                                     sb!vm:*read-only-space-start*))
           (*static*    (make-gspace :static
                                     static-space-id

-                                    sb!vm:*static-space-start*))
+                                    sb!vm:static-space-start))

           (*dynamic*   (make-gspace :dynamic
                                     dynamic-space-id
                                     sb!vm:*dynamic-space-start*))
           (*dynamic*   (make-gspace :dynamic
                                     dynamic-space-id
                                     sb!vm:*dynamic-space-start*))

diff --git a/src/compiler/x86/alloc.lisp b/src/compiler/x86/alloc.lisp
index 11c4d78..c233755 100644 (file)
--- a/src/compiler/x86/alloc.lisp
+++ b/src/compiler/x86/alloc.lisp
@@ -27,8 +27,8 @@
   (:node-var node)
   (:generator 0
     (cond ((zerop num)
   (:node-var node)
   (:generator 0
     (cond ((zerop num)

-          ;; (move result *nil-value*)
-          (inst mov result *nil-value*))
+          ;; (move result nil-value)
+          (inst mov result nil-value))

          ((and star (= num 1))
           (move result (tn-ref-tn things)))
          (t
          ((and star (= num 1))
           (move result (tn-ref-tn things)))
          (t

@@ -58,7 +58,7 @@
                       (setf things (tn-ref-across things))
                       (store-car (tn-ref-tn things) ptr cons-cdr-slot))
                      (t
                       (setf things (tn-ref-across things))
                       (store-car (tn-ref-tn things) ptr cons-cdr-slot))
                      (t

-                      (storew *nil-value* ptr cons-cdr-slot
+                      (storew nil-value ptr cons-cdr-slot

                               list-pointer-type)))
                (assert (null (tn-ref-across things)))))
             (move result res))))))
                               list-pointer-type)))
                (assert (null (tn-ref-across things)))))
             (move result res))))))

@@ -110,7 +110,7 @@
      (inst or boxed code-header-type)
      (storew boxed result 0 other-pointer-type)
      (storew unboxed result code-code-size-slot other-pointer-type)
      (inst or boxed code-header-type)
      (storew boxed result 0 other-pointer-type)
      (storew unboxed result code-code-size-slot other-pointer-type)

-     (inst mov temp *nil-value*)
+     (inst mov temp nil-value)

      (storew temp result code-entry-points-slot other-pointer-type))
     (storew temp result code-debug-info-slot other-pointer-type)))
 
      (storew temp result code-entry-points-slot other-pointer-type))
     (storew temp result code-debug-info-slot other-pointer-type)))
 

@@ -138,8 +138,8 @@
      (inst or boxed code-header-type)
      (storew boxed result 0 other-pointer-type)
      (storew unboxed result code-code-size-slot other-pointer-type)
      (inst or boxed code-header-type)
      (storew boxed result 0 other-pointer-type)
      (storew unboxed result code-code-size-slot other-pointer-type)

-     (storew *nil-value* result code-entry-points-slot other-pointer-type))
-    (storew *nil-value* result code-debug-info-slot other-pointer-type)))
+     (storew nil-value result code-entry-points-slot other-pointer-type))
+    (storew nil-value result code-debug-info-slot other-pointer-type)))

 \f
 (define-vop (make-fdefn)
   (:policy :fast-safe)
 \f
 (define-vop (make-fdefn)
   (:policy :fast-safe)

@@ -150,7 +150,7 @@
   (:generator 37
     (with-fixed-allocation (result fdefn-type fdefn-size node)
       (storew name result fdefn-name-slot other-pointer-type)
   (:generator 37
     (with-fixed-allocation (result fdefn-type fdefn-size node)
       (storew name result fdefn-name-slot other-pointer-type)

-      (storew *nil-value* result fdefn-function-slot other-pointer-type)
+      (storew nil-value result fdefn-function-slot other-pointer-type)

       (storew (make-fixup (extern-alien-name "undefined_tramp") :foreign)
              result fdefn-raw-addr-slot other-pointer-type))))
 
       (storew (make-fixup (extern-alien-name "undefined_tramp") :foreign)
              result fdefn-raw-addr-slot other-pointer-type))))
 

@@ -251,5 +251,5 @@
       (inst shr temp 1)
       (inst and temp #xfffffffc)
       (storew temp result symbol-hash-slot other-pointer-type)
       (inst shr temp 1)
       (inst and temp #xfffffffc)
       (storew temp result symbol-hash-slot other-pointer-type)

-      (storew *nil-value* result symbol-plist-slot other-pointer-type)
-      (storew *nil-value* result symbol-package-slot other-pointer-type))))
+      (storew nil-value result symbol-plist-slot other-pointer-type)
+      (storew nil-value result symbol-package-slot other-pointer-type))))

diff --git a/src/compiler/x86/c-call.lisp b/src/compiler/x86/c-call.lisp
index 87440e0..b9c2240 100644 (file)
--- a/src/compiler/x86/c-call.lisp
+++ b/src/compiler/x86/c-call.lisp
@@ -218,7 +218,7 @@
     (unless (zerop amount)
       (let ((delta (logandc2 (+ amount 3) 3)))
        (inst sub (make-ea :dword
     (unless (zerop amount)
       (let ((delta (logandc2 (+ amount 3) 3)))
        (inst sub (make-ea :dword

-                          :disp (+ *nil-value*
+                          :disp (+ nil-value

                                    (static-symbol-offset '*alien-stack*)
                                    (ash symbol-value-slot word-shift)
                                    (- other-pointer-type)))
                                    (static-symbol-offset '*alien-stack*)
                                    (ash symbol-value-slot word-shift)
                                    (- other-pointer-type)))

@@ -231,7 +231,7 @@
     (unless (zerop amount)
       (let ((delta (logandc2 (+ amount 3) 3)))
        (inst add (make-ea :dword
     (unless (zerop amount)
       (let ((delta (logandc2 (+ amount 3) 3)))
        (inst add (make-ea :dword

-                          :disp (+ *nil-value*
+                          :disp (+ nil-value

                                    (static-symbol-offset '*alien-stack*)
                                    (ash symbol-value-slot word-shift)
                                    (- other-pointer-type)))
                                    (static-symbol-offset '*alien-stack*)
                                    (ash symbol-value-slot word-shift)
                                    (- other-pointer-type)))

diff --git a/src/compiler/x86/call.lisp b/src/compiler/x86/call.lisp
index f55f2cd..a0fb814 100644 (file)
--- a/src/compiler/x86/call.lisp
+++ b/src/compiler/x86/call.lisp
@@ -251,7 +251,7 @@
       ;; Default the unsuppled registers.
       (let* ((2nd-tn-ref (tn-ref-across values))
             (2nd-tn (tn-ref-tn 2nd-tn-ref)))
       ;; Default the unsuppled registers.
       (let* ((2nd-tn-ref (tn-ref-across values))
             (2nd-tn (tn-ref-tn 2nd-tn-ref)))

-       (inst mov 2nd-tn *nil-value*)
+       (inst mov 2nd-tn nil-value)

        (when (> nvals 2)
          (loop
            for tn-ref = (tn-ref-across 2nd-tn-ref)
        (when (> nvals 2)
          (loop
            for tn-ref = (tn-ref-across 2nd-tn-ref)

@@ -274,7 +274,7 @@
       (inst jmp-short regs-defaulted)
       ;; Do the single value case.
       ;; Default the register args
       (inst jmp-short regs-defaulted)
       ;; Do the single value case.
       ;; Default the register args

-      (inst mov eax-tn *nil-value*)
+      (inst mov eax-tn nil-value)

       (do ((i 1 (1+ i))
           (val (tn-ref-across values) (tn-ref-across val)))
          ((= i (min nvals register-arg-count)))
       (do ((i 1 (1+ i))
           (val (tn-ref-across values) (tn-ref-across val)))
          ((= i (min nvals register-arg-count)))

@@ -288,7 +288,7 @@
 
       (emit-label regs-defaulted)
 
 
       (emit-label regs-defaulted)
 

-      (inst mov eax-tn *nil-value*)
+      (inst mov eax-tn nil-value)

       (storew edx-tn ebx-tn -1)
       (collect ((defaults))
        (do ((i register-arg-count (1+ i))
       (storew edx-tn ebx-tn -1)
       (collect ((defaults))
        (do ((i register-arg-count (1+ i))

@@ -335,7 +335,7 @@
       ;; the MV return point.
       (inst mov ebx-tn esp-tn)
       (inst push edx-tn)
       ;; the MV return point.
       (inst mov ebx-tn esp-tn)
       (inst push edx-tn)

-      (inst mov edi-tn *nil-value*)
+      (inst mov edi-tn nil-value)

       (inst push edi-tn)
       (inst mov esi-tn edi-tn)
       ;; Compute a pointer to where to put the [defaulted] stack values.
       (inst push edi-tn)
       (inst mov esi-tn edi-tn)
       ;; Compute a pointer to where to put the [defaulted] stack values.

@@ -345,7 +345,7 @@
                     :disp (* (- (1+ register-arg-count)) word-bytes)))
       ;; Load EAX with NIL so we can quickly store it, and set up stuff
       ;; for the loop.
                     :disp (* (- (1+ register-arg-count)) word-bytes)))
       ;; Load EAX with NIL so we can quickly store it, and set up stuff
       ;; for the loop.

-      (inst mov eax-tn *nil-value*)
+      (inst mov eax-tn nil-value)

       (inst std)
       (inst mov ecx-tn (- nvals register-arg-count))
       ;; Jump into the default loop.
       (inst std)
       (inst mov ecx-tn (- nvals register-arg-count))
       ;; Jump into the default loop.

@@ -392,7 +392,7 @@
       (inst mov ecx-tn eax-tn)
       (inst shr ecx-tn word-shift)     ; word count
       ;; Load EAX with NIL for fast storing.
       (inst mov ecx-tn eax-tn)
       (inst shr ecx-tn word-shift)     ; word count
       ;; Load EAX with NIL for fast storing.

-      (inst mov eax-tn *nil-value*)
+      (inst mov eax-tn nil-value)

       ;; Do the store.
       (emit-label default-stack-vals)
       (inst rep)
       ;; Do the store.
       (emit-label default-stack-vals)
       (inst rep)

@@ -1033,7 +1033,7 @@
     (when (< nvals register-arg-count)
       (let* ((arg-tns (nthcdr nvals (list a0 a1 a2)))
             (first (first arg-tns)))
     (when (< nvals register-arg-count)
       (let* ((arg-tns (nthcdr nvals (list a0 a1 a2)))
             (first (first arg-tns)))

-       (inst mov first *nil-value*)
+       (inst mov first nil-value)

        (dolist (tn (cdr arg-tns))
          (inst mov tn first))))
     ;; And away we go. Except that return-pc is still on the
        (dolist (tn (cdr arg-tns))
          (inst mov tn first))))
     ;; And away we go. Except that return-pc is still on the

@@ -1294,7 +1294,7 @@
       (move src context)
       (move ecx count)
       ;; Check to see whether there are no args, and just return NIL if so.
       (move src context)
       (move ecx count)
       ;; Check to see whether there are no args, and just return NIL if so.

-      (inst mov result *nil-value*)
+      (inst mov result nil-value)

       (inst jecxz done)
       (inst lea dst (make-ea :dword :index ecx :scale 2))
       (pseudo-atomic
       (inst jecxz done)
       (inst lea dst (make-ea :dword :index ecx :scale 2))
       (pseudo-atomic

@@ -1321,7 +1321,7 @@
        ;; Go back for more.
        (inst loop loop)
        ;; NIL out the last cons.
        ;; Go back for more.
        (inst loop loop)
        ;; NIL out the last cons.

-       (storew *nil-value* dst 1 sb!vm:list-pointer-type))
+       (storew nil-value dst 1 sb!vm:list-pointer-type))

       (emit-label done))))
 
 ;;; Return the location and size of the more arg glob created by Copy-More-Arg.
       (emit-label done))))
 
 ;;; Return the location and size of the more arg glob created by Copy-More-Arg.

diff --git a/src/compiler/x86/cell.lisp b/src/compiler/x86/cell.lisp
index 336b5dc..8c97721 100644 (file)
--- a/src/compiler/x86/cell.lisp
+++ b/src/compiler/x86/cell.lisp
@@ -43,7 +43,7 @@
               (inst mov
                     (make-ea :dword :base object
                              :disp (- (* offset word-bytes) lowtag))
               (inst mov
                     (make-ea :dword :base object
                              :disp (- (* offset word-bytes) lowtag))

-                    (+ *nil-value* (static-symbol-offset val))))
+                    (+ nil-value (static-symbol-offset val))))

              (character
               (inst mov
                     (make-ea :dword :base object
              (character
               (inst mov
                     (make-ea :dword :base object

@@ -140,7 +140,7 @@
   (:save-p :compute-only)
   (:generator 10
     (loadw value object fdefn-function-slot other-pointer-type)
   (:save-p :compute-only)
   (:generator 10
     (loadw value object fdefn-function-slot other-pointer-type)

-    (inst cmp value *nil-value*)
+    (inst cmp value nil-value)

     ;; FIXME: UNDEFINED-SYMBOL-ERROR seems to actually be for symbols with no
     ;; function value, not, as the name might suggest, symbols with no ordinary
     ;; value. Perhaps the name could be made more mnemonic?
     ;; FIXME: UNDEFINED-SYMBOL-ERROR seems to actually be for symbols with no
     ;; function value, not, as the name might suggest, symbols with no ordinary
     ;; value. Perhaps the name could be made more mnemonic?

@@ -175,7 +175,7 @@
   (:args (fdefn :scs (descriptor-reg) :target result))
   (:results (result :scs (descriptor-reg)))
   (:generator 38
   (:args (fdefn :scs (descriptor-reg) :target result))
   (:results (result :scs (descriptor-reg)))
   (:generator 38

-    (storew *nil-value* fdefn fdefn-function-slot other-pointer-type)
+    (storew nil-value fdefn fdefn-function-slot other-pointer-type)

     (storew (make-fixup (extern-alien-name "undefined_tramp") :foreign)
            fdefn fdefn-raw-addr-slot other-pointer-type)
     (move result fdefn)))
     (storew (make-fixup (extern-alien-name "undefined_tramp") :foreign)
            fdefn fdefn-raw-addr-slot other-pointer-type)
     (move result fdefn)))

diff --git a/src/compiler/x86/debug.lisp b/src/compiler/x86/debug.lisp
index 5e663f7..091a61c 100644 (file)
--- a/src/compiler/x86/debug.lisp
+++ b/src/compiler/x86/debug.lisp
@@ -112,7 +112,7 @@
       (emit-label done)
       (assemble (*elsewhere*)
        (emit-label bogus)
       (emit-label done)
       (assemble (*elsewhere*)
        (emit-label bogus)

-       (inst mov code *nil-value*)
+       (inst mov code nil-value)

        (inst jmp done)))))
 
 (define-vop (code-from-lra code-from-mumble)
        (inst jmp done)))))
 
 (define-vop (code-from-lra code-from-mumble)

diff --git a/src/compiler/x86/macros.lisp b/src/compiler/x86/macros.lisp
index 39d1f16..ca830c3 100644 (file)
--- a/src/compiler/x86/macros.lisp
+++ b/src/compiler/x86/macros.lisp
@@ -68,12 +68,12 @@
 ;;;; macros to generate useful values
 
 (defmacro load-symbol (reg symbol)
 ;;;; macros to generate useful values
 
 (defmacro load-symbol (reg symbol)

-  `(inst mov ,reg (+ *nil-value* (static-symbol-offset ,symbol))))
+  `(inst mov ,reg (+ nil-value (static-symbol-offset ,symbol))))

 
 (defmacro load-symbol-value (reg symbol)
   `(inst mov ,reg
         (make-ea :dword
 
 (defmacro load-symbol-value (reg symbol)
   `(inst mov ,reg
         (make-ea :dword

-                 :disp (+ *nil-value*
+                 :disp (+ nil-value

                           (static-symbol-offset ',symbol)
                           (ash symbol-value-slot word-shift)
                           (- other-pointer-type)))))
                           (static-symbol-offset ',symbol)
                           (ash symbol-value-slot word-shift)
                           (- other-pointer-type)))))

@@ -81,7 +81,7 @@
 (defmacro store-symbol-value (reg symbol)
   `(inst mov
         (make-ea :dword
 (defmacro store-symbol-value (reg symbol)
   `(inst mov
         (make-ea :dword

-                 :disp (+ *nil-value*
+                 :disp (+ nil-value

                           (static-symbol-offset ',symbol)
                           (ash symbol-value-slot word-shift)
                           (- other-pointer-type)))
                           (static-symbol-offset ',symbol)
                           (ash symbol-value-slot word-shift)
                           (- other-pointer-type)))

@@ -389,7 +389,7 @@
        (when *enable-pseudo-atomic*
         ;; FIXME: The MAKE-EA noise should become a MACROLET macro or
         ;; something. (perhaps SVLB, for static variable low byte)
        (when *enable-pseudo-atomic*
         ;; FIXME: The MAKE-EA noise should become a MACROLET macro or
         ;; something. (perhaps SVLB, for static variable low byte)

-        (inst mov (make-ea :byte :disp (+ *nil-value*
+        (inst mov (make-ea :byte :disp (+ nil-value

                                           (static-symbol-offset
                                            'sb!impl::*pseudo-atomic-interrupted*)
                                           (ash symbol-value-slot word-shift)
                                           (static-symbol-offset
                                            'sb!impl::*pseudo-atomic-interrupted*)
                                           (ash symbol-value-slot word-shift)

@@ -397,7 +397,7 @@
                                           ;; take out type bits.
                                           (- other-pointer-type)))
               0)
                                           ;; take out type bits.
                                           (- other-pointer-type)))
               0)

-        (inst mov (make-ea :byte :disp (+ *nil-value*
+        (inst mov (make-ea :byte :disp (+ nil-value

                                           (static-symbol-offset
                                            'sb!impl::*pseudo-atomic-atomic*)
                                           (ash symbol-value-slot word-shift)
                                           (static-symbol-offset
                                            'sb!impl::*pseudo-atomic-atomic*)
                                           (ash symbol-value-slot word-shift)

@@ -405,7 +405,7 @@
               (fixnumize 1)))
        ,@forms
        (when *enable-pseudo-atomic*
               (fixnumize 1)))
        ,@forms
        (when *enable-pseudo-atomic*

-        (inst mov (make-ea :byte :disp (+ *nil-value*
+        (inst mov (make-ea :byte :disp (+ nil-value

                                           (static-symbol-offset
                                            'sb!impl::*pseudo-atomic-atomic*)
                                           (ash symbol-value-slot word-shift)
                                           (static-symbol-offset
                                            'sb!impl::*pseudo-atomic-atomic*)
                                           (ash symbol-value-slot word-shift)

@@ -418,7 +418,7 @@
         ;; are pending? I wish I could find the documentation for
         ;; pseudo-atomics.. -- WHN 19991130
         (inst cmp (make-ea :byte
         ;; are pending? I wish I could find the documentation for
         ;; pseudo-atomics.. -- WHN 19991130
         (inst cmp (make-ea :byte

-                           :disp (+ *nil-value*
+                           :disp (+ nil-value

                                     (static-symbol-offset
                                      'sb!impl::*pseudo-atomic-interrupted*)
                                     (ash symbol-value-slot word-shift)
                                     (static-symbol-offset
                                      'sb!impl::*pseudo-atomic-interrupted*)
                                     (ash symbol-value-slot word-shift)

diff --git a/src/compiler/x86/memory.lisp b/src/compiler/x86/memory.lisp
index 21670d7..8c34a65 100644 (file)
--- a/src/compiler/x86/memory.lisp
+++ b/src/compiler/x86/memory.lisp
@@ -112,7 +112,7 @@
              (inst mov
                    (make-ea :dword :base object
                             :disp (- (* (+ base offset) word-bytes) lowtag))
              (inst mov
                    (make-ea :dword :base object
                             :disp (- (* (+ base offset) word-bytes) lowtag))

-                   (+ *nil-value* (static-symbol-offset val))))
+                   (+ nil-value (static-symbol-offset val))))

             (character
              (inst mov
                    (make-ea :dword :base object
             (character
              (inst mov
                    (make-ea :dword :base object

diff --git a/src/compiler/x86/move.lisp b/src/compiler/x86/move.lisp
index 5c6cab4..505314f 100644 (file)
--- a/src/compiler/x86/move.lisp
+++ b/src/compiler/x86/move.lisp
@@ -82,7 +82,7 @@
                 (inst xor y y)
               (inst mov y (fixnumize val))))
            (symbol
                 (inst xor y y)
               (inst mov y (fixnumize val))))
            (symbol

-            (inst mov y (+ *nil-value* (static-symbol-offset val))))
+            (inst mov y (+ nil-value (static-symbol-offset val))))

            (character
             (inst mov y (logior (ash (char-code val) type-bits)
                                 base-char-type)))))
            (character
             (inst mov y (logior (ash (char-code val) type-bits)
                                 base-char-type)))))

@@ -135,7 +135,7 @@
                   (integer
                    (storew (fixnumize val) fp (tn-offset y)))
                   (symbol
                   (integer
                    (storew (fixnumize val) fp (tn-offset y)))
                   (symbol

-                   (storew (+ *nil-value* (static-symbol-offset val))
+                   (storew (+ nil-value (static-symbol-offset val))

                            fp (tn-offset y)))
                   (character
                    (storew (logior (ash (char-code val) type-bits)
                            fp (tn-offset y)))
                   (character
                    (storew (logior (ash (char-code val) type-bits)

@@ -146,7 +146,7 @@
                 (integer
                  (storew (fixnumize val) fp (- (1+ (tn-offset y)))))
                 (symbol
                 (integer
                  (storew (fixnumize val) fp (- (1+ (tn-offset y)))))
                 (symbol

-                 (storew (+ *nil-value* (static-symbol-offset val))
+                 (storew (+ nil-value (static-symbol-offset val))

                          fp (- (1+ (tn-offset y)))))
                 (character
                  (storew (logior (ash (char-code val) type-bits)
                          fp (- (1+ (tn-offset y)))))
                 (character
                  (storew (logior (ash (char-code val) type-bits)

diff --git a/src/compiler/x86/nlx.lisp b/src/compiler/x86/nlx.lisp
index f354b92..3ce63fe 100644 (file)
--- a/src/compiler/x86/nlx.lisp
+++ b/src/compiler/x86/nlx.lisp
@@ -157,7 +157,7 @@
     (cond ((zerop nvals))
          ((= nvals 1)
           (let ((no-values (gen-label)))
     (cond ((zerop nvals))
          ((= nvals 1)
           (let ((no-values (gen-label)))

-            (inst mov (tn-ref-tn values) *nil-value*)
+            (inst mov (tn-ref-tn values) nil-value)

             (inst jecxz no-values)
             (loadw (tn-ref-tn values) start -1)
             (emit-label no-values)))
             (inst jecxz no-values)
             (loadw (tn-ref-tn values) start -1)
             (emit-label no-values)))

@@ -183,7 +183,7 @@
               (assemble (*elsewhere*)
                 (dolist (def (defaults))
                   (emit-label (car def))
               (assemble (*elsewhere*)
                 (dolist (def (defaults))
                   (emit-label (car def))

-                  (inst mov (cdr def) *nil-value*))
+                  (inst mov (cdr def) nil-value))

                 (inst jmp defaulting-done))))))
     (inst mov esp-tn sp)))
 
                 (inst jmp defaulting-done))))))
     (inst mov esp-tn sp)))
 

diff --git a/src/compiler/x86/parms.lisp b/src/compiler/x86/parms.lisp
index 7da5ea4..92cae5e 100644 (file)
--- a/src/compiler/x86/parms.lisp
+++ b/src/compiler/x86/parms.lisp
@@ -125,24 +125,24 @@
 ;;; Note: Mostly these values are black magic, inherited from CMU CL
 ;;; without any documentation. However, there have been a few changes
 ;;; since the fork:
 ;;; Note: Mostly these values are black magic, inherited from CMU CL
 ;;; without any documentation. However, there have been a few changes
 ;;; since the fork:

-;;;   * The FreeBSD *STATIC-SPACE-START* value was bumped up
+;;;   * The FreeBSD STATIC-SPACE-START value was bumped up

 ;;;     from #x28000000 to #x30000000 when FreeBSD ld.so dynamic linking
 ;;;     support was added for FreeBSD ca. 20000910. This was to keep from
 ;;;     stomping on an address range that the dynamic libraries want to use. 
 ;;;     (They want to use this address range even if we try to reserve it
 ;;;     with a call to validate() as the first operation in main().)
 #!-linux (defparameter *read-only-space-start* #x10000000)
 ;;;     from #x28000000 to #x30000000 when FreeBSD ld.so dynamic linking
 ;;;     support was added for FreeBSD ca. 20000910. This was to keep from
 ;;;     stomping on an address range that the dynamic libraries want to use. 
 ;;;     (They want to use this address range even if we try to reserve it
 ;;;     with a call to validate() as the first operation in main().)
 #!-linux (defparameter *read-only-space-start* #x10000000)

-#!-linux (defparameter *static-space-start*
-                       #!+freebsd #x30000000
-                       #!+openbsd #x28000000)
+#!-linux (defconstant static-space-start
+                      #!+freebsd #x30000000
+                      #!+openbsd #x28000000)

 #!-linux (defparameter *dynamic-space-start*   #x48000000)
 #!+linux (defparameter *read-only-space-start* #x01000000)
 #!-linux (defparameter *dynamic-space-start*   #x48000000)
 #!+linux (defparameter *read-only-space-start* #x01000000)

-#!+linux (defparameter *static-space-start*    #x05000000)
+#!+linux (defconstant static-space-start    #x05000000)

 #!+linux (defparameter *dynamic-space-start*   #x09000000)
 
 ;;; Given that NIL is the first thing allocated in static space, we
 ;;; know its value at compile time:
 #!+linux (defparameter *dynamic-space-start*   #x09000000)
 
 ;;; Given that NIL is the first thing allocated in static space, we
 ;;; know its value at compile time:

-(defparameter *nil-value* (+ *static-space-start* #xb))
+(defconstant nil-value (+ static-space-start #xb))

 \f
 ;;;; other miscellaneous constants
 
 \f
 ;;;; other miscellaneous constants
 

diff --git a/src/compiler/x86/pred.lisp b/src/compiler/x86/pred.lisp
index 975a9a2..8a43d15 100644 (file)
--- a/src/compiler/x86/pred.lisp
+++ b/src/compiler/x86/pred.lisp
@@ -50,7 +50,7 @@
               (inst test x x) ; smaller
             (inst cmp x (fixnumize val))))
          (symbol
               (inst test x x) ; smaller
             (inst cmp x (fixnumize val))))
          (symbol

-          (inst cmp x (+ *nil-value* (static-symbol-offset val))))
+          (inst cmp x (+ nil-value (static-symbol-offset val))))

          (character
           (inst cmp x (logior (ash (char-code val) type-bits)
                               base-char-type))))))
          (character
           (inst cmp x (logior (ash (char-code val) type-bits)
                               base-char-type))))))

@@ -63,7 +63,7 @@
               (inst test y y) ; smaller
             (inst cmp y (fixnumize val))))
          (symbol
               (inst test y y) ; smaller
             (inst cmp y (fixnumize val))))
          (symbol

-          (inst cmp y (+ *nil-value* (static-symbol-offset val))))
+          (inst cmp y (+ nil-value (static-symbol-offset val))))

          (character
           (inst cmp y (logior (ash (char-code val) type-bits)
                               base-char-type))))))
          (character
           (inst cmp y (logior (ash (char-code val) type-bits)
                               base-char-type))))))

diff --git a/src/compiler/x86/static-fn.lisp b/src/compiler/x86/static-fn.lisp
index 2989928..5874224 100644 (file)
--- a/src/compiler/x86/static-fn.lisp
+++ b/src/compiler/x86/static-fn.lisp
@@ -108,7 +108,7 @@
         ;; low tag of 3 is added the resulting value points to the
         ;; raw address slot of the fdefn (at +4).
         (inst call (make-ea :dword
         ;; low tag of 3 is added the resulting value points to the
         ;; raw address slot of the fdefn (at +4).
         (inst call (make-ea :dword

-                            :disp (+ *nil-value*
+                            :disp (+ nil-value

                                      (static-function-offset function))))
         ,(collect ((bindings) (links))
                   (do ((temp (temp-names) (cdr temp))
                                      (static-function-offset function))))
         ,(collect ((bindings) (links))
                   (do ((temp (temp-names) (cdr temp))

diff --git a/src/compiler/x86/subprim.lisp b/src/compiler/x86/subprim.lisp
index a69d208..41c4887 100644 (file)
--- a/src/compiler/x86/subprim.lisp
+++ b/src/compiler/x86/subprim.lisp
@@ -32,8 +32,8 @@
     ;; Move OBJECT into a temp we can bash on, and initialize the count.
     (move ptr object)
     (inst xor count count)
     ;; Move OBJECT into a temp we can bash on, and initialize the count.
     (move ptr object)
     (inst xor count count)

-    ;; If we are starting with NIL, then it's real easy.
-    (inst cmp ptr *nil-value*)
+    ;; If we are starting with NIL, then it's really easy.
+    (inst cmp ptr nil-value)

     (inst jmp :e done)
     ;; Note: we don't have to test to see whether the original argument is a
     ;; list, because this is a :fast-safe vop.
     (inst jmp :e done)
     ;; Note: we don't have to test to see whether the original argument is a
     ;; list, because this is a :fast-safe vop.

@@ -42,7 +42,7 @@
     (loadw ptr ptr cons-cdr-slot list-pointer-type)
     (inst add count (fixnumize 1))
     ;; If we hit NIL, then we are done.
     (loadw ptr ptr cons-cdr-slot list-pointer-type)
     (inst add count (fixnumize 1))
     ;; If we hit NIL, then we are done.

-    (inst cmp ptr *nil-value*)
+    (inst cmp ptr nil-value)

     (inst jmp :e done)
     ;; Otherwise, check to see whether we hit the end of a dotted list. If
     ;; not, loop back for more.
     (inst jmp :e done)
     ;; Otherwise, check to see whether we hit the end of a dotted list. If
     ;; not, loop back for more.

@@ -71,14 +71,14 @@
     (move ptr object)
     (inst xor count count)
     ;; If we are starting with NIL, we be done.
     (move ptr object)
     (inst xor count count)
     ;; If we are starting with NIL, we be done.

-    (inst cmp ptr *nil-value*)
+    (inst cmp ptr nil-value)

     (inst jmp :e done)
     ;; Indirect the next cons cell, and boost the count.
     LOOP
     (loadw ptr ptr cons-cdr-slot list-pointer-type)
     (inst add count (fixnumize 1))
     ;; If we aren't done, go back for more.
     (inst jmp :e done)
     ;; Indirect the next cons cell, and boost the count.
     LOOP
     (loadw ptr ptr cons-cdr-slot list-pointer-type)
     (inst add count (fixnumize 1))
     ;; If we aren't done, go back for more.

-    (inst cmp ptr *nil-value*)
+    (inst cmp ptr nil-value)

     (inst jmp :ne loop)
     DONE))
 
     (inst jmp :ne loop)
     DONE))
 

diff --git a/src/compiler/x86/system.lisp b/src/compiler/x86/system.lisp
index fb12e33..17d315b 100644 (file)
--- a/src/compiler/x86/system.lisp
+++ b/src/compiler/x86/system.lisp
@@ -316,7 +316,7 @@
   (:temporary (:sc unsigned-reg :from (:eval 0) :to (:eval 1)) temp)
   (:save-p t)
   (:generator 25
   (:temporary (:sc unsigned-reg :from (:eval 0) :to (:eval 1)) temp)
   (:save-p t)
   (:generator 25

-    (inst cmp inherit *nil-value*)
+    (inst cmp inherit nil-value)

     (inst jmp :e FRESH-STACK)
 
     ;; Child inherits the stack of the parent.
     (inst jmp :e FRESH-STACK)
 
     ;; Child inherits the stack of the parent.

@@ -385,7 +385,7 @@
 
     RETURN
     ;; Stack already clean if it reaches here. Parent returns NIL.
 
     RETURN
     ;; Stack already clean if it reaches here. Parent returns NIL.

-    (inst mov child *nil-value*)
+    (inst mov child nil-value)

     (inst jmp-short DONE)
 
     STACK-SAVE-DONE
     (inst jmp-short DONE)
 
     STACK-SAVE-DONE

diff --git a/src/compiler/x86/type-vops.lisp b/src/compiler/x86/type-vops.lisp
index 77c8f46..6a53827 100644 (file)
--- a/src/compiler/x86/type-vops.lisp
+++ b/src/compiler/x86/type-vops.lisp
@@ -722,7 +722,7 @@
   (:translate symbolp)
   (:generator 12
     (let ((is-symbol-label (if not-p drop-thru target)))
   (:translate symbolp)
   (:generator 12
     (let ((is-symbol-label (if not-p drop-thru target)))

-      (inst cmp value *nil-value*)
+      (inst cmp value nil-value)

       (inst jmp :e is-symbol-label)
       (test-type value target not-p symbol-header-type))
     DROP-THRU))
       (inst jmp :e is-symbol-label)
       (test-type value target not-p symbol-header-type))
     DROP-THRU))

@@ -730,7 +730,7 @@
 (define-vop (check-symbol check-type)
   (:generator 12
     (let ((error (generate-error-code vop object-not-symbol-error value)))
 (define-vop (check-symbol check-type)
   (:generator 12
     (let ((error (generate-error-code vop object-not-symbol-error value)))

-      (inst cmp value *nil-value*)
+      (inst cmp value nil-value)

       (inst jmp :e drop-thru)
       (test-type value error t symbol-header-type))
     DROP-THRU
       (inst jmp :e drop-thru)
       (test-type value error t symbol-header-type))
     DROP-THRU

@@ -740,7 +740,7 @@
   (:translate consp)
   (:generator 8
     (let ((is-not-cons-label (if not-p target drop-thru)))
   (:translate consp)
   (:generator 8
     (let ((is-not-cons-label (if not-p target drop-thru)))

-      (inst cmp value *nil-value*)
+      (inst cmp value nil-value)

       (inst jmp :e is-not-cons-label)
       (test-type value target not-p list-pointer-type))
     DROP-THRU))
       (inst jmp :e is-not-cons-label)
       (test-type value target not-p list-pointer-type))
     DROP-THRU))

@@ -748,7 +748,7 @@
 (define-vop (check-cons check-type)
   (:generator 8
     (let ((error (generate-error-code vop object-not-cons-error value)))
 (define-vop (check-cons check-type)
   (:generator 8
     (let ((error (generate-error-code vop object-not-cons-error value)))

-      (inst cmp value *nil-value*)
+      (inst cmp value nil-value)

       (inst jmp :e error)
       (test-type value error t list-pointer-type)
       (move result value))))
       (inst jmp :e error)
       (test-type value error t list-pointer-type)
       (move result value))))

diff --git a/src/compiler/x86/values.lisp b/src/compiler/x86/values.lisp
index 0677168..c73f597 100644 (file)
--- a/src/compiler/x86/values.lisp
+++ b/src/compiler/x86/values.lisp
@@ -55,7 +55,7 @@
   (:generator 0
     (move list arg)
     (move start esp-tn)                        ; WARN pointing 1 below
   (:generator 0
     (move list arg)
     (move start esp-tn)                        ; WARN pointing 1 below

-    (inst mov nil-temp *nil-value*)
+    (inst mov nil-temp nil-value)

 
     LOOP
     (inst cmp list nil-temp)
 
     LOOP
     (inst cmp list nil-temp)

diff --git a/src/runtime/gencgc.c b/src/runtime/gencgc.c
index a476686..29dea31 100644 (file)
--- a/src/runtime/gencgc.c
+++ b/src/runtime/gencgc.c
@@ -1767,7 +1767,7 @@ scavenge(lispobj *start, long nwords)
                lispobj first_word = *ptr;
        
                if (first_word == 0x01) {
                lispobj first_word = *ptr;
        
                if (first_word == 0x01) {

-                   /* Yep, there be a forwarding pointer. */
+                   /* Yes, there's a forwarding pointer. */

                    *start = ptr[1];
                    words_scavenged = 1;
                }
                    *start = ptr[1];
                    words_scavenged = 1;
                }

@@ -1780,7 +1780,7 @@ scavenge(lispobj *start, long nwords)
            }
        } else {
            if ((object & 3) == 0) {
            }
        } else {
            if ((object & 3) == 0) {

-               /* It's a fixnum. Real easy.. */
+               /* It's a fixnum: really easy.. */

                words_scavenged = 1;
            } else {
                /* It's some sort of header object or another. */
                words_scavenged = 1;
            } else {
                /* It's some sort of header object or another. */

diff --git a/version.lisp-expr b/version.lisp-expr
index 417836e..6c75e56 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -15,4 +15,4 @@
 ;;; versions, and a string a la "0.6.5.12" is used for versions which
 ;;; aren't released but correspond only to CVS tags or snapshots.
 
 ;;; versions, and a string a la "0.6.5.12" is used for versions which
 ;;; aren't released but correspond only to CVS tags or snapshots.
 

-"0.6.7.9"
+"0.6.7.10"