Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

768 lines (605 sloc) 27.116 kb
;;;; -*- Lisp -*-
;;;; This software is part of the SBCL system. See the README file for
;;;; more information.
;;;;
;;;; This software is derived from the CMU CL system, which was
;;;; written at Carnegie Mellon University and released into the
;;;; public domain. The software is in the public domain and is
;;;; 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
;;;
;;; 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.
;;; But the dependencies are varied and subtle, and it'd be extremely
;;; difficult to extract them automatically, and it'd be extremely
;;; tedious and error-prone to extract them manually, so we don't
;;; extract them. (It would be nice to fix this someday. The most
;;; feasible approach that I can think of would be to make the
;;; dependencies work on a package level, not an individual file
;;; level. Doing it at the package level would make the granularity
;;; coarse enough that it would probably be pretty easy to maintain
;;; 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
(
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; miscellaneous
("src/code/cross-early" :not-target)
;; This comes early because it's useful for debugging everywhere.
("src/code/show")
;; This comes as early as possible, so that we catch the source locations
;; for everything.
("src/code/early-source-location")
("src/code/early-constants")
;; This comes early because the cross-compilation host's backquote
;; logic can expand into something which can't be executed on the
;; target Lisp (e.g. in CMU CL where it expands into internal
;; functions like BACKQ-LIST), and by replacing the host backquote
;; logic with our own as early as possible, we minimize the chance of
;; any forms referring to cross-compilation host internal functions
;; leaking into target SBCL code.
("src/code/backq")
;; It's difficult to be too early with a DECLAIM SPECIAL (or DEFVAR
;; or whatever) thanks to the sullenly-do-the-wrong-thing semantics
;; of CL special binding when the variable is undeclared.
("src/code/globals" :not-host)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; various DEFSETFs and/or other DEFMACROish things, defined as early as
;; possible so we don't need to fiddle with any subtleties of defining them
;; before any possible use
;; KLUDGE: It would be nice to reimplement most or all of these as
;; functions (possibly inlined functions) so that we wouldn't need to
;; worry so much about forcing them all to be defined before any possible
;; 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
("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)
("src/code/cross-thread" :not-target)
("src/code/cross-make-load-form" :not-target)
("src/code/cross-condition" :not-target)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; stuff needed early both in cross-compilation host and in target Lisp
("src/code/uncross")
("src/code/primordial-type")
("src/code/early-defbangmethod")
("src/code/defbangtype")
("src/code/defbangmacro")
("src/code/defbangconstant")
("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/parms")
("src/compiler/target/parms")
("src/compiler/generic/early-vm")
("src/compiler/generic/early-objdef")
("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/compiler/deftype") ; on host for SB!XC:DEFTYPE
("src/compiler/defconstant")
("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"
("src/code/debug-var-io")
("src/code/early-thread")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; basic machinery for the target Lisp. Note that although most of these
;;; files are flagged :NOT-HOST, a few might not be.
("src/code/target-defbangmethod" :not-host)
("src/code/early-print" :not-host)
("src/code/early-pprint" :not-host)
("src/code/early-impl" :not-host)
("src/code/target-extensions" :not-host)
;; Needed before the first use of WITH-SINGLE-PACKAGE-LOCKED-ERROR.
("src/code/early-package" :not-host)
("src/code/early-defstructs" :not-host) ; gotta-be-first DEFSTRUCTs
("src/code/defbangstruct")
("src/code/unportable-float")
("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.)
("src/code/type-class")
("src/code/early-pcounter")
("src/code/pcounter" :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
("src/code/target-error" :not-host)
("src/compiler/early-backend")
;; "src/code/toplevel.lisp" si the first to need this. It's generated
;; automatically by grovel_headers.c, i.e. it's not in CVS.
("output/stuff-groveled-from-headers" :not-host)
;; a comment from classic CMU CL:
;; "These guys can supposedly come in any order, but not really.
;; Some are put at the end so that macros don't run interpreted
;; and stuff."
;; Dunno exactly what this meant or whether it still holds. -- WHN 19990803
;; FIXME: more informative and up-to-date comment?
("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".
;; In classic CMU CL, code/type was here. I've since split that into
;; 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
("src/code/target-type" :not-host)
("src/code/pred" :not-host)
("src/code/target-alieneval" :not-host)
("src/code/target-c-call" :not-host)
("src/code/target-allocate" :not-host)
;; This needs DEFINE-ALIEN-ROUTINE from target-alieneval.
("src/code/misc-aliens" :not-host)
("src/code/array" :not-host)
("src/code/early-float" :not-host)
("src/code/target-sxhash" :not-host) ; needs most-fooative-foo-float constants
("src/code/list" :not-host)
("src/code/seq" :not-host) ; "code/seq" should come after "code/list".
("src/code/coerce" :not-host)
("src/code/string" :not-host)
("src/code/mipsstrops" :not-host)
("src/code/early-time" :not-host)
("src/code/unix" :not-host)
#!+win32 ("src/code/win32" :not-host)
#!+mach ("src/code/mach" :not-host)
("src/code/common-os" :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)
#!+win32 ("src/code/win32-os" :not-host)
;; sparc-vm and ppc-vm need sc-offset defined to get at internal
;; error args. This file contains stuff previously in
;; debug-info.lisp. Should it therefore be :not-host? -- CSR,
;; 2002-02-05
("src/code/sc-offset")
;; KLUDGE: I'd prefer to have this done with a "code/target" softlink
;; instead of a bunch of reader macros. -- WHN 19990308
#!+sparc ("src/code/sparc-vm" :not-host)
#!+hppa ("src/code/hppa-vm" :not-host)
#!+x86 ("src/code/x86-vm" :not-host)
#!+x86-64("src/code/x86-64-vm" :not-host)
#!+ppc ("src/code/ppc-vm" :not-host)
#!+alpha ("src/code/alpha-vm" :not-host)
#!+mips ("src/code/mips-vm" :not-host)
;; FIXME: do we really want to keep this? -- CSR, 2002-08-31
#!+rt ("src/code/rt-vm" :not-host)
#!-win32 ("src/code/target-signal" :not-host) ; needs OS-CONTEXT-T from x86-vm
#!+win32 ("src/code/target-exception" :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/huffman")
("src/code/target-char" :not-host)
("src/code/target-misc" :not-host)
("src/code/misc")
("src/code/room" :not-host)
("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)
("src/code/error-error" :not-host) ; needs WITH-STANDARD-IO-SYNTAX macro
("src/code/deadline" :not-host)
("src/code/serve-event" :not-host)
("src/code/fd-stream" :not-host)
("src/code/module" :not-host)
("src/code/interr" :not-host)
("src/code/query" :not-host)
("src/code/sort" :not-host)
("src/code/time" :not-host)
("src/code/timer" :not-host)
("src/code/weak" :not-host)
("src/code/final" :not-host)
("src/code/setf-funs" :not-host)
("src/code/stubs" :not-host)
("src/code/exhaust" :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/compiler/policies")
("src/code/typedefs")
;; ("src/code/defbangmacro" was here until sbcl-0.6.7.3.)
("src/compiler/macros")
("src/compiler/generic/vm-macs")
;; needed by "compiler/vop"
("src/compiler/sset")
;; for e.g. BLOCK-ANNOTATION, needed by "compiler/vop"
("src/compiler/node")
;; for e.g. PRIMITIVE-TYPE, needed by "vmdef"
("src/compiler/vop")
;; needed by "vm" and "primtype"
("src/compiler/backend")
;; for e.g. MAX-VOP-TN-REFS, needed by "meta-vmdef"
("src/compiler/vmdef")
;; needs "backend"
("src/compiler/target/backend-parms")
;; for INFO and SB!XC:MACRO-FUNCTION, needed by defmacro.lisp
("src/compiler/globaldb")
("src/compiler/info-functions")
("src/code/force-delayed-defbangconstants")
("src/code/defmacro")
("src/code/force-delayed-defbangmacros")
("src/compiler/late-macros")
;; for e.g. !DEF-PRIMITIVE-TYPE, needed by primtype.lisp, and
;; DEFINE-STORAGE-CLASS, needed by target/vm.lisp
("src/compiler/meta-vmdef")
;; for e.g. DESCRIPTOR-REG, needed by primtype.lisp
("src/compiler/target/vm")
("src/code/xset")
;; for e.g. SPECIFIER-TYPE, needed by primtype.lisp
("src/code/early-type")
;; FIXME: Classic CMU CL had (OPTIMIZE (SAFETY 2) (DEBUG 2) declared
;; around the compilation of "code/class". Why?
("src/code/class")
;; The definition of CONDITION-CLASS depends on SLOT-CLASS, defined
;; 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
;; DEFMACRO and DEFTYPE; must be loaded before we can start
;; 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" #+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" #+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
;; %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.
("src/code/late-type")
("src/code/deftypes-for-target")
;; defines IR1-ATTRIBUTES macro, needed by proclaim.lisp
("src/compiler/knownfun")
("src/compiler/constantp")
;; needs FUN-INFO structure slot setters, defined in knownfun.lisp
("src/compiler/fun-info-funs")
;; stuff needed by "code/defstruct"
("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
;; "code/late-type", and SB!XC:TYPEP, defined in "code/cross-type",
;; 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.
("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-FUN-NAME defined in proclaim.lisp.
("src/code/force-delayed-defbangstructs")
;; early-full-eval uses !DEFSTRUCT-WITH-ALTERNATE-METACLASS and
;; DEF!METHOD. It split out from the rest of full-eval because
;; defstruct/metaclass fun makes it unslammable, and to define
;; INTERPRETED-FUNCTION before it is used in compiler/main and in the
;; definition of the COMPILED-FUNCTION type.
#!+sb-eval
("src/code/early-full-eval")
("src/code/typep" :not-host)
("src/compiler/compiler-error")
("src/code/late-deftypes-for-target")
("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")
("src/code/random")
("src/code/hash-table")
("src/code/readtable")
("src/code/pathname")
("src/code/host-pprint")
("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
;; understand the system if those things were split off into packages
;; SB-TYPE and SB-INFO and built in their own sections. -- WHN 20000124
;; In classic CMU CL (re)build order, these were done later, but
;; in building from scratch, these must be loaded before
;; "compiler/generic/objdef" in order to allow forms like
;; (DEFINE-PRIMITIVE-OBJECT (..) (CAR ..) ..) to work.
("src/compiler/fndb")
("src/compiler/generic/vm-fndb")
("src/compiler/generic/objdef")
("src/compiler/generic/interr")
("src/compiler/bit-util")
;; 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).
("src/compiler/generic/core")
("src/code/thread")
("src/code/load")
#!+linkage-table ("src/code/linkage-table" :not-host)
#!+os-provides-dlopen ("src/code/foreign-load" :not-host)
#!+(and os-provides-dlopen (not win32)) ("src/code/unix-foreign-load" :not-host)
#!+(and os-provides-dlopen win32) ("src/code/win32-foreign-load" :not-host)
("src/code/foreign")
("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")
("src/compiler/main") ; needs DEFSTRUCT FASL-OUTPUT from dump.lisp
("src/compiler/xref")
("src/code/source-location")
("src/compiler/target-main" :not-host)
("src/compiler/ir1tran")
("src/compiler/ir1tran-lambda")
("src/compiler/ir1-translators")
("src/compiler/ir1util")
("src/compiler/ir1report")
("src/compiler/ir1opt")
("src/compiler/loop")
("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/generic/vm-tran")
("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/compiler/fopcompile")
("src/assembly/assemfile")
;; Compiling this file requires the macros SB!ASSEM:EMIT-LABEL and
;; SB!ASSEM:EMIT-POST-IT, defined in assem.lisp, and also possibly
;; the definition of the LOCATION-INFO structure (if structures in
;; the host lisp have setf expanders rather than setf functions).
("src/compiler/late-vmdef")
("src/compiler/fixup") ; for DEFSTRUCT FIXUP, used by insts.lisp
("src/compiler/target/insts")
("src/compiler/target/macros")
("src/compiler/generic/early-type-vops")
("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"
;; 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/code/cross-modular" :not-target)
("src/compiler/target/subprim")
("src/compiler/target/debug")
;; src/compiler/sparc/c-call contains a deftransform for
;; %ALIEN-FUNCALL -- CSR
("src/compiler/early-aliencomp")
("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/generic/late-nlx")
("src/compiler/target/show")
("src/compiler/target/array")
("src/compiler/generic/array")
("src/compiler/target/pred")
("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")
("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/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
("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.
("src/code/macroexpand")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 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-stream" :not-host) ; needs WHITESPACEP from "code/reader"
("src/code/target-pathname" :not-host) ; needs "code/pathname"
("src/code/unix-pathname" :not-host)
("src/code/win32-pathname" :not-host)
("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"
("src/code/alloc" :not-host)
("src/code/early-step") ; target-thread needs *STEP-OUT*
("src/code/target-thread" :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
("src/compiler/target-disassem" :not-host)
("src/compiler/target/target-insts" :not-host)
("src/code/debug" :not-host)
("src/code/octets" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-cyr" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-dos" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-iso" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-win" :not-host)
#!+sb-unicode
("src/code/external-formats/mb-util" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-cn-tbl" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-cn" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-jpn-tbl" :not-host)
#!+sb-unicode
("src/code/external-formats/enc-jpn" :not-host)
#!+sb-unicode
("src/code/external-formats/ucs-2" :not-host)
;; 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")
#!+sb-eval
("src/code/full-eval" :not-host) ; uses INFO, ARG-COUNT-ERROR
("src/code/bit-bash" :not-host) ; needs %NEGATE from assembly/target/arith
("src/code/target-load" :not-host) ; needs special vars from code/load.lisp
("src/compiler/target/sanctify" :not-host)
;; 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
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; target macros and DECLAIMs installed at build-the-cross-compiler time
;; Declare all target special variables defined by ANSI now, so that
;; 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.
("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")
("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
("src/code/late-format") ; needs SB!XC:DEFMACRO
("src/code/sxhash") ; needs SB!XC:DEFINE-MODIFY-MACRO
("src/code/signal")
("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"))
Jump to Line
Something went wrong with that request. Please try again.