X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=base-target-features.lisp-expr;h=93066ab4c4cb331a526cf420891f26879157c2c1;hb=17532463fa19f2fc2aba53b65c32e200a27ccd6a;hp=0dad915cb25ea7860854c43fc2f0f4f5c8b7910b;hpb=accfb3272fece64c18584965f85e975fcc2d6785;p=sbcl.git diff --git a/base-target-features.lisp-expr b/base-target-features.lisp-expr index 0dad915..93066ab 100644 --- a/base-target-features.lisp-expr +++ b/base-target-features.lisp-expr @@ -7,13 +7,16 @@ ;;;; ;;;; 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: +;;;; tweak customize-target-features.lisp. (You must create this file +;;;; first; it is not in the SBCL distribution, and is in fact +;;;; explicitly excluded from the distribution in places like +;;;; .cvsignore.) 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)))) +;;;; (disable (x) (setf list (remove x list)))) ;;;; #+nil (enable :sb-show) ;;;; (enable :sb-after-xc-core) ;;;; #+nil (disable :sb-doc) @@ -107,11 +110,13 @@ ;; 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 + ;; Build SBCL with the old CMU CL low level debugger, "ldb". In the + ;; ideal world you would not need this unless you are messing with + ;; SBCL 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). However, + ;; experience shows that sooner or later everyone lose()'s, in which + ;; case SB-LDB can at least provide an informative backtrace. + :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 @@ -147,34 +152,58 @@ ;; 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. + ;; break it, either. ;; ; :high-security ; :high-security-support ;; 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. + ;; As of SBCL 0.8, this is only supposed to work in x86 Linux with + ;; NPTL support (usually kernel 2.6, though sme Red Hat distributions + ;; with older kernels also have it) and is 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. ; :sb-thread - ;; 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 - ;; runtime - ; :sb-futex + ;; lutex support + ;; + ;; While on linux we are able to use futexes for our locking + ;; primitive, on other platforms we don't have this luxury. NJF's + ;; lutexes present a locking API similar to the futex-based API that + ;; allows for sb-thread support on x86 OS X, Solaris and + ;; FreeBSD. + ;; + ; :sb-lutex + + ;; On some operating systems the FS segment register (used for SBCL's + ;; thread local storage) is not reliably preserved in signal + ;; handlers, so we need to restore its value from the pthread thread + ;; local storage. + ; :restore-tls-segment-register-from-tls ;; 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. :sb-package-locks - + + ;; Support for the entirety of the 21-bit character space defined by + ;; the Unicode consortium, rather than the classical 8-bit ISO-8859-1 + ;; character set. + :sb-unicode + + ;; Support for a full evaluator that can execute all the CL special + ;; forms, as opposed to the traditional SBCL evaluator which called + ;; COMPILE for everything complicated. + :sb-eval + + ;; Record source location information for variables, classes, conditions, + ;; packages, etc. Gives much better information on M-. in Slime, but + ;; increases core size by about 100kB. + :sb-source-locations + ;; 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. @@ -205,6 +234,16 @@ ;; again, if anyone's sufficiently motivated. ; :long-float + ;; Some platforms don't use a 32-bit off_t by default, and thus can't + ;; handle files larger than 2GB. This feature will control whether + ;; we'll try to use platform-specific compilation options to enable a + ;; 64-bit off_t. The intent is for this feature to be automatically + ;; enabled by make-config.sh on platforms where it's needed and known + ;; to work, you shouldn't be enabling it manually. You might however + ;; want to disable it, if you need to pass file descriptors to + ;; foreign code that uses a 32-bit off_t. + ; :largefile + ;; ;; miscellaneous notes on other things which could have special significance ;; in the *FEATURES* list @@ -242,10 +281,12 @@ ;; 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: ;; :x86 ;; any Intel 386 or better, or compatibles like the AMD K6 or K7 + ;; :x86-64 + ;; any x86-64 CPU running in 64-bit mode ;; :alpha ;; DEC/Compaq Alpha CPU ;; :sparc @@ -257,7 +298,7 @@ ;; :mips ;; any MIPS CPU (in little-endian mode with :little-endian -- currently ;; untested) - ;; + ;; ;; (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 @@ -267,7 +308,7 @@ ;; :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. + ;; 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 @@ -276,6 +317,12 @@ ;; just parameterized by #!+X86, but it'd probably be better to ;; use new flags like :CONTROL-STACK-CONTAINS-C-STACK. ;; + ;; :stack-allocatable-closures + ;; The compiler can allocate dynamic-extent closures on stack. + ;; + ;; :alien-callbacks + ;; Alien callbacks have been implemented for this platform. + ;; ;; 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 @@ -284,12 +331,13 @@ ;; :freebsd = We're intended to run under FreeBSD. ;; :openbsd = We're intended to run under OpenBSD. ;; :netbsd = We're intended to run under NetBSD. + ;; :darwin = We're intended to run under Darwin (including MacOS X). ;; :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 + ;; (No others are supported by SBCL as of 0.9.6, 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.) + ;; port the system to Microsoft Windows.) )