X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=stems-and-flags.lisp-expr;h=5bc126d90b4b989e87ad251124030a881a694abc;hb=7fd2eb4b1bc68e8aaec233c4a39bdfc40225bda2;hp=c4978598dc1a3a08b214eec514332edf19b41681;hpb=4cf50b1896b25f5337e7c258b0b560da00d47993;p=sbcl.git diff --git a/stems-and-flags.lisp-expr b/stems-and-flags.lisp-expr index c497859..5bc126d 100644 --- a/stems-and-flags.lisp-expr +++ b/stems-and-flags.lisp-expr @@ -88,16 +88,16 @@ ("src/compiler/target/parms") ("src/code/early-array") ; needs "early-vm" numbers - ("src/code/parse-body") ; on host for PARSE-BODY - ("src/code/parse-defmacro") ; on host for PARSE-DEFMACRO - ("src/code/extensions") ; on host for COLLECT, SYMBOLICATE, etc. - ("src/compiler/deftype") ; on host for SB!XC:DEFTYPE - ("src/code/early-alieneval") ; for vars needed both at build and run time + ("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/code/early-alieneval") ; for vars needed both at build and run time ("src/code/specializable-array") ("src/code/early-cl") - ("src/code/early-load") + ("src/code/early-fasl") ;; mostly needed by stuff from comcom, but also used by "x86-vm" ("src/code/debug-var-io") @@ -120,6 +120,8 @@ ("src/code/defbangstruct") + ("src/code/funutils" :not-host) + ;; This needs DEF!STRUCT, and is itself needed early so that structure ;; accessors and inline functions defined here can be compiled inline ;; later. (Avoiding full calls not only increases efficiency, but also @@ -127,6 +129,8 @@ ;; accessors.) ("src/code/type-class") + ("src/code/pcounter" :not-host) + ("src/code/lisp-stream" :not-host) ("src/code/sysmacs" :not-host) @@ -136,13 +140,7 @@ ;; inherited from CMU CL comcom.lisp. We shouldn't need two versions, ;; so I've deleted the one here. -- WHN 19990620 - ;; FIXME: There are lots of "maybe" notes in this file, e.g. - ;; "maybe should be :BYTE-COMPILE T". Once the system is stable, - ;; look into them. - - ("src/code/early-target-error" :not-host) ; maybe should be :BYTE-COMPILE T - ;; FIXME: maybe should be called "target-error", with "late-target-error" - ;; called "condition" + ("src/code/target-error" :not-host) ;; a comment from classic CMU CL: ;; "These guys can supposedly come in any order, but not really. @@ -211,47 +209,40 @@ ("src/code/target-signal" :not-host) ; needs OS-CONTEXT-T from x86-vm - ("src/code/symbol" :not-host) - ("src/code/bignum" :not-host) - ("src/code/target-numbers" :not-host) - ("src/code/float-trap" :not-host) - ("src/code/float" :not-host) - ("src/code/irrat" :not-host) + ("src/code/symbol" :not-host) + ("src/code/bignum" :not-host) + ("src/code/numbers" :not-host) + ("src/code/float-trap" :not-host) + ("src/code/float" :not-host) + ("src/code/irrat" :not-host) ("src/code/char") ("src/code/target-char" :not-host) ("src/code/target-misc" :not-host) ("src/code/misc") - #!-gengc ("src/code/room" :not-host) - #!-gengc ("src/code/gc" :not-host) - #!-gengc ("src/code/purify" :not-host) - - #!+gengc ("src/code/gengc" :not-host) + ("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) - ("src/code/pprint" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/pprint" :not-host) ("src/code/early-format") - ("src/code/target-format" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/target-format" :not-host) ("src/code/defpackage" :not-host) - ("src/code/pp-backq" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/pp-backq" :not-host) ("src/code/error-error" :not-host) ; needs WITH-STANDARD-IO-SYNTAX macro ("src/code/serve-event" :not-host) ("src/code/fd-stream" :not-host) - ("src/code/module" :not-host) ; maybe should be :BYTE-COMPILE T - - #!+sb-interpreter - ("src/code/eval") - - ("src/code/target-eval" :not-host) ; FIXME: uses INFO, wants compiler macro + ("src/code/module" :not-host) ("src/code/interr" :not-host) - ("src/code/query" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/query" :not-host) ("src/code/sort" :not-host) ("src/code/time" :not-host) @@ -262,14 +253,14 @@ ("src/code/setf-funs" :not-host) + ("src/code/stubs" :not-host) + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; compiler (and a few miscellaneous files whose dependencies make it ;;; convenient to stick them here) ("src/compiler/early-c") ("src/compiler/policy") - ("src/code/numbers") - ("src/code/typedefs") ;; ("src/code/defbangmacro" was here until sbcl-0.6.7.3.) @@ -320,7 +311,7 @@ ;; The definitions for CONDITION and CONDITION-CLASS depend on ;; SLOT-CLASS, defined in classes.lisp. - ("src/code/late-target-error" :not-host) ; FIXME: maybe should be :BYTE-COMPILE T + ("src/code/condition" :not-host) ("src/compiler/generic/primtype") @@ -421,7 +412,7 @@ ("src/code/load") - ("src/code/fop") ; needs macros from code/host-load.lisp + ("src/code/fop") ; needs macros from code/load.lisp ("src/compiler/ctype") ("src/compiler/disassem") @@ -429,14 +420,32 @@ ("src/compiler/trace-table") ; needs EMIT-LABEL macro from compiler/assem.lisp - ;; Compiling this file requires fop definitions from code/fop.lisp - ;; and trace table definitions from compiler/trace-table.lisp. - ("src/compiler/dump") + ;; Compiling this requires fop definitions from code/fop.lisp and + ;; trace table definitions from compiler/trace-table.lisp. + ("src/compiler/dump" + ;; FIXME: When building sbcl-0.pre7.14.flaky4.5 under sbcl-0.6.12.1 + ;; with :SB-SHOW on the target *FEATURES* list, cross-compilation of + ;; this file gives a WARNING in HEXSTR, + ;; Lisp error during constant folding: + ;; Argument X is not a REAL: NIL + ;; This seems to come from DEF!MACRO %WITH-ARRAY-DATA-MACRO code + ;; which looks like + ;; (cond (,end + ;; (unless (or ,unsafe? (<= ,end ,size)) + ;; ..)) + ;; ..) + ;; where the system is trying to constant-fold the <= form when the + ;; ,END binding is known to be NIL at compile time. Since the <= form + ;; is unreachable in that case, this shouldn't be signalling a WARNING; + ;; but as long as it is, we have to ignore it in order to go on. + :ignore-failure-p) - ("src/compiler/main") ; needs DEFSTRUCT FASL-FILE from compiler/dump.lisp + ("src/compiler/main") ; needs DEFSTRUCT FASL-OUTPUT from dump.lisp ("src/compiler/target-main" :not-host) ("src/compiler/ir1tran") + ("src/compiler/ir1-translators") ("src/compiler/ir1util") + ("src/compiler/ir1report") ("src/compiler/ir1opt") ;; Compiling this file requires the macros SB!ASSEM:EMIT-LABEL and @@ -455,7 +464,7 @@ ("src/compiler/dfo") ("src/compiler/checkgen") ("src/compiler/constraint") - ("src/compiler/envanal") + ("src/compiler/physenvanal") ("src/compiler/tn") ("src/compiler/life") @@ -524,12 +533,6 @@ ("src/compiler/entry") ("src/compiler/ir2tran") - ;; KLUDGE: This has #!+GENGC things in it which are intended to - ;; overwrite code in ir2tran.lisp, so it has to come after ir2tran.lisp. - ;; - ;; FIXME: Those things should probably be ir2tran.lisp instead, and the - ;; things they now overwrite should instead be #!-GENGC so they're never - ;; generated in the first place. ("src/compiler/generic/vm-ir2tran") ("src/compiler/copyprop") @@ -542,7 +545,7 @@ #!+sb-dyncount ("src/compiler/dyncount") #!+sb-dyncount ("src/code/dyncount") - ;; needed by OPEN-FASL-FILE, which is called by COMPILE-FILE + ;; needed by OPEN-FASL-OUTPUT, which is called by COMPILE-FILE ("src/code/format-time") ;; needed by various unhappy-path cases in the cross-compiler @@ -553,36 +556,25 @@ ("src/code/macroexpand") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - ;; files which are only needed in the target system, and/or which are - ;; only possible in the target system, and which depend in some way - ;; (directly or indirectly) on stuff compiled as part of the compiler + ;; files which depend in some way (directly or indirectly) on stuff + ;; compiled as part of the compiler + ("src/code/late-extensions") ; needs condition system ("src/compiler/generic/target-core" :not-host) ; uses stuff from - ; "compiler/generic/core" + ; "compiler/generic/core" + ("src/code/eval" :not-host) ; uses INFO, wants compiler macro ("src/code/target-sap" :not-host) ; uses SAP-INT-TYPE ("src/code/target-package" :not-host) ; needs "code/package" ("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-pathname" :not-host) ; needs "code/pathname", maybe - ; should be :BYTE-COMPILE T - ("src/code/filesys" :not-host) ; needs HOST from "code/pathname", - ; maybe should be :BYTE-COMPILE T + ("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" + ; from "code/pathname" ("src/code/sharpm" :not-host) ; uses stuff from "code/reader" - ;; stuff for byte compilation. Note that although byte code is - ;; "portable", it'd be hard to make it work on the cross-compilation - ;; host, because fundamental BYTE-FUNCTION-OR-CLOSURE types are - ;; implemented as FUNCALLABLE-INSTANCEs, and it's not obvious - ;; how to emulate those in a vanilla ANSI Common Lisp. - ("src/code/byte-types" :not-host) - ("src/compiler/byte-comp") - ("src/compiler/target-byte-comp" :not-host) - ("src/code/byte-interp" :not-host) ; needs byte-comp *SYSTEM-CONSTANT-CODES* - ;; defines SB!DI:DO-DEBUG-FUNCTION-BLOCKS, needed by target-disassem.lisp ("src/code/debug-int" :not-host) @@ -590,11 +582,7 @@ ("src/compiler/target-disassem" :not-host) ("src/compiler/target/target-insts" :not-host) - ;; the IR1 interpreter (as opposed to the byte code interpreter) - #!+sb-interpreter ("src/compiler/eval-comp" :not-host) - #!+sb-interpreter ("src/compiler/eval" :not-host) - - ("src/code/debug" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/debug" :not-host) ;; These can't be compiled until CONDITION and DEFINE-CONDITION ;; are defined, and they also use SB-DEBUG:*STACK-TOP-HINT*. @@ -607,7 +595,23 @@ ;; FIXME: Does this really need stuff from compiler/dump.lisp? ("src/compiler/target-dump" :not-host) ; needs stuff from compiler/dump.lisp - ("src/code/cold-init" :not-host) ; needs (SETF EXTERN-ALIEN) macroexpansion + ("src/code/cold-init" :not-host ; needs (SETF EXTERN-ALIEN) macroexpansion + ;; FIXME: When building sbcl-0.pre7.14.flaky4.5 under sbcl-0.6.12.1 + ;; with :SB-SHOW on the target *FEATURES* list, cross-compilation of + ;; this file gives a WARNING in HEXSTR, + ;; Lisp error during constant folding: + ;; Argument X is not a REAL: NIL + ;; This seems to come from DEF!MACRO %WITH-ARRAY-DATA-MACRO code + ;; which looks like + ;; (cond (,end + ;; (unless (or ,unsafe? (<= ,end ,size)) + ;; ..)) + ;; ..) + ;; where the system is trying to constant-fold the <= form when the + ;; ,END binding is known to be NIL at compile time. Since the <= form + ;; is unreachable in that case, this shouldn't be signalling a WARNING; + ;; but as long as it is, we have to ignore it in order to go on. + :ignore-failure-p) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; target macros and DECLAIMs installed at build-the-cross-compiler time @@ -620,9 +624,6 @@ ;; fundamental target macros (e.g. CL:DO and CL:DEFUN) and support ;; for them - ;; - ;; FIXME: Since a lot of this code is just macros, perhaps it should be - ;; byte compiled? ("src/code/defboot") ("src/code/destructuring-bind") ("src/code/early-setf")