X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=stems-and-flags.lisp-expr;h=5bc126d90b4b989e87ad251124030a881a694abc;hb=7fd2eb4b1bc68e8aaec233c4a39bdfc40225bda2;hp=3018510b851abd91181a5707f734c85519f12438;hpb=f392742d2781f42b3bb15b637e5008e10fbbe092;p=sbcl.git diff --git a/stems-and-flags.lisp-expr b/stems-and-flags.lisp-expr index 3018510..5bc126d 100644 --- a/stems-and-flags.lisp-expr +++ b/stems-and-flags.lisp-expr @@ -1,3 +1,4 @@ +;;;; -*- Lisp -*- ;;;; build order ;;;; This software is part of the SBCL system. See the README file for @@ -31,13 +32,13 @@ ;;; FIXME: Perhaps now that a significant number of files are built ;;; in warm load instead of cold load, this file should now be called ;;; cold-stems-and-flags.lisp-expr? Also, perhaps this file should move -;;; into the src/cold/ directory? +;;; into the src/cold directory? ( ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; miscellaneous ;; This comes early because it's useful for debugging everywhere. - ("code/show") + ("src/code/show") ;; This comes early because the cross-compilation host's backquote logic ;; expand into something which can't be executed on the target Lisp (e.g. @@ -45,7 +46,7 @@ ;; by replacing the host backquote logic with our own as early as possible, ;; we minimize the chance of any forms referring to host Lisp internal ;; functions leaking into target Lisp code. - ("code/backq") + ("src/code/backq") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; various DEFSETFs and/or other DEFMACROish things, defined as early as @@ -58,93 +59,88 @@ ;; use. It might be pretty tedious, though, working through any ;; transforms and translators and optimizers and so forth to make sure ;; that they can handle the change. -- WHN 19990919 - ("code/defsetfs") + ("src/code/defsetfs") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; cross-compiler-only replacements for stuff which in target Lisp would be ;;; supplied by basic machinery - ("code/cross-misc" :not-target) - ("code/cross-float" :not-target) - ("code/cross-io" :not-target) - ("code/cross-sap" :not-target) + ("src/code/cross-misc" :not-target) + ("src/code/cross-float" :not-target) + ("src/code/cross-io" :not-target) + ("src/code/cross-sap" :not-target) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; stuff needed early both in cross-compilation host and in target Lisp - ("code/uncross") - ("code/early-defbangmethod") + ("src/code/uncross") + ("src/code/early-defbangmethod") - ("code/defbangtype") - ("code/defbangmacro") + ("src/code/defbangtype") + ("src/code/defbangmacro") - ("code/primordial-extensions") + ("src/code/primordial-extensions") ;; for various constants e.g. SB!VM:*TARGET-MOST-POSITIVE-FIXNUM* and ;; SB!VM:LOWTAG-BITS, needed by "early-objdef" and others - ("compiler/generic/early-vm") - ("compiler/generic/early-objdef") - ("compiler/target/parms") - ("code/early-array") ; needs "early-vm" numbers + ("src/compiler/generic/early-vm") + ("src/compiler/generic/early-objdef") + ("src/compiler/target/parms") + ("src/code/early-array") ; needs "early-vm" numbers - ("code/parse-body") ; on host for PARSE-BODY - ("code/parse-defmacro") ; on host for PARSE-DEFMACRO - ("code/boot-extensions") ; on host for COLLECT etc. - ("code/early-extensions") ; on host for SYMBOLICATE etc. - ("code/late-extensions") ; FIXME: maybe no longer needed on host now that - ; we are no longer doing PRINT-HERALD stuff - ("compiler/deftype") ; on host for SB!XC:DEFTYPE - ("code/early-alieneval") ; for vars needed both at build time and at runtime + ("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 - ("code/specializable-array") + ("src/code/specializable-array") - ("code/early-cl") - ("code/early-load") + ("src/code/early-cl") + ("src/code/early-fasl") ;; mostly needed by stuff from comcom, but also used by "x86-vm" - ("code/debug-var-io") + ("src/code/debug-var-io") - ("code/cold-init-helper-macros") + ("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. - ("code/target-defbangmethod" :not-host) + ("src/code/target-defbangmethod" :not-host) - ("code/early-print" :not-host) - ("code/early-pprint" :not-host) - ("code/early-impl" :not-host) + ("src/code/early-print" :not-host) + ("src/code/early-pprint" :not-host) + ("src/code/early-impl" :not-host) - ("code/target-extensions" :not-host) + ("src/code/target-extensions" :not-host) - ("code/early-defstructs" :not-host) ; gotta-be-first DEFSTRUCTs + ("src/code/early-defstructs" :not-host) ; gotta-be-first DEFSTRUCTs - ("code/defbangstruct") + ("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 ;; avoids some cold init issues involving full calls to structure ;; accessors.) - ("code/type-class") + ("src/code/type-class") + + ("src/code/pcounter" :not-host) - ("code/lisp-stream" :not-host) + ("src/code/lisp-stream" :not-host) - ("code/sysmacs" :not-host) + ("src/code/sysmacs" :not-host) ;; "assembly/assemfile" was here in the sequence inherited from ;; CMU CL worldcom.lisp, but also appears later in the sequence ;; 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. - - ("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. @@ -152,11 +148,11 @@ ;; and stuff." ;; Dunno exactly what this meant or whether it still holds. -- WHN 19990803 ;; FIXME: more informative and up-to-date comment? - ("code/globals" :not-host) - ("code/kernel" :not-host) - ("code/toplevel" :not-host) - ("code/cold-error" :not-host) - ("code/fdefinition" :not-host) + ("src/code/globals" :not-host) + ("src/code/kernel" :not-host) + ("src/code/toplevel" :not-host) + ("src/code/cold-error" :not-host) + ("src/code/fdefinition" :not-host) ;; FIXME: Figure out some way to make the compiler macro for INFO ;; available for compilation of "code/fdefinition". @@ -164,227 +160,227 @@ ;; lots of smaller pieces, some of which are here and some of which ;; are handled later in the sequence, when the cross-compiler is ;; built. -- WHN 19990620 - ("code/target-type" :not-host) + ("src/code/target-type" :not-host) - ("code/pred" :not-host) + ("src/code/pred" :not-host) - ("code/target-alieneval" :not-host) - ("code/target-c-call" :not-host) - ("code/target-sap" :not-host) + ("src/code/target-alieneval" :not-host) + ("src/code/target-c-call" :not-host) + ("src/code/target-allocate" :not-host) - ("code/array" :not-host) - ("code/target-sxhash" :not-host) + ;; This needs DEF-ALIEN-ROUTINE from target-alieneval. + ("src/code/misc-aliens" :not-host) - ("code/list" :not-host) - ("code/seq" :not-host) ; "code/seq" should come after "code/list". - ("code/coerce" :not-host) + ("src/code/array" :not-host) + ("src/code/target-sxhash" :not-host) - ("code/string" :not-host) - ("code/mipsstrops" :not-host) + ("src/code/list" :not-host) + ("src/code/seq" :not-host) ; "code/seq" should come after "code/list". + ("src/code/coerce" :not-host) - ("code/unix" :not-host) + ("src/code/string" :not-host) + ("src/code/mipsstrops" :not-host) - #!+mach ("code/mach" :not-host) - #!+mach ("code/mach-os" :not-host) - #!+sunos ("code/sunos-os" :not-host) - #!+hpux ("code/hpux-os" :not-host) - #!+osf1 ("code/osf1-os" :not-host) - #!+irix ("code/irix-os" :not-host) - #!+bsd ("code/bsd-os" :not-host) - #!+linux ("code/linux-os" :not-host) + ;; "src/code/unix.lisp" needs this. It's generated automatically by + ;; grovel_headers.c, i.e. it's not in CVS. + ("output/stuff-groveled-from-headers" :not-host) - ;; KLUDGE: I'd prefer to have this done with a "code/target" softlink - ;; instead of a bunch of reader macros. -- WHN 19990308 - #!+pmax ("code/pmax-vm" :not-host) - #!+(and sparc svr4) ("code/sparc-svr4-vm" :not-host) - #!+(and sparc (not svr4)) ("code/sparc-vm" :not-host) - #!+rt ("code/rt-vm" :not-host) - #!+hppa ("code/hppa-vm" :not-host) - #!+x86 ("code/x86-vm" :not-host) - #!+alpha ("code/alpha-vm" :not-host) - #!+sgi ("code/sgi-vm" :not-host) + ("src/code/unix" :not-host) - ("code/target-signal" :not-host) ; needs OS-CONTEXT-T from x86-vm + #!+mach ("src/code/mach" :not-host) + #!+mach ("src/code/mach-os" :not-host) + #!+sunos ("src/code/sunos-os" :not-host) + #!+hpux ("src/code/hpux-os" :not-host) + #!+osf1 ("src/code/osf1-os" :not-host) + #!+irix ("src/code/irix-os" :not-host) + #!+bsd ("src/code/bsd-os" :not-host) + #!+linux ("src/code/linux-os" :not-host) - ("code/symbol" :not-host) - ("code/bignum" :not-host) - ("code/target-numbers" :not-host) - ("code/float-trap" :not-host) - ("code/float" :not-host) - ("code/irrat" :not-host) + ;; KLUDGE: I'd prefer to have this done with a "code/target" softlink + ;; instead of a bunch of reader macros. -- WHN 19990308 + #!+pmax ("src/code/pmax-vm" :not-host) + #!+(and sparc svr4) ("src/code/sparc-svr4-vm" :not-host) + #!+(and sparc (not svr4)) ("src/code/sparc-vm" :not-host) + #!+rt ("src/code/rt-vm" :not-host) + #!+hppa ("src/code/hppa-vm" :not-host) + #!+x86 ("src/code/x86-vm" :not-host) + #!+alpha ("src/code/alpha-vm" :not-host) + #!+sgi ("src/code/sgi-vm" :not-host) - ("code/char" :not-host) - ("code/target-misc" :not-host) - ("code/misc") + ("src/code/target-signal" :not-host) ; needs OS-CONTEXT-T from x86-vm - #!-gengc ("code/room" :not-host) - #!-gengc ("code/gc" :not-host) - #!-gengc ("code/purify" :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) - #!+gengc ("code/gengc" :not-host) + ("src/code/char") + ("src/code/target-char" :not-host) + ("src/code/target-misc" :not-host) + ("src/code/misc") - ("code/stream" :not-host) - ("pcl/gray-streams-stubs" :not-host) - ("code/print" :not-host) - ("code/pprint" :not-host) ; maybe should be :BYTE-COMPILE T - ("code/early-format") - ("code/target-format" :not-host) ; maybe should be :BYTE-COMPILE T - ("code/defpackage" :not-host) - ("code/pp-backq" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/room" :not-host) + ("src/code/gc" :not-host) + ("src/code/purify" :not-host) - ("code/error-error" :not-host) ; needs WITH-STANDARD-IO-SYNTAX macro + ("src/code/stream" :not-host) + ("src/code/print" :not-host) + ("src/code/pprint" :not-host) + ("src/code/early-format") + ("src/code/target-format" :not-host) + ("src/code/defpackage" :not-host) + ("src/code/pp-backq" :not-host) - ("code/serve-event" :not-host) - ("code/fd-stream" :not-host) + ("src/code/error-error" :not-host) ; needs WITH-STANDARD-IO-SYNTAX macro - ("code/module" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/serve-event" :not-host) + ("src/code/fd-stream" :not-host) - #!+sb-interpreter - ("code/eval") + ("src/code/module" :not-host) - ("code/target-eval" :not-host) ; FIXME: uses INFO, wants compiler macro + ("src/code/interr" :not-host) - ("code/interr" :not-host) + ("src/code/query" :not-host) - ("code/query" :not-host) ; maybe should be :BYTE-COMPILE T + ("src/code/sort" :not-host) + ("src/code/time" :not-host) + ("src/code/weak" :not-host) + ("src/code/final" :not-host) - ("code/sort" :not-host) - ("code/time" :not-host) - ("code/weak" :not-host) - ("code/final" :not-host) + #!+mp ("src/code/multi-proc" :not-host) - #!+mp ("code/multi-proc" :not-host) + ("src/code/setf-funs" :not-host) - ("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) - ("compiler/early-c") - ("compiler/policy") - ("code/numbers") + ("src/compiler/early-c") + ("src/compiler/policy") + ("src/code/typedefs") - ("code/typedefs") + ;; ("src/code/defbangmacro" was here until sbcl-0.6.7.3.) - ;; ("code/defbangmacro" was here until sbcl-0.6.7.3.) - - ("compiler/macros") - ("compiler/generic/vm-macs") + ("src/compiler/macros") + ("src/compiler/generic/vm-macs") ;; needed by "compiler/vop" - ("compiler/sset") + ("src/compiler/sset") ;; for e.g. BLOCK-ANNOTATION, needed by "compiler/vop" - ("compiler/node") + ("src/compiler/node") ;; for e.g. PRIMITIVE-TYPE, needed by "vmdef" - ("compiler/vop") + ("src/compiler/vop") ;; needed by "vm" and "primtype" - ("compiler/backend") + ("src/compiler/backend") ;; for e.g. MAX-VOP-TN-REFS, needed by "meta-vmdef" - ("compiler/vmdef") + ("src/compiler/vmdef") ;; needs "backend" - ("compiler/target/backend-parms") + ("src/compiler/target/backend-parms") ;; for INFO and SB!XC:MACRO-FUNCTION, needed by defmacro.lisp - ("compiler/globaldb") - ("compiler/info-functions") + ("src/compiler/globaldb") + ("src/compiler/info-functions") - ("code/defmacro") - ("code/force-delayed-defbangmacros") + ("src/code/defmacro") + ("src/code/force-delayed-defbangmacros") - ("compiler/late-macros") + ("src/compiler/late-macros") - ;; for e.g. DEF-PRIMITIVE-TYPE, needed by primtype.lisp, and + ;; for e.g. !DEF-PRIMITIVE-TYPE, needed by primtype.lisp, and ;; DEFINE-STORAGE-CLASS, needed by target/vm.lisp - ("compiler/meta-vmdef") + ("src/compiler/meta-vmdef") ;; for e.g. DESCRIPTOR-REG, needed by primtype.lisp - ("compiler/target/vm") + ("src/compiler/target/vm") ;; for e.g. SPECIFIER-TYPE, needed by primtype.lisp - ("code/early-type") + ("src/code/early-type") ;; FIXME: Classic CMU CL had SAFETY 2 DEBUG 2 set around the compilation ;; of "code/class". Why? - ("code/class") + ("src/code/class") ;; The definitions for CONDITION and CONDITION-CLASS depend on ;; SLOT-CLASS, defined in classes.lisp. - ("code/late-target-error" :not-host) ; FIXME: maybe should be :BYTE-COMPILE T + ("src/code/condition" :not-host) - ("compiler/generic/primtype") + ("src/compiler/generic/primtype") ;; the implementation of the compiler-affecting part of forms like ;; DEFMACRO and DEFTYPE; must be loaded before we can start ;; defining types - ("compiler/parse-lambda-list") + ("src/compiler/parse-lambda-list") ;; for DEFSTRUCT ALIEN-TYPE, needed by host-type.lisp - ("code/host-alieneval") + ("src/code/host-alieneval") ;; can't be done until definition of e.g. DEF-ALIEN-TYPE-CLASS in ;; host-alieneval.lisp - ("code/host-c-call") + ("src/code/host-c-call") - ;; SB!XC:DEFTYPE is needed in order to compile late-target-type + ;; SB!XC:DEFTYPE is needed in order to compile late-type ;; in the host Common Lisp, and in order to run, it needs ;; %COMPILER-DEFTYPE. - ("compiler/compiler-deftype") + ("src/compiler/compiler-deftype") ;; These appear here in the build sequence because they require ;; * the macro INFO, defined in globaldb.lisp, and ;; * the function PARSE-DEFMACRO, defined in parse-defmacro.lisp, ;; and because they define ;; * the function SPECIFIER-TYPE, which is used in fndb.lisp. - ("code/late-type") - ("code/deftypes-for-target") + ("src/code/late-type") + ("src/code/deftypes-for-target") ;; The inline definition of TYPEP-TO-LAYOUT here needs inline ;; functions defined in classes.lisp, and is needed in turn by ;; the target version of "code/defstruct". - ("code/target-defstruct" :not-host) + ("src/code/target-defstruct" :not-host) ;; stuff needed by "code/defstruct" - ("code/cross-type" :not-target) - ("compiler/generic/vm-type") + ("src/code/cross-type" :not-target) + ("src/compiler/generic/vm-type") ;; The DEFSTRUCT machinery needs SB!XC:SUBTYPEP, defined in ;; "code/late-type", and SB!XC:TYPEP, defined in "code/cross-type", ;; and SPECIALIZE-ARRAY-TYPE, defined in "compiler/generic/vm-type". - ("code/defstruct") + ("src/code/defstruct") ;; ALIEN-VALUE has to be defined as a class (done by DEFSTRUCT ;; machinery) before we can set its superclasses here. - ("code/alien-type") + ("src/code/alien-type") - ("compiler/knownfun") + ("src/compiler/knownfun") ;; needs IR1-ATTRIBUTES macro, defined in knownfun.lisp - ("compiler/proclaim") + ("src/compiler/proclaim") ;; This needs not just the SB!XC:DEFSTRUCT machinery, but also ;; the TYPE= stuff defined in late-type.lisp, and the ;; CHECK-FUNCTION-NAME defined in proclaim.lisp. - ("code/force-delayed-defbangstructs") + ("src/code/force-delayed-defbangstructs") - ("code/typep") + ("src/code/typep") - ("compiler/compiler-error") + ("src/compiler/compiler-error") - ("code/type-init") + ("src/code/type-init") ;; These define target types needed by fndb.lisp. - ("code/package") - ("code/random") - ("code/hash-table") - ("code/readtable") - ("code/pathname") - ("compiler/lexenv") + ("src/code/package") + ("src/code/random") + ("src/code/hash-table") + ("src/code/readtable") + ("src/code/pathname") + ("src/compiler/lexenv") ;; KLUDGE: Much stuff above here is the type system and/or the INFO ;; system, not really the compiler proper. It might be easier to @@ -395,97 +391,116 @@ ;; in building from scratch, these must be loaded before ;; "compiler/generic/objdef" in order to allow forms like ;; (DEFINE-PRIMITIVE-OBJECT (..) (CAR ..) ..) to work. - ("compiler/fndb") - ("compiler/generic/vm-fndb") + ("src/compiler/fndb") + ("src/compiler/generic/vm-fndb") - ("compiler/generic/objdef") + ("src/compiler/generic/objdef") - ("compiler/generic/interr") + ("src/compiler/generic/interr") - ("compiler/bit-util") + ("src/compiler/bit-util") - ("compiler/early-assem") ; has ASSEMBLY-UNIT-related stuff needed by core.lisp + ;; This has ASSEMBLY-UNIT-related stuff needed by core.lisp. + ("src/compiler/early-assem") ;; core.lisp contains DEFSTRUCT CORE-OBJECT, and "compiler/main.lisp" ;; does lots of (TYPEP FOO 'CORE-OBJECT), so it's nice to compile this ;; before "compiler/main.lisp" so that those can be coded efficiently ;; (and so that they don't cause lots of annoying compiler warnings ;; about undefined types). - ("compiler/generic/core") - - ("code/load") - - ("code/fop") ; needs macros from code/host-load.lisp - - ("compiler/ctype") - ("compiler/disassem") - ("compiler/assem") - - ("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. - ("compiler/dump") + ("src/compiler/generic/core") + + ("src/code/load") + + ("src/code/fop") ; needs macros from code/load.lisp + + ("src/compiler/ctype") + ("src/compiler/disassem") + ("src/compiler/assem") + + ("src/compiler/trace-table") ; needs EMIT-LABEL macro from compiler/assem.lisp + + ;; 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) - ("compiler/main") ; needs DEFSTRUCT FASL-FILE from compiler/dump.lisp - ("compiler/target-main" :not-host) - ("compiler/ir1tran") - ("compiler/ir1util") - ("compiler/ir1opt") + ("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 ;; SB!ASSEM:EMIT-POST-IT, defined in assem.lisp. - ("compiler/late-vmdef") - - ("compiler/ir1final") - ("compiler/array-tran") - ("compiler/seqtran") - ("compiler/typetran") - ("compiler/generic/vm-typetran") - ("compiler/float-tran") - ("compiler/saptran") - ("compiler/srctran") - ("compiler/locall") - ("compiler/dfo") - ("compiler/checkgen") - ("compiler/constraint") - ("compiler/envanal") - - ("compiler/tn") - ("compiler/life") - - ("code/debug-info") - - ("compiler/debug-dump") - ("compiler/generic/utils") - ("assembly/assemfile") - - ("compiler/fixup") ; for DEFSTRUCT FIXUP, used by insts.lisp - - ("compiler/target/insts") - ("compiler/target/macros") - - ("assembly/target/support") - - ("compiler/target/move") - ("compiler/target/float") - ("compiler/target/sap") - ("compiler/target/system") - ("compiler/target/char") - ("compiler/target/memory") - ("compiler/target/static-fn") - ("compiler/target/arith") - ("compiler/target/subprim") - - ("compiler/target/debug") - ("compiler/target/c-call") - ("compiler/target/cell") - ("compiler/target/values") - ("compiler/target/alloc") - ("compiler/target/call") - ("compiler/target/nlx") - ("compiler/target/show") - ("compiler/target/array" + ("src/compiler/late-vmdef") + + ("src/compiler/ir1final") + ("src/compiler/array-tran") + ("src/compiler/seqtran") + ("src/compiler/typetran") + ("src/compiler/generic/vm-typetran") + ("src/compiler/float-tran") + ("src/compiler/saptran") + ("src/compiler/srctran") + ("src/compiler/locall") + ("src/compiler/dfo") + ("src/compiler/checkgen") + ("src/compiler/constraint") + ("src/compiler/physenvanal") + + ("src/compiler/tn") + ("src/compiler/life") + + ("src/code/debug-info") + + ("src/compiler/debug-dump") + ("src/compiler/generic/utils") + ("src/assembly/assemfile") + + ("src/compiler/fixup") ; for DEFSTRUCT FIXUP, used by insts.lisp + + ("src/compiler/target/insts") + ("src/compiler/target/macros") + + ("src/assembly/target/support") + + ("src/compiler/target/move") + ("src/compiler/target/float") + ("src/compiler/target/sap") + ("src/compiler/target/system") + ("src/compiler/target/char") + ("src/compiler/target/memory") + ("src/compiler/target/static-fn") + ("src/compiler/target/arith") + ("src/compiler/target/subprim") + + ("src/compiler/target/debug") + ("src/compiler/target/c-call") + ("src/compiler/target/cell") + ("src/compiler/target/values") + ("src/compiler/target/alloc") + ("src/compiler/target/call") + ("src/compiler/target/nlx") + ("src/compiler/target/show") + ("src/compiler/target/array" ;; KLUDGE: Compiling this file 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: @@ -498,109 +513,105 @@ ;; pressing problems. Someday, though, it would be nice to figure out ;; what the problem is and fix it.. -- WHN 19990323 :ignore-failure-p) - ("compiler/target/pred") - ("compiler/target/type-vops") - - ("assembly/target/assem-rtns" :assem) - ("assembly/target/array" :assem) - ("assembly/target/arith" :assem) - ("assembly/target/alloc" :assem) - - ("compiler/pseudo-vops") - - ("compiler/aliencomp") - - ("compiler/ltv") - ("compiler/gtn") - ("compiler/ltn") - ("compiler/stack") - ("compiler/control") - ("compiler/entry") - ("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. - ("compiler/generic/vm-ir2tran") - - ("compiler/copyprop") - ("compiler/represent") - ("compiler/generic/vm-tran") - ("compiler/pack") - ("compiler/codegen") - ("compiler/debug") - - #!+sb-dyncount ("compiler/dyncount") - #!+sb-dyncount ("code/dyncount") - - ;; needed by OPEN-FASL-FILE, which is called by COMPILE-FILE - ("code/format-time") + ("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/pseudo-vops") + + ("src/compiler/aliencomp") + + ("src/compiler/ltv") + ("src/compiler/gtn") + ("src/compiler/ltn") + ("src/compiler/stack") + ("src/compiler/control") + ("src/compiler/entry") + ("src/compiler/ir2tran") + + ("src/compiler/generic/vm-ir2tran") + + ("src/compiler/copyprop") + ("src/compiler/represent") + ("src/compiler/generic/vm-tran") + ("src/compiler/pack") + ("src/compiler/codegen") + ("src/compiler/debug") + + #!+sb-dyncount ("src/compiler/dyncount") + #!+sb-dyncount ("src/code/dyncount") + + ;; 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 - ("code/error") + ("src/code/error") ;; This wasn't in classic CMU CL "comcom.lisp", but it has some stuff ;; that Python-as-cross-compiler has turned out to need. - ("code/macroexpand") + ("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 - - ("compiler/generic/target-core" :not-host) ; uses stuff from - ; "compiler/generic/core" - - ("code/target-package" :not-host) ; needs "code/package" - ("code/target-random" :not-host) ; needs "code/random" - ("code/target-hash-table" :not-host) ; needs "code/hash-table" - ("code/reader" :not-host) ; needs "code/readtable" - ("code/target-pathname" :not-host) ; needs "code/pathname", maybe - ; should be :BYTE-COMPILE T - ("code/filesys" :not-host) ; needs HOST from "code/pathname", - ; maybe should be :BYTE-COMPILE T - ("code/save" :not-host) ; uses the definition of PATHNAME - ; from "code/pathname" - ("code/sharpm" :not-host) ; uses stuff from "code/reader" - - ;; stuff for byte compilation. This works only in the target system, - ;; because fundamental BYTE-FUNCTION-OR-CLOSURE types are implemented - ;; as nonportable FUNCALLABLE-INSTANCEs. - ("code/byte-types" :not-host) - ("compiler/byte-comp") - ("compiler/target-byte-comp" :not-host) - ;; FIXME: Could byte-interp be moved here? It'd be logical.. + ;; 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" + + ("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" + ("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" ;; defines SB!DI:DO-DEBUG-FUNCTION-BLOCKS, needed by target-disassem.lisp - ("code/debug-int" :not-host) + ("src/code/debug-int" :not-host) ;; target-only assemblerish stuff - ("compiler/target-disassem" :not-host) - ("compiler/target/target-insts" :not-host) - - ;; the IR1 interpreter (as opposed to the byte code interpreter) - #!+sb-interpreter ("compiler/eval-comp" :not-host) - #!+sb-interpreter ("compiler/eval" :not-host) + ("src/compiler/target-disassem" :not-host) + ("src/compiler/target/target-insts" :not-host) - ("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*. - ("code/parse-defmacro-errors" :not-host) + ("src/code/parse-defmacro-errors" :not-host) - ("code/bit-bash" :not-host) ; needs %NEGATE from assembly/target/arith + ("src/code/bit-bash" :not-host) ; needs %NEGATE from assembly/target/arith - ("code/byte-interp" :not-host) ; needs *SYSTEM-CONSTANT-CODES* from byte-comp - - ("code/target-load" :not-host) ; needs specials from code/load.lisp + ("src/code/target-load" :not-host) ; needs specials from code/load.lisp ;; FIXME: Does this really need stuff from compiler/dump.lisp? - ("compiler/target-dump" :not-host) ; needs stuff from compiler/dump.lisp - - ("code/cold-init" :not-host) ; needs (SETF EXTERN-ALIEN) macroexpansion + ("src/compiler/target-dump" :not-host) ; needs stuff from compiler/dump.lisp + + ("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 @@ -609,26 +620,23 @@ ;; we don't have to worry about any of them being bound incorrectly ;; when the compiler processes code which appears before the appropriate ;; DEFVAR or DEFPARAMETER. - ("code/cl-specials") + ("src/code/cl-specials") ;; 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? - ("code/defboot") - ("code/destructuring-bind") - ("code/early-setf") - ("code/macros") - ("code/loop") - ("code/late-setf") + ("src/code/defboot") + ("src/code/destructuring-bind") + ("src/code/early-setf") + ("src/code/macros") + ("src/code/loop") + ("src/code/late-setf") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; other target-code-building stuff which can't be processed until ;; machinery like SB!XC:DEFMACRO exists - ("code/late-format") ; needs SB!XC:DEFMACRO - ("code/sxhash") ; needs SB!XC:DEFINE-MODIFY-MACRO - ("code/signal") - ("code/late-defbangmethod")) + ("src/code/late-format") ; needs SB!XC:DEFMACRO + ("src/code/sxhash") ; needs SB!XC:DEFINE-MODIFY-MACRO + ("src/code/signal") + ("src/code/late-defbangmethod"))