X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fmain.lisp;h=b01695dd0e088cdf13e9e3cff2dae291ac723216;hb=cd2c70c8b5d4dcc62b968f5a9bedd3c9c8698e82;hp=37ae3690e66cff9d911f90b4c7e5a322f145cbd7;hpb=d40a76606c86722b0aef8179155f9f2840739b72;p=sbcl.git diff --git a/src/compiler/main.lisp b/src/compiler/main.lisp index 37ae369..b01695d 100644 --- a/src/compiler/main.lisp +++ b/src/compiler/main.lisp @@ -14,10 +14,10 @@ (in-package "SB!C") ;;; FIXME: Doesn't this belong somewhere else, like early-c.lisp? -(declaim (special *constants* *free-variables* *component-being-compiled* +(declaim (special *constants* *free-vars* *component-being-compiled* *code-vector* *next-location* *result-fixups* - *free-functions* *source-paths* - *seen-blocks* *seen-functions* *list-conflicts-table* + *free-funs* *source-paths* + *seen-blocks* *seen-funs* *list-conflicts-table* *continuation-number* *continuation-numbers* *number-continuations* *tn-id* *tn-ids* *id-tns* *label-ids* *label-id* *id-labels* @@ -40,13 +40,11 @@ ;;; :BLOCK-COMPILE and :ENTRY-POINTS arguments that COMPILE-FILE was ;;; called with. ;;; -;;; *BLOCK-COMPILE-ARGUMENT* holds the original value of the -;;; :BLOCK-COMPILE argument, which overrides any internal -;;; declarations. +;;; *BLOCK-COMPILE-ARG* holds the original value of the :BLOCK-COMPILE +;;; argument, which overrides any internal declarations. (defvar *block-compile*) -(defvar *block-compile-argument*) -(declaim (type (member nil t :specified) - *block-compile* *block-compile-argument*)) +(defvar *block-compile-arg*) +(declaim (type (member nil t :specified) *block-compile* *block-compile-arg*)) (defvar *entry-points*) (declaim (list *entry-points*)) @@ -317,8 +315,8 @@ (declare (special *constraint-number* *delayed-ir1-transforms*)) (loop (ir1-optimize-until-done component) - (when (or (component-new-funs component) - (component-reanalyze-funs component)) + (when (or (component-new-functionals component) + (component-reanalyze-functionals component)) (maybe-mumble "locall ") (locall-analyze-component component)) (dfo-as-needed component) @@ -330,8 +328,8 @@ (flet ((want-reoptimization-p () (or (component-reoptimize component) (component-reanalyze component) - (component-new-funs component) - (component-reanalyze-funs component)))) + (component-new-functionals component) + (component-reanalyze-functionals component)))) (unless (and (want-reoptimization-p) ;; We delay the generation of type checks until ;; the type constraints have had time to @@ -507,7 +505,7 @@ ;;;; global data structures entirely when possible and consing up the ;;;; others from scratch instead of clearing and reusing them? -;;; Clear the INFO in constants in the *FREE-VARIABLES*, etc. In +;;; Clear the INFO in constants in the *FREE-VARS*, etc. In ;;; addition to allowing stuff to be reclaimed, this is required for ;;; correct assignment of constant offsets, since we need to assign a ;;; new offset for each component. We don't clear the FUNCTIONAL-INFO @@ -522,7 +520,7 @@ (declare (ignore k)) (when (constant-p v) (setf (leaf-info v) nil))) - *free-variables*) + *free-vars*) (values)) ;;; Blow away the REFS for all global variables, and let COMPONENT @@ -541,8 +539,8 @@ x)) (here-p (x) (eq (node-component x) component))) - (blast *free-variables*) - (blast *free-functions*) + (blast *free-vars*) + (blast *free-funs*) (blast *constants*)) (values)) @@ -555,14 +553,14 @@ (defun clear-stuff (&optional (debug-too t)) ;; Clear global tables. - (when (boundp '*free-functions*) - (clrhash *free-functions*) - (clrhash *free-variables*) + (when (boundp '*free-funs*) + (clrhash *free-funs*) + (clrhash *free-vars*) (clrhash *constants*)) ;; Clear debug counters and tables. (clrhash *seen-blocks*) - (clrhash *seen-functions*) + (clrhash *seen-funs*) (clrhash *list-conflicts-table*) (when debug-too @@ -595,7 +593,7 @@ ;;;; trace output -;;; Print out some useful info about Component to Stream. +;;; Print out some useful info about COMPONENT to STREAM. (defun describe-component (component *standard-output*) (declare (type component component)) (format t "~|~%;;;; component: ~S~2%" (component-name component)) @@ -624,7 +622,7 @@ ;;;; the error context and for recovering from errors. ;;;; ;;;; The interface we provide to this stuff is the stream-oid -;;;; Source-Info structure. The bookkeeping is done as a side-effect +;;;; SOURCE-INFO structure. The bookkeeping is done as a side effect ;;;; of getting the next source form. ;;; A FILE-INFO structure holds all the source information for a @@ -803,7 +801,7 @@ ;;; We parse declarations and then recursively process the body. (defun process-toplevel-locally (body path compile-time-too) (declare (list path)) - (multiple-value-bind (forms decls) (sb!sys:parse-body body nil) + (multiple-value-bind (forms decls) (parse-body body nil) (let* ((*lexenv* (process-decls decls nil nil (make-continuation))) ;; Binding *POLICY* is pretty much of a hack, since it @@ -905,8 +903,8 @@ ;; nice default for things where we don't have a ;; real source path (as in e.g. inside CL:COMPILE). '(original-source-start 0 0))) - (unless (or (null name) (legal-fun-name-p name)) - (error "not a legal function name: ~S" name)) + (when name + (legal-fun-name-or-type-error name)) (let* ((*lexenv* (make-lexenv :policy *policy*)) (fun (make-functional-from-toplevel-lambda lambda-expression :name name @@ -947,14 +945,36 @@ (gethash (leaf-info fun) entry-table) (aver found-p) result)) + ;; KLUDGE: This code duplicates some other code in this + ;; file. In the great reorganzation, the flow of program logic + ;; changed from the original CMUCL model, and that path (as of + ;; sbcl-0.7.5 in SUB-COMPILE-FILE) was no longer followed for + ;; CORE-OBJECTS, leading to BUG 156. This place is + ;; transparently not the right one for this code, but I don't + ;; have a clear enough overview of the compiler to know how to + ;; rearrange it all so that this operation fits in nicely, and + ;; it was blocking reimplementation of + ;; (DECLAIM (INLINE FOO)) (MACROLET ((..)) (DEFUN FOO ...)) + ;; + ;; FIXME: This KLUDGE doesn't solve all the problem in an + ;; ideal way, as (1) definitions typed in at the REPL without + ;; an INLINE declaration will give a NULL + ;; FUNCTION-LAMBDA-EXPRESSION (allowable, but not ideal) and + ;; (2) INLINE declarations will yield a + ;; FUNCTION-LAMBDA-EXPRESSION headed by + ;; SB-C:LAMBDA-WITH-LEXENV, even for null LEXENV. + ;; + ;; CSR, 2002-07-02 + (when (core-object-p *compile-object*) + (fix-core-source-info *source-info* *compile-object*)) + (mapc #'clear-ir1-info components-from-dfo) (clear-stuff))))) (defun process-toplevel-cold-fset (name lambda-expression path) (unless (producing-fasl-file) (error "can't COLD-FSET except in a fasl file")) - (unless (legal-fun-name-p name) - (error "not a legal function name: ~S" name)) + (legal-fun-name-or-type-error name) (fasl-dump-cold-fset name (%compile lambda-expression *compile-object* @@ -979,8 +999,9 @@ (*compiler-error-bailout* (lambda () (convert-and-maybe-compile - `(error "execution of a form compiled with errors:~% ~S" - ',form) + `(error 'simple-program-error + :format-control "execution of a form compiled with errors:~% ~S" + :format-arguments (list ',form)) path) (throw 'process-toplevel-form-error-abort nil)))) @@ -1117,15 +1138,8 @@ ;;; Compile FORM and arrange for it to be called at load-time. Return ;;; the dumper handle and our best guess at the type of the object. -(defun compile-load-time-value - (form &optional - (name (let ((*print-level* 2) (*print-length* 3)) - (format nil "load time value of ~S" - (if (and (listp form) - (eq (car form) 'make-value-cell)) - (second form) - form))))) - (let ((lambda (compile-load-time-stuff form name t))) +(defun compile-load-time-value (form) + (let ((lambda (compile-load-time-stuff form t))) (values (fasl-dump-load-time-value-lambda lambda *compile-object*) (let ((type (leaf-type lambda))) @@ -1135,13 +1149,13 @@ ;;; Compile the FORMS and arrange for them to be called (for effect, ;;; not value) at load time. -(defun compile-make-load-form-init-forms (forms name) - (let ((lambda (compile-load-time-stuff `(progn ,@forms) name nil))) +(defun compile-make-load-form-init-forms (forms) + (let ((lambda (compile-load-time-stuff `(progn ,@forms) nil))) (fasl-dump-toplevel-lambda-call lambda *compile-object*))) ;;; Do the actual work of COMPILE-LOAD-TIME-VALUE or ;;; COMPILE-MAKE-LOAD-FORM-INIT-FORMS. -(defun compile-load-time-stuff (form name for-value) +(defun compile-load-time-stuff (form for-value) (with-ir1-namespace (let* ((*lexenv* (make-null-lexenv)) (lambda (ir1-toplevel form *current-path* for-value))) @@ -1234,7 +1248,11 @@ (node-component (lambda-bind x))) :toplevel))) lambdas - :start start) + ;; this used to read ":start start", but + ;; start can be greater than len, which + ;; is an error according to ANSI - CSR, + ;; 2002-04-25 + :start (min start len)) len))) (do* ((start 0 (1+ loser)) (loser (loser start) (loser start))) @@ -1302,7 +1320,7 @@ ;;; Return (VALUES NIL WARNINGS-P FAILURE-P). (defun sub-compile-file (info) (declare (type source-info info)) - (let* ((*block-compile* *block-compile-argument*) + (let* ((*block-compile* *block-compile-arg*) (*package* (sane-package)) (*policy* *policy*) (*lexenv* (make-null-lexenv)) @@ -1415,7 +1433,7 @@ ;; extensions (trace-file nil) - ((:block-compile *block-compile-argument*) nil)) + ((:block-compile *block-compile-arg*) nil)) #!+sb-doc "Compile INPUT-FILE, producing a corresponding fasl file and returning @@ -1532,7 +1550,7 @@ #!+sb-doc "Return a pathname describing what file COMPILE-FILE would write to given these arguments." - (pathname output-file)) + (merge-pathnames output-file (merge-pathnames input-file))) ;;;; MAKE-LOAD-FORM stuff @@ -1567,7 +1585,7 @@ ;;; If the constant doesn't show up in *CONSTANTS-BEING-CREATED*, then ;;; we have to create it. We call MAKE-LOAD-FORM and check to see ;;; whether the creation form is the magic value -;;; :JUST-DUMP-IT-NORMALLY. If it is, then we don't do anything. The +;;; :SB-JUST-DUMP-IT-NORMALLY. If it is, then we don't do anything. The ;;; dumper will eventually get its hands on the object and use the ;;; normal structure dumping noise on it. ;;; @@ -1584,7 +1602,7 @@ ;;; deal with it. (defvar *constants-being-created* nil) (defvar *constants-created-since-last-init* nil) -;;; FIXME: Shouldn't these^ variables be bound in LET forms? +;;; FIXME: Shouldn't these^ variables be unbound outside LET forms? (defun emit-make-load-form (constant) (aver (fasl-output-p *compile-object*)) (unless (or (fasl-constant-already-dumped-p constant *compile-object*) @@ -1608,7 +1626,7 @@ constant condition))) (case creation-form - (:just-dump-it-normally + (:sb-just-dump-it-normally (fasl-validate-structure constant *compile-object*) t) (:ignore-it @@ -1632,8 +1650,7 @@ (fasl-note-handle-for-constant constant (compile-load-time-value - creation-form - (format nil "creation form for ~A" name)) + creation-form) *compile-object*) nil) (compiler-error "circular references in creation form for ~S" @@ -1645,11 +1662,7 @@ (loop for (name form) on (cdr info) by #'cddr collect name into names collect form into forms - finally - (compile-make-load-form-init-forms - forms - (format nil "init form~:[~;s~] for ~{~A~^, ~}" - (cdr forms) names))) + finally (compile-make-load-form-init-forms forms)) nil))) (when circular-ref (setf (cdr circular-ref)