("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
+ ;; 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/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/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
;; 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.
("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)
("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.)
;; 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")
;; the target version of "code/defstruct".
("src/code/target-defstruct" :not-host)
+ ;; defines IR1-ATTRIBUTES macro, needed by proclaim.lisp
+ ("src/compiler/knownfun")
+
;; stuff needed by "code/defstruct"
("src/code/cross-type" :not-target)
("src/compiler/generic/vm-type")
+ ("src/compiler/proclaim")
;; 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".
+ ;; and SPECIALIZE-ARRAY-TYPE, defined in "compiler/generic/vm-type",
+ ;; and SB!XC:PROCLAIM, defined in "src/compiler/proclaim"
("src/code/defstruct")
;; ALIEN-VALUE has to be defined as a class (done by DEFSTRUCT
;; machinery) before we can set its superclasses here.
("src/code/alien-type")
- ("src/compiler/knownfun")
-
- ;; needs IR1-ATTRIBUTES macro, defined in knownfun.lisp
- ("src/compiler/proclaim")
+ ;; was here until sbcl-0.pre7.67
+ #+nil ("src/compiler/knownfun")
;; 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.
+ ;; CHECK-FUN-NAME defined in proclaim.lisp.
("src/code/force-delayed-defbangstructs")
("src/code/typep")
("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")
;; Compiling this requires fop definitions from code/fop.lisp and
;; trace table definitions from compiler/trace-table.lisp.
- ("src/compiler/dump")
+ ("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-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
("src/compiler/dfo")
("src/compiler/checkgen")
("src/compiler/constraint")
- ("src/compiler/envanal")
+ ("src/compiler/physenvanal")
("src/compiler/tn")
("src/compiler/life")
("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")
("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
+ ;; defines SB!DI:DO-DEBUG-FUN-BLOCKS, needed by target-disassem.lisp
("src/code/debug-int" :not-host)
;; target-only assemblerish stuff
("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*.
;; 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
;; 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")
projects / sbcl.git / blobdiff