X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=base-target-features.lisp-expr;h=db5dfbcddd1a94cfa39509191b52f84e4bb56cea;hb=740af378fef405f7d3735fd95423d90100a10beb;hp=5aa58f73a9f9f768c22de08febd5c395fcfc2fc6;hpb=dccfa0f4e378a267744c03b1416accdf9d888987;p=sbcl.git diff --git a/base-target-features.lisp-expr b/base-target-features.lisp-expr index 5aa58f7..db5dfbc 100644 --- a/base-target-features.lisp-expr +++ b/base-target-features.lisp-expr @@ -1,3 +1,5 @@ +;;;; -*- 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 @@ -5,8 +7,10 @@ ;;;; ;;;; 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. E.g. you can use code like -;;;; this: +;;;; 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)))) @@ -14,9 +18,12 @@ ;;;; (enable :sb-after-xc-core) ;;;; #+nil (disable :sb-doc) ;;;; list)) -;;;; That way, because customize-target-features.lisp is in -;;;; .cvsignore, your local changes will remain local even if you use -;;;; "cvs diff" to submit patches to SBCL. +;;;; 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. @@ -35,13 +42,17 @@ ;; our standard :ansi-cl :common-lisp ;; 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 :sbcl ;; Douglas Thomas Crosher's conservative generational GC (the only one - ;; we currently support for X86) - :gencgc + ;; 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 @@ -64,59 +75,16 @@ ;; the executable I'm running. :sb-doc - ;; When this is set, EVAL is implemented as an "IR1 interpreter": - ;; code is compiled into the compiler's first internal representation, - ;; then the IR1 is interpreted. When this is not set, EVAL is implemented - ;; as a little bit of hackery wrapped around a call to COMPILE, i.e. - ;; the system becomes a "compiler-only implementation" of Common Lisp. - ;; As of sbcl-0.6.7, the compiler-only implementation is prototype code, - ;; and much less mature than the old IR1 interpreter. Thus, the safe - ;; thing is to leave :SB-INTERPRETER set. However, the compiler-only - ;; system is noticeably smaller, so you might want to omit - ;; :SB-INTERPRETER if you have a small machine. - ;; - ;; Probably, the compiler-only implementation will become more - ;; stable someday, and support for the IR1 interpreter will then be - ;; dropped. This will make the system smaller and easier to maintain - ;; not only because we no longer need to support the interpreter, - ;; but because code elsewhere in the system (the dumper, the debugger, - ;; etc.) no longer needs special cases for interpreted code. - :sb-interpreter - - ;; 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. + ;; 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). :sb-test - ;; :SB-PROPAGATE-FLOAT-TYPE and :SB-PROPAGATE-FUN-TYPE enable - ;; some numeric optimizer code in the target compiler. They - ;; correspond to the :PROPAGATE-FLOAT-TYPE and :PROPAGATE-FUN-TYPE - ;; features in the original CMU CL code, and while documentation - ;; existed for those, it seemed a little inconsistent. Despite the - ;; name, :SB-PROPAGATE-FLOAT-TYPE seems to control not only - ;; floating point optimizations, but some integer optimizations as - ;; well. - ;; - ;; CROSS-FLOAT-INFINITY-KLUDGE: - ;; * Even when these target features are enabled, the optimizations - ;; aren't enabled in the cross-compiler, because some of them - ;; depend on floating point infinities, which aren't in general - ;; supported on the cross-compilation host. - ;; * This is supported by hacking the features out of the - ;; *SHEBANG-FEATURES* list while we're building the cross-compiler. - ;; This is ugly and confusing and weird, but all the alternatives - ;; that I could think of seem messy and error-prone. That doesn't - ;; mean there's not a better way, though. Suggestions are welcome; - ;; or if you'd like to submit patches to make this code work - ;; without requiring floating point infinities, so that the entire - ;; problem goes away, that might be even better! -- WHN 2001-03-22 - :sb-propagate-float-type - :sb-propagate-fun-type - - ;; Setting this makes more debugging information available. - ;; If you aren't hacking or troubleshooting SBCL itself, you - ;; probably don't want this set. + ;; 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 ;; option: @@ -139,11 +107,17 @@ ;; readtable configured so that the system sources can be read. ; :sb-show + ;; 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. + ; :sb-ldb + ;; 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 if - ;; you're messing around with low-level internals of the system, - ;; as in slam.sh. Otherwise you don't need it. + ;; 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. ; :sb-after-xc-core ;; Enable extra debugging output in the assem.lisp assembler/scheduler @@ -167,10 +141,13 @@ ;; anyone who wants to collect such statistics in the future. ; :sb-dyncount - ;; Peter Van Eynde's increase-bulletproofness code + ;; Peter Van Eynde's increase-bulletproofness code for CMU CL ;; - ;; This is not maintained or tested in current SBCL, but I haven't - ;; gone out of my way to remove or break it, either. + ;; 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. ;; ; :high-security ; :high-security-support @@ -199,11 +176,6 @@ ;; affects a lot of floating point code. ; :negative-zero-is-not-zero - ;; It's unclear to me what this does (but it was enabled in the code - ;; that I picked up from Peter Van Eynde, called CONSTRAIN-FLOAT-TYPE - ;; instead of SB-CONSTRAIN-FLOAT-TYPE). -- WHN 19990224 - :sb-constrain-float-type - ;; 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 @@ -213,10 +185,6 @@ ;; the underlying x86 hardware tries). :ieee-floating-point - ;; This seems to be the pre-GENCGC garbage collector for CMU CL, which was - ;; AFAIK never supported for the X86. - ; :gengc - ;; 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 @@ -272,14 +240,33 @@ ;; any Intel 386 or better, or compatibles like the AMD K6 or K7 ;; :alpha ;; DEC/Compaq Alpha CPU - ;; (No other CPUs are supported by SBCL as of 0.6.12.15, but SPARC or - ;; PowerPC support could be ported from CMU CL if anyone is - ;; sufficiently motivated to do so, or if you're *really* motivated, - ;; you could write a port from scratch for a new CPU architecture.) + ;; :sparc + ;; any Sun UltraSPARC (possibly also non-Ultras -- currently untested) + ;; :ppc + ;; any PowerPC CPU + ;; + ;; (No other CPUs are supported by SBCL as of 0.7.5, but MIPS or HPPA + ;; support could be ported from CMU CL if anyone is sufficiently + ;; motivated to do so, or if you're *really* motivated, you could + ;; write a port from scratch for a new CPU architecture.) + ;; ;; (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 is - ;; present but stale in SBCL as of 0.6.12.) + ;; 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 + ;; :control-stack-grows-downward-not-upward + ;; 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. @@ -287,9 +274,13 @@ ;; 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 FreeBSD. - ;; (No others are supported by SBCL as of 0.6.7, but :hpux or - ;; :solaris support could be ported from CMU CL if anyone is + ;; :openbsd = We're intended to run under OpenBSD. + ;; :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.) )