X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=stems-and-flags.lisp-expr;h=dae1556339afcbd64b756eb972916b6a692f8206;hb=8eb6f7d3da3960c827b704e23b5a47008274be7d;hp=68f37d99e723fc79eb992ededa9201435df59bed;hpb=a530bbe337109d898d5b4a001fc8f1afa3b5dc39;p=sbcl.git diff --git a/stems-and-flags.lisp-expr b/stems-and-flags.lisp-expr index 68f37d9..dae1556 100644 --- a/stems-and-flags.lisp-expr +++ b/stems-and-flags.lisp-expr @@ -1,4 +1,4 @@ -;;;; build order +;;;; -*- Lisp -*- ;;;; This software is part of the SBCL system. See the README file for ;;;; more information. @@ -27,17 +27,12 @@ ;;; the dependency information manually, and the brittleness of the ;;; package system would help make most violations of the declared ;;; dependencies obvious at build time. -- WHN 20000803 -;;; -;;; 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? ( ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; 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 +40,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,89 +53,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/parse-body") ; on host for PARSE-BODY - ("code/parse-defmacro") ; on host for PARSE-DEFMACRO - ("code/early-defboot") ; on host for FILE-COMMENT, DO-ANONYMOUS, etc. - ("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/defbangtype") + ("src/code/defbangmacro") - ("code/specializable-array") + ("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-vm-macs") - ("compiler/generic/early-objdef") - ("compiler/target/parms") - ("code/early-array") ; needs "early-vm" numbers - ("code/early-cl") - ("code/early-load") + ;; SB!VM:N-LOWTAG-BITS, needed by "early-objdef" and others + ("src/compiler/generic/early-vm") + ("src/compiler/generic/early-objdef") + ("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/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-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) + + ("src/code/early-print" :not-host) + ("src/code/early-pprint" :not-host) + ("src/code/early-impl" :not-host) - ("code/early-print" :not-host) - ("code/early-pprint" :not-host) - ("code/early-impl" :not-host) + ("src/code/target-extensions" :not-host) - ("code/target-extensions" :not-host) + ("src/code/early-defstructs" :not-host) ; gotta-be-first DEFSTRUCTs - ("code/early-defstructs" :not-host) ; gotta-be-first DEFSTRUCTs + ("src/code/defbangstruct") - ("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") - ("code/lisp-stream" :not-host) + ("src/code/pcounter" :not-host) - ("code/sysmacs" :not-host) + ("src/code/ansi-stream" :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. @@ -148,11 +142,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". @@ -160,234 +154,224 @@ ;; 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) - ("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 :NOT-HOST files whose - ;;; dependencies make it convenient to stick them here) - -; replaced with defbangtype.lisp in sbcl-0.6.2 -; ;; There are some things (e.g. the type SB!KERNEL:INDEX) which are -; ;; used early in the compiler in both host and target forms (i.e. -; ;; SB!KERNEL:INDEX defined to cross-compilation host and -; ;; SB!KERNEL:INDEX defined to cross-compiler itself). -; ("code/early-ugly-duplicates") - - ("code/defbangtype") + ;;; compiler (and a few miscellaneous files whose dependencies make it + ;;; convenient to stick them here) - ("compiler/early-c") - ("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") - - ("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 + ;; The definition of CONDITION-CLASS depends on SLOT-CLASS, defined + ;; in class.lisp. + ("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) + ;; defines IR1-ATTRIBUTES macro, needed by proclaim.lisp + ("src/compiler/knownfun") ;; 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") + ("src/compiler/proclaim") + ("src/code/typecheckfuns") ;; 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") + ;; and SPECIALIZE-ARRAY-TYPE, defined in "compiler/generic/vm-type", + ;; and SB!XC:PROCLAIM, defined in "src/compiler/proclaim" + ("src/code/defstruct") + ("src/code/target-defstruct" :not-host) ;; ALIEN-VALUE has to be defined as a class (done by DEFSTRUCT ;; machinery) before we can set its superclasses here. - ("code/alien-type") - - ("compiler/knownfun") - - ;; needs IR1-ATTRIBUTES macro, defined in knownfun.lisp - ("compiler/proclaim") + ("src/code/alien-type") ;; 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") + ;; CHECK-FUN-NAME defined in proclaim.lisp. + ("src/code/force-delayed-defbangstructs") - ("code/typep") + ("src/code/typep" :not-host) - ("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 @@ -398,97 +382,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: @@ -500,115 +503,107 @@ ;; 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.. -- WHN 19990323 - ;; FIXME: This problem doesn't seem to occur in the cross-compiler. - ;; Check whether it occurs when compiling with the final target SBCL. - ;; If it doesn't, we can punt the KLUDGE message. :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.. - - ;; defines SB!DI:DO-DEBUG-FUNCTION-BLOCKS, needed by target-disassem.lisp - ("code/debug-int" :not-host) + ;; 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-FUN-BLOCKS, needed by target-disassem.lisp + ("src/code/debug-int" :not-host) ;; target-only assemblerish stuff - ("compiler/target-disassem" :not-host) - ("compiler/target/target-insts" :not-host) + ("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 ("compiler/eval-comp" :not-host) - #!+sb-interpreter ("compiler/eval" :not-host) + ("src/code/debug" :not-host) - ("code/debug" :not-host) ; maybe should be :BYTE-COMPILE T - ;; FIXME: This has been moved to warm init, and should be deleted here. - #+nil ("code/ntrace" :not-host) ; maybe should be :BYTE-COMPILE T + ;; The code here can't be compiled until CONDITION and + ;; DEFINE-CONDITION are defined and SB!DEBUG:*STACK-TOP-HINT* is + ;; declared special. + ("src/code/parse-defmacro-errors") - ;; 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/bit-bash" :not-host) ; needs %NEGATE from assembly/target/arith - ("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 @@ -617,26 +612,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"))