7.4 Compiler control

There are ways to control the nature of compiled code via thedeclare special form andproclaim function. See later in this chapter for fuller discussion of these two forms.

In particular there are a set of optimize qualities which take integral values from 0 to 3, in order to control the trade-offs between code size, speed, compilation time, debuggability of the resulting code, and the safety of the code (whether type checks are omitted). For example:

(proclaim '(optimize (speed 3) (safety 0) (debug 0)))

tells the compiler to concentrate on code speed rather than anything else, and

(proclaim '(optimize (safety 3)))

ensures that the compiler never takes liberties with Lisp semantics and produces code that checks for every kind of signallable error.

The important declarations to the compiler are type declarations and optimize declarations. To declare that the type of the value of a variable can be relied upon to be unchanging (and hence allow the compiler to omit various checks in the code), say:

(declare (type the-type variable * )

Optimize declarations have various qualities, and these take values from 0 to 3. The keywords aresafety,fixnum-safety,sys:interruptable,debug,speed, compilation-speed, andspace.

Most of the qualities default to 1 (butsafety andfixnum-safety default to 3 andinterruptable defaults to 0). You can either associate an optimize quality with a new value (with local lexical scope if indeclare, and global scope ifproclaim), or just give it by itself, which implies the value 3 (taken to mean "maximum" in some loose sense).

Thus you ensure code is at maximum safety by:

(proclaim '(optimize (safety 3)))

or

(proclaim '(optimize safety))

and reduce debugging information to a minimum by

(proclaim '(optimize (debug 0)))

Normally code is interruptible, but when going for the extreme levels of speed and "undebuggability" this ceases to be the case unless you also ensure it thus:

(proclaim '(optimize (debug 0) (safety 0) (speed 3) interruptable))

The levels of safety have the following implications:

• 0 implies no type checking upon reading or writing from defstructs, arrays and objects in general, nor any range checking of subscripts.
• 1 implies no type checking upon reading from defstructs, arrays and objects in general, nor any range checking of subscripts when reading.
• 2 implies generally safe code, but allows type and fixnum-safety declarations to take effect.
• 3 (default) implies complete type and range checking, and disallows fixnum-safety and type declarations from taking any effect.

The levels of fixnum-safety have the following implications:

• 0 implies no type checking of arguments to numeric operations, which are assumed to be fixnums. Also the result is assumed, without checking, to not overflow - this level means single machine instructions can be generated for most common integer operations, but risks generating values that may confuse the garbage collector.
• 1 implies that numeric operations do not check their argument types (assumed fixnum), but do signal an error if the result would have been out of range.
• 2 implies that numeric operations signal an error if their arguments are non-fixnum, and also check for overflow.
• 3 (default) implies complete conformance to the semantics of Common Lisp numbers, so that types other than integers are handled in compiled code.

The effects of combining these qualities is summarized below:

Table 7.1 Combining debug and safety levels in the compiler

Keyword settings	Operations
safety=0	Array access optimizations
debug>0	Dumps symbol names for arglist
debug>=2	"Uniquely spills" various registers (sometimes only when source debugging is on)
debug<1	Does not generate any debug info at all
debug=3	Avoidsmake-instance andfind-class optimizations
debug=3	Avoidsgethash andputhash optimizations
debug=3	Avoidsldb anddpb optimizations
debug=3	Avoids an optimization to last
safety>1	Be careful when multiple value counts are wrong
safety<1	Do not check array indices during write
safety<2	Do not check array indices during read
debug<3	Eliminate tail recursion
speed>space	Inline map functions (unlessdebug>2)
debug<=2	"Tail merging"
debug<2 andsafety<2	"Self calls"
safety>=2	"Check get special"
safety<1	Do not check array indices during write
safety<2	Do not check array indices during read
safety>=1	"Check structure access"
debug>=1	Call count count
safety>1	Check number of args
safety>=1 orinterruptible>0	Check stack overflow
safety>1	Ensures the thing being funcalled is a function
safety<3 andfixnum-safety=2	Fixnum-only arithmetic except where overridden by type declarations
safety<3 andfixnum-safety=1	No fixnum overflow checks
safety<3 andfixnum-safety=0	No fixnum arithmetic checks at all
safety>2	char= checks for arguments of type character
safety>=2	Ensures symbols inprogv
debug=3	Avoids "ad hoc" predicate type transforms
compilation-speed=3	Reuse virtual registers in very large functions

The other optimize qualities are:speed -- the attention to fast code,space -- the degree of compactness,compilation-speed -- speed of compilation,interruptable -- whether code must be interruptible when unsafe.

Note that if you compile code with a low level of safety, you may get segmentation violations if the code is incorrect (for example, if type checking is turned off and you supply incorrect types). You can check this by interpreting the code rather than compiling it.

---

LispWorks User Guide - 14 Oct 1998

Generated with Harlequin WebMaker