Changeset 11420

Timestamp:

Nov 20, 2008, 6:51:45 PM (12 years ago)

Author:

gz

Message:

Remove obsolete bootstrapping code, fix indentation

Location:

trunk/source

Files:

• compiler/X86/x862.lisp (modified) (2 diffs)
• compiler/nx-basic.lisp (modified) (2 diffs)
• lib/nfcomp.lisp (modified) (2 diffs)
• lib/source-files.lisp (modified) (1 diff)

trunk/source/compiler/X86/x862.lisp

@@ -4383 +4383 @@
                    (! make-tsp-cons result y z)
                    (setq val result)))
-                 ((eq op (%nx1-operator %consmacptr%))
-                  (with-imm-target () (address :address)
-                    (x862-one-targeted-reg-form seg form address)
-                    (with-node-target () node
-                      (! macptr->stack node address)
-                      (x862-open-undo $undo-x86-c-frame)
-                      (setq val node))))
-                 ((eq op (%nx1-operator %new-ptr))
-                  (let* ((clear-form (caddr form))
-                         (cval (nx-constant-form-p clear-form)))
-                    (if cval
-                      (progn 
-                        (x862-one-targeted-reg-form seg (%cadr form) ($ *x862-arg-z*))
-                        (if (nx-null cval)
-                          (! make-stack-block)
-                          (! make-stack-block0)))
-                      (with-crf-target () crf
-                        (let ((stack-block-0-label (backend-get-next-label))
-                              (done-label (backend-get-next-label))
-                              (rval ($ *x862-arg-z*))
-                              (rclear ($ *x862-arg-y*)))
-                          (x862-two-targeted-reg-forms seg (%cadr form) rval clear-form rclear)
-                          (! compare-to-nil crf rclear)
-                          (! cbranch-false (aref *backend-labels* stack-block-0-label) crf x86::x86-e-bits)
-                          (! make-stack-block)
-                          (-> done-label)
-                          (@ stack-block-0-label)
-                          (! make-stack-block0)
-                          (@ done-label)))))
-                  (x862-open-undo $undo-x86-c-frame)
-                  (setq val ($ *x862-arg-z*)))
-                 ((eq op (%nx1-operator make-list))
-                  (x862-two-targeted-reg-forms seg (%cadr form) ($ *x862-arg-y*) (%caddr form) ($ *x862-arg-z*))
-                  (x862-open-undo $undostkblk curstack)
-                  (! make-stack-list)
-                  (setq val *x862-arg-z*))       
-                 ((eq op (%nx1-operator vector))
-                  (let* ((*x862-vstack* *x862-vstack*)
-                         (*x862-top-vstack-lcell* *x862-top-vstack-lcell*))
-                    (x862-set-nargs seg (x862-formlist seg (%cadr form) nil))
-                    (! make-stack-vector))
-                  (x862-open-undo $undostkblk)
-                  (setq val *x862-arg-z*))
-                 ((eq op (%nx1-operator %gvector))
-                  (let* ((*x862-vstack* *x862-vstack*)
-                         (*x862-top-vstack-lcell* *x862-top-vstack-lcell*)
-                         (arglist (%cadr form)))
-                    (x862-set-nargs seg (x862-formlist seg (append (car arglist) (reverse (cadr arglist))) nil))
-                    (! make-stack-gvector))
-                  (x862-open-undo $undostkblk)
-                  (setq val *x862-arg-z*)) 
-                 ((eq op (%nx1-operator closed-function)) 
-                  (setq val (x862-make-closure seg (cadr form) t))) ; can't error
-                 ((eq op (%nx1-operator %make-uvector))
-                  (destructuring-bind (element-count subtag &optional (init 0 init-p)) (%cdr form)
-                    (let* ((fix-subtag (acode-fixnum-form-p subtag))
-                           (is-node (x862-target-is-node-subtag fix-subtag))
-                           (is-imm  (x862-target-is-imm-subtag fix-subtag)))
-                      (when (or is-node is-imm)
-                        (if init-p
-                          (progn
-                            (x862-three-targeted-reg-forms seg element-count
-                                                           (target-arch-case
-                                                            (:x8632
-                                                             ($ x8632::temp1))
-                                                            (:x8664
-                                                             ($ x8664::arg_x)))
-                                                           subtag ($ *x862-arg-y*)
-                                                           init ($ *x862-arg-z*))
-                            (! stack-misc-alloc-init))
-                          (progn
-                            (x862-two-targeted-reg-forms seg element-count ($ *x862-arg-y*)  subtag ($ *x862-arg-z*))
-                            (! stack-misc-alloc)))
-                        (if is-node
-                          (x862-open-undo $undostkblk)
-                          (x862-open-undo $undo-x86-c-frame))
-                        (setq val ($ *x862-arg-z*))))))))))
-      val))
+                ((eq op (%nx1-operator %consmacptr%))
+                 (with-imm-target () (address :address)
+                   (x862-one-targeted-reg-form seg form address)
+                   (with-node-target () node
+                     (! macptr->stack node address)
+                     (x862-open-undo $undo-x86-c-frame)
+                     (setq val node))))
+                ((eq op (%nx1-operator %new-ptr))
+                 (let* ((clear-form (caddr form))
+                        (cval (nx-constant-form-p clear-form)))
+                   (if cval
+                     (progn 
+                       (x862-one-targeted-reg-form seg (%cadr form) ($ *x862-arg-z*))
+                       (if (nx-null cval)
+                         (! make-stack-block)
+                         (! make-stack-block0)))
+                     (with-crf-target () crf
+                       (let ((stack-block-0-label (backend-get-next-label))
+                             (done-label (backend-get-next-label))
+                             (rval ($ *x862-arg-z*))
+                             (rclear ($ *x862-arg-y*)))
+                         (x862-two-targeted-reg-forms seg (%cadr form) rval clear-form rclear)
+                         (! compare-to-nil crf rclear)
+                         (! cbranch-false (aref *backend-labels* stack-block-0-label) crf x86::x86-e-bits)
+                         (! make-stack-block)
+                         (-> done-label)
+                         (@ stack-block-0-label)
+                         (! make-stack-block0)
+                         (@ done-label)))))
+                 (x862-open-undo $undo-x86-c-frame)
+                 (setq val ($ *x862-arg-z*)))
+                ((eq op (%nx1-operator make-list))
+                 (x862-two-targeted-reg-forms seg (%cadr form) ($ *x862-arg-y*) (%caddr form) ($ *x862-arg-z*))
+                 (x862-open-undo $undostkblk curstack)
+                 (! make-stack-list)
+                 (setq val *x862-arg-z*))       
+                ((eq op (%nx1-operator vector))
+                 (let* ((*x862-vstack* *x862-vstack*)
+                        (*x862-top-vstack-lcell* *x862-top-vstack-lcell*))
+                   (x862-set-nargs seg (x862-formlist seg (%cadr form) nil))
+                   (! make-stack-vector))
+                 (x862-open-undo $undostkblk)
+                 (setq val *x862-arg-z*))
+                ((eq op (%nx1-operator %gvector))
+                 (let* ((*x862-vstack* *x862-vstack*)
+                        (*x862-top-vstack-lcell* *x862-top-vstack-lcell*)
+                        (arglist (%cadr form)))
+                   (x862-set-nargs seg (x862-formlist seg (append (car arglist) (reverse (cadr arglist))) nil))
+                   (! make-stack-gvector))
+                 (x862-open-undo $undostkblk)
+                 (setq val *x862-arg-z*)) 
+                ((eq op (%nx1-operator closed-function)) 
+                 (setq val (x862-make-closure seg (cadr form) t))) ; can't error
+                ((eq op (%nx1-operator %make-uvector))
+                 (destructuring-bind (element-count subtag &optional (init 0 init-p)) (%cdr form)
+                   (let* ((fix-subtag (acode-fixnum-form-p subtag))
+                          (is-node (x862-target-is-node-subtag fix-subtag))
+                          (is-imm  (x862-target-is-imm-subtag fix-subtag)))
+                     (when (or is-node is-imm)
+                       (if init-p
+                         (progn
+                           (x862-three-targeted-reg-forms seg element-count
+                                                          (target-arch-case
+                                                           (:x8632
+                                                            ($ x8632::temp1))
+                                                           (:x8664
+                                                            ($ x8664::arg_x)))
+                                                          subtag ($ *x862-arg-y*)
+                                                          init ($ *x862-arg-z*))
+                           (! stack-misc-alloc-init))
+                         (progn
+                           (x862-two-targeted-reg-forms seg element-count ($ *x862-arg-y*)  subtag ($ *x862-arg-z*))
+                           (! stack-misc-alloc)))
+                       (if is-node
+                         (x862-open-undo $undostkblk)
+                         (x862-open-undo $undo-x86-c-frame))
+                       (setq val ($ *x862-arg-z*))))))))))
+    val))
 
 (defun x862-addrspec-to-reg (seg addrspec reg)
@@ -10242 +10242 @@
 
 
-
-

trunk/source/compiler/nx-basic.lisp

@@ -37 +37 @@
 (defvar *lisp-compiler-version* 666 "I lost count.")
 
-#-BOOTSTRAPPED (defvar *record-pc-mapping* nil) ;; defined in level-1
-
 (defvar *nx-compile-time-types* nil)
 (defvar *nx-proclaimed-types* nil)
@@ -102 +100 @@
                  ;; other reference) in code that's never executed.
                  (loop for p = parent-note then (code-note-parent-note p)
-                       when (null p)
-                         return t
+                       when (null p) return t
                        when (code-note-source-note p)
-                         return (eq (loop for n = source-note then s
-                                          as s = (source-note-source n)
-                                          unless (source-note-p s) return n)
-                                    (loop for n = (code-note-source-note p) then s
-                                          as s = (source-note-source n)
-                                          unless (source-note-p s) return n))))
+                       return (eq (loop for n = source-note then s
+                                        as s = (source-note-source n)
+                                        unless (source-note-p s) return n)
+                                  (loop for n = (code-note-source-note p) then s
+                                        as s = (source-note-source n)
+                                        unless (source-note-p s) return n))))
       (setq source-note nil))
     (make-code-note :form form :source-note source-note :parent-note parent-note)))

trunk/source/lib/nfcomp.lisp

@@ -45 +45 @@
 ) ;eval-when (:compile-toplevel :execute)
 
-; inited in l1-init, this is for when loading into a lisp that doesn't have it yet.
-#-BOOTSTRAPPED (eval-when (compile load eval)
-                 (unless (boundp '*LOADING-TOPLEVEL-LOCATION*)
-                   (declaim (special *loading-toplevel-location*))
-                   (defparameter *save-source-locations* nil)))
 
 ;File compiler options.  Not all of these need to be exported/documented, but
@@ -471 +466 @@
                                 (signal c))))
                   (multiple-value-setq (form *loading-toplevel-location*)
-                    (if *fcomp-source-note-map* ;; #-BOOTSTRAPPED
-                      (read-recording-source stream
-                                             :eofval eofval
-                                             :file-name *loading-file-source-file*
-                                             :start-offset orig-offset
-                                             :map *fcomp-source-note-map*
-                                             :save-source-text (neq *save-source-locations* :no-text))
-                      (read-recording-source stream
-                                             :eofval eofval
-                                             :file-name *loading-file-source-file*
-                                             :start-offset orig-offset))))))
+                    (read-recording-source stream
+                                           :eofval eofval
+                                           :file-name *loading-file-source-file*
+                                           :start-offset orig-offset
+                                           :map *fcomp-source-note-map*
+                                           :save-source-text (neq *save-source-locations* :no-text))))))
             (when (eq eofval form)
               (require-type *loading-toplevel-location* 'null)

trunk/source/lib/source-files.lisp

@@ -683 +683 @@
 ;; Define the real record-source-file, which will be the last defn handled by the
 ;; bootstrapping record-source-file, so convert all queued up data right afterwards.
-(when (BOUNDP '*LOADING-TOPLEVEL-LOCATION*) ;; #-BOOTSTRAPPED
+(progn
 
 (defun record-source-file (name def-type &optional (source (or *loading-toplevel-location*