X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=build-order.lisp-expr;h=4af82837f7918e7cee73b539d579bd2952482b42;hb=c47519c9e63fd32a635943a84ec13d8a60d95f08;hp=67331680a2827332094dfbe29b9feda16ea29e01;hpb=4ae1b794a5d6a90794468cf8017f5307f2c30dfe;p=sbcl.git diff --git a/build-order.lisp-expr b/build-order.lisp-expr index 6733168..4af8283 100644 --- a/build-order.lisp-expr +++ b/build-order.lisp-expr @@ -9,9 +9,15 @@ ;;;; provided with absolutely no warranty. See the COPYING and CREDITS ;;;; files for more information. -;;; a linear ordering of system sources which works both to compile/load -;;; the cross-compiler under the host Common Lisp and then to cross-compile -;;; the complete system into the under-construction target SBCL +;;; a linear ordering of system sources which works both to +;;; compile/load the cross-compiler under the host Common Lisp and +;;; then to cross-compile the complete system into the +;;; under-construction target SBCL +;;; +;;; The keyword flags (:NOT-HOST, :NOT-TARGET, :ASSEM...) are +;;; documented in the code which implements their effects. (As of +;;; sbcl-0.7.10, the comments are on DEFPARAMETER *EXPECTED-STEM-FLAGS* +;;; in src/cold/shared.lisp.) ;;; ;;; Of course, it'd be very nice to have this be a dependency DAG ;;; instead, so that we could do automated incremental recompilation. @@ -60,12 +66,16 @@ ;; that they can handle the change. -- WHN 19990919 ("src/code/defsetfs") + ("src/code/cold-init-helper-macros") + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; cross-compiler-only replacements for stuff which in target Lisp would be ;;; supplied by basic machinery ("src/code/cross-misc" :not-target) + ("src/code/cross-char" :not-target) ("src/code/cross-byte" :not-target) + ("src/code/cross-boole" :not-target) ("src/code/cross-float" :not-target) ("src/code/cross-io" :not-target) ("src/code/cross-sap" :not-target) @@ -83,6 +93,9 @@ ("src/code/primordial-extensions") + ;; comes early so that stuff can reason about function names + ("src/code/function-names") + ;; for various constants e.g. SB!XC:MOST-POSITIVE-FIXNUM and ;; SB!VM:N-LOWTAG-BITS, needed by "early-objdef" and others ("src/compiler/generic/early-vm") @@ -90,9 +103,9 @@ ("src/compiler/target/parms") ("src/code/early-array") ; needs "early-vm" numbers + ("src/code/early-extensions") ; on host for COLLECT, SYMBOLICATE, etc. ("src/code/parse-body") ; on host for PARSE-BODY ("src/code/parse-defmacro") ; on host for PARSE-DEFMACRO - ("src/code/early-extensions") ; on host for COLLECT, SYMBOLICATE, etc. ("src/compiler/deftype") ; on host for SB!XC:DEFTYPE ("src/compiler/defconstant") ("src/code/early-alieneval") ; for vars needed both at build and run time @@ -105,8 +118,6 @@ ;; mostly needed by stuff from comcom, but also used by "x86-vm" ("src/code/debug-var-io") - ("src/code/cold-init-helper-macros") - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; basic machinery for the target Lisp. Note that although most of these ;;; files are flagged :NOT-HOST, a few might not be. @@ -123,6 +134,8 @@ ("src/code/defbangstruct") + ("src/code/unportable-float") + ("src/code/funutils" :not-host) ;; This needs DEF!STRUCT, and is itself needed early so that structure @@ -232,8 +245,6 @@ ("src/code/misc") ("src/code/room" :not-host) - ("src/code/gc" :not-host) - ("src/code/purify" :not-host) ("src/code/stream" :not-host) ("src/code/print" :not-host) @@ -259,8 +270,6 @@ ("src/code/weak" :not-host) ("src/code/final" :not-host) - #!+mp ("src/code/multi-proc" :not-host) - ("src/code/setf-funs" :not-host) ("src/code/stubs" :not-host) @@ -273,6 +282,7 @@ ("src/compiler/early-c") ("src/compiler/policy") + ("src/compiler/policies") ("src/code/typedefs") ;; ("src/code/defbangmacro" was here until sbcl-0.6.7.3.) @@ -326,6 +336,7 @@ ;; in class.lisp. ("src/code/condition" :not-host) + ("src/compiler/generic/vm-array") ("src/compiler/generic/primtype") ;; the implementation of the compiler-affecting part of forms like @@ -333,12 +344,16 @@ ;; defining types ("src/compiler/parse-lambda-list") + ;; The following two files trigger function/macro redefinition + ;; warnings in clisp during make-host-2; as a workaround, we ignore + ;; the failure values from COMPILE-FILE under clisp. + ;; for DEFSTRUCT ALIEN-TYPE, needed by host-type.lisp - ("src/code/host-alieneval") + ("src/code/host-alieneval" #+clisp :ignore-failure-p) ;; can't be done until definition of e.g. DEFINE-ALIEN-TYPE-CLASS in ;; host-alieneval.lisp - ("src/code/host-c-call") + ("src/code/host-c-call" #+clisp :ignore-failure-p) ;; SB!XC:DEFTYPE is needed in order to compile late-type ;; in the host Common Lisp, and in order to run, it needs @@ -363,6 +378,8 @@ ("src/code/cross-type" :not-target) ("src/compiler/generic/vm-type") ("src/compiler/proclaim") + + ("src/code/class-init") ("src/code/typecheckfuns") ;; The DEFSTRUCT machinery needs SB!XC:SUBTYPEP, defined in @@ -386,6 +403,9 @@ ("src/compiler/compiler-error") ("src/code/type-init") + ;; Now that the type system is initialized, fix up UNKNOWN types that + ;; have crept in. + ("src/compiler/fixup-type") ;; These define target types needed by fndb.lisp. ("src/code/package") @@ -422,7 +442,8 @@ ;; (and so that they don't cause lots of annoying compiler warnings ;; about undefined types). ("src/compiler/generic/core") - + ("src/code/cross-thread" :not-target) + ("src/code/thread") ("src/code/load") ("src/code/fop") ; needs macros from code/load.lisp @@ -440,6 +461,7 @@ ("src/compiler/main") ; needs DEFSTRUCT FASL-OUTPUT from dump.lisp ("src/compiler/target-main" :not-host) ("src/compiler/ir1tran") + ("src/compiler/ir1tran-lambda") ("src/compiler/ir1-translators") ("src/compiler/ir1util") ("src/compiler/ir1report") @@ -453,6 +475,7 @@ ("src/compiler/float-tran") ("src/compiler/saptran") ("src/compiler/srctran") + ("src/compiler/generic/vm-tran") ("src/compiler/locall") ("src/compiler/dfo") ("src/compiler/checkgen") @@ -478,6 +501,7 @@ ("src/compiler/target/insts") ("src/compiler/target/macros") + ("src/compiler/generic/early-type-vops") ("src/assembly/target/support") @@ -489,10 +513,24 @@ ("src/compiler/target/memory") ("src/compiler/target/static-fn") ("src/compiler/target/arith" - ;; KLUDGE: for ppc and sparc this appears to be necessary -- see the - ;; comment below regarding src/compiler/target/array -- CSR, - ;; 2002-05-05 - :ignore-failure-p) + ;; KLUDGE: for ppc and sparc this appears to be necessary, as it + ;; used to be for array VOPs for X86 until ca. 0.8.5.24 when CSR's + ;; patch for that architecture was finally committed + ;; + ;; old (0.8.5.23) comment on the array-VOP hack for X86: + ;; x Compiling this file for X86 raises alarming warnings of + ;; x the form + ;; x Argument FOO to VOP CHECK-BOUND has SC restriction + ;; x DESCRIPTOR-REG which is not allowed by the operand type: + ;; x (:OR POSITIVE-FIXNUM) + ;; x This seems not to be something that I broke, but rather a "feature" + ;; x inherited from classic CMU CL. (Debian cmucl_2.4.8.deb compiling + ;; x Debian cmucl_2.4.8.tar.gz raises the same warning). Thus, even though + ;; x these warnings are severe enough that they would ordinarily abort + ;; x compilation, for now we blithely ignore them and press on to more + ;; x pressing problems. Someday, though, it would be nice to figure out + ;; x what the problem is and fix it. + #!+(or ppc sparc) :ignore-failure-p) ("src/compiler/target/subprim") ("src/compiler/target/debug") @@ -505,29 +543,28 @@ ("src/compiler/target/alloc") ("src/compiler/target/call") ("src/compiler/target/nlx") + ("src/compiler/generic/late-nlx") ("src/compiler/target/show") - ("src/compiler/target/array" - ;; KLUDGE: Compiling this file for X86 raises alarming warnings of - ;; the form - ;; Argument FOO to VOP CHECK-BOUND has SC restriction - ;; DESCRIPTOR-REG which is not allowed by the operand type: - ;; (:OR POSITIVE-FIXNUM) - ;; This seems not to be something that I broke, but rather a "feature" - ;; inherited from classic CMU CL. (Debian cmucl_2.4.8.deb compiling - ;; Debian cmucl_2.4.8.tar.gz raises the same warning). Thus, even though - ;; these warnings are severe enough that they would ordinarily abort - ;; compilation, for now we blithely ignore them and press on to more - ;; pressing problems. Someday, though, it would be nice to figure out - ;; what the problem is and fix it. (See the comments in - ;; src/compiler/x86/array for a candidate patch.) -- WHN 19990323 - :ignore-failure-p) + ("src/compiler/target/array") + ("src/compiler/generic/array") ("src/compiler/target/pred") - ("src/compiler/target/type-vops") - ("src/assembly/target/assem-rtns" :assem) - ("src/assembly/target/array" :assem) - ("src/assembly/target/arith" :assem) - ("src/assembly/target/alloc" :assem) + ("src/compiler/target/type-vops") + ("src/compiler/generic/late-type-vops") + + ;; KLUDGE: The assembly files need to be compiled twice: once as + ;; normal lisp files, and once by sb-c:assemble-file. We play some + ;; symlink games to make sure we don't scribble over anything we + ;; shouldn't, but these are actually the same files: + + ("src/compiler/assembly/target/assem-rtns") + ("src/compiler/assembly/target/array") + ("src/compiler/assembly/target/arith") + ("src/compiler/assembly/target/alloc") + ("src/assembly/target/assem-rtns" :assem :not-host) + ("src/assembly/target/array" :assem :not-host) + ("src/assembly/target/arith" :assem :not-host) + ("src/assembly/target/alloc" :assem :not-host) ("src/compiler/pseudo-vops") @@ -545,7 +582,6 @@ ("src/compiler/copyprop") ("src/compiler/represent") - ("src/compiler/generic/vm-tran") ("src/compiler/pack") ("src/compiler/codegen") ("src/compiler/debug") @@ -577,13 +613,20 @@ ("src/code/target-random" :not-host) ; needs "code/random" ("src/code/target-hash-table" :not-host) ; needs "code/hash-table" ("src/code/reader" :not-host) ; needs "code/readtable" + ("src/code/target-stream" :not-host) ; needs WHITESPACEP from "code/reader" ("src/code/target-pathname" :not-host) ; needs "code/pathname" ("src/code/filesys" :not-host) ; needs HOST from "code/pathname" ("src/code/save" :not-host) ; uses the definition of PATHNAME ; from "code/pathname" ("src/code/sharpm" :not-host) ; uses stuff from "code/reader" + #!+sb-thread + ("src/code/target-thread" :not-host) + #!-sb-thread + ("src/code/target-unithread" :not-host) ;; defines SB!DI:DO-DEBUG-FUN-BLOCKS, needed by target-disassem.lisp + ("src/code/gc" :not-host) + ("src/code/purify" :not-host) ("src/code/debug-int" :not-host) ;; target-only assemblerish stuff @@ -616,6 +659,10 @@ ;; DEFVAR or DEFPARAMETER. ("src/code/cl-specials") + ;; FIXME: here? earlier? can probably be as late as possible. Also + ;; maybe call it FORCE-DELAYED-PROCLAIMS? + ("src/compiler/late-proclaim") + ;; fundamental target macros (e.g. CL:DO and CL:DEFUN) and support ;; for them ("src/code/defboot") @@ -626,11 +673,17 @@ ("src/code/late-setf") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - ;; other target-code-building stuff which can't be processed until ;; machinery like SB!XC:DEFMACRO exists ("src/code/late-format") ; needs SB!XC:DEFMACRO ("src/code/sxhash") ; needs SB!XC:DEFINE-MODIFY-MACRO ("src/code/signal") - ("src/code/late-defbangmethod")) + ("src/code/late-defbangmethod") + + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + ;; PCL-related stuff, which shouldn't need to be done earlier than + ;; anything else in cold build because after all it used to be + ;; postponed 'til warm init with no problems. + + ("src/pcl/walk"))