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-PROLOGUE*
SB-LOOP::*LOOP-SOURCE-CODE*
SB-LOOP::*LOOP-MINIMAX-TYPE-INFINITIES-ALIST* 
SB-LOOP::*LOOP-NAMES*
SB-LOOP::*LOOP-BODY*
SB-LOOP::*LOOP-AFTER-BODY*
SB-LOOP::*LOOP-DESETQ-CROCKS*
SB-LOOP::*LOOP-EPILOGUE*
SB-LOOP::*LOOP-EMITTED-BODY*
SB-LOOP::*LOOP-NEVER-STEPPED-VAR*
SB-LOOP::*LOOP-NAMED-VARS*
SB-LOOP::*LOOP-ITERATION-VARS*
SB-LOOP::*LOOP-WHEN-IT-VAR*
SB-LOOP::*LOOP-BEFORE-LOOP*
SB-LOOP::*ESTIMATE-CODE-SIZE-PUNT* 
SB-LOOP::*LOOP-WRAPPERS*
SB-LOOP::*LOOP-DESETQ-TEMPORARY* 
SB-LOOP::*LOOP-MACRO-ENVIRONMENT*
SB-LOOP::*LOOP-VARS*
SB-LOOP::*IGNORES*
SB-LOOP::*LOOP-SOURCE-CONTEXT*
SB-LOOP::*LOOP-AFTER-EPILOGUE*
SB-LOOP::*LOOP-DECLARATIONS*
SB-LOOP::*LOOP-FINAL-VALUE-CULPRIT*
SB-LOOP::*LOOP-COLLECTION-CRUFT*
SB-LOOP::*SPECIAL-CODE-SIZES* 
SB-LOOP::*LOOP-UNIVERSE*
SB-LOOP::*LOOP-DUPLICATE-CODE* 
SB-LOOP::*LOOP-INSIDE-CONDITIONAL*
SB-LOOP::*LOOP-ORIGINAL-SOURCE-CODE*
SB-LOOP::*LOOP-ITERATION-FLAG-VAR* 
SB-LOOP::*LOOP-ANSI-UNIVERSE* 
SB-LOOP::*LOOP-BIND-STACK*

= 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::*FOREIGN-SYMBOLS-BY-ADDR* 
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)

(defparameter *format-whitespace-chars*
(defvar *format-directive-expanders*
(defvar *format-directive-interpreters*
(defvar *default-format-error-control-string* nil)
(defvar *default-format-error-offset* nil)
SB-FORMAT::*CARDINAL-ONES* ; readonly
SB-FORMAT::*CARDINAL-TENS* 
SB-FORMAT::*CARDINAL-TEENS* 
SB-FORMAT::*ORDINAL-ONES* 
SB-FORMAT::*ORDINAL-TENS* 
SB-FORMAT::*CARDINAL-PERIODS* 
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

Note that INFO functions use a shared cache for the globaldb, and
don't lock for cache invalidation. This will need fixing when BCL is
removed.

*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:*ASSEMBLY-OPTIMIZE* 
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:*SETF-ASSUMED-FBOUNDP* 
SB-C:*FREE-FUNS*
SB-C:*BACKEND-DISASSEM-PARAMS*
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::*BACKEND-SUPPORT-ROUTINES* 
SB-C::*COMPILED-CODE-LOCATION-KINDS* 
SB-C::*VOP-TN-REFS* 
SB-C::*INFO-CACHE-VECTOR* 
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* 
SB-C::*CACHED-INFO-ENVIRONMENT* 
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::*BACKEND-META-SC-NAMES* 
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::*META-PRIMITIVE-TYPE-NAMES*
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* 
SB-C::*-DERIVE-TYPE-AUX 
SB-C::*BLOCK-COMPILE*
SB-C::*BIG-COMPILER-LOCK*                ; protecting the rest
SB-C::*VM-SUPPORT-ROUTINES* 
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::*ARGS* 
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::*BACKEND-META-SC-NUMBERS* 
SB-C::*FLAME-ON-NECESSARILY-UNDEFINED-FUNCTION* 
SB-C::*UNPACK-FALLBACK-EVENT-INFO* 
SB-C::*SOURCE-INFO* 
SB-C::*LIVE-BLOCK*
SB-C::*BACKEND-META-PRIMITIVE-TYPE-NAMES* 
SB-C::*NEXT-LOCATION*
SB-C::*ELSEWHERE-LABEL* 
SB-C::*SOURCE-PATHS*
SB-C::*CONSTANTS*
SB-C::*BACKEND-META-SB-NAMES* 
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::*INFO-CLASSES* 
SB-C::*RESULT-FIXUPS*
SB-C::*REPACK-BLOCKS*
SB-C::IR1-CONVERT-LET* 
SB-C::*CODE-VECTOR*
SB-C::*FREE-VARS*
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::*BURP-ACTION* 
SB-C::*UNWINNAGE-DETECTED*
SB-C::*ID-TNS* 

= fasloader

SB-FASL:*STATIC-FOREIGN-SYMBOLS* 
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-C:*BACKEND-INSTRUCTION-FORMATS* 
SB-C:*BACKEND-INSTRUCTION-FLAVORS* 
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::*FUN-HEADER-WIDETAGS* 
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* 
SB-VM::*LABEL-2-PREFILTER-WRAPPER* 
SB-VM::*ROOM-INFO* 
SB-VM::*ADJUSTABLE-VECTORS* 
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:*COLD-INIT-COMPLETE-P* 
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* 
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* 
SB-KERNEL::*VALUES-SUBTYPEP-CACHE-VECTOR* 
SB-KERNEL::*TYPECHECKFUNS* 
SB-KERNEL::*%TYPE-INTERSECTION-CACHE-VECTOR* 
SB-KERNEL::*TYPE-INTERSECTION2-CACHE-VECTOR* 
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* 
SB-KERNEL::*INTERNAL-ERRORS* 
SB-KERNEL::*VALUES-TYPE-INTERSECTION-CACHE-VECTOR* 
SB-KERNEL::*FORWARD-REFERENCED-LAYOUTS* 
SB-KERNEL::*SYSTEM-LETS*                                ; bound
SB-KERNEL::*%COERCE-TO-VALUES-CACHE-VECTOR* 
SB-KERNEL::*IGNORABLE-VARS*
SB-KERNEL::*ENV-VAR*                                    ; bound
SB-KERNEL::|*%%MAKE-UNION-TYPE-cached-CACHE-VECTOR*| 
SB-KERNEL::*CSUBTYPEP-CACHE-VECTOR* 
SB-KERNEL::*EMPTY-CONDITION-SLOT* 
SB-KERNEL::*TYPE-UNION2-CACHE-VECTOR* 
SB-KERNEL::*TYPE-CLASS-FUN-SLOTS* 
SB-KERNEL::*ARG-TESTS*                                  ; bound
SB-KERNEL::*USER-LETS*                                  ; bound
SB-KERNEL::|*%%MAKE-ARRAY-TYPE-cached-CACHE-VECTOR*| 
SB-KERNEL::*FINDING-NAME* 
SB-KERNEL::*TYPE-CLASSES* 
SB-KERNEL::*VALUES-SPECIFIER-TYPE-CACHE-VECTOR* 
SB-KERNEL::*FLOAT-FORMATS*                              ; readonly
SB-KERNEL::*INTERNAL-ERROR-ARGS*
SB-KERNEL::*DEF!STRUCT-SUPERTYPE* 
SB-KERNEL::*%TYPE-UNION-CACHE-VECTOR* 
SB-KERNEL::*CTYPE-OF-CACHE-VECTOR* 

SB-IMPL::*READ-BUFFER*  ; FIXME: non-threadsafe
SB-IMPL::*SECONDARY-ATTRIBUTE-TABLE* 
SB-IMPL::*STANDARD-READTABLE* 
SB-IMPL::*OUCH-PTR*  ; FIXME: non-threadsafe
SB-IMPL::*ERROR-ERROR-DEPTH* 
SB-IMPL::*CURRENT-ERROR-DEPTH* 
SB-IMPL::*INTERNAL-REAL-TIME-BASE-SECONDS* 
SB-IMPL::*DAYLIGHT-TABLE* 
SB-IMPL::*OFFENDING-DATUM*
SB-IMPL::*HANDLERS-INSTALLED* 
SB-IMPL::*READ-FROM-STRING-SPARES* 
SB-IMPL::*HASH-TABLE-TESTS* 
SB-IMPL::*ATTRIBUTE-NAMES* 
SB-IMPL::*DAYS-BEFORE-MONTH*                            ; readonly
SB-IMPL::*CHARACTER-ATTRIBUTES* 
SB-IMPL::*UNIX-HOST* 
SB-IMPL::*DESCRIPTOR-HANDLERS* 
SB-IMPL::*STRING-OUTPUT-STREAMS* 
SB-IMPL::*CLOSE-ON-ERROR* 
SB-IMPL::*INTEGER-READER-SAFE-DIGITS* 
SB-IMPL::*TIMEZONE-TABLE* 
SB-IMPL::*BQ-COMMA-FLAG*                                ; readonly
SB-IMPL::*PRINT-OBJECT-IS-DISABLED-P*
SB-IMPL::*PROFILE-HASH-CACHE* 
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::*BASE-POWER* 
SB-IMPL::*LOGICAL-PATHNAME-DEFAULTS* 
SB-IMPL::*AVAILABLE-BUFFERS* 
SB-IMPL::*BQ-DOT-FLAG*                          ; readonly
SB-IMPL::*CIRCULARITY-COUNTER* 
SB-IMPL::*DIGITS* 
SB-IMPL::*PREVIOUS-READTABLE-CASE* ; FIXME: printer not threadsafe
SB-IMPL::*BQ-VECTOR-FLAG*                       ; readonly
SB-IMPL::*ABBREV-WEEKDAY-TABLE* 
SB-IMPL::*LOGICAL-HOSTS* 
SB-IMPL::*PACKAGE-NAMES* 
SB-IMPL::*INSPECT-FUN* 
SB-IMPL::*ABBREV-MONTH-TABLE* 
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::*LONG-WEEKDAY-TABLE* 
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::*READ-BUFFER-LENGTH* ; FIXME: not threadsafe
SB-IMPL::*LONG-MONTH-TABLE* 
SB-IMPL::*OLD-PACKAGE* 
SB-IMPL::*INTEGER-READER-BASE-POWER* 
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::*INCH-PTR*  ; FIXME: non-threadsafe
SB-IMPL::*SHARP-EQUAL-ALIST* 
SB-IMPL::*PREVIOUS-CASE* ; FIXME: printer not threadsafe

*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* 
SB-INT:*AFTER-SAVE-INITIALIZATIONS* 
SB-INT:*LOAD-SOURCE-DEFAULT-TYPE* 
SB-INT:*BEFORE-SAVE-INITIALIZATIONS* 
SB-INT:*INFO-ENVIRONMENT*