296 lines (266 with data), 13.6 kB
;;;; -*- Lisp -*-
;;;; tags which are set during the build process and which end up in
;;;; CL:*FEATURES* in the target SBCL, plus some comments about other
;;;; CL:*FEATURES* tags which have special meaning to SBCL or which
;;;; have a special conventional meaning
;;;; Note that the recommended way to customize the features of a
;;;; local build of SBCL is not to edit this file, but instead to
;;;; tweak customize-target-features.lisp. If you define a function
;;;; in customize-target-features.lisp, it will be used to transform
;;;; the target features list after it's read and before it's used.
;;;; E.g. you can use code like this:
;;;; (lambda (list)
;;;; (flet ((enable (x) (pushnew x list))
;;;; (disable (x) (setf list (remove x list))))
;;;; #+nil (enable :sb-show)
;;;; (enable :sb-after-xc-core)
;;;; #+nil (disable :sb-doc)
;;;; By thus editing a local file (one which is not in the source
;;;; distribution, and which is in .cvsignore) your customizations
;;;; will remain local even if you do things like "cvs update",
;;;; will not show up if you try to submit a patch with "cvs diff",
;;;; and might even stay out of the way if you use other non-CVS-based
;;;; methods to upgrade the files or store your configuration.
;;;; 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.
;; features present in all builds
;; our standard
;; FIXME: Isn't there a :x3jsomething feature which we should set too?
;; No. CLHS says ":x3j13 [...] A conforming implementation might or
;; might not contain such a feature." -- CSR, 2002-02-21
;; our dialect
;; Douglas Thomas Crosher's conservative generational GC (the only one
;; we currently support for X86).
;; :gencgc used to be here; CSR moved it into
;; local-target-features.lisp-expr via make-config.sh, as alpha,
;; sparc and ppc ports don't currently support it. -- CSR, 2002-02-21
;; We're running under a UNIX. This is sort of redundant, and it was also
;; sort of redundant under CMU CL, which we inherited it from: neither SBCL
;; nor CMU CL supports anything but UNIX (and "technically not UNIX"es
;; such as *BSD and Linux). But someday, maybe we might, and in that case
;; we'd presumably remove this, so its presence conveys the information
;; that the system isn't one which follows such a change.
;; features present in this particular build
;; Setting this enables the compilation of documentation strings
;; from the system sources into the target Lisp executable.
;; Traditional Common Lisp folk will want this option set.
;; I (WHN) made it optional because I came to Common Lisp from
;; C++ through Scheme, so I'm accustomed to asking
;; Emacs about things that I'm curious about instead of asking
;; the executable I'm running.
;; Do regression and other tests when building the system. You might
;; or might not want this if you're not a developer, depending on how
;; paranoid you are. You probably do want it if you are a developer.
;; This test does not affect the target system (in much the same way
;; as :sb-after-xc-core, below).
;; Make more debugging information available (for debugging SBCL
;; itself). If you aren't hacking or troubleshooting SBCL itself,
;; you probably don't want this set.
;; At least two varieties of debugging information are enabled by this
;; * SBCL is compiled with a higher level of OPTIMIZE DEBUG, so that
;; the debugger can tell more about the state of the system.
;; * Various code to print debugging messages, and similar debugging code,
;; is compiled only when this feature is present.
;; Note that the extra information recorded by the compiler at
;; this higher level of OPTIMIZE DEBUG includes the source location
;; forms. In order for the debugger to use this information, it has to
;; re-READ the source file. In an ordinary installation of SBCL, this
;; re-READing may not work very well, for either of two reasons:
;; * The sources aren't present on the system in the same location that
;; they were on the system where SBCL was compiled.
;; * SBCL is using the standard readtable, without the added hackage
;; which allows it to handle things like target features.
;; If you want to be able to use the extra debugging information,
;; therefore, be sure to keep the sources around, and run with the
;; readtable configured so that the system sources can be read.
;; Build SBCL with the old CMU CL low level debugger, "ldb". If
;; are aren't messing with CMU CL at a very low level (e.g.
;; trying to diagnose GC problems, or trying to debug assembly
;; code for a port to a new CPU) you shouldn't need this.
;; This isn't really a target Lisp feature at all, but controls
;; whether the build process produces an after-xc.core file. This
;; can be useful for shortening the edit/compile/debug cycle when
;; you modify SBCL's own source code, as in slam.sh. Otherwise
;; you don't need it.
;; Enable extra debugging output in the assem.lisp assembler/scheduler
;; code. (This is the feature which was called :DEBUG in the
;; original CMU CL code.)
;; Setting this makes SBCL more "fluid", i.e. more amenable to
;; modification at runtime, by suppressing various INLINE declarations,
;; compiler macro definitions, FREEZE-TYPE declarations; and by
;; suppressing various burning-our-ships-behind-us actions after
;; initialization is complete; and so forth. This tends to clobber the
;; performance of the system, so unless you have some special need for
;; this when hacking SBCL itself, you don't want this set.
;; Enable code for collecting statistics on usage of various operations,
;; useful for performance tuning of the SBCL system itself. This code
;; is probably pretty stale (having not been tested since the fork from
;; base CMU CL) but might nonetheless be a useful starting point for
;; anyone who wants to collect such statistics in the future.
;; Peter Van Eynde's increase-bulletproofness code for CMU CL
;; Some of the code which was #+high-security before the fork has now
;; been either made unconditional, deleted, or rewritten into
;; unrecognizability, but some remains. What remains is not maintained
;; or tested in current SBCL, but I haven't gone out of my way to
;; break it, either.
;; low-level thread primitives support
;; As of SBCL 0.8, this is only supposed to work in x86 Linux, on which
;; system it's implemented using clone(2) and the %fs segment register.
;; Note that no consistent effort to audit the SBCL library code for
;; thread safety has been performed, so caveat executor.
;; Kernel support for futexes (so-called "fast userspace mutexes") is
;; available in Linux 2.6 and some versions of 2.4 (Red Hat vendor
;; kernels, possibly other vendors too). We can take advantage of
;; these to do faster and probably more reliable mutex and condition
;; variable support. An SBCL built with this feature will fall back
;; to the old system if the futex() syscall is not available at
;; Support for detection of unportable code (when applied to the
;; COMMON-LISP package, or SBCL-internal pacakges) or bad-neighbourly
;; code (when applied to user-level packages), relating to material
;; alteration to packages or to bindings in symbols in packages.
;; This affects the definition of a lot of things in bignum.lisp. It
;; doesn't seem to be documented anywhere what systems it might apply
;; to. It doesn't seem to be needed for X86 systems anyway.
;; This is set in classic CMU CL, and presumably there it means
;; that the floating point arithmetic implementation
;; conforms to IEEE's standard. Here it definitely means that the
;; floating point arithmetic implementation conforms to IEEE's standard.
;; I (WHN 19990702) haven't tried to verify
;; that it does conform, but it should at least mostly conform (because
;; the underlying x86 hardware tries).
;; CMU CL had, and we inherited, code to support 80-bit LONG-FLOAT on the x86
;; architecture. Nothing has been done to actively destroy the long float
;; support, but it hasn't been thoroughly maintained, and needs at least
;; some maintenance before it will work. (E.g. the LONG-FLOAT-only parts of
;; genesis are still implemented in terms of unportable CMU CL functions
;; which are not longer available at genesis time in SBCL.) A deeper
;; problem is SBCL's bootstrap process implicitly assumes that the
;; cross-compilation host will be able to make the same distinctions
;; between floating point types that it does. This assumption is
;; fundamentally sleazy, even though in practice it's unlikely to break down
;; w.r.t. distinguishing SINGLE-FLOAT from DOUBLE-FLOAT; it's much more
;; likely to break down w.r.t. distinguishing DOUBLE-FLOAT from LONG-FLOAT.
;; Still it's likely to be quite doable to get LONG-FLOAT support working
;; again, if anyone's sufficiently motivated.
;; miscellaneous notes on other things which could have special significance
;; in the *FEATURES* list
;; Any target feature which affects binary compatibility of fasl files
;; needs to be recorded in *FEATURES-POTENTIALLY-AFFECTING-FASL-FORMAT*
;; notes on the :NIL and :IGNORE features:
;; #+NIL is used to comment out forms. Occasionally #+IGNORE is used
;; for this too. So don't use :NIL or :IGNORE as the names of features..
;; notes on :SB-XC and :SB-XC-HOST features (which aren't controlled by this
;; file, but are instead temporarily pushed onto *FEATURES* or
;; *TARGET-FEATURES* during some phases of cross-compilation):
;; :SB-XC-HOST stands for "cross-compilation host" and is in *FEATURES*
;; during the first phase of cross-compilation bootstrapping, when the
;; host Lisp is being used to compile the cross-compiler.
;; :SB-XC stands for "cross compiler", and is in *FEATURES* during the second
;; phase of cross-compilation bootstrapping, when the cross-compiler is
;; being used to create the first target Lisp.
;; notes on the :SB-ASSEMBLING feature (which isn't controlled by
;; this file):
;; This is a flag for whether we're in the assembler. It's
;; temporarily pushed onto the *FEATURES* list in the setup for
;; the ASSEMBLE-FILE function. It would be a bad idea
;; to use it as a name for a permanent feature.
;; notes on local features (which are set automatically by the
;; configuration script, and should not be set here unless you
;; really, really know what you're doing):
;; machine architecture features:
;; any Intel 386 or better, or compatibles like the AMD K6 or K7
;; DEC/Compaq Alpha CPU
;; any Sun UltraSPARC (possibly also non-Ultras -- currently untested)
;; any PowerPC CPU
;; any PA-RISC CPU
;; any MIPS CPU (in little-endian mode with :little-endian -- currently
;; (CMU CL also had a :pentium feature, which affected the definition
;; of some floating point vops. It was present but not enabled or
;; documented in the CMU CL code that SBCL is derived from, and has
;; now been moved to the backend-subfeatures mechanism.)
;; properties derived from the machine architecture
;; On the X86, the Lisp control stack grows downward. On the
;; other supported CPU architectures as of sbcl-0.7.1.40, the
;; system stack grows upward.
;; Note that there are other stack-related differences between the
;; X86 port and the other ports. E.g. on the X86, the Lisp control
;; stack coincides with the C stack, meaning that on the X86 there's
;; stuff on the control stack that the Lisp-level debugger doesn't
;; understand very well. As of sbcl-0.7.1.40 things like that are
;; just parameterized by #!+X86, but it'd probably be better to
;; use new flags like :CONTROL-STACK-CONTAINS-C-STACK.
;; operating system features:
;; :linux = We're intended to run under some version of Linux.
;; :bsd = We're intended to run under some version of BSD Unix. (This
;; is not exclusive with the features which indicate which
;; particular version of BSD we're intended to run under.)
;; :freebsd = We're intended to run under FreeBSD.
;; :openbsd = We're intended to run under OpenBSD.
;; :netbsd = We're intended to run under NetBSD.
;; :sunos = We're intended to run under Solaris user environment
;; with the SunOS kernel.
;; :osf1 = We're intended to run under Tru64 (aka Digital Unix
;; aka OSF/1).
;; (No others are supported by SBCL as of 0.7.5, but :hpux or :irix
;; support could be ported from CMU CL if anyone is sufficiently
;; motivated to do so, and it'd even be possible, though harder, to
;; port the system to Microsoft Windows or MacOS X.)