Things in SBCL that look like special variables (list created by
(apropos "*")) and could conceivably indicate potental thread safety
issues.  Organised by functional area.

The goals are

	(1) classify the unclassified symbols (in such a way as to
	make sense for 2)

	(2) read through the subsystems identified looking for places
	where global state is mutated.  Use this list of symbols as a
	guide, but be open to the possibility that other state
	(e.g. closures, foreign variables) is touched too.

	When looking at a particular symbol, please annotate it in
	this file when you figure out what it's for and how it's
	changed. To give us some confidence that we have reasonable
	coverage, please don't just delete it if it looks ok. Symbols
	shoud only be deleted here if they're obviously not specials
	at all (e.g. functions with * in their names), or if the same
	commit actually rids SBCL of the symbol itself. Otherwise,
	just add a comment saying "read-only" or "unused" or whatever.

	(3) anything else that comes to mind as potential trouble
        spots.  Global state in closures, etc etc

	(4) suggest strategies (e.g. rewrites of affected code, suitable
	locks and lock acquisition/release places) to fix the issues
	revealed in (2) and (3)

	(5) implement same

	Candidates may attempt any of the above simultaneously.
	Points will be awarded for style


Summary so far:

= loop
= PCL            (probably ok if PCL authors did *without-interrupts* right)
= debugger
= profiler
= disassembler
= assembler       (I assume protected by *big-compiler-lock*)
= unix interface  (apparently ok)
= toplevel/environment stuff
= the formatter & pretty printer  (two vars need checking)
= compiler        (protected by *big-compiler-lock*)
= fasloader       (protected by *big-compiler-lock*)
= runtime stuff - gc, control stacks, interrupts etc
= backend constants
= dead
= unclassified

==================

= loop

I suspect that stuff in sb-loop is only ever frobbed at
macroexpand/compile time anyway, so covered by *big-compiler-lock*.
Haven't thought about this too hard, though

SB-LOOP::*LOOP-BODY*
SB-LOOP::*LOOP-DESETQ-TEMPORARY*
SB-LOOP::*LOOP-INSIDE-CONDITIONAL*
SB-LOOP::*LOOP-EPILOGUE*
SB-LOOP::*LOOP-ANSI-UNIVERSE*

= PCL

Critical parts of PCL are protected by *world-lock* (particularly
those dealing with class graph changes), and some with finer-grained locks.

accesses locked with a nice granularity
   SB-PCL::*CLASSOID-CELLS*

read-only & safe:
   SB-PCL::*BUILT-IN-TYPEP-COST*
   SB-PCL::*CACHE-EXPAND-THRESHOLD*
   SB-PCL::*CACHE-LOOKUP-COST*
   SB-PCL::*CASE-TABLE-LIMIT*
   SB-PCL::*CHECK-CACHE-P*
   SB-PCL::*COMPUTE-STD-CPL-CLASS->ENTRY-TABLE-SIZE*
   SB-PCL::*EQ-CASE-TABLE-LIMIT*
   SB-PCL::*NON-BUILT-IN-TYPEP-COST*
   SB-PCL::*NON-VAR-DECLARATIONS*
   SB-PCL::*SECONDARY-DFUN-CALL-COST*
   SB-PCL::*SGF-WRAPPER*
   SB-PCL::*STRUCTURE-TYPEP-COST*
   SB-PCL::*UNSPECIFIC-ARG*
   SB-PCL::*VAR-DECLARATIONS-WITH-ARG*
   SB-PCL::*WRAPPER-OF-COST*

bound & safe:
   SB-PCL::*ALLOW-FORWARD-REFERENCED-CLASSES-IN-CPL-P*
   SB-PCL::*IN-OBSOLETE-INSTANCE-TRAP*
   SB-PCL::*PRECOMPILING-LAP*
   SB-PCL::*CACHE-MISS-VALUES-STACK*

protected by PCL-LOCK:
   SB-PCL::*PREVIOUS-NWRAPPERS*

believed protected by the compiler-lock:
   SB-PCL::*ALL-CTORS*
   SB-PCL::*FGENS*
   SB-PCL::*SGF-DFUN-STATE-INDEX*
   SB-PCL::*VAR-DECLARATIONS-WITHOUT-ARG*

potentially unsafe:
   SB-PCL::*CLASS-EQ-SPECIALIZER-METHODS*
   SB-PCL::*EFFECTIVE-METHOD-CACHE*
   SB-PCL::*EQL-SPECIALIZER-METHODS*
   SB-PCL::*METHOD-FUNCTION-PLIST*
   SB-PCL::*PV-KEY-TO-PV-TABLE-TABLE*
   SB-PCL::*PV-TABLE-CACHE-UPDATE-INFO*
   SB-PCL::*PVS*
   SB-PCL::*SLOT-NAME-LISTS-INNER*
   SB-PCL::*SLOT-NAME-LISTS-OUTER*

debugging / profiling -- low relevance:
   SB-PCL::*DFUN-COUNT*
   SB-PCL::*ALLOW-EMF-CALL-TRACING-P*

build-options and bootstrap machinery -- irrelevant for user-code:
   SB-PCL::*ALLOW-EXPERIMENTAL-SPECIALIZERS-P*
   SB-PCL::*BOOT-STATE* ; pseudoconstant in finished lisp (not in bootstrap)
   SB-PCL::*BUILT-IN-CLASS-SYMBOLS*
   SB-PCL::*BUILT-IN-CLASSES*
   SB-PCL::*BUILT-IN-WRAPPER-SYMBOLS*
   SB-PCL::*CHECKING-OR-CACHING-LIST*

;;; global, frobbed on generic function
;;; initialization/reinitialization, method precomputation, and
;;; compute-effective-method.  Potentially unsafe, may be OK because
;;; of *pcl-lock*, but could easily be liable to races.

SB-PCL::*CONDITION-SETF-SLOT-VALUE-USING-CLASS-METHOD*
SB-PCL::*CONDITION-SLOT-BOUNDP-USING-CLASS-METHOD*
SB-PCL::*CONDITION-SLOT-VALUE-USING-CLASS-METHOD*
SB-PCL::*CREATE-CLASSES-FROM-INTERNAL-STRUCTURE-DEFINITIONS-P*
SB-PCL::*DFUN-ARG-SYMBOLS*
SB-PCL::*DFUN-CONSTRUCTORS*
SB-PCL::*DFUN-LIST*
SB-PCL::*DFUN-MISS-GFS-ON-STACK*
SB-PCL::*EARLY-CLASS-DEFINITIONS*
SB-PCL::*EARLY-CLASS-PREDICATES*
SB-PCL::*EARLY-CLASS-SLOTS*
SB-PCL::*EARLY-P*
SB-PCL::*EMF-CALL-TRACE*
SB-PCL::*EMF-CALL-TRACE-INDEX*
SB-PCL::*EMF-CALL-TRACE-SIZE*
SB-PCL::*EMIT-FUNCTION-P*
SB-PCL::*ENABLE-DFUN-CONSTRUCTOR-CACHING*
SB-PCL::*ENABLE-EMF-CALL-TRACING-P*
SB-PCL::*EQL-SPECIALIZER-TABLE*
SB-PCL::*GLOBAL-EFFECTIVE-METHOD-GENSYMS*
SB-PCL::*IN-GF-ARG-INFO-P*
SB-PCL::*IN-PRECOMPUTE-EFFECTIVE-METHODS-P*
SB-PCL::*INITFUNCTIONS-FOR-THIS-DEFCLASS*
SB-PCL::*INTERNAL-PCL-GENERALIZED-FUN-NAME-SYMBOLS*
SB-PCL::*LAZY-DFUN-COMPUTE-P*
SB-PCL::*LONG-METHOD-COMBINATION-FUNCTIONS*
SB-PCL::*MINIMUM-CACHE-SIZE-TO-LIST*
SB-PCL::*NAME->CLASS->SLOTD-TABLE*
SB-PCL::*NEW-CLASS*
SB-PCL::*NORMALIZE-TYPE
SB-PCL::*NOT-IN-CACHE*
SB-PCL::*OLD-C-A-M-GF-METHODS*
SB-PCL::*OPTIMIZE-CACHE-FUNCTIONS-P*
SB-PCL::*OPTIMIZE-SPEED*
SB-PCL::*PCL-CLASS-BOOT*
SB-PCL::*PCL-LOCK*                         ; protecting the rest
SB-PCL::*PCL-PACKAGE*
SB-PCL::*RAISE-METATYPES-TO-CLASS-P*
SB-PCL::*READERS-FOR-THIS-DEFCLASS*
SB-PCL::*REBOUND-EFFECTIVE-METHOD-GENSYMS*
SB-PCL::*SGF-ARG-INFO-INDEX*
SB-PCL::*SGF-METHOD-CLASS-INDEX*
SB-PCL::*SGF-METHODS-INDEX*
SB-PCL::*SGF-NAME-INDEX*
SB-PCL::*SGF-SLOTS-INIT*
SB-PCL::*SHOW-MAKE-UNORDERED-METHODS-EMF-CALLS*
SB-PCL::*SLOT-NAMES-FOR-THIS-DEFCLASS*
SB-PCL::*SLOT-VECTOR-SYMBOLS*
SB-PCL::*STANDARD-CLASSES*
SB-PCL::*STANDARD-METHOD-COMBINATION*
SB-PCL::*STANDARD-SETF-SLOT-VALUE-USING-CLASS-METHOD*
SB-PCL::*STANDARD-SLOT-BOUNDP-USING-CLASS-METHOD*
SB-PCL::*STANDARD-SLOT-LOCATIONS*
SB-PCL::*STANDARD-SLOT-VALUE-USING-CLASS-METHOD*
SB-PCL::*STD-CAM-METHODS*
SB-PCL::*STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD*
SB-PCL::*STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD*
SB-PCL::*STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD*
SB-PCL::*SUBTYPEP
SB-PCL::*THE-CLASS-ARRAY*
SB-PCL::*THE-CLASS-BASE-CHAR*
SB-PCL::*THE-CLASS-BIGNUM*
SB-PCL::*THE-CLASS-BIT-VECTOR*
SB-PCL::*THE-CLASS-BUILT-IN-CLASS*
SB-PCL::*THE-CLASS-CHARACTER*
SB-PCL::*THE-CLASS-CLASS*
SB-PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
SB-PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
SB-PCL::*THE-CLASS-CODE-COMPONENT*
SB-PCL::*THE-CLASS-COMPLEX*
SB-PCL::*THE-CLASS-COMPLEX-DOUBLE-FLOAT*
SB-PCL::*THE-CLASS-COMPLEX-SINGLE-FLOAT*
SB-PCL::*THE-CLASS-CONDITION*
SB-PCL::*THE-CLASS-CONDITION-CLASS*
SB-PCL::*THE-CLASS-CONDITION-DIRECT-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-CONDITION-EFFECTIVE-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-CONDITION-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-CONS*
SB-PCL::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
SB-PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
SB-PCL::*THE-CLASS-DIRECT-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-DOCUMENTATION-MIXIN*
SB-PCL::*THE-CLASS-DOUBLE-FLOAT*
SB-PCL::*THE-CLASS-EFFECTIVE-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-EQL-SPECIALIZER*
SB-PCL::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
SB-PCL::*THE-CLASS-FDEFN*
SB-PCL::*THE-CLASS-FIXNUM*
SB-PCL::*THE-CLASS-FLOAT*
SB-PCL::*THE-CLASS-FORWARD-REFERENCED-CLASS*
SB-PCL::*THE-CLASS-FUNCALLABLE-INSTANCE*
SB-PCL::*THE-CLASS-FUNCALLABLE-STANDARD-CLASS*
SB-PCL::*THE-CLASS-FUNCALLABLE-STANDARD-OBJECT*
SB-PCL::*THE-CLASS-FUNCTION*
SB-PCL::*THE-CLASS-GENERIC-FUNCTION*
SB-PCL::*THE-CLASS-INSTANCE*
SB-PCL::*THE-CLASS-INTEGER*
SB-PCL::*THE-CLASS-LIST*
SB-PCL::*THE-CLASS-LONG-METHOD-COMBINATION*
SB-PCL::*THE-CLASS-LRA*
SB-PCL::*THE-CLASS-METHOD*
SB-PCL::*THE-CLASS-METHOD-COMBINATION*
SB-PCL::*THE-CLASS-NULL*
SB-PCL::*THE-CLASS-NUMBER*
SB-PCL::*THE-CLASS-PCL-CLASS*
SB-PCL::*THE-CLASS-PLIST-MIXIN*
SB-PCL::*THE-CLASS-RANDOM-CLASS*
SB-PCL::*THE-CLASS-RATIO*
SB-PCL::*THE-CLASS-RATIONAL*
SB-PCL::*THE-CLASS-REAL*
SB-PCL::*THE-CLASS-SEQUENCE*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-DOUBLE-FLOAT*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-16*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-30*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-32*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-8*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SINGLE-FLOAT*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-16*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-2*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-32*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-4*
SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-8*
SB-PCL::*THE-CLASS-SIMPLE-BIT-VECTOR*
SB-PCL::*THE-CLASS-SIMPLE-STRING*
SB-PCL::*THE-CLASS-SIMPLE-VECTOR*
SB-PCL::*THE-CLASS-SINGLE-FLOAT*
SB-PCL::*THE-CLASS-SLOT-CLASS*
SB-PCL::*THE-CLASS-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-SLOT-OBJECT*
SB-PCL::*THE-CLASS-SPECIALIZER*
SB-PCL::*THE-CLASS-SPECIALIZER-WITH-OBJECT*
SB-PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD*
SB-PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD*
SB-PCL::*THE-CLASS-STANDARD-CLASS*
SB-PCL::*THE-CLASS-STANDARD-DIRECT-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-STANDARD-EFFECTIVE-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-STANDARD-GENERIC-FUNCTION*
SB-PCL::*THE-CLASS-STANDARD-METHOD*
SB-PCL::*THE-CLASS-STANDARD-METHOD-COMBINATION*
SB-PCL::*THE-CLASS-STANDARD-OBJECT*
SB-PCL::*THE-CLASS-STANDARD-READER-METHOD*
SB-PCL::*THE-CLASS-STANDARD-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-STANDARD-WRITER-METHOD*
SB-PCL::*THE-CLASS-STD-CLASS*
SB-PCL::*THE-CLASS-STD-OBJECT*
SB-PCL::*THE-CLASS-STREAM*
SB-PCL::*THE-CLASS-STRING*
SB-PCL::*THE-CLASS-STRUCTURE-CLASS*
SB-PCL::*THE-CLASS-STRUCTURE-DIRECT-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-STRUCTURE-EFFECTIVE-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-STRUCTURE-OBJECT*
SB-PCL::*THE-CLASS-STRUCTURE-SLOT-DEFINITION*
SB-PCL::*THE-CLASS-SYMBOL*
SB-PCL::*THE-CLASS-SYSTEM-AREA-POINTER*
SB-PCL::*THE-CLASS-T*
SB-PCL::*THE-CLASS-VECTOR*
SB-PCL::*THE-CLASS-WEAK-POINTER*
SB-PCL::*THE-ESLOTD-FUNCALLABLE-STANDARD-CLASS-SLOTS*
SB-PCL::*THE-ESLOTD-STANDARD-CLASS-SLOTS*
SB-PCL::*THE-SYSTEM-II-METHOD*
SB-PCL::*THE-SYSTEM-SI-METHOD*
SB-PCL::*THE-WRAPPER-OF-ARRAY*
SB-PCL::*THE-WRAPPER-OF-BASE-CHAR*
SB-PCL::*THE-WRAPPER-OF-BIGNUM*
SB-PCL::*THE-WRAPPER-OF-BIT-VECTOR*
SB-PCL::*THE-WRAPPER-OF-CHARACTER*
SB-PCL::*THE-WRAPPER-OF-CODE-COMPONENT*
SB-PCL::*THE-WRAPPER-OF-COMPLEX*
SB-PCL::*THE-WRAPPER-OF-COMPLEX-DOUBLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-COMPLEX-SINGLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-CONS*
SB-PCL::*THE-WRAPPER-OF-DOUBLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-FDEFN*
SB-PCL::*THE-WRAPPER-OF-FIXNUM*
SB-PCL::*THE-WRAPPER-OF-FLOAT*
SB-PCL::*THE-WRAPPER-OF-INTEGER*
SB-PCL::*THE-WRAPPER-OF-LIST*
SB-PCL::*THE-WRAPPER-OF-LRA*
SB-PCL::*THE-WRAPPER-OF-NULL*
SB-PCL::*THE-WRAPPER-OF-NUMBER*
SB-PCL::*THE-WRAPPER-OF-RANDOM-CLASS*
SB-PCL::*THE-WRAPPER-OF-RATIO*
SB-PCL::*THE-WRAPPER-OF-RATIONAL*
SB-PCL::*THE-WRAPPER-OF-REAL*
SB-PCL::*THE-WRAPPER-OF-SEQUENCE*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-DOUBLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-16*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-30*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-32*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-8*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SINGLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-16*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-2*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-32*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-4*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-8*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-BIT-VECTOR*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-STRING*
SB-PCL::*THE-WRAPPER-OF-SIMPLE-VECTOR*
SB-PCL::*THE-WRAPPER-OF-SINGLE-FLOAT*
SB-PCL::*THE-WRAPPER-OF-STRING*
SB-PCL::*THE-WRAPPER-OF-STRUCTURE-OBJECT*
SB-PCL::*THE-WRAPPER-OF-SYMBOL*
SB-PCL::*THE-WRAPPER-OF-SYSTEM-AREA-POINTER*
SB-PCL::*THE-WRAPPER-OF-T*
SB-PCL::*THE-WRAPPER-OF-VECTOR*
SB-PCL::*THE-WRAPPER-OF-WEAK-POINTER*
SB-PCL::*WRITERS-FOR-THIS-DEFCLASS*
SB-PCL::WRAPPER-CLASS*


= debugger

*DEBUG-PRINT-LENGTH*
*TRACE-FRAME*
*TRACE-ENCAPSULATE-DEFAULT*
*MAX-TRACE-INDENTATION*
*IN-THE-DEBUGGER*
*DEBUG-BEGINNER-HELP-P*
*STACK-TOP-HINT*
*DEBUG-HELP-STRING*
*ONLY-BLOCK-START-LOCATIONS*
*FLUSH-DEBUG-ERRORS*
*DEBUG-CONDITION*
*TRACE-VALUES*
*PRINT-LOCATION-KIND*
*DEBUG-PRINT-LEVEL*
*TRACED-FUN-LIST*
*TRACE-INDENTATION-STEP*
*DEBUG-READTABLE*
SB-DEBUG::*CACHED-DEBUG-SOURCE*
SB-DEBUG::*POSSIBLE-BREAKPOINTS*
SB-DEBUG::*BAD-CODE-LOCATION-TYPES*
SB-DEBUG::*TRACED-ENTRIES*
SB-DEBUG::*DEBUG-COMMAND-LEVEL*
SB-DEBUG::*CACHED-SOURCE-STREAM*
SB-DEBUG::*DEBUG-LOOP-FUN*
SB-DEBUG::*NESTED-DEBUG-CONDITION*
SB-DEBUG::*STEP-BREAKPOINTS*
SB-DEBUG::*DEBUG-RESTARTS*
SB-DEBUG::*BREAKPOINTS*
SB-DEBUG::*TRACED-FUNS*
SB-DEBUG::*DEBUG-COMMANDS*
SB-DEBUG::*DEFAULT-BREAKPOINT-DEBUG-FUN*
SB-DEBUG::*CACHED-READTABLE*
SB-DEBUG::*IN-TRACE*
SB-DEBUG::*CACHED-TOPLEVEL-FORM-OFFSET*
SB-DEBUG::*STACK-TOP*
SB-DEBUG::*CURRENT-FRAME*
SB-DEBUG::*CACHED-TOPLEVEL-FORM*
SB-DEBUG::*NUMBER-OF-STEPS*
SB-DEBUG::*REAL-STACK-TOP*
SB-DI::*PARSING-BUFFER*
SB-DI::*IR1-BLOCK-DEBUG-BLOCK*
SB-DI::*OTHER-PARSING-BUFFER*
SB-DI::*COMPILED-DEBUG-FUNS*
SB-DI::*COMPONENT-BREAKPOINT-OFFSETS*
SB-DI::*FUN-END-COOKIES*
SB-DI::*FORM-NUMBER-CIRCULARITY-TABLE*
SB-DI::*EXECUTING-BREAKPOINT-HOOKS*
SB-DI::*IR1-LAMBDA-DEBUG-FUN*

= profiler

SB-PROFILE::*PROFILED-FUN-NAME->INFO*
SB-PROFILE::*ENCLOSED-CONSING*
SB-PROFILE::*COMPUTING-PROFILING-DATA-FOR*
SB-PROFILE::*ENCLOSED-PROFILES*
SB-PROFILE::*TIMER-OVERHEAD-ITERATIONS*
SB-PROFILE::*OVERHEAD*
SB-PROFILE::*ENCLOSED-TICKS*

= disassembler

SB-DISASSEM:*DISASSEM-INST-ALIGNMENT-BYTES*
SB-DISASSEM:*DISASSEM-NOTE-COLUMN*
SB-DISASSEM:*DEFAULT-DSTATE-HOOKS*
SB-DISASSEM:*DISASSEM-OPCODE-COLUMN-WIDTH*
SB-DISASSEM:*DISASSEM-SCHEDULER-P*
SB-DISASSEM:*DISASSEM-LOCATION-COLUMN-WIDTH*
SB-DISASSEM::*ARG-FUN-PARAMS*
SB-DISASSEM::*ADDRESS-OF-NIL-OBJECT*
SB-DISASSEM::*DISASSEM-INSTS*
SB-DISASSEM::*DISASSEM-FUN-CACHE*
SB-DISASSEM::*DISASSEM-INST-FORMATS*
SB-DISASSEM::*GROKKED-SYMBOL-SLOTS*
SB-DISASSEM::*ARG-FORM-KINDS*
SB-DISASSEM::*DISASSEM-INST-SPACE*
SB-DISASSEM::*CURRENT-INSTRUCTION-FLAVOR*
SB-DISASSEM::*DISASSEM-ARG-TYPES*
SB-DISASSEM::*ASSEMBLER-ROUTINES-BY-ADDR*

= assembler

Currently protected by *big-compiler-lock*.  Mostly uninvestigated

SB-ASSEM:*ASSEM-MAX-LOCATIONS*
SB-ASSEM:*ASSEM-INSTRUCTIONS*
SB-ASSEM:*ASSEM-SCHEDULER-P*
SB-ASSEM::*INSTRUCTION-ATTRIBUTE-TRANSLATIONS*
SB-ASSEM::**CURRENT-VOP**
SB-ASSEM::**CURRENT-SEGMENT**


= unix interface

Looks good to me

SB-UNIX::*INTERRUPTS-ENABLED*  ; ok,  bound
SB-UNIX::*UNIX-SIGNALS*        ; ok, read-only
SB-UNIX::*INTERRUPT-PENDING*  ; ok, bound

= toplevel/environment stuff

Some of these should probably be bound on thread entry.  I haven't
checked them yet, except where indicated

*DEBUG-IO*
SB-SYS:*TTY*
SB-SYS:*STDIN*
SB-SYS:*STDOUT*
SB-SYS:*STDERR*
SB-SYS:*LONG-SITE-NAME*    ; readonly
SB-SYS:*SHORT-SITE-NAME*   ; readonly
SB-SYS::*SOFTWARE-VERSION* ; readonly
SB-THREAD::*SESSION-LOCK*  ; bound
SB-THREAD::*BACKGROUND-THREADS-WAIT-FOR-DEBUGGER* ; intentionally global
***   ; bound
**    ; bound
*     ; bound
*PRINT-PRETTY*
*LOAD-VERBOSE*
*LOAD-TRUENAME*
*READ-BASE*
*BREAK-ON-SIGNALS*
*PRINT-READABLY*
*PRINT-CIRCLE*
*FEATURES*                     ; write at own risk
*PRINT-BASE*
*PACKAGE*
*PRINT-RADIX*
*READ-SUPPRESS*
*ERROR-OUTPUT*
*DEFAULT-PATHNAME-DEFAULTS*
*LOAD-PATHNAME*
*STANDARD-OUTPUT*
*PRINT-RIGHT-MARGIN*
*READTABLE*
*PRINT-CASE*
*PRINT-MISER-WIDTH*
*PRINT-PPRINT-DISPATCH*
*PRINT-LENGTH*
*TERMINAL-IO*
*PRINT-GENSYM*
*QUERY-IO*
*STANDARD-INPUT*
*LOAD-PRINT*
*DEBUGGER-HOOK*
*PRINT-LINES*
*PRINT-ESCAPE*
*PRINT-LEVEL*
*READ-EVAL*
*PRINT-ESCAPE*
*TRACE-OUTPUT*
SB-IMPL::*INSPECT-LENGTH*
SB-IMPL::*DRIBBLE-STREAM*         ; what to do with dribble in threaded lisp?
SB-IMPL::*HELP-FOR-INSPECT*       ; read-only
*PRINT-ARRAY*



*POSIX-ARGV*     ; read-only
*READ-DEFAULT-FLOAT-FORMAT*   ; probably "change at own risk"
*MODULES*   ; should be changed only by provide/require, needs locking
*MODULE-PROVIDER-FUNCTIONS* ; probably "change at own risk"
SB-IMPL::*REPL-FUN*
SB-INT:*REPL-READ-FORM-FUN*
SB-INT:*REPL-PROMPT-FUN*

= the formatter & pretty printer

== probably safe (readonly unless indicated)

(defvar *default-format-error-control-string* nil)
(defvar *default-format-error-offset* nil)
SB-FORMAT::*ILLEGAL-INSIDE-JUSTIFICATION*
SB-FORMAT::*OUTSIDE-ARGS* ; safe, bound


(defvar *up-up-and-out-allowed* nil) ; safe, bound
(defvar *logical-block-popper* nil) ; bound
(defvar *expander-next-arg-macro* 'expander-next-arg) ; bound
(defvar *orig-args-available* nil) ; bound

== needs checking

;;; Used by the expander stuff. Initially starts as T, and gets set to NIL
;;; if someone needs to do something strange with the arg list (like use
;;; the rest, or something).  Setf in late-format, haven't checked if it's
;;; always in a bound context
(defvar *only-simple-args*)

;;; setf in late-format, haven't checked
(defvar *simple-args*)

== haven't looked at yet

SB-PRETTY::*INITIAL-PPRINT-DISPATCH*
SB-PRETTY::*BUILDING-INITIAL-TABLE*
SB-PRETTY::*PRECOMPILED-PPRINT-DISPATCH-FUNS*


= compiler

Note that the compiler and fasloader are strongly believed not to be
thread-safe, so there is currently a big lock (*big-compiler-lock*)
around all calls to the compiler or fasloader

INFO functions are currently believed to be multi-writer/reader threadsafe,
though it's hard to know for sure since they were definitely read-safe,
and writes are done only while holding **WORLD-LOCK** as things stand.
The algorithms employed are used in at least one industrial-strength Lisp
application, though a bug has been reported (to me, dougk) regarding
the fasloader that might be related to INFO, or to the fasloader.
Catch 22: can't expose threading bugs until lock is removed
          can't remove the lock until INFO is proven to be threadsafe.

*COMPILE-FILE-PATHNAME*
*COMPILE-FILE-TRUENAME*
*COMPILE-PRINT*
*COMPILE-VERBOSE*
*COMPILE-PROGRESS*
SB-C:*BACKEND-INTERNAL-ERRORS*
SB-C:*BACKEND-SPECIAL-ARG-TYPES*
SB-C:*LEXENV*
SB-C:*CODE-SEGMENT*
SB-C:*COMPONENT-BEING-COMPILED*
SB-C:*BACKEND-SB-NAMES*
SB-C:*BACKEND-PAGE-SIZE*
SB-C:*BACKEND-SC-NUMBERS*
SB-C:*ELSEWHERE*
SB-C:*BACKEND-T-PRIMITIVE-TYPE*
SB-C:*BACKEND-SB-LIST*
SB-C:*BACKEND-SUBFEATURES*
SB-C:*COUNT-VOP-USAGES*
SB-C:*SUPPRESS-VALUES-DECLARATION*
SB-C:*BACKEND-SC-NAMES*
SB-C::*CURRENT-COMPONENT*
SB-C::*SLOT-INHERIT-ALIST*
SB-C::*COMPILER-NOTE-COUNT*
SB-C::*BACKEND-PREDICATE-TYPES*
SB-C::*POLICY*
SB-C::*INLINEP-TRANSLATIONS*
SB-C::*PACK-OPTIMIZE-SAVES*
SB-C::*DELETION-IGNORED-OBJECTS*
SB-C::*LAST-FORMAT-ARGS*
SB-C::*CONSTANTS-BEING-CREATED*
SB-C::*IGNORED-ERRORS*
SB-C::*COMPILE-OBJECT*
SB-C::*TN-IDS*
SB-C::*LOSSAGE-FUN*
SB-C::*COMPILER-ERROR-COUNT*
SB-C::*EVENT-NOTE-THRESHOLD*
SB-C::*LAST-MESSAGE-COUNT*
SB-C::*EMIT-ASSEMBLY-CODE-NOT-VOPS-P*
SB-C::*LAST-FORMAT-STRING*
SB-C::*UNWINNAGE-FUN*
SB-C::*COMPILER-ERROR-CONTEXT*
SB-C::*SEEN-BLOCKS*
SB-C::*TN-ID*
SB-C::*IR1-OPTIMIZE-UNTIL-DONE-EVENT-INFO*
SB-C::*SPECIALIZED-ARRAY-ELEMENT-TYPE-PROPERTIES*       ; readonly
SB-C::*NUMBER-CONTINUATIONS*
SB-C::*CTYPE-TEST-FUN*
SB-C::*IGNORE-COST-VOPS*
SB-C::*QUEUED-PROCLAIMS*
SB-C::*COMPILER-STYLE-WARNING-COUNT*
SB-C::*LABEL-IDS*
SB-C::TN-NEXT*
SB-C::*COMPILED-CODE-LOCATION-KINDS*
SB-C::*VOP-TN-REFS*
SB-C::*FAILURE-P*
SB-C::*LAST-ORIGINAL-SOURCE*
SB-C::NEXT*
SB-C::LIST*-IR2-CONVERT-OPTIMIZER
SB-C::*COMPILER-ERROR-BAILOUT*
SB-C::*DELAYED-IR1-TRANSFORMS*
SB-C::*INFO-TYPES* ; readonly
SB-C::*CHECK-CONSISTENCY*
SB-C::*SEEN-FUNS*
SB-C::*USING-VOP-TN-REFS*
SB-C::*MAKE-VALUE-CELL-EVENT-EVENT-INFO*
SB-C::*IN-PACK*
SB-C::*REPACK-BLOCK-EVENT-INFO*
SB-C::*UNPACK-TN-EVENT-INFO*
SB-C::*COALESCE-MORE-LTN-NUMBERS-EVENT-INFO*
SB-C::*IN-COMPILATION-UNIT*
SB-C::*BACKEND-TEMPLATE-NAMES*
SB-C::*BACKEND-PRIMITIVE-TYPE-NAMES*
SB-C::*CONSTRAINT-PROPAGATE*
SB-C::*BACKEND-PRIMITIVE-TYPE-ALIASES*
SB-C::*NO-COSTS*
SB-C::*PACK-ASSIGN-COSTS*
SB-C::*CURRENT-FORM-NUMBER*
SB-C::*BLOCK-COMPILE-ARG*
SB-C::*COMPILER-ERROR-PRINT-LENGTH*
SB-C::*CONTINUATION-NUMBER*
SB-C::*PREV-SEGMENT*
SB-C::*CONTROL-DELETED-BLOCK-EVENT-INFO*
SB-C::*ALLOW-DEBUG-CATCH-TAG*
SB-C::*ID-LABELS*
SB-C::*BACKEND-TYPE-PREDICATES*
SB-C::*COMPILER-WARNING-COUNT*
SB-C::*SUPPRESS-NOTE-VOPS*
SB-C::*COMPILER-ERROR-PRINT-LEVEL*
SB-C::*COMPLEMENT-TYPE-CHECKS*
SB-C::*FUN-NAMES-IN-THIS-FILE*
SB-C::*SPLIT-IR2-BLOCK-EVENT-INFO*
SB-C::*TRACE-TABLE*
SB-C::*LAST-SOURCE-FORM*
SB-C::*WEAKEN-TYPE-CACHE-VECTOR*         ; threadsafe
SB-C::*-DERIVE-TYPE-AUX
SB-C::*BLOCK-COMPILE*
SB-C::*BIG-COMPILER-LOCK*                ; protecting the rest
SB-C::*PRIMITIVE-TYPE-SLOT-ALIST*
SB-C::*PREVIOUS-LOCATION*
SB-C::*BYTE-BUFFER*
SB-C::*CONSTANTS-CREATED-SINCE-LAST-INIT*
SB-C::*LAST-SOURCE-CONTEXT*
SB-C::*FIXUPS*
SB-C::VOP*
SB-C::*REOPTIMIZE-MAXED-OUT-EVENT-INFO*
SB-C::*LIST-CONFLICTS-TABLE*
SB-C::*LOSSAGE-DETECTED*
SB-C::*LAST-ERROR-CONTEXT*
SB-C::*PREV-VOP*
SB-C::*POLICY-DEPENDENT-QUALITIES*
SB-C::*REOPTIMIZE-AFTER-TYPE-CHECK-MAX*
SB-C::*-DERIVE-TYPE-OPTIMIZER
SB-C::*IR1-ATTRIBUTE-TRANSLATIONS*
SB-C::*DYNAMIC-COUNTS-TN*
SB-C::*EXTREME-NTHCDR-OPEN-CODE-LIMIT*
SB-C::*BACKEND-PARSED-VOPS*
SB-C::*ABORTED-COMPILATION-UNIT-COUNT*
SB-C::*COPY-DELETED-MOVE-EVENT-INFO*
SB-C::*MAX-OPTIMIZE-ITERATIONS*
SB-C::*TOPLEVEL-LAMBDAS*
SB-C::*SC-VOP-SLOTS*
SB-C::*IR1-OPTIMIZE-MAXED-OUT-EVENT-INFO*
SB-C::*CONTINUATION-NUMBERS*
SB-C::*WARNINGS-P*
SB-C::*FLAME-ON-NECESSARILY-UNDEFINED-FUNCTION*
SB-C::*UNPACK-FALLBACK-EVENT-INFO*
SB-C::*SOURCE-INFO*
SB-C::*LIVE-BLOCK*
SB-C::*NEXT-LOCATION*
SB-C::*ELSEWHERE-LABEL*
SB-C::*SOURCE-PATHS*
SB-C::*DEFAULT-NTHCDR-OPEN-CODE-LIMIT*
SB-C::*ALWAYS-OPTIMIZED-AWAY*
SB-C::*CURRENT-PATH*
SB-C::*LABEL-ID*
SB-C::*ENTRY-POINTS*
SB-C::*COMPILER-TRACE-OUTPUT*
SB-C::*CONSTRAINT-NUMBER*
SB-C::*RESULT-FIXUPS*
SB-C::*REPACK-BLOCKS*
SB-C::IR1-CONVERT-LET*
SB-C::*CODE-VECTOR*
SB-C::*SOURCE-CONTEXT-METHODS*
SB-C::*VOP-ATTRIBUTE-TRANSLATIONS*
SB-C::*COMPILER-ERROR-PRINT-LINES*
SB-C::*LIVE-VOP*
SB-C::*POLICY-QUALITIES*
SB-C::*NO-LOADS*
SB-C::*TRACE-TABLE-INFO*
SB-C::*UNDEFINED-WARNINGS*
SB-C::*BLOCK-ATTRIBUTE-TRANSLATIONS*
SB-C::*EVENT-INFO*
SB-C::*UNWINNAGE-DETECTED*
SB-C::*ID-TNS*

= fasloader

SB-FASL:*ASSEMBLER-ROUTINES*
SB-FASL:*FASL-FILE-TYPE*
SB-FASL::FOP-LIST*-4
SB-FASL::*COLD-LOAD-DUMP*
SB-FASL::FOP-LIST*-7
SB-FASL::FOP-LIST*-8
SB-FASL::FOP-LIST*-1
SB-FASL::FOP-LIST*-2
SB-FASL::*FASL-INPUT-STREAM*
SB-FASL::*FOP-STACK*
SB-FASL::*LOAD-DEPTH*
SB-FASL::*FEATURES-AFFECTING-FASL-FORMAT*
SB-FASL::*DUMP-ONLY-VALID-STRUCTURES*
SB-FASL::*CURRENT-FOP-TABLE-SIZE*
SB-FASL::*FOP-STACK-POINTER-ON-ENTRY*
SB-FASL::*FREE-FOP-TABLES*
SB-FASL::*LOAD-SYMBOL-BUFFER*
SB-FASL::*FASL-HEADER-STRING-START-STRING*
SB-FASL::DUMP-FOP*
SB-FASL::FOP-LIST*
SB-FASL::*CIRCULARITIES-DETECTED*
SB-FASL::*LOAD-CODE-VERBOSE*
SB-FASL::*FEATURES-POTENTIALLY-AFFECTING-FASL-FORMAT*
SB-FASL::*LOAD-SYMBOL-BUFFER-SIZE*
SB-FASL::*CURRENT-FOP-TABLE*
SB-FASL::*FOP-STACK-POINTER*
SB-FASL::*CURRENT-FOP-TABLE-INDEX*
SB-FASL::*FOP-FUNS*
SB-FASL::*CURRENT-UNWIND-PROTECT-BLOCK*
SB-FASL::FOP-LIST*-5
SB-FASL::*FOP-NAMES*
SB-FASL::FOP-LIST*-6
SB-FASL::FOP-LIST*-3


= runtime stuff


SB-VM:*STATIC-SPACE-FREE-POINTER*
SB-VM:*INITIAL-DYNAMIC-SPACE-FREE-POINTER*
SB-VM:*CURRENT-CATCH-BLOCK* ; bound at thread entry (in C)
SB-VM:*STATIC-SYMBOLS*
SB-VM:*CONTROL-STACK-START* ; safe, bound at thread entry
SB-VM:*READ-ONLY-SPACE-FREE-POINTER*
SB-VM:*BINDING-STACK-START* ; safe, bound at thread entry
SB-VM:*CONTROL-STACK-END* ; safe, bound at thread entry
SB-VM::*CURRENT-UNWIND-PROTECT-BLOCK*  ; bound at thread entry (in C)
SB-VM::*FREE-TLS-INDEX*
SB-VM::*BINDING-STACK-POINTER*
SB-VM::*ALLOCATION-POINTER*    ; may be mostly unused ?
SB-KERNEL:*PSEUDO-ATOMIC-ATOMIC*  ; bound
SB-KERNEL:*CONTROL-STACK-EXHAUSTION-SAP*
SB-KERNEL:*FREE-INTERRUPT-CONTEXT-INDEX*   ; bound
SB-KERNEL:*GC-INHIBIT*  ; do not touch directly.  accessors may be broke too
SB-KERNEL:*NEED-TO-COLLECT-GARBAGE*
SB-KERNEL:*ALREADY-MAYBE-GCING*
SB-KERNEL:*PSEUDO-ATOMIC-INTERRUPTED* ; bound
SB-KERNEL::*GC-TRIGGER*  ; I think this is dead, check
SB-IMPL::*CURRENT-UNWIND-PROTECT-BLOCK* ; thread-local
SB-IMPL::*READ-ONLY-SPACE-FREE-POINTER*
SB-VM::*ALIEN-STACK*  ; bound in create_thread_struct()

SB-IMPL::*OBJECTS-PENDING-FINALIZATION*  ; needs locking for writers

*AFTER-GC-HOOKS*     ; must be global
*GC-RUN-TIME*
SB-INT:*N-BYTES-FREED-OR-PURIFIED*

Note also the following may need attention
SB-PROFILE::TOTAL-CONSED
GET-BYTES-CONSED (fbound)
BYTES-CONSED-BETWEEN-GCS (fbound)


= backend constants

These are believed to be constant (in the general sense, not necessarily
eligible for defconstant).  Mostly they're attributes of the backend machine


SB-C:*BACKEND-REGISTER-SAVE-PENALTY*
SB-C:*BACKEND-BYTE-ORDER*
SB-VM:*PRIMITIVE-OBJECTS*
SB-VM:*ASSEMBLY-UNIT-LENGTH*
SB-VM::*FP-CONSTANT-L2E*
SB-VM::*FLOAT-REGISTER-NAMES*
SB-VM::*FP-CONSTANT-1L0*
SB-VM::*BYTE-REGISTER-NAMES*
SB-VM::*DWORD-SC-NAMES*
SB-VM::*FP-CONSTANT-1F0*
SB-VM::*WORD-REGS*
SB-VM::*BYTE-SC-NAMES*
SB-VM::*DEFAULT-ADDRESS-SIZE*
SB-VM::*FP-CONSTANT-0D0*
SB-VM::*FP-CONSTANT-LG2*
SB-VM::*FP-CONSTANT-L2T*
SB-VM::*DWORD-REGS*
SB-VM::*WORD-REGISTER-NAMES*
SB-VM::*FP-CONSTANT-0F0*
SB-VM::*FLOAT-SC-NAMES*
SB-VM::*FLOAT-REGS*
SB-VM::*DWORD-REGISTER-NAMES*
SB-VM::*WORD-SC-NAMES*
SB-VM::*FP-CONSTANT-PI*
SB-VM::*BYTE-REGS*
SB-VM::*FP-CONSTANT-1D0*
SB-VM::*DOUBLE-SC-NAMES*
SB-VM::*FP-CONSTANT-0L0*
SB-VM::*REGISTER-ARG-OFFSETS*
SB-VM::*FLOAT-TRAP-ALIST*
SB-VM::*DWORD-REG-NAMES*
SB-VM::*BYTE-REG-NAMES*
SB-VM::*ROUNDING-MODE-ALIST*
SB-VM::*REGISTER-ARG-NAMES*
SB-VM::*FIXNUM-PRIMITIVE-TYPE*
SB-VM:*STATIC-FUNS*
SB-VM::*FP-CONSTANT-LN2*
SB-VM::*WORD-REG-NAMES*
SB-KERNEL::*BUILT-IN-CLASSES*

= dead stuff

------------------------------------------------------------------------

= unclassified

SB-ALIEN-INTERNALS:*VALUES-TYPE-OKAY*
SB-ALIEN::ALIEN-*-TYPE-TRANSLATOR
SB-ALIEN::*DSO-LINKER*
SB-ALIEN::*HANDLES-FROM-DLOPEN*
SB-ALIEN::*ALIEN-TYPE-CLASSES*
SB-ALIEN::*RECORD-TYPES-ALREADY-UNPARSED*
SB-ALIEN::*NEW-AUXILIARY-TYPES*
SB-ALIEN::*DSO-LINKER-OPTIONS*
SB-ALIEN::*METHOD-SLOT-ALIST*

SB-VM::*SIGNED-IMM-BYTE-PREFILTER-WRAPPER*
SB-VM::*DISPLACEMENT-PRINTER-WRAPPER*
SB-VM::*ACCUM-PRINTER-WRAPPER*
SB-VM::*WIDTH-PRINTER-WRAPPER*
SB-VM::*LABEL-1-PREFILTER-WRAPPER*
SB-VM::*WORD-ACCUM-PRINTER-WRAPPER*
SB-VM::*NUM-FIXUPS*
SB-VM::*SIGNED-IMM-DATA-PREFILTER-WRAPPER*
SB-VM::*FIXNUM-PRIMITIVE-TYPE*
SB-VM::*CONDITIONS*
SB-VM::*IGNORE-AFTER*
SB-VM::*IMM-WORD-PREFILTER-WRAPPER*
SB-VM::*REGISTER-ARG-TNS*
SB-VM::*IMM-DATA-PREFILTER-WRAPPER*
SB-VM::*PRIMITIVE-TYPE-AUX-CACHE-VECTOR* ; threadsafe
SB-VM::*LABEL-2-PREFILTER-WRAPPER*
SB-VM::*ROOM-INFO*
SB-VM::*ADJUSTABLE-VECTORS* ; under **WORLD-LOCK** - should be done better
SB-VM::*CONDITION-NAME-VEC*
SB-VM::*IMM-WORD-16-PREFILTER-WRAPPER*
SB-VM::*SIMPLE-ARRAY-PRIMITIVE-TYPES*
SB-VM::*MAYBE-USE-INLINE-ALLOCATION*
SB-VM::*SIGNED-IMM-DWORD-PREFILTER-WRAPPER*
SB-VM::*IMMEDIATE-TYPES*

SB-KERNEL:*WILD-TYPE*                                   ; readonly
SB-KERNEL:*UNPARSE-FUN-TYPE-SIMPLIFY*
SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*
SB-KERNEL:*UNIVERSAL-FUN-TYPE*
SB-KERNEL:*UNIVERSAL-TYPE*                              ; readonly
SB-KERNEL:*HANDLER-CLUSTERS*                            ; bound per-thread
SB-KERNEL:*EMPTY-TYPE*                                  ; readonly
SB-KERNEL:*MAXIMUM-ERROR-DEPTH*
SB-KERNEL:*CONDITION-RESTARTS*                                  ; bound per-thread
SB-KERNEL:*TYPE-SYSTEM-INITIALIZED*
SB-KERNEL:*RESTART-CLUSTERS*                            ; bound per-thread
SB-KERNEL::*MAKE-VALUES-TYPE-CACHED-CACHE-VECTOR*       ; threadsafe
SB-KERNEL::*BUILT-IN-CLASS-CODES*                       ; readonly
SB-KERNEL::*DEF!STRUCT-TYPE-MAKE-LOAD-FORM-FUN*
SB-KERNEL::*LAYOUT-CLOS-HASH-RANDOM-STATE*
SB-KERNEL::*TYPE-TEST-ORDERING*
SB-KERNEL::*COMMON-TYPESPECS*
SB-KERNEL::*TYPE=-CACHE-VECTOR*                         ; threadsafe
SB-KERNEL::*VALUES-SUBTYPEP-CACHE-VECTOR*               ; threadsafe
SB-KERNEL::*TYPECHECKFUNS*
SB-KERNEL::*%TYPE-INTERSECTION-CACHE-VECTOR*            ; threadsafe
SB-KERNEL::*TYPE-INTERSECTION2-CACHE-VECTOR*            ; threadsafe
SB-KERNEL::*COLD-INIT-FORMS*
SB-KERNEL::*DEFAULT-DEFAULT*
SB-KERNEL::*RAW-SLOT-DATA-LIST*
SB-KERNEL::*SPECIALIZED-ARRAY-ELEMENT-TYPES*            ; readonly
SB-KERNEL::*DEFSTRUCT-HOOKS*
SB-KERNEL::*VALUES-TYPE-UNION-CACHE-VECTOR*             ; threadsafe
SB-KERNEL::*INTERNAL-ERRORS*
SB-KERNEL::*VALUES-TYPE-INTERSECTION-CACHE-VECTOR*      ; threadsafe
SB-KERNEL::*FORWARD-REFERENCED-LAYOUTS*
SB-KERNEL::*SYSTEM-LETS*                                ; bound
SB-KERNEL::*%COERCE-TO-VALUES-CACHE-VECTOR*             ; threadsafe
SB-KERNEL::*IGNORABLE-VARS*
SB-KERNEL::*ENV-VAR*                                    ; bound
SB-KERNEL::|*%%MAKE-UNION-TYPE-cached-CACHE-VECTOR*|    ; threadsafe
SB-KERNEL::*CSUBTYPEP-CACHE-VECTOR*                     ; threadsafe
SB-KERNEL::*EMPTY-CONDITION-SLOT*
SB-KERNEL::*TYPE-UNION2-CACHE-VECTOR*                   ; threadsafe
SB-KERNEL::*TYPE-CLASS-FUN-SLOTS*
SB-KERNEL::*ARG-TESTS*                                  ; bound
SB-KERNEL::*USER-LETS*                                  ; bound
SB-KERNEL::|*%%MAKE-ARRAY-TYPE-cached-CACHE-VECTOR*|    ; threadsafe
SB-KERNEL::*FINDING-NAME*
SB-KERNEL::*TYPE-CLASSES*
SB-KERNEL::*VALUES-SPECIFIER-TYPE-CACHE-VECTOR*         ; threadsafe
SB-KERNEL::*FLOAT-FORMATS*                              ; readonly
SB-KERNEL::*INTERNAL-ERROR-ARGS*
SB-KERNEL::*DEF!STRUCT-SUPERTYPE*
SB-KERNEL::*%TYPE-UNION-CACHE-VECTOR*                   ; threadsafe
SB-KERNEL::*CTYPE-OF-CACHE-VECTOR*                      ; threadsafe

SB-IMPL::*READ-BUFFER*  ; safe when used via WITH-READ-BUFFER
SB-IMPL::*SECONDARY-ATTRIBUTE-TABLE* ; now *CONSTITUENT-TRAIT-TABLE*, constant
SB-IMPL::*STANDARD-READTABLE*
SB-IMPL::*ERROR-ERROR-DEPTH*
SB-IMPL::*CURRENT-ERROR-DEPTH*
SB-IMPL::*INTERNAL-REAL-TIME-BASE-SECONDS*
SB-IMPL::*OFFENDING-DATUM*
SB-IMPL::*HANDLERS-INSTALLED*
SB-IMPL::*HASH-TABLE-TESTS*
SB-IMPL::*ATTRIBUTE-NAMES*
SB-IMPL::*CHARACTER-ATTRIBUTES*
SB-IMPL::*UNIX-HOST*
SB-IMPL::*DESCRIPTOR-HANDLERS*
SB-IMPL::*STRING-OUTPUT-STREAMS*
SB-IMPL::*CLOSE-ON-ERROR*
SB-IMPL::*BQ-COMMA-FLAG*                                ; readonly
SB-IMPL::*PROFILE-HASH-CACHE* ; not threadsafe, but don't care- debug only
SB-IMPL::*FIXNUM-POWER--1*
SB-IMPL::*SHARP-EQUAL-CIRCLE-TABLE*
SB-IMPL::*SOFTWARE-INTERRUPT-VECTOR*        ; suspect unused
SB-IMPL::*INSPECT-UNBOUND-OBJECT-MARKER*
SB-IMPL::*IN-PACKAGE-INIT*
SB-IMPL::*DELAYED-DEF!METHOD-ARGS*
SB-IMPL::*GENTEMP-COUNTER*
SB-IMPL::*CLOSE-IN-PARENT*
SB-IMPL::*IN-COMPILATION-UNIT*
SB-IMPL::*CIRCULARITY-HASH-TABLE*
SB-IMPL::*LOAD-PRINT-STUFF*
SB-IMPL::*ACTIVE-PROCESSES*
SB-IMPL::*SHARP-SHARP-ALIST*
SB-IMPL::*LOGICAL-PATHNAME-DEFAULTS*
SB-IMPL::*AVAILABLE-BUFFERS*
SB-IMPL::*BQ-DOT-FLAG*                          ; readonly
SB-IMPL::*CIRCULARITY-COUNTER*
SB-IMPL::*DIGITS*
SB-IMPL::*BQ-VECTOR-FLAG*                       ; readonly
SB-IMPL::*LOGICAL-HOSTS*
SB-IMPL::*PACKAGE-NAMES*
SB-IMPL::*INSPECT-FUN*
SB-IMPL::*OUTPUT-ROUTINES*
SB-IMPL::*CHAR-NAME-ALIST*
SB-IMPL::*VALID-FUN-NAMES-ALIST*
SB-IMPL::*PERIODIC-POLLING-FUNCTION*
SB-IMPL::*ABORTED-COMPILATION-UNIT-COUNT*
SB-IMPL::*INTERNAL-SYMBOL-OUTPUT-FUN* ; FIXME: printer not threadsafe
SB-IMPL::*BACKQUOTE-COUNT*                      ; bound
SB-IMPL::*DIGIT-BASES*
SB-IMPL::*PREVIOUS-DRIBBLE-STREAMS*
SB-IMPL::*MAX-EVENT-TO-USEC*
SB-IMPL::*INPUT-ROUTINES*
SB-IMPL::*MAX-EVENT-TO-SEC*
SB-IMPL::*OLD-PACKAGE*
SB-IMPL::*ERROR-THROW-UP-COUNT*
SB-IMPL::*BQ-AT-FLAG*                           ; readonly
SB-IMPL::*MACHINE-VERSION*   ; unset/unbound ?  are we using this?
SB-IMPL::*IGNORE-WILDCARDS*
SB-IMPL::*SHARP-EQUAL-ALIST*

*INLINE-EXPANSION-LIMIT*
*DERIVE-FUNCTION-TYPES*
*ENCLOSING-SOURCE-CUTOFF*
*INSPECTED*
*UNDEFINED-WARNING-LIMIT*
*EFFICIENCY-NOTE-COST-THRESHOLD*
*EFFICIENCY-NOTE-LIMIT*
*USE-IMPLEMENTATION-TYPES*
*INTEXP-MAXIMUM-EXPONENT*
*GENSYM-COUNTER*
*MACROEXPAND-HOOK*
*RANDOM-STATE*

SB-INT:*CL-PACKAGE*                     ; readonly
SB-INT:*KEYWORD-PACKAGE*                ; readonly
SB-INT:*SETF-FDEFINITION-HOOK*
SB-INT:*DEFAULT-INIT-CHAR-FORM*
SB-INT:*EOF-OBJECT*                     ; readonly
SB-INT:*AFTER-SAVE-INITIALIZATIONS*
SB-INT:*LOAD-SOURCE-DEFAULT-TYPE*
SB-INT:*BEFORE-SAVE-INITIALIZATIONS*
SB-INT:*INFO-ENVIRONMENT*               ; threadsafe
