Port to x86-64 versions of Windows
[sbcl.git] / base-target-features.lisp-expr
1 ;;;; -*- Lisp -*-
2
3 ;;;; tags which are set during the build process and which end up in
4 ;;;; CL:*FEATURES* in the target SBCL, plus some comments about other
5 ;;;; CL:*FEATURES* tags which have special meaning to SBCL or which
6 ;;;; have a special conventional meaning
7 ;;;;
8 ;;;; Note that the recommended way to customize the features of a
9 ;;;; local build of SBCL is not to edit this file, but instead to
10 ;;;; tweak customize-target-features.lisp. (You must create this file
11 ;;;; first; it is not in the SBCL distribution, and is in fact
12 ;;;; explicitly excluded from the distribution in places like
13 ;;;; .cvsignore.) If you define a function in
14 ;;;; customize-target-features.lisp, it will be used to transform the
15 ;;;; target features list after it's read and before it's used. E.g.,
16 ;;;; you can use code like this:
17 ;;;;    (lambda (list)
18 ;;;;      (flet ((enable (x) (pushnew x list))
19 ;;;;             (disable (x) (setf list (remove x list))))
20 ;;;;        #+nil (enable :sb-show)
21 ;;;;        (enable :sb-after-xc-core)
22 ;;;;        #+nil (disable :sb-doc)
23 ;;;;        list))
24 ;;;; By thus editing a local file (one which is not in the source
25 ;;;; distribution, and which is in .cvsignore) your customizations
26 ;;;; will remain local even if you do things like "cvs update",
27 ;;;; will not show up if you try to submit a patch with "cvs diff",
28 ;;;; and might even stay out of the way if you use other non-CVS-based
29 ;;;; methods to upgrade the files or store your configuration.
30
31 ;;;; This software is part of the SBCL system. See the README file for
32 ;;;; more information.
33 ;;;;
34 ;;;; This software is derived from the CMU CL system, which was
35 ;;;; written at Carnegie Mellon University and released into the
36 ;;;; public domain. The software is in the public domain and is
37 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
38 ;;;; files for more information.
39
40 (
41  ;;
42  ;; features present in all builds
43  ;;
44
45  ;; our standard
46  :ansi-cl :common-lisp
47  ;; FIXME: Isn't there a :x3jsomething feature which we should set too?
48  ;; No. CLHS says ":x3j13 [...] A conforming implementation might or
49  ;; might not contain such a feature." -- CSR, 2002-02-21
50
51  ;; our dialect
52  :sbcl
53
54  ;; Douglas Thomas Crosher's conservative generational GC (the only one
55  ;; we currently support for X86).
56  ;; :gencgc used to be here; CSR moved it into
57  ;; local-target-features.lisp-expr via make-config.sh, as alpha,
58  ;; sparc and ppc ports don't currently support it. -- CSR, 2002-02-21
59
60  ;;
61  ;; features present in this particular build
62  ;;
63
64  ;; Setting this enables the compilation of documentation strings
65  ;; from the system sources into the target Lisp executable.
66  ;; Traditional Common Lisp folk will want this option set.
67  ;; I (WHN) made it optional because I came to Common Lisp from
68  ;; C++ through Scheme, so I'm accustomed to asking
69  ;; Emacs about things that I'm curious about instead of asking
70  ;; the executable I'm running.
71  :sb-doc
72
73  ;; Do regression and other tests when building the system. You might
74  ;; or might not want this if you're not a developer, depending on how
75  ;; paranoid you are. You probably do want it if you are a developer.
76  ;; This test does not affect the target system (in much the same way
77  ;; as :sb-after-xc-core, below).
78  :sb-test
79
80  ;; Make more debugging information available (for debugging SBCL
81  ;; itself). If you aren't hacking or troubleshooting SBCL itself,
82  ;; you probably don't want this set.
83  ;;
84  ;; At least two varieties of debugging information are enabled by this
85  ;; option:
86  ;;   * SBCL is compiled with a higher level of OPTIMIZE DEBUG, so that
87  ;;     the debugger can tell more about the state of the system.
88  ;;   * Various code to print debugging messages, and similar debugging code,
89  ;;     is compiled only when this feature is present.
90  ;;
91  ;; Note that the extra information recorded by the compiler at
92  ;; this higher level of OPTIMIZE DEBUG includes the source location
93  ;; forms. In order for the debugger to use this information, it has to
94  ;; re-READ the source file. In an ordinary installation of SBCL, this
95  ;; re-READing may not work very well, for either of two reasons:
96  ;;   * The sources aren't present on the system in the same location that
97  ;;     they were on the system where SBCL was compiled.
98  ;;   * SBCL is using the standard readtable, without the added hackage
99  ;;     which allows it to handle things like target features.
100  ;; If you want to be able to use the extra debugging information,
101  ;; therefore, be sure to keep the sources around, and run with the
102  ;; readtable configured so that the system sources can be read.
103  ; :sb-show
104
105  ;; Build SBCL with the old CMU CL low level debugger, "ldb". In the
106  ;; ideal world you would not need this unless you are messing with
107  ;; SBCL at a very low level (e.g., trying to diagnose GC problems, or
108  ;; trying to debug assembly code for a port to a new CPU). However,
109  ;; experience shows that sooner or later everyone lose()'s, in which
110  ;; case SB-LDB can at least provide an informative backtrace.
111  :sb-ldb
112
113  ;; This isn't really a target Lisp feature at all, but controls
114  ;; whether the build process produces an after-xc.core file. This
115  ;; can be useful for shortening the edit/compile/debug cycle when
116  ;; you modify SBCL's own source code, as in slam.sh. Otherwise
117  ;; you don't need it.
118  ; :sb-after-xc-core
119
120  ;; Enable extra debugging output in the assem.lisp assembler/scheduler
121  ;; code. (This is the feature which was called :DEBUG in the
122  ;; original CMU CL code.)
123  ; :sb-show-assem
124
125  ;; Compile the C runtime with support for low-level debugging output
126  ;; through FSHOW and FSHOW_SIGNAL.  If enabled, this feature allows
127  ;; users to turn on such debugging output using environment variables at
128  ;; run-time.
129  ; :sb-qshow
130
131  ;; Setting this makes SBCL more "fluid", i.e. more amenable to
132  ;; modification at runtime, by suppressing various INLINE declarations,
133  ;; compiler macro definitions, FREEZE-TYPE declarations; and by
134  ;; suppressing various burning-our-ships-behind-us actions after
135  ;; initialization is complete; and so forth. This tends to clobber the
136  ;; performance of the system, so unless you have some special need for
137  ;; this when hacking SBCL itself, you don't want this set.
138  ; :sb-fluid
139
140  ;; Enable code for collecting statistics on usage of various operations,
141  ;; useful for performance tuning of the SBCL system itself. This code
142  ;; is probably pretty stale (having not been tested since the fork from
143  ;; base CMU CL) but might nonetheless be a useful starting point for
144  ;; anyone who wants to collect such statistics in the future.
145  ; :sb-dyncount
146
147  ;; Enable code for detecting concurrent accesses to the same hash-table
148  ;; in multiple threads. Note that this implementation is currently
149  ;; (2007-09-11) somewhat too eager: even though in the current implementation
150  ;; multiple readers are thread safe as long as there are no writers, this
151  ;; code will also trap multiple readers.
152  ; :sb-hash-table-debug
153
154  ;; Enabled automatically by make-config.sh for platforms which implement
155  ;; the %READ-CYCLE-COUNTER VOP. Can be disabled manually: affects TIME.
156  ;;
157  ;; FIXME: Should this be :SB-CYCLE-COUNTER instead? If so, then the same goes
158  ;; for :COMPARE-AND-SWAP-VOPS as well, and a bunch of others. Perhaps
159  ;; built-time convenience features like this should all live in eg. SB!INT
160  ;; instead?
161  ;;
162  ; :cycle-counter
163
164  ;; Enabled automatically for platforms which implement complex arithmetic
165  ;; VOPs. Such platforms should implement real-complex, complex-real and
166  ;; complex-complex addition and subtractions (for complex-single-float
167  ;; and complex-double-float). They should also also implement complex-real
168  ;; and real-complex multiplication, complex-real division, and
169  ;; sb!vm::swap-complex, which swaps the real and imaginary parts.
170  ;; Finally, they should implement conjugate and complex-real, real-complex
171  ;; and complex-complex CL:= (complex-complex EQL would usually be a good
172  ;; idea).
173  ;;
174  ; :complex-float-vops
175
176  ;; Enabled automatically for platforms which implement VOPs for EQL
177  ;; of single and double floats.
178  ;;
179  ; :float-eql-vops
180
181  ;; Enabled automatically for platform that can implement inline constants.
182  ;;
183  ;; Such platform must implement 5 functions, in SB!VM:
184  ;; * canonicalize-inline-constant: converts a constant descriptor (list) into
185  ;;    a canonical description, to be used as a key in an EQUAL hash table
186  ;;    and to guide the generation of the constant itself.
187  ;; * inline-constant-value: given a canonical constant descriptor, computes
188  ;;    two values:
189  ;;     1. A label that will be used to emit the constant (usually a
190  ;;         sb!assem:label)
191  ;;     2. A value that will be returned to code generators referring to
192  ;;         the constant (on x86oids, an EA object)
193  ;; * sort-inline-constants: Receives a vector of unique constants;
194  ;;    the car of each entry is the constant descriptor, and the cdr the
195  ;;    corresponding label. Destructively returns a vector of constants
196  ;;    sorted in emission order. It could actually perform arbitrary
197  ;;    modifications to the vector, e.g. to fuse constants of different
198  ;;    size.
199  ;; * emit-constant-segment-header: receives the vector of sorted constants
200  ;;    and a flag (true iff speed > space). Expected to emit padding
201  ;;    of some sort between the ELSEWHERE segment and the constants, or some
202  ;;    metadata.
203  ;; * emit-inline-constant: receives a constant descriptor and its associated
204  ;;    label. Emits the constant.
205  ;;
206  ;; Implementing this features lets VOP generators use sb!c:register-inline-constant
207  ;; to get handles (as returned by sb!vm:inline-constant-value) from constant
208  ;; descriptors.
209  ;;
210  ; :inline-constants
211
212  ;; Peter Van Eynde's increase-bulletproofness code for CMU CL
213  ;;
214  ;; Some of the code which was #+high-security before the fork has now
215  ;; been either made unconditional, deleted, or rewritten into
216  ;; unrecognizability, but some remains. What remains is not maintained
217  ;; or tested in current SBCL, but I haven't gone out of my way to
218  ;; break it, either.
219  ;;
220  ; :high-security
221  ; :high-security-support
222
223  ;; low-level thread primitives support
224  ;;
225  ;; As of SBCL 1.0.33.26, threads are part of the default build on
226  ;; x86oid Linux. Other platforms that support them include
227  ;; x86oid Darwin, FreeBSD, and Solaris.
228  ; :sb-thread
229
230  ;; futex support
231  ;;
232  ;; While on linux we are able to use futexes for our locking
233  ;; primitive, on other platforms we don't have this luxury.
234  ;;
235  ; :sb-futex
236
237  ;; On some operating systems the FS segment register (used for SBCL's
238  ;; thread local storage) is not reliably preserved in signal
239  ;; handlers, so we need to restore its value from the pthread thread
240  ;; local storage.
241  ; :restore-tls-segment-register-from-tls
242
243  ;; On some x86oid operating systems (darwin) SIGTRAP is not reliably
244  ;; delivered for the INT3 instruction, so we use the UD2 instruction
245  ;; which generates SIGILL instead.
246  ; :ud2-breakpoints
247
248  ;; Support for detection of unportable code (when applied to the
249  ;; COMMON-LISP package, or SBCL-internal pacakges) or bad-neighbourly
250  ;; code (when applied to user-level packages), relating to material
251  ;; alteration to packages or to bindings in symbols in packages.
252  :sb-package-locks
253
254  ;; Support for the entirety of the 21-bit character space defined by
255  ;; the Unicode consortium, rather than the classical 8-bit ISO-8859-1
256  ;; character set.
257  :sb-unicode
258
259  ;; Support for a full evaluator that can execute all the CL special
260  ;; forms, as opposed to the traditional SBCL evaluator which called
261  ;; COMPILE for everything complicated.
262  :sb-eval
263
264  ;; Record source location information for variables, classes, conditions,
265  ;; packages, etc. Gives much better information on M-. in Slime, but
266  ;; increases core size by about 100kB.
267  :sb-source-locations
268
269  ;; Record xref data for SBCL internals. This can be rather useful for
270  ;; people who want to develop on SBCL itself because it'll make M-?
271  ;; (slime-edit-uses) work which lists call/expansion/etc. sites.
272  ;; It'll increase the core size by major 5-6mB, though.
273  ; :sb-xref-for-internals
274
275  ;; This affects the definition of a lot of things in bignum.lisp. It
276  ;; doesn't seem to be documented anywhere what systems it might apply
277  ;; to. It doesn't seem to be needed for X86 systems anyway.
278  ; :32x16-divide
279
280  ;; This is set in classic CMU CL, and presumably there it means
281  ;; that the floating point arithmetic implementation
282  ;; conforms to IEEE's standard. Here it definitely means that the
283  ;; floating point arithmetic implementation conforms to IEEE's standard.
284  ;; I (WHN 19990702) haven't tried to verify
285  ;; that it does conform, but it should at least mostly conform (because
286  ;; the underlying x86 hardware tries).
287  :ieee-floating-point
288
289  ;; CMU CL had, and we inherited, code to support 80-bit LONG-FLOAT on the x86
290  ;; architecture. Nothing has been done to actively destroy the long float
291  ;; support, but it hasn't been thoroughly maintained, and needs at least
292  ;; some maintenance before it will work. (E.g. the LONG-FLOAT-only parts of
293  ;; genesis are still implemented in terms of unportable CMU CL functions
294  ;; which are not longer available at genesis time in SBCL.) A deeper
295  ;; problem is SBCL's bootstrap process implicitly assumes that the
296  ;; cross-compilation host will be able to make the same distinctions
297  ;; between floating point types that it does. This assumption is
298  ;; fundamentally sleazy, even though in practice it's unlikely to break down
299  ;; w.r.t. distinguishing SINGLE-FLOAT from DOUBLE-FLOAT; it's much more
300  ;; likely to break down w.r.t. distinguishing DOUBLE-FLOAT from LONG-FLOAT.
301  ;; Still it's likely to be quite doable to get LONG-FLOAT support working
302  ;; again, if anyone's sufficiently motivated.
303  ; :long-float
304
305  ;; Some platforms don't use a 32-bit off_t by default, and thus can't
306  ;; handle files larger than 2GB. This feature will control whether
307  ;; we'll try to use platform-specific compilation options to enable a
308  ;; 64-bit off_t. The intent is for this feature to be automatically
309  ;; enabled by make-config.sh on platforms where it's needed and known
310  ;; to work, you shouldn't be enabling it manually. You might however
311  ;; want to disable it, if you need to pass file descriptors to
312  ;; foreign code that uses a 32-bit off_t.
313  ; :largefile
314
315  ;; Enabled automatically on platforms that have VOPs to compute the
316  ;; high half of a full word-by-word multiplication.  When disabled,
317  ;; SB-KERNEL:%MULTIPLY-HIGH is implemented in terms of
318  ;; SB-BIGNUM:%MULTIPLY.
319  ; :multiply-high-vops
320
321  ;; SBCL has optional support for zlib-based compressed core files.  Enable
322  ;; this feature to compile it in.  Obviously, doing so adds a dependency
323  ;; on zlib.
324  ; :sb-core-compression
325
326  ;; On certain thread-enabled platforms, synchronization between threads
327  ;; for the purpose of stopping and starting the world around GC can be
328  ;; performed using safepoints instead of signals.  Enable this feature
329  ;; to compile with safepoints and to use them for GC.
330  ;; (Replaces use of SIG_STOP_FOR_GC.)
331  ; :sb-safepoint
332
333  ;; When compiling with safepoints, the INTERRUPT-THREAD mechanism can
334  ;; also use safepoints to roll the target thread to a point at which it
335  ;; can be interrupted safely, instead of using a signal for this
336  ;; purpose.  Enable this feature in addition to :SB-SAFEPOINT to enable
337  ;; such behaviour.
338  ;; (Replaces use of SIGPIPE, except to wake up syscalls.)
339  ; :sb-thruption
340
341  ;; When compiling with safepoints and thruptions, the TIMER facility
342  ;; can replace its use of setitimer with a background thread.
343  ;; (Replaces use of SIGALRM.)
344  ; :sb-wtimer
345
346  ;;
347  ;; miscellaneous notes on other things which could have special significance
348  ;; in the *FEATURES* list
349  ;;
350
351  ;; Any target feature which affects binary compatibility of fasl files
352  ;; needs to be recorded in *FEATURES-POTENTIALLY-AFFECTING-FASL-FORMAT*
353  ;; (elsewhere).
354
355  ;; notes on the :NIL and :IGNORE features:
356  ;;
357  ;; #+NIL is used to comment out forms. Occasionally #+IGNORE is used
358  ;; for this too. So don't use :NIL or :IGNORE as the names of features..
359
360  ;; notes on :SB-XC and :SB-XC-HOST features (which aren't controlled by this
361  ;; file, but are instead temporarily pushed onto *FEATURES* or
362  ;; *TARGET-FEATURES* during some phases of cross-compilation):
363  ;;
364  ;; :SB-XC-HOST stands for "cross-compilation host" and is in *FEATURES*
365  ;; during the first phase of cross-compilation bootstrapping, when the
366  ;; host Lisp is being used to compile the cross-compiler.
367  ;;
368  ;; :SB-XC stands for "cross compiler", and is in *FEATURES* during the second
369  ;; phase of cross-compilation bootstrapping, when the cross-compiler is
370  ;; being used to create the first target Lisp.
371
372  ;; notes on the :SB-ASSEMBLING feature (which isn't controlled by
373  ;; this file):
374  ;;
375  ;; This is a flag for whether we're in the assembler. It's
376  ;; temporarily pushed onto the *FEATURES* list in the setup for
377  ;; the ASSEMBLE-FILE function. It would be a bad idea
378  ;; to use it as a name for a permanent feature.
379
380  ;; notes on local features (which are set automatically by the
381  ;; configuration script, and should not be set here unless you
382  ;; really, really know what you're doing):
383  ;;
384  ;; machine architecture features:
385  ;;   :x86
386  ;;      any Intel 386 or better, or compatibles like the AMD K6 or K7
387  ;;   :x86-64
388  ;;      any x86-64 CPU running in 64-bit mode
389  ;;   :alpha
390  ;;      DEC/Compaq Alpha CPU
391  ;;   :sparc
392  ;;      any Sun UltraSPARC (possibly also non-Ultras -- currently untested)
393  ;;   :ppc
394  ;;      any PowerPC CPU
395  ;;   :hppa
396  ;;      any PA-RISC CPU
397  ;;   :mips
398  ;;      any MIPS CPU (in little-endian mode with :little-endian)
399  ;;
400  ;; (CMU CL also had a :pentium feature, which affected the definition
401  ;; of some floating point vops. It was present but not enabled or
402  ;; documented in the CMU CL code that SBCL is derived from, and has
403  ;; now been moved to the backend-subfeatures mechanism.)
404  ;;
405  ;; properties derived from the machine architecture
406  ;;   :control-stack-grows-downward-not-upward
407  ;;     On the X86, the Lisp control stack grows downward. On the
408  ;;     other supported CPU architectures as of sbcl-0.7.1.40, the
409  ;;     system stack grows upward.
410  ;;   Note that there are other stack-related differences between the
411  ;;   X86 port and the other ports. E.g. on the X86, the Lisp control
412  ;;   stack coincides with the C stack, meaning that on the X86 there's
413  ;;   stuff on the control stack that the Lisp-level debugger doesn't
414  ;;   understand very well. As of sbcl-0.7.1.40 things like that are
415  ;;   just parameterized by #!+X86, but it'd probably be better to
416  ;;   use new flags like :CONTROL-STACK-CONTAINS-C-STACK.
417  ;;
418  ;;   :stack-allocatable-closures
419  ;;     The compiler can allocate dynamic-extent closures on stack.
420  ;;
421  ;;   :alien-callbacks
422  ;;     Alien callbacks have been implemented for this platform.
423  ;;
424  ;;   :compare-and-swap-vops
425  ;;     The backend implements compare-and-swap VOPs.
426  ;;
427  ;;   :memory-barrier-vops
428  ;;     Memory barriers (for multi-threaded synchronization) have been
429  ;;     implemented for this platform.
430  ;;
431  ;; operating system features:
432  ;;   :unix    = We're intended to run under some Unix-like OS. (This is not
433  ;;              exclusive with the features which indicate which particular
434  ;;              Unix-like OS we're intended to run under.)
435  ;;   :linux   = We're intended to run under some version of Linux.
436  ;;   :bsd     = We're intended to run under some version of BSD Unix. (This
437  ;;              is not exclusive with the features which indicate which
438  ;;              particular version of BSD we're intended to run under.)
439  ;;   :freebsd = We're intended to run under FreeBSD.
440  ;;   :openbsd = We're intended to run under OpenBSD.
441  ;;   :netbsd  = We're intended to run under NetBSD.
442  ;;   :darwin  = We're intended to run under Darwin (including MacOS X).
443  ;;   :sunos   = We're intended to run under Solaris user environment
444  ;;              with the SunOS kernel.
445  ;;   :hpux    = We're intended to run under HP-UX 11.11 or later
446  ;;   :osf1    = We're intended to run under Tru64 (aka Digital Unix
447  ;;              aka OSF/1).
448  ;;   :win32   = We're intended to under some version of Microsoft Windows.
449  ;; (No others are supported by SBCL as of 1.0.8, but :hpux or :irix
450  ;; support could be ported from CMU CL if anyone is sufficiently
451  ;; motivated to do so.)
452  )