+
+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 (as we may soon
+ do for e.g. SB-SYS:*TASK-SELF*). 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 acquitision/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
+
+The PCL authors thought a bit about thread safety, adding
+(without-interrupts ...) in some places to protect critical forms.
+We've implemented their without-interrupts macro as an acquitision of
+*pcl-lock*, so we hope they've done it properly.
+
+SB-PCL::*STRUCTURE-TYPEP-COST*
+SB-PCL::*SLOT-NAME-LISTS-OUTER*
+SB-PCL::*THE-WRAPPER-OF-T*
+SB-PCL::*CREATE-CLASSES-FROM-INTERNAL-STRUCTURE-DEFINITIONS-P*
+SB-PCL::*WRITERS-FOR-THIS-DEFCLASS*
+SB-PCL::*BOOT-STATE*
+SB-PCL::*THE-WRAPPER-OF-BIT-VECTOR*
+SB-PCL::*EFFECTIVE-METHOD-TABLE*
+SB-PCL::*THE-WRAPPER-OF-COMPLEX-DOUBLE-FLOAT*
+SB-PCL::*THE-CLASS-COMPLEX-DOUBLE-FLOAT*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SINGLE-FLOAT*
+SB-PCL::*CACHE-LOOKUP-COST*
+SB-PCL::*SLOT-NAME-LISTS-INNER*
+SB-PCL::*MF2P*
+SB-PCL::*THE-CLASS-RATIONAL*
+SB-PCL::WRAPPER-CLASS*
+SB-PCL::*PREVIOUS-NWRAPPERS*
+SB-PCL::*MF1*
+SB-PCL::*THE-CLASS-STANDARD-OBJECT*
+SB-PCL::*THE-CLASS-CONDITION-DIRECT-SLOT-DEFINITION*
+SB-PCL::*THE-CLASS-RATIO*
+SB-PCL::*SHOW-MAKE-UNORDERED-METHODS-EMF-CALLS*
+SB-PCL::*ALL-CTORS*
+SB-PCL::*SUBTYPEP
+SB-PCL::*THE-WRAPPER-OF-LRA*
+SB-PCL::*INITFUNCTIONS-FOR-THIS-DEFCLASS*
+SB-PCL::*STANDARD-SLOT-VALUE-USING-CLASS-METHOD*
+SB-PCL::*EMPTY-PV*
+SB-PCL::*CACHE-EXPAND-THRESHOLD*
+SB-PCL::*THE-CLASS-INTEGER*
+SB-PCL::*SGF-DFUN-STATE-INDEX*
+SB-PCL::*ALL-PV-TABLE-LIST*
+SB-PCL::*THE-WRAPPER-OF-RANDOM-CLASS*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT*
+SB-PCL::*THE-CLASS-FDEFN*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-32*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-VECTOR*
+SB-PCL::*CHECK-CACHE-P*
+SB-PCL::*SGF-WRAPPER*
+SB-PCL::*CONDITION-SLOT-VALUE-USING-CLASS-METHOD*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-BIT-VECTOR*
+SB-PCL::*THE-CLASS-SPECIALIZER*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT*
+SB-PCL::*THE-CLASS-STANDARD-CLASS*
+SB-PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD*
+SB-PCL::*THE-CLASS-STANDARD-READER-METHOD*
+SB-PCL::*THE-WRAPPER-OF-DOUBLE-FLOAT*
+SB-PCL::*NON-BUILT-IN-TYPEP-COST*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-8*
+SB-PCL::*THE-CLASS-DOCUMENTATION-MIXIN*
+SB-PCL::*EMF-CALL-TRACE-SIZE*
+SB-PCL::*OLD-C-A-M-GF-METHODS*
+SB-PCL::*EMPTY-CACHE*
+SB-PCL::*THE-WRAPPER-OF-SYMBOL*
+SB-PCL::*THE-CLASS-STANDARD-METHOD-COMBINATION*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-DOUBLE-FLOAT*
+SB-PCL::*THE-CLASS-METHOD*
+SB-PCL::*PRECOMPILING-LAP*
+SB-PCL::*STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD*
+SB-PCL::*ENABLE-DFUN-CONSTRUCTOR-CACHING*
+SB-PCL::*THE-CLASS-CONDITION-EFFECTIVE-SLOT-DEFINITION*
+SB-PCL::*THE-WRAPPER-OF-STRUCTURE-OBJECT*
+SB-PCL::*THE-CLASS-WEAK-POINTER*
+SB-PCL::*STANDARD-SLOT-BOUNDP-USING-CLASS-METHOD*
+SB-PCL::*THE-CLASS-FUNCALLABLE-STANDARD-OBJECT*
+SB-PCL::*VAR-DECLARATIONS-WITH-ARG*
+SB-PCL::*PV-TABLE-CACHE-UPDATE-INFO*
+SB-PCL::*THE-WRAPPER-OF-STRING*
+SB-PCL::*THE-CLASS-CONDITION*
+SB-PCL::*THE-CLASS-PCL-CLASS*
+SB-PCL::*THE-CLASS-CLASS*
+SB-PCL::*PCL-LOCK* ; protecting the rest
+SB-PCL::*EARLY-P*
+SB-PCL::*PCL-CLASS-BOOT*
+SB-PCL::*THE-CLASS-EFFECTIVE-SLOT-DEFINITION*
+SB-PCL::*THE-WRAPPER-OF-CONS*
+SB-PCL::*THE-CLASS-LRA*
+SB-PCL::*THE-CLASS-EQL-SPECIALIZER*
+SB-PCL::*EQL-SPECIALIZER-METHODS*
+SB-PCL::*THE-WRAPPER-OF-FLOAT*
+SB-PCL::*INITIAL-PV-TABLE*
+SB-PCL::*THE-CLASS-COMPLEX-SINGLE-FLOAT*
+SB-PCL::*STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD*
+SB-PCL::*EMF-CALL-TRACE*
+SB-PCL::*IN-OBSOLETE-INSTANCE-TRAP*
+SB-PCL::*BUILT-IN-CLASS-SYMBOLS*
+SB-PCL::*FREE-HASH-TABLES*
+SB-PCL::*THE-WRAPPER-OF-WEAK-POINTER*
+SB-PCL::*THE-CLASS-RANDOM-CLASS*
+SB-PCL::*PVS*
+SB-PCL::*THE-WRAPPER-OF-REAL*
+SB-PCL::*LONG-METHOD-COMBINATION-FUNCTIONS*
+SB-PCL::*EMIT-FUNCTION-P*
+SB-PCL::*THE-CLASS-DOUBLE-FLOAT*
+SB-PCL::*NAME->CLASS->SLOTD-TABLE*
+SB-PCL::*DFUN-COUNT*
+SB-PCL::*COMPUTE-STD-CPL-CLASS->ENTRY-TABLE-SIZE*
+SB-PCL::*THE-CLASS-SYMBOL*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-16*
+SB-PCL::*THE-CLASS-STANDARD-DIRECT-SLOT-DEFINITION*
+SB-PCL::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
+SB-PCL::*THE-CLASS-FLOAT*
+SB-PCL::*THE-CLASS-BASE-CHAR*
+SB-PCL::*PV-KEY-TO-PV-TABLE-TABLE*
+SB-PCL::*THE-CLASS-STD-CLASS*
+SB-PCL::*THE-CLASS-SLOT-OBJECT*
+SB-PCL::*OPTIMIZE-SPEED*
+SB-PCL::*THE-CLASS-STRUCTURE-EFFECTIVE-SLOT-DEFINITION*
+SB-PCL::*VAR-DECLARATIONS-WITHOUT-ARG*
+SB-PCL::*THE-CLASS-INSTANCE*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-4*
+SB-PCL::*THE-CLASS-CONS*
+SB-PCL::*THE-WRAPPER-OF-FIXNUM*
+SB-PCL::*THE-SYSTEM-II-METHOD*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-8*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-16*
+SB-PCL::*THE-WRAPPER-OF-COMPLEX-SINGLE-FLOAT*
+SB-PCL::*THE-WRAPPER-OF-SINGLE-FLOAT*
+SB-PCL::*DFUN-MISS-GFS-ON-STACK*
+SB-PCL::*THE-CLASS-CONDITION-CLASS*
+SB-PCL::*THE-WRAPPER-OF-BIGNUM*
+SB-PCL::*THE-CLASS-SPECIALIZER-WITH-OBJECT*
+SB-PCL::*THE-CLASS-COMPLEX*
+SB-PCL::*THE-WRAPPER-OF-INTEGER*
+SB-PCL::*CONDITION-SLOT-BOUNDP-USING-CLASS-METHOD*
+SB-PCL::*THE-CLASS-CHARACTER*
+SB-PCL::*EARLY-CLASS-DEFINITIONS*
+SB-PCL::*THE-WRAPPER-OF-NULL*
+SB-PCL::*INTERNAL-PCL-GENERALIZED-FUN-NAME-SYMBOLS*
+SB-PCL::*THE-CLASS-STRUCTURE-CLASS*
+SB-PCL::*UNSPECIFIC-ARG*
+SB-PCL::*SECONDARY-DFUN-CALL-COST*
+SB-PCL::*THE-CLASS-SIMPLE-STRING*
+SB-PCL::*THE-CLASS-STRUCTURE-SLOT-DEFINITION*
+SB-PCL::*METHOD-FUNCTION-PLIST*
+SB-PCL::*STANDARD-METHOD-COMBINATION*
+SB-PCL::*LAZY-DFUN-COMPUTE-P*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-8*
+SB-PCL::*THE-CLASS-STRING*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-2*
+SB-PCL::*EQL-SPECIALIZER-TABLE*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT*
+SB-PCL::*BUILT-IN-WRAPPER-SYMBOLS*
+SB-PCL::*THE-CLASS-STREAM*
+SB-PCL::*CLASS-EQ-SPECIALIZER-METHODS*
+SB-PCL::*THE-CLASS-REAL*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-32*
+SB-PCL::*THE-CLASS-SIMPLE-VECTOR*
+SB-PCL::*THE-CLASS-GENERIC-FUNCTION*
+SB-PCL::*STANDARD-SETF-SLOT-VALUE-USING-CLASS-METHOD*
+SB-PCL::*STD-CAM-METHODS*
+SB-PCL::*THE-CLASS-STRUCTURE-DIRECT-SLOT-DEFINITION*
+SB-PCL::*THE-WRAPPER-OF-FDEFN*
+SB-PCL::*THE-WRAPPER-OF-VECTOR*
+SB-PCL::*THE-CLASS-NULL*
+SB-PCL::*NORMALIZE-TYPE
+SB-PCL::*REBOUND-EFFECTIVE-METHOD-GENSYMS*
+SB-PCL::*THE-CLASS-NUMBER*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-STRING*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-30*
+SB-PCL::*MF2CP*
+SB-PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-32*
+SB-PCL::*THE-CLASS-VECTOR*
+SB-PCL::*FIND-CLASS*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-16*
+SB-PCL::*STANDARD-SLOT-LOCATIONS*
+SB-PCL::*FGENS*
+SB-PCL::*PCL-PACKAGE*
+SB-PCL::*THE-CLASS-ARRAY*
+SB-PCL::*CASE-TABLE-LIMIT*
+SB-PCL::*THE-CLASS-METHOD-COMBINATION*
+SB-PCL::*THE-CLASS-DIRECT-SLOT-DEFINITION*
+SB-PCL::*THE-CLASS-FIXNUM*
+SB-PCL::*THE-CLASS-STD-OBJECT*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-32*
+SB-PCL::*EARLY-CLASS-PREDICATES*
+SB-PCL::*WRAPPER-OF-COST*
+SB-PCL::*STANDARD-CLASSES*
+SB-PCL::*THE-CLASS-LONG-METHOD-COMBINATION*
+SB-PCL::*READERS-FOR-THIS-DEFCLASS*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-30*
+SB-PCL::*EMF-CALL-TRACE-INDEX*
+SB-PCL::*BUILT-IN-TYPEP-COST*
+SB-PCL::*THE-CLASS-STANDARD-SLOT-DEFINITION*
+SB-PCL::*THE-CLASS-PLIST-MIXIN*
+SB-PCL::*CONDITION-SETF-SLOT-VALUE-USING-CLASS-METHOD*
+SB-PCL::*THE-CLASS-BIGNUM*
+SB-PCL::*THE-WRAPPER-OF-CODE-COMPONENT*
+SB-PCL::*THE-ESLOTD-STANDARD-CLASS-SLOTS*
+SB-PCL::*SLOT-NAMES-FOR-THIS-DEFCLASS*
+SB-PCL::*THE-CLASS-FUNCTION*
+SB-PCL::*THE-WRAPPER-OF-SYSTEM-AREA-POINTER*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY*
+SB-PCL::*THE-CLASS-STANDARD-EFFECTIVE-SLOT-DEFINITION*
+SB-PCL::*THE-WRAPPER-OF-SEQUENCE*
+SB-PCL::*THE-CLASS-FUNCALLABLE-STANDARD-CLASS*
+SB-PCL::*THE-CLASS-SYSTEM-AREA-POINTER*
+SB-PCL::*THE-WRAPPER-OF-LIST*
+SB-PCL::*THE-CLASS-BUILT-IN-CLASS*
+SB-PCL::*STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-4*
+SB-PCL::*THE-CLASS-SIMPLE-BIT-VECTOR*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT*
+SB-PCL::*GLOBAL-EFFECTIVE-METHOD-GENSYMS*
+SB-PCL::*DFUN-CONSTRUCTORS*
+SB-PCL::*THE-CLASS-CODE-COMPONENT*
+SB-PCL::*THE-CLASS-STANDARD-WRITER-METHOD*
+SB-PCL::*NON-VAR-DECLARATIONS*
+SB-PCL::*IN-PRECOMPUTE-EFFECTIVE-METHODS-P*
+SB-PCL::*CHECKING-OR-CACHING-LIST*
+SB-PCL::*THE-CLASS-BIT-VECTOR*
+SB-PCL::*THE-WRAPPER-OF-CHARACTER*
+SB-PCL::*THE-WRAPPER-OF-COMPLEX*
+SB-PCL::*BUILT-IN-CLASSES*
+SB-PCL::*ALLOW-EXPERIMENTAL-SPECIALIZERS-P*
+SB-PCL::*ALLOW-EMF-CALL-TRACING-P*
+SB-PCL::*SGF-METHOD-CLASS-INDEX*
+SB-PCL::*SGF-METHODS-INDEX*
+SB-PCL::*THE-WRAPPER-OF-NUMBER*
+SB-PCL::*THE-WRAPPER-OF-RATIO*
+SB-PCL::*RAISE-METATYPES-TO-CLASS-P*
+SB-PCL::*EARLY-CLASS-SLOTS*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY*
+SB-PCL::*MF1CP*
+SB-PCL::*THE-WRAPPER-OF-RATIONAL*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-16*
+SB-PCL::*THE-WRAPPER-OF-ARRAY*
+SB-PCL::*THE-ESLOTD-FUNCALLABLE-STANDARD-CLASS-SLOTS*
+SB-PCL::*THE-CLASS-SLOT-CLASS*
+SB-PCL::*THE-CLASS-SLOT-DEFINITION*
+SB-PCL::*OPTIMIZE-CACHE-FUNCTIONS-P*
+SB-PCL::*MF2*
+SB-PCL::*THE-CLASS-SEQUENCE*
+SB-PCL::*EQ-CASE-TABLE-LIMIT*
+SB-PCL::*THE-CLASS-STRUCTURE-OBJECT*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-DOUBLE-FLOAT*
+SB-PCL::*SLOT-VECTOR-SYMBOLS*
+SB-PCL::*ENABLE-EMF-CALL-TRACING-P*
+SB-PCL::*THE-CLASS-SINGLE-FLOAT*
+SB-PCL::*THE-SYSTEM-SI-METHOD*
+SB-PCL::*THE-WRAPPER-OF-BASE-CHAR*
+SB-PCL::*THE-CLASS-CONDITION-SLOT-DEFINITION*
+SB-PCL::*DFUN-LIST*
+SB-PCL::*THE-CLASS-STANDARD-METHOD*
+SB-PCL::*DFUN-ARG-SYMBOLS*
+SB-PCL::*NOT-IN-CACHE*
+SB-PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD*
+SB-PCL::*THE-CLASS-LIST*
+SB-PCL::*NEW-CLASS*
+SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-8*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-2*
+SB-PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
+SB-PCL::*THE-CLASS-FUNCALLABLE-INSTANCE*
+SB-PCL::*IN-GF-ARG-INFO-P*
+SB-PCL::*THE-CLASS-STANDARD-GENERIC-FUNCTION*
+SB-PCL::*SGF-ARG-INFO-INDEX*
+SB-PCL::*ALLOW-FORWARD-REFERENCED-CLASSES-IN-CPL-P*
+SB-PCL::*THE-CLASS-FORWARD-REFERENCED-CLASS*
+SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SINGLE-FLOAT*
+SB-PCL::*MF1P*
+SB-PCL::*MINIMUM-CACHE-SIZE-TO-LIST*
+SB-PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
+SB-PCL::*THE-CLASS-T*
+SB-PCL::*CACHE-MISS-VALUES-STACK*
+SB-PCL::*SGF-NAME-INDEX*
+SB-PCL::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
+SB-PCL::*SGF-SLOTS-INIT*
+
+
+= 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::*CACHED-FORM-NUMBER-TRANSLATIONS*
+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::*FORM-NUMBER-TEMP*
+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*
+*ERROR-PRINT-LENGTH*
+*ERROR-PRINT-LINES*
+*READ-EVAL*
+*PRINT-ESCAPE*
+*TRACE-OUTPUT*
+SB-IMPL::*INSPECT-LENGTH*
+*ERROR-PRINT-LEVEL*
+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
+
+*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*
+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::*ALL-COMPONENTS*
+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::*CURRENT-CATCH-BLOCK*
+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*
+SB-VM:*STATIC-SYMBOLS*
+SB-VM:*CONTROL-STACK-START* ; bound at thread entry
+SB-VM:*READ-ONLY-SPACE-FREE-POINTER*
+SB-VM:*BINDING-STACK-START*
+SB-VM:*CONTROL-STACK-END*
+SB-VM::*CURRENT-UNWIND-PROTECT-BLOCK*
+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*
+SB-IMPL::*CURRENT-CATCH-BLOCK*
+SB-IMPL::*READ-ONLY-SPACE-FREE-POINTER*
+SB-VM::*ALIEN-STACK*
+
+*GC-NOTIFY-STREAM* ; going away
+*BEFORE-GC-HOOKS* ; must be global
+*AFTER-GC-HOOKS* ; ditto
+*GC-NOTIFY-AFTER* ; going away
+*GC-NOTIFY-BEFORE* ; going away
+*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
+
+SB-SYS:*TASK-NOTIFY* ; unused
+SB-SYS:*TASK-SELF* ; unused
+SB-SYS:*TASK-DATA* ; unused
+SB-SYS:*TYPESCRIPTPORT* ' unused
+SB-THREAD::*FOREGROUND-THREAD-STACK* ; unused, I think
+
+
+
+
+------------------------------------------------------------------------
+
+= 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*
+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*
+SB-KERNEL:*HANDLER-CLUSTERS*
+SB-KERNEL:*EMPTY-TYPE*
+SB-KERNEL:*MAXIMUM-ERROR-DEPTH*
+SB-KERNEL:*CONDITION-RESTARTS*
+SB-KERNEL:*TYPE-SYSTEM-INITIALIZED*
+SB-KERNEL:*RESTART-CLUSTERS*
+SB-KERNEL::*MAKE-VALUES-TYPE-CACHED-CACHE-VECTOR*
+SB-KERNEL::*BUILT-IN-CLASS-CODES*
+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*
+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*
+SB-KERNEL::*%COERCE-TO-VALUES-CACHE-VECTOR*
+SB-KERNEL::*IGNORABLE-VARS*
+SB-KERNEL::*ENV-VAR*
+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*
+SB-KERNEL::*USER-LETS*
+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*
+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*
+SB-IMPL::*SECONDARY-ATTRIBUTE-TABLE*
+SB-IMPL::*STANDARD-READTABLE*
+SB-IMPL::*OUCH-PTR*
+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*
+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*
+SB-IMPL::*PRINT-OBJECT-IS-DISABLED-P*
+SB-IMPL::*MERGE-SORT-TEMP-VECTOR*
+SB-IMPL::*PROFILE-HASH-CACHE*
+SB-IMPL::*FIXNUM-POWER--1*
+SB-IMPL::*OBJECTS-PENDING-FINALIZATION*
+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::*ZAP-ARRAY-DATA-TEMP*
+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*
+SB-IMPL::*CIRCULARITY-COUNTER*
+SB-IMPL::*DIGITS*
+SB-IMPL::*PREVIOUS-READTABLE-CASE*
+SB-IMPL::*BQ-VECTOR-FLAG*
+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*
+SB-IMPL::*BACKQUOTE-COUNT*
+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*
+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*
+SB-IMPL::*MACHINE-VERSION* ; unset/unbound ? are we using this?
+SB-IMPL::*IGNORE-WILDCARDS*
+SB-IMPL::*INCH-PTR*
+SB-IMPL::*SHARP-EQUAL-ALIST*
+SB-IMPL::*PREVIOUS-CASE*
+
+*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-BIGNUM::*TRUNCATE-Y*
+SB-BIGNUM::*TRUNCATE-X*
+
+SB-INT:*CL-PACKAGE*
+SB-INT:*KEYWORD-PACKAGE*
+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*