X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=base-target-features.lisp-expr;h=8b9de1bdecad83797c4fd67f71a5439197f46ea5;hb=3c65762b927af861c9c8bc416e4cbac9a14ec0c3;hp=44a6a891af812196916d7b255ce925f1b391b55f;hpb=e02c32bd4d07a7d30c9a9d78be54f1f9f84f9877;p=sbcl.git diff --git a/base-target-features.lisp-expr b/base-target-features.lisp-expr index 44a6a89..8b9de1b 100644 --- a/base-target-features.lisp-expr +++ b/base-target-features.lisp-expr @@ -2,6 +2,26 @@ ;;;; 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) +;;;; list)) +;;;; 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. @@ -25,7 +45,7 @@ :sbcl ;; Douglas Thomas Crosher's conservative generational GC (the only one - ;; we currently support) + ;; we currently support for X86) :gencgc ;; We're running under a UNIX. This is sort of redundant, and it was also @@ -49,34 +69,15 @@ ;; 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. :sb-test - ;; 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: @@ -99,6 +100,18 @@ ;; 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) 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. + ; :sb-after-xc-core + ;; 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.) @@ -143,61 +156,15 @@ ; :mp ; :mp-i486 - ;; KLUDGE: used to suppress stale code related to floating point infinities. - ;; I intend to delete this code completely some day, since it was a pain - ;; for me to try to work with and since all benefits it provides are - ;; non-portable. Until I actually pull the trigger, though, I've left - ;; various stale code in place protected with #!-SB-INFINITIES. - ; :sb-infinities - ;; 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. + ;; doesn't seem to be documented anywhere what systems it might apply + ;; to. It doesn't seem to be needed for X86 systems anyway. ; :32x16-divide - ;; This is probably true for some processor types, but not X86. It affects - ;; a lot of floating point code. + ;; This is probably true for some processor types, but not X86. It + ;; affects a lot of floating point code. ; :negative-zero-is-not-zero - ;; This is mentioned in cmu-user.tex, which says that it enables - ;; the compiler to reason about integer arithmetic. It also seems to - ;; control other fancy numeric reasoning, e.g. knowing the result type of - ;; a remainder calculation given the type of its inputs. - ;; - ;; KLUDGE: Even when this is implemented for the target feature list, - ;; the code to implement this feature will not generated in the - ;; cross-compiler (i.e. will only be generated in the target compiler). - ;; The reason for this is that the interval arithmetic routines used - ;; to implement this feature are written under the assumption that - ;; Lisp arithmetic supports plus and minus infinity, which isn't guaranteed by - ;; ANSI Common Lisp. I've tried to mark the conditionals which implement - ;; this kludge with the string CROSS-FLOAT-INFINITY-KLUDGE so that - ;; sometime it might be possible to undo them (perhaps by using - ;; nice portable :PLUS-INFINITY and :MINUS-INFINITY values instead of - ;; implementation dependent floating infinity values, which would - ;; admittedly involve extra consing; or perhaps by finding some cleaner - ;; way of suppressing the construction of this code in the cross-compiler). - ;; - ;; KLUDGE: Even after doing the KLUDGE above, the cross-compiler doesn't work, - ;; because some interval operations are conditional on PROPAGATE-FUN-TYPE - ;; instead of PROPAGATE-FLOAT-TYPE. So for now, I've completely turned off - ;; both PROPAGATE-FUN-TYPE and PROPAGATE-FLOAT-TYPE. (After I build - ;; a compiler which works, then I can think about getting the optimization - ;; to work.) -- WHN 19990702 - ; :propagate-float-type - - ;; According to cmu-user.tex, this enables the compiler to infer result - ;; types for mathematical functions like SQRT, EXPT, and LOG, allowing - ;; it to e.g. eliminate the possibility that a complex result will be - ;; generated. - ;; - ;; KLUDGE: turned off as per the comments for PROPAGATE-FLOAT-TYPE above - ; :propagate-fun-type - - ;; It's unclear to me what this does (but it was enabled in the code that I - ;; picked up from Peter Van Eynde). -- WHN 19990224 - :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 @@ -207,10 +174,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 @@ -262,14 +225,18 @@ ;; really, really know what you're doing): ;; ;; machine architecture features: - ;; :x86 ; any Intel 386 or better, or compatibles like the AMD K6 or K7 - ;; (No others are supported by SBCL as of 0.6.7, but :alpha or - ;; :sparc support could be ported from CMU CL if anyone is - ;; sufficiently motivated to do so.) - ;; (CMU CL also had a :pentium feature, which affected the definition - ;; of some floating point vops. It was present but not enabled in the - ;; CMU CL code that SBCL is derived from, and is present but stale - ;; in SBCL as of 0.6.7.) + ;; :x86 + ;; 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.) + ;; (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.) ;; ;; operating system features: ;; :linux = We're intended to run under some version of Linux. @@ -280,5 +247,6 @@ ;; :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 - ;; sufficiently motivated to do so.) + ;; sufficiently motivated to do so, and it'd even be possible, + ;; though harder, to port the system to Microsoft Windows.) )