doc/internals-notes/threading-specials

   1 Things in SBCL that look like special variables (list created by
   2 (apropos "*")) and could conceivably indicate potental thread safety
   3 issues.  Organised by functional area.
   4
   5 The goals are
   6
   7         (1) classify the unclassified symbols (in such a way as to
   8         make sense for 2)
   9
  10         (2) read through the subsystems identified looking for places
  11         where global state is mutated.  Use this list of symbols as a
  12         guide, but be open to the possibility that other state
  13         (e.g. closures, foreign variables) is touched too.
  14
  15         When looking at a particular symbol, please annotate it in
  16         this file when you figure out what it's for and how it's
  17         changed. To give us some confidence that we have reasonable
  18         coverage, please don't just delete it if it looks ok. Symbols
  19         shoud only be deleted here if they're obviously not specials
  20         at all (e.g. functions with * in their names), or if the same
  21         commit actually rids SBCL of the symbol itself. Otherwise,
  22         just add a comment saying "read-only" or "unused" or whatever.
  23
  24         (3) anything else that comes to mind as potential trouble
  25         spots.  Global state in closures, etc etc
  26
  27         (4) suggest strategies (e.g. rewrites of affected code, suitable
  28         locks and lock acquisition/release places) to fix the issues
  29         revealed in (2) and (3)
  30
  31         (5) implement same
  32
  33         Candidates may attempt any of the above simultaneously.
  34         Points will be awarded for style
  35
  36
  37 Summary so far:
  38
  39 = loop
  40 = PCL            (probably ok if PCL authors did *without-interrupts* right)
  41 = debugger
  42 = profiler
  43 = disassembler
  44 = assembler       (I assume protected by *big-compiler-lock*)
  45 = unix interface  (apparently ok)
  46 = toplevel/environment stuff
  47 = the formatter & pretty printer  (two vars need checking)
  48 = compiler        (protected by *big-compiler-lock*)
  49 = fasloader       (protected by *big-compiler-lock*)
  50 = runtime stuff - gc, control stacks, interrupts etc
  51 = backend constants
  52 = dead
  53 = unclassified
  54
  55 ==================
  56
  57 = loop
  58
  59 I suspect that stuff in sb-loop is only ever frobbed at
  60 macroexpand/compile time anyway, so covered by *big-compiler-lock*.
  61 Haven't thought about this too hard, though
  62
  63 SB-LOOP::*LOOP-BODY*
  64 SB-LOOP::*LOOP-DESETQ-TEMPORARY*
  65 SB-LOOP::*LOOP-INSIDE-CONDITIONAL*
  66 SB-LOOP::*LOOP-EPILOGUE*
  67 SB-LOOP::*LOOP-ANSI-UNIVERSE*
  68
  69 = PCL
  70
  71 Critical parts of PCL are protected by *world-lock* (particularly
  72 those dealing with class graph changes), and some with finer-grained locks.
  73
  74 accesses locked with a nice granularity
  75    SB-PCL::*CLASSOID-CELLS*
  76
  77 read-only & safe:
  78    SB-PCL::*BUILT-IN-TYPEP-COST*
  79    SB-PCL::*CACHE-EXPAND-THRESHOLD*
  80    SB-PCL::*CACHE-LOOKUP-COST*
  81    SB-PCL::*CASE-TABLE-LIMIT*
  82    SB-PCL::*CHECK-CACHE-P*
  83    SB-PCL::*COMPUTE-STD-CPL-CLASS->ENTRY-TABLE-SIZE*
  84    SB-PCL::*EQ-CASE-TABLE-LIMIT*
  85    SB-PCL::*NON-BUILT-IN-TYPEP-COST*
  86    SB-PCL::*NON-VAR-DECLARATIONS*
  87    SB-PCL::*SECONDARY-DFUN-CALL-COST*
  88    SB-PCL::*SGF-WRAPPER*
  89    SB-PCL::*STRUCTURE-TYPEP-COST*
  90    SB-PCL::*UNSPECIFIC-ARG*
  91    SB-PCL::*VAR-DECLARATIONS-WITH-ARG*
  92    SB-PCL::*WRAPPER-OF-COST*
  93
  94 bound & safe:
  95    SB-PCL::*ALLOW-FORWARD-REFERENCED-CLASSES-IN-CPL-P*
  96    SB-PCL::*IN-OBSOLETE-INSTANCE-TRAP*
  97    SB-PCL::*PRECOMPILING-LAP*
  98    SB-PCL::*CACHE-MISS-VALUES-STACK*
  99
 100 protected by PCL-LOCK:
 101    SB-PCL::*PREVIOUS-NWRAPPERS*
 102
 103 believed protected by the compiler-lock:
 104    SB-PCL::*ALL-CTORS*
 105    SB-PCL::*FGENS*
 106    SB-PCL::*SGF-DFUN-STATE-INDEX*
 107    SB-PCL::*VAR-DECLARATIONS-WITHOUT-ARG*
 108
 109 potentially unsafe:
 110    SB-PCL::*CLASS-EQ-SPECIALIZER-METHODS*
 111    SB-PCL::*EFFECTIVE-METHOD-CACHE*
 112    SB-PCL::*EQL-SPECIALIZER-METHODS*
 113    SB-PCL::*METHOD-FUNCTION-PLIST*
 114    SB-PCL::*PV-KEY-TO-PV-TABLE-TABLE*
 115    SB-PCL::*PV-TABLE-CACHE-UPDATE-INFO*
 116    SB-PCL::*PVS*
 117    SB-PCL::*SLOT-NAME-LISTS-INNER*
 118    SB-PCL::*SLOT-NAME-LISTS-OUTER*
 119
 120 debugging / profiling -- low relevance:
 121    SB-PCL::*DFUN-COUNT*
 122    SB-PCL::*ALLOW-EMF-CALL-TRACING-P*
 123
 124 build-options and bootstrap machinery -- irrelevant for user-code:
 125    SB-PCL::*ALLOW-EXPERIMENTAL-SPECIALIZERS-P*
 126    SB-PCL::*BOOT-STATE* ; pseudoconstant in finished lisp (not in bootstrap)
 127    SB-PCL::*BUILT-IN-CLASS-SYMBOLS*
 128    SB-PCL::*BUILT-IN-CLASSES*
 129    SB-PCL::*BUILT-IN-WRAPPER-SYMBOLS*
 130    SB-PCL::*CHECKING-OR-CACHING-LIST*
 131
 132 ;;; global, frobbed on generic function
 133 ;;; initialization/reinitialization, method precomputation, and
 134 ;;; compute-effective-method.  Potentially unsafe, may be OK because
 135 ;;; of *pcl-lock*, but could easily be liable to races.
 136
 137 SB-PCL::*CONDITION-SETF-SLOT-VALUE-USING-CLASS-METHOD*
 138 SB-PCL::*CONDITION-SLOT-BOUNDP-USING-CLASS-METHOD*
 139 SB-PCL::*CONDITION-SLOT-VALUE-USING-CLASS-METHOD*
 140 SB-PCL::*CREATE-CLASSES-FROM-INTERNAL-STRUCTURE-DEFINITIONS-P*
 141 SB-PCL::*DFUN-ARG-SYMBOLS*
 142 SB-PCL::*DFUN-CONSTRUCTORS*
 143 SB-PCL::*DFUN-LIST*
 144 SB-PCL::*DFUN-MISS-GFS-ON-STACK*
 145 SB-PCL::*EARLY-CLASS-DEFINITIONS*
 146 SB-PCL::*EARLY-CLASS-PREDICATES*
 147 SB-PCL::*EARLY-CLASS-SLOTS*
 148 SB-PCL::*EARLY-P*
 149 SB-PCL::*EMF-CALL-TRACE*
 150 SB-PCL::*EMF-CALL-TRACE-INDEX*
 151 SB-PCL::*EMF-CALL-TRACE-SIZE*
 152 SB-PCL::*EMIT-FUNCTION-P*
 153 SB-PCL::*ENABLE-DFUN-CONSTRUCTOR-CACHING*
 154 SB-PCL::*ENABLE-EMF-CALL-TRACING-P*
 155 SB-PCL::*EQL-SPECIALIZER-TABLE*
 156 SB-PCL::*GLOBAL-EFFECTIVE-METHOD-GENSYMS*
 157 SB-PCL::*IN-GF-ARG-INFO-P*
 158 SB-PCL::*IN-PRECOMPUTE-EFFECTIVE-METHODS-P*
 159 SB-PCL::*INITFUNCTIONS-FOR-THIS-DEFCLASS*
 160 SB-PCL::*INTERNAL-PCL-GENERALIZED-FUN-NAME-SYMBOLS*
 161 SB-PCL::*LAZY-DFUN-COMPUTE-P*
 162 SB-PCL::*LONG-METHOD-COMBINATION-FUNCTIONS*
 163 SB-PCL::*MINIMUM-CACHE-SIZE-TO-LIST*
 164 SB-PCL::*NAME->CLASS->SLOTD-TABLE*
 165 SB-PCL::*NEW-CLASS*
 166 SB-PCL::*NORMALIZE-TYPE
 167 SB-PCL::*NOT-IN-CACHE*
 168 SB-PCL::*OLD-C-A-M-GF-METHODS*
 169 SB-PCL::*OPTIMIZE-CACHE-FUNCTIONS-P*
 170 SB-PCL::*OPTIMIZE-SPEED*
 171 SB-PCL::*PCL-CLASS-BOOT*
 172 SB-PCL::*PCL-LOCK*                         ; protecting the rest
 173 SB-PCL::*PCL-PACKAGE*
 174 SB-PCL::*RAISE-METATYPES-TO-CLASS-P*
 175 SB-PCL::*READERS-FOR-THIS-DEFCLASS*
 176 SB-PCL::*REBOUND-EFFECTIVE-METHOD-GENSYMS*
 177 SB-PCL::*SGF-ARG-INFO-INDEX*
 178 SB-PCL::*SGF-METHOD-CLASS-INDEX*
 179 SB-PCL::*SGF-METHODS-INDEX*
 180 SB-PCL::*SGF-NAME-INDEX*
 181 SB-PCL::*SGF-SLOTS-INIT*
 182 SB-PCL::*SHOW-MAKE-UNORDERED-METHODS-EMF-CALLS*
 183 SB-PCL::*SLOT-NAMES-FOR-THIS-DEFCLASS*
 184 SB-PCL::*SLOT-VECTOR-SYMBOLS*
 185 SB-PCL::*STANDARD-CLASSES*
 186 SB-PCL::*STANDARD-METHOD-COMBINATION*
 187 SB-PCL::*STANDARD-SETF-SLOT-VALUE-USING-CLASS-METHOD*
 188 SB-PCL::*STANDARD-SLOT-BOUNDP-USING-CLASS-METHOD*
 189 SB-PCL::*STANDARD-SLOT-LOCATIONS*
 190 SB-PCL::*STANDARD-SLOT-VALUE-USING-CLASS-METHOD*
 191 SB-PCL::*STD-CAM-METHODS*
 192 SB-PCL::*STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD*
 193 SB-PCL::*STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD*
 194 SB-PCL::*STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD*
 195 SB-PCL::*SUBTYPEP
 196 SB-PCL::*THE-CLASS-ARRAY*
 197 SB-PCL::*THE-CLASS-BASE-CHAR*
 198 SB-PCL::*THE-CLASS-BIGNUM*
 199 SB-PCL::*THE-CLASS-BIT-VECTOR*
 200 SB-PCL::*THE-CLASS-BUILT-IN-CLASS*
 201 SB-PCL::*THE-CLASS-CHARACTER*
 202 SB-PCL::*THE-CLASS-CLASS*
 203 SB-PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
 204 SB-PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
 205 SB-PCL::*THE-CLASS-CODE-COMPONENT*
 206 SB-PCL::*THE-CLASS-COMPLEX*
 207 SB-PCL::*THE-CLASS-COMPLEX-DOUBLE-FLOAT*
 208 SB-PCL::*THE-CLASS-COMPLEX-SINGLE-FLOAT*
 209 SB-PCL::*THE-CLASS-CONDITION*
 210 SB-PCL::*THE-CLASS-CONDITION-CLASS*
 211 SB-PCL::*THE-CLASS-CONDITION-DIRECT-SLOT-DEFINITION*
 212 SB-PCL::*THE-CLASS-CONDITION-EFFECTIVE-SLOT-DEFINITION*
 213 SB-PCL::*THE-CLASS-CONDITION-SLOT-DEFINITION*
 214 SB-PCL::*THE-CLASS-CONS*
 215 SB-PCL::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
 216 SB-PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
 217 SB-PCL::*THE-CLASS-DIRECT-SLOT-DEFINITION*
 218 SB-PCL::*THE-CLASS-DOCUMENTATION-MIXIN*
 219 SB-PCL::*THE-CLASS-DOUBLE-FLOAT*
 220 SB-PCL::*THE-CLASS-EFFECTIVE-SLOT-DEFINITION*
 221 SB-PCL::*THE-CLASS-EQL-SPECIALIZER*
 222 SB-PCL::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
 223 SB-PCL::*THE-CLASS-FDEFN*
 224 SB-PCL::*THE-CLASS-FIXNUM*
 225 SB-PCL::*THE-CLASS-FLOAT*
 226 SB-PCL::*THE-CLASS-FORWARD-REFERENCED-CLASS*
 227 SB-PCL::*THE-CLASS-FUNCALLABLE-INSTANCE*
 228 SB-PCL::*THE-CLASS-FUNCALLABLE-STANDARD-CLASS*
 229 SB-PCL::*THE-CLASS-FUNCALLABLE-STANDARD-OBJECT*
 230 SB-PCL::*THE-CLASS-FUNCTION*
 231 SB-PCL::*THE-CLASS-GENERIC-FUNCTION*
 232 SB-PCL::*THE-CLASS-INSTANCE*
 233 SB-PCL::*THE-CLASS-INTEGER*
 234 SB-PCL::*THE-CLASS-LIST*
 235 SB-PCL::*THE-CLASS-LONG-METHOD-COMBINATION*
 236 SB-PCL::*THE-CLASS-LRA*
 237 SB-PCL::*THE-CLASS-METHOD*
 238 SB-PCL::*THE-CLASS-METHOD-COMBINATION*
 239 SB-PCL::*THE-CLASS-NULL*
 240 SB-PCL::*THE-CLASS-NUMBER*
 241 SB-PCL::*THE-CLASS-PCL-CLASS*
 242 SB-PCL::*THE-CLASS-PLIST-MIXIN*
 243 SB-PCL::*THE-CLASS-RANDOM-CLASS*
 244 SB-PCL::*THE-CLASS-RATIO*
 245 SB-PCL::*THE-CLASS-RATIONAL*
 246 SB-PCL::*THE-CLASS-REAL*
 247 SB-PCL::*THE-CLASS-SEQUENCE*
 248 SB-PCL::*THE-CLASS-SIMPLE-ARRAY*
 249 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT*
 250 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT*
 251 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-DOUBLE-FLOAT*
 252 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-16*
 253 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-30*
 254 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-32*
 255 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SIGNED-BYTE-8*
 256 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-SINGLE-FLOAT*
 257 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-16*
 258 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-2*
 259 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-32*
 260 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-4*
 261 SB-PCL::*THE-CLASS-SIMPLE-ARRAY-UNSIGNED-BYTE-8*
 262 SB-PCL::*THE-CLASS-SIMPLE-BIT-VECTOR*
 263 SB-PCL::*THE-CLASS-SIMPLE-STRING*
 264 SB-PCL::*THE-CLASS-SIMPLE-VECTOR*
 265 SB-PCL::*THE-CLASS-SINGLE-FLOAT*
 266 SB-PCL::*THE-CLASS-SLOT-CLASS*
 267 SB-PCL::*THE-CLASS-SLOT-DEFINITION*
 268 SB-PCL::*THE-CLASS-SLOT-OBJECT*
 269 SB-PCL::*THE-CLASS-SPECIALIZER*
 270 SB-PCL::*THE-CLASS-SPECIALIZER-WITH-OBJECT*
 271 SB-PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD*
 272 SB-PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD*
 273 SB-PCL::*THE-CLASS-STANDARD-CLASS*
 274 SB-PCL::*THE-CLASS-STANDARD-DIRECT-SLOT-DEFINITION*
 275 SB-PCL::*THE-CLASS-STANDARD-EFFECTIVE-SLOT-DEFINITION*
 276 SB-PCL::*THE-CLASS-STANDARD-GENERIC-FUNCTION*
 277 SB-PCL::*THE-CLASS-STANDARD-METHOD*
 278 SB-PCL::*THE-CLASS-STANDARD-METHOD-COMBINATION*
 279 SB-PCL::*THE-CLASS-STANDARD-OBJECT*
 280 SB-PCL::*THE-CLASS-STANDARD-READER-METHOD*
 281 SB-PCL::*THE-CLASS-STANDARD-SLOT-DEFINITION*
 282 SB-PCL::*THE-CLASS-STANDARD-WRITER-METHOD*
 283 SB-PCL::*THE-CLASS-STD-CLASS*
 284 SB-PCL::*THE-CLASS-STD-OBJECT*
 285 SB-PCL::*THE-CLASS-STREAM*
 286 SB-PCL::*THE-CLASS-STRING*
 287 SB-PCL::*THE-CLASS-STRUCTURE-CLASS*
 288 SB-PCL::*THE-CLASS-STRUCTURE-DIRECT-SLOT-DEFINITION*
 289 SB-PCL::*THE-CLASS-STRUCTURE-EFFECTIVE-SLOT-DEFINITION*
 290 SB-PCL::*THE-CLASS-STRUCTURE-OBJECT*
 291 SB-PCL::*THE-CLASS-STRUCTURE-SLOT-DEFINITION*
 292 SB-PCL::*THE-CLASS-SYMBOL*
 293 SB-PCL::*THE-CLASS-SYSTEM-AREA-POINTER*
 294 SB-PCL::*THE-CLASS-T*
 295 SB-PCL::*THE-CLASS-VECTOR*
 296 SB-PCL::*THE-CLASS-WEAK-POINTER*
 297 SB-PCL::*THE-ESLOTD-FUNCALLABLE-STANDARD-CLASS-SLOTS*
 298 SB-PCL::*THE-ESLOTD-STANDARD-CLASS-SLOTS*
 299 SB-PCL::*THE-SYSTEM-II-METHOD*
 300 SB-PCL::*THE-SYSTEM-SI-METHOD*
 301 SB-PCL::*THE-WRAPPER-OF-ARRAY*
 302 SB-PCL::*THE-WRAPPER-OF-BASE-CHAR*
 303 SB-PCL::*THE-WRAPPER-OF-BIGNUM*
 304 SB-PCL::*THE-WRAPPER-OF-BIT-VECTOR*
 305 SB-PCL::*THE-WRAPPER-OF-CHARACTER*
 306 SB-PCL::*THE-WRAPPER-OF-CODE-COMPONENT*
 307 SB-PCL::*THE-WRAPPER-OF-COMPLEX*
 308 SB-PCL::*THE-WRAPPER-OF-COMPLEX-DOUBLE-FLOAT*
 309 SB-PCL::*THE-WRAPPER-OF-COMPLEX-SINGLE-FLOAT*
 310 SB-PCL::*THE-WRAPPER-OF-CONS*
 311 SB-PCL::*THE-WRAPPER-OF-DOUBLE-FLOAT*
 312 SB-PCL::*THE-WRAPPER-OF-FDEFN*
 313 SB-PCL::*THE-WRAPPER-OF-FIXNUM*
 314 SB-PCL::*THE-WRAPPER-OF-FLOAT*
 315 SB-PCL::*THE-WRAPPER-OF-INTEGER*
 316 SB-PCL::*THE-WRAPPER-OF-LIST*
 317 SB-PCL::*THE-WRAPPER-OF-LRA*
 318 SB-PCL::*THE-WRAPPER-OF-NULL*
 319 SB-PCL::*THE-WRAPPER-OF-NUMBER*
 320 SB-PCL::*THE-WRAPPER-OF-RANDOM-CLASS*
 321 SB-PCL::*THE-WRAPPER-OF-RATIO*
 322 SB-PCL::*THE-WRAPPER-OF-RATIONAL*
 323 SB-PCL::*THE-WRAPPER-OF-REAL*
 324 SB-PCL::*THE-WRAPPER-OF-SEQUENCE*
 325 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY*
 326 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT*
 327 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT*
 328 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-DOUBLE-FLOAT*
 329 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-16*
 330 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-30*
 331 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-32*
 332 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SIGNED-BYTE-8*
 333 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-SINGLE-FLOAT*
 334 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-16*
 335 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-2*
 336 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-32*
 337 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-4*
 338 SB-PCL::*THE-WRAPPER-OF-SIMPLE-ARRAY-UNSIGNED-BYTE-8*
 339 SB-PCL::*THE-WRAPPER-OF-SIMPLE-BIT-VECTOR*
 340 SB-PCL::*THE-WRAPPER-OF-SIMPLE-STRING*
 341 SB-PCL::*THE-WRAPPER-OF-SIMPLE-VECTOR*
 342 SB-PCL::*THE-WRAPPER-OF-SINGLE-FLOAT*
 343 SB-PCL::*THE-WRAPPER-OF-STRING*
 344 SB-PCL::*THE-WRAPPER-OF-STRUCTURE-OBJECT*
 345 SB-PCL::*THE-WRAPPER-OF-SYMBOL*
 346 SB-PCL::*THE-WRAPPER-OF-SYSTEM-AREA-POINTER*
 347 SB-PCL::*THE-WRAPPER-OF-T*
 348 SB-PCL::*THE-WRAPPER-OF-VECTOR*
 349 SB-PCL::*THE-WRAPPER-OF-WEAK-POINTER*
 350 SB-PCL::*WRITERS-FOR-THIS-DEFCLASS*
 351 SB-PCL::WRAPPER-CLASS*
 352
 353
 354 = debugger
 355
 356 *DEBUG-PRINT-LENGTH*
 357 *TRACE-FRAME*
 358 *TRACE-ENCAPSULATE-DEFAULT*
 359 *MAX-TRACE-INDENTATION*
 360 *IN-THE-DEBUGGER*
 361 *DEBUG-BEGINNER-HELP-P*
 362 *STACK-TOP-HINT*
 363 *DEBUG-HELP-STRING*
 364 *ONLY-BLOCK-START-LOCATIONS*
 365 *FLUSH-DEBUG-ERRORS*
 366 *DEBUG-CONDITION*
 367 *TRACE-VALUES*
 368 *PRINT-LOCATION-KIND*
 369 *DEBUG-PRINT-LEVEL*
 370 *TRACED-FUN-LIST*
 371 *TRACE-INDENTATION-STEP*
 372 *DEBUG-READTABLE*
 373 SB-DEBUG::*CACHED-DEBUG-SOURCE*
 374 SB-DEBUG::*POSSIBLE-BREAKPOINTS*
 375 SB-DEBUG::*BAD-CODE-LOCATION-TYPES*
 376 SB-DEBUG::*TRACED-ENTRIES*
 377 SB-DEBUG::*DEBUG-COMMAND-LEVEL*
 378 SB-DEBUG::*CACHED-SOURCE-STREAM*
 379 SB-DEBUG::*DEBUG-LOOP-FUN*
 380 SB-DEBUG::*NESTED-DEBUG-CONDITION*
 381 SB-DEBUG::*STEP-BREAKPOINTS*
 382 SB-DEBUG::*DEBUG-RESTARTS*
 383 SB-DEBUG::*BREAKPOINTS*
 384 SB-DEBUG::*TRACED-FUNS*
 385 SB-DEBUG::*DEBUG-COMMANDS*
 386 SB-DEBUG::*DEFAULT-BREAKPOINT-DEBUG-FUN*
 387 SB-DEBUG::*CACHED-READTABLE*
 388 SB-DEBUG::*IN-TRACE*
 389 SB-DEBUG::*CACHED-TOPLEVEL-FORM-OFFSET*
 390 SB-DEBUG::*STACK-TOP*
 391 SB-DEBUG::*CURRENT-FRAME*
 392 SB-DEBUG::*CACHED-TOPLEVEL-FORM*
 393 SB-DEBUG::*NUMBER-OF-STEPS*
 394 SB-DEBUG::*REAL-STACK-TOP*
 395 SB-DI::*PARSING-BUFFER*
 396 SB-DI::*IR1-BLOCK-DEBUG-BLOCK*
 397 SB-DI::*OTHER-PARSING-BUFFER*
 398 SB-DI::*COMPILED-DEBUG-FUNS*
 399 SB-DI::*COMPONENT-BREAKPOINT-OFFSETS*
 400 SB-DI::*FUN-END-COOKIES*
 401 SB-DI::*FORM-NUMBER-CIRCULARITY-TABLE*
 402 SB-DI::*EXECUTING-BREAKPOINT-HOOKS*
 403 SB-DI::*IR1-LAMBDA-DEBUG-FUN*
 404
 405 = profiler
 406
 407 SB-PROFILE::*PROFILED-FUN-NAME->INFO*
 408 SB-PROFILE::*ENCLOSED-CONSING*
 409 SB-PROFILE::*COMPUTING-PROFILING-DATA-FOR*
 410 SB-PROFILE::*ENCLOSED-PROFILES*
 411 SB-PROFILE::*TIMER-OVERHEAD-ITERATIONS*
 412 SB-PROFILE::*OVERHEAD*
 413 SB-PROFILE::*ENCLOSED-TICKS*
 414
 415 = disassembler
 416
 417 SB-DISASSEM:*DISASSEM-INST-ALIGNMENT-BYTES*
 418 SB-DISASSEM:*DISASSEM-NOTE-COLUMN*
 419 SB-DISASSEM:*DEFAULT-DSTATE-HOOKS*
 420 SB-DISASSEM:*DISASSEM-OPCODE-COLUMN-WIDTH*
 421 SB-DISASSEM:*DISASSEM-SCHEDULER-P*
 422 SB-DISASSEM:*DISASSEM-LOCATION-COLUMN-WIDTH*
 423 SB-DISASSEM::*ARG-FUN-PARAMS*
 424 SB-DISASSEM::*ADDRESS-OF-NIL-OBJECT*
 425 SB-DISASSEM::*DISASSEM-INSTS*
 426 SB-DISASSEM::*DISASSEM-FUN-CACHE*
 427 SB-DISASSEM::*DISASSEM-INST-FORMATS*
 428 SB-DISASSEM::*GROKKED-SYMBOL-SLOTS*
 429 SB-DISASSEM::*ARG-FORM-KINDS*
 430 SB-DISASSEM::*DISASSEM-INST-SPACE*
 431 SB-DISASSEM::*CURRENT-INSTRUCTION-FLAVOR*
 432 SB-DISASSEM::*DISASSEM-ARG-TYPES*
 433 SB-DISASSEM::*ASSEMBLER-ROUTINES-BY-ADDR*
 434
 435 = assembler
 436
 437 Currently protected by *big-compiler-lock*.  Mostly uninvestigated
 438
 439 SB-ASSEM:*ASSEM-MAX-LOCATIONS*
 440 SB-ASSEM:*ASSEM-INSTRUCTIONS*
 441 SB-ASSEM:*ASSEM-SCHEDULER-P*
 442 SB-ASSEM::*INSTRUCTION-ATTRIBUTE-TRANSLATIONS*
 443 SB-ASSEM::**CURRENT-VOP**
 444 SB-ASSEM::**CURRENT-SEGMENT**
 445
 446
 447 = unix interface
 448
 449 Looks good to me
 450
 451 SB-UNIX::*INTERRUPTS-ENABLED*  ; ok,  bound
 452 SB-UNIX::*UNIX-SIGNALS*        ; ok, read-only
 453 SB-UNIX::*INTERRUPT-PENDING*  ; ok, bound
 454
 455 = toplevel/environment stuff
 456
 457 Some of these should probably be bound on thread entry.  I haven't
 458 checked them yet, except where indicated
 459
 460 *DEBUG-IO*
 461 SB-SYS:*TTY*
 462 SB-SYS:*STDIN*
 463 SB-SYS:*STDOUT*
 464 SB-SYS:*STDERR*
 465 SB-SYS:*LONG-SITE-NAME*    ; readonly
 466 SB-SYS:*SHORT-SITE-NAME*   ; readonly
 467 SB-SYS::*SOFTWARE-VERSION* ; readonly
 468 SB-THREAD::*SESSION-LOCK*  ; bound
 469 SB-THREAD::*BACKGROUND-THREADS-WAIT-FOR-DEBUGGER* ; intentionally global
 470 ***   ; bound
 471 **    ; bound
 472 *     ; bound
 473 *PRINT-PRETTY*
 474 *LOAD-VERBOSE*
 475 *LOAD-TRUENAME*
 476 *READ-BASE*
 477 *BREAK-ON-SIGNALS*
 478 *PRINT-READABLY*
 479 *PRINT-CIRCLE*
 480 *FEATURES*                     ; write at own risk
 481 *PRINT-BASE*
 482 *PACKAGE*
 483 *PRINT-RADIX*
 484 *READ-SUPPRESS*
 485 *ERROR-OUTPUT*
 486 *DEFAULT-PATHNAME-DEFAULTS*
 487 *LOAD-PATHNAME*
 488 *STANDARD-OUTPUT*
 489 *PRINT-RIGHT-MARGIN*
 490 *READTABLE*
 491 *PRINT-CASE*
 492 *PRINT-MISER-WIDTH*
 493 *PRINT-PPRINT-DISPATCH*
 494 *PRINT-LENGTH*
 495 *TERMINAL-IO*
 496 *PRINT-GENSYM*
 497 *QUERY-IO*
 498 *STANDARD-INPUT*
 499 *LOAD-PRINT*
 500 *DEBUGGER-HOOK*
 501 *PRINT-LINES*
 502 *PRINT-ESCAPE*
 503 *PRINT-LEVEL*
 504 *READ-EVAL*
 505 *PRINT-ESCAPE*
 506 *TRACE-OUTPUT*
 507 SB-IMPL::*INSPECT-LENGTH*
 508 SB-IMPL::*DRIBBLE-STREAM*         ; what to do with dribble in threaded lisp?
 509 SB-IMPL::*HELP-FOR-INSPECT*       ; read-only
 510 *PRINT-ARRAY*
 511
 512
 513
 514 *POSIX-ARGV*     ; read-only
 515 *READ-DEFAULT-FLOAT-FORMAT*   ; probably "change at own risk"
 516 *MODULES*   ; should be changed only by provide/require, needs locking
 517 *MODULE-PROVIDER-FUNCTIONS* ; probably "change at own risk"
 518 SB-IMPL::*REPL-FUN*
 519 SB-INT:*REPL-READ-FORM-FUN*
 520 SB-INT:*REPL-PROMPT-FUN*
 521
 522 = the formatter & pretty printer
 523
 524 == probably safe (readonly unless indicated)
 525
 526 (defparameter *format-whitespace-chars*
 527 (defvar *format-directive-expanders*
 528 (defvar *format-directive-interpreters*
 529 (defvar *default-format-error-control-string* nil)
 530 (defvar *default-format-error-offset* nil)
 531 SB-FORMAT::*CARDINAL-ONES* ; readonly
 532 SB-FORMAT::*CARDINAL-TENS*
 533 SB-FORMAT::*CARDINAL-TEENS*
 534 SB-FORMAT::*ORDINAL-ONES*
 535 SB-FORMAT::*ORDINAL-TENS*
 536 SB-FORMAT::*CARDINAL-PERIODS*
 537 SB-FORMAT::*ILLEGAL-INSIDE-JUSTIFICATION*
 538 SB-FORMAT::*OUTSIDE-ARGS* ; safe, bound
 539
 540
 541 (defvar *up-up-and-out-allowed* nil) ; safe, bound
 542 (defvar *logical-block-popper* nil) ; bound
 543 (defvar *expander-next-arg-macro* 'expander-next-arg) ; bound
 544 (defvar *orig-args-available* nil) ; bound
 545
 546 == needs checking
 547
 548 ;;; Used by the expander stuff. Initially starts as T, and gets set to NIL
 549 ;;; if someone needs to do something strange with the arg list (like use
 550 ;;; the rest, or something).  Setf in late-format, haven't checked if it's
 551 ;;; always in a bound context
 552 (defvar *only-simple-args*)
 553
 554 ;;; setf in late-format, haven't checked
 555 (defvar *simple-args*)
 556
 557 == haven't looked at yet
 558
 559 SB-PRETTY::*INITIAL-PPRINT-DISPATCH*
 560 SB-PRETTY::*BUILDING-INITIAL-TABLE*
 561 SB-PRETTY::*PRECOMPILED-PPRINT-DISPATCH-FUNS*
 562
 563
 564 = compiler
 565
 566 Note that the compiler and fasloader are strongly believed not to be
 567 thread-safe, so there is currently a big lock (*big-compiler-lock*)
 568 around all calls to the compiler or fasloader
 569
 570 INFO functions are currently believed to be multi-writer/reader threadsafe,
 571 though it's hard to know for sure since they were definitely read-safe,
 572 and writes are done only while holding **WORLD-LOCK** as things stand.
 573 The algorithms employed are used in at least one industrial-strength Lisp
 574 application, though a bug has been reported (to me, dougk) regarding
 575 the fasloader that might be related to INFO, or to the fasloader.
 576 Catch 22: can't expose threading bugs until lock is removed
 577           can't remove the lock until INFO is proven to be threadsafe.
 578
 579 *COMPILE-FILE-PATHNAME*
 580 *COMPILE-FILE-TRUENAME*
 581 *COMPILE-PRINT*
 582 *COMPILE-VERBOSE*
 583 *COMPILE-PROGRESS*
 584 SB-C:*BACKEND-INTERNAL-ERRORS*
 585 SB-C:*BACKEND-SPECIAL-ARG-TYPES*
 586 SB-C:*ASSEMBLY-OPTIMIZE*
 587 SB-C:*LEXENV*
 588 SB-C:*CODE-SEGMENT*
 589 SB-C:*COMPONENT-BEING-COMPILED*
 590 SB-C:*BACKEND-SB-NAMES*
 591 SB-C:*BACKEND-PAGE-SIZE*
 592 SB-C:*BACKEND-SC-NUMBERS*
 593 SB-C:*ELSEWHERE*
 594 SB-C:*BACKEND-T-PRIMITIVE-TYPE*
 595 SB-C:*BACKEND-SB-LIST*
 596 SB-C:*FREE-FUNS*
 597 SB-C:*BACKEND-SUBFEATURES*
 598 SB-C:*COUNT-VOP-USAGES*
 599 SB-C:*SUPPRESS-VALUES-DECLARATION*
 600 SB-C:*BACKEND-SC-NAMES*
 601 SB-C::*CURRENT-COMPONENT*
 602 SB-C::*SLOT-INHERIT-ALIST*
 603 SB-C::*COMPILER-NOTE-COUNT*
 604 SB-C::*BACKEND-PREDICATE-TYPES*
 605 SB-C::*POLICY*
 606 SB-C::*INLINEP-TRANSLATIONS*
 607 SB-C::*PACK-OPTIMIZE-SAVES*
 608 SB-C::*DELETION-IGNORED-OBJECTS*
 609 SB-C::*LAST-FORMAT-ARGS*
 610 SB-C::*CONSTANTS-BEING-CREATED*
 611 SB-C::*IGNORED-ERRORS*
 612 SB-C::*COMPILE-OBJECT*
 613 SB-C::*TN-IDS*
 614 SB-C::*LOSSAGE-FUN*
 615 SB-C::*COMPILER-ERROR-COUNT*
 616 SB-C::*EVENT-NOTE-THRESHOLD*
 617 SB-C::*LAST-MESSAGE-COUNT*
 618 SB-C::*EMIT-ASSEMBLY-CODE-NOT-VOPS-P*
 619 SB-C::*LAST-FORMAT-STRING*
 620 SB-C::*UNWINNAGE-FUN*
 621 SB-C::*COMPILER-ERROR-CONTEXT*
 622 SB-C::*SEEN-BLOCKS*
 623 SB-C::*TN-ID*
 624 SB-C::*IR1-OPTIMIZE-UNTIL-DONE-EVENT-INFO*
 625 SB-C::*SPECIALIZED-ARRAY-ELEMENT-TYPE-PROPERTIES*       ; readonly
 626 SB-C::*NUMBER-CONTINUATIONS*
 627 SB-C::*CTYPE-TEST-FUN*
 628 SB-C::*IGNORE-COST-VOPS*
 629 SB-C::*QUEUED-PROCLAIMS*
 630 SB-C::*COMPILER-STYLE-WARNING-COUNT*
 631 SB-C::*LABEL-IDS*
 632 SB-C::TN-NEXT*
 633 SB-C::*COMPILED-CODE-LOCATION-KINDS*
 634 SB-C::*VOP-TN-REFS*
 635 SB-C::*FAILURE-P*
 636 SB-C::*LAST-ORIGINAL-SOURCE*
 637 SB-C::NEXT*
 638 SB-C::LIST*-IR2-CONVERT-OPTIMIZER
 639 SB-C::*COMPILER-ERROR-BAILOUT*
 640 SB-C::*DELAYED-IR1-TRANSFORMS*
 641 SB-C::*INFO-TYPES* ; readonly
 642 SB-C::*CHECK-CONSISTENCY*
 643 SB-C::*SEEN-FUNS*
 644 SB-C::*USING-VOP-TN-REFS*
 645 SB-C::*MAKE-VALUE-CELL-EVENT-EVENT-INFO*
 646 SB-C::*IN-PACK*
 647 SB-C::*REPACK-BLOCK-EVENT-INFO*
 648 SB-C::*UNPACK-TN-EVENT-INFO*
 649 SB-C::*COALESCE-MORE-LTN-NUMBERS-EVENT-INFO*
 650 SB-C::*IN-COMPILATION-UNIT*
 651 SB-C::*BACKEND-TEMPLATE-NAMES*
 652 SB-C::*BACKEND-PRIMITIVE-TYPE-NAMES*
 653 SB-C::*CONSTRAINT-PROPAGATE*
 654 SB-C::*BACKEND-PRIMITIVE-TYPE-ALIASES*
 655 SB-C::*NO-COSTS*
 656 SB-C::*PACK-ASSIGN-COSTS*
 657 SB-C::*CURRENT-FORM-NUMBER*
 658 SB-C::*BLOCK-COMPILE-ARG*
 659 SB-C::*COMPILER-ERROR-PRINT-LENGTH*
 660 SB-C::*CONTINUATION-NUMBER*
 661 SB-C::*PREV-SEGMENT*
 662 SB-C::*CONTROL-DELETED-BLOCK-EVENT-INFO*
 663 SB-C::*ALLOW-DEBUG-CATCH-TAG*
 664 SB-C::*ID-LABELS*
 665 SB-C::*BACKEND-TYPE-PREDICATES*
 666 SB-C::*COMPILER-WARNING-COUNT*
 667 SB-C::*SUPPRESS-NOTE-VOPS*
 668 SB-C::*COMPILER-ERROR-PRINT-LEVEL*
 669 SB-C::*COMPLEMENT-TYPE-CHECKS*
 670 SB-C::*FUN-NAMES-IN-THIS-FILE*
 671 SB-C::*SPLIT-IR2-BLOCK-EVENT-INFO*
 672 SB-C::*TRACE-TABLE*
 673 SB-C::*LAST-SOURCE-FORM*
 674 SB-C::*WEAKEN-TYPE-CACHE-VECTOR*         ; threadsafe
 675 SB-C::*-DERIVE-TYPE-AUX
 676 SB-C::*BLOCK-COMPILE*
 677 SB-C::*BIG-COMPILER-LOCK*                ; protecting the rest
 678 SB-C::*PRIMITIVE-TYPE-SLOT-ALIST*
 679 SB-C::*PREVIOUS-LOCATION*
 680 SB-C::*BYTE-BUFFER*
 681 SB-C::*CONSTANTS-CREATED-SINCE-LAST-INIT*
 682 SB-C::*LAST-SOURCE-CONTEXT*
 683 SB-C::*FIXUPS*
 684 SB-C::VOP*
 685 SB-C::*REOPTIMIZE-MAXED-OUT-EVENT-INFO*
 686 SB-C::*LIST-CONFLICTS-TABLE*
 687 SB-C::*LOSSAGE-DETECTED*
 688 SB-C::*LAST-ERROR-CONTEXT*
 689 SB-C::*PREV-VOP*
 690 SB-C::*POLICY-DEPENDENT-QUALITIES*
 691 SB-C::*REOPTIMIZE-AFTER-TYPE-CHECK-MAX*
 692 SB-C::*-DERIVE-TYPE-OPTIMIZER
 693 SB-C::*IR1-ATTRIBUTE-TRANSLATIONS*
 694 SB-C::*ARGS*
 695 SB-C::*DYNAMIC-COUNTS-TN*
 696 SB-C::*EXTREME-NTHCDR-OPEN-CODE-LIMIT*
 697 SB-C::*BACKEND-PARSED-VOPS*
 698 SB-C::*ABORTED-COMPILATION-UNIT-COUNT*
 699 SB-C::*COPY-DELETED-MOVE-EVENT-INFO*
 700 SB-C::*MAX-OPTIMIZE-ITERATIONS*
 701 SB-C::*TOPLEVEL-LAMBDAS*
 702 SB-C::*SC-VOP-SLOTS*
 703 SB-C::*IR1-OPTIMIZE-MAXED-OUT-EVENT-INFO*
 704 SB-C::*CONTINUATION-NUMBERS*
 705 SB-C::*WARNINGS-P*
 706 SB-C::*FLAME-ON-NECESSARILY-UNDEFINED-FUNCTION*
 707 SB-C::*UNPACK-FALLBACK-EVENT-INFO*
 708 SB-C::*SOURCE-INFO*
 709 SB-C::*LIVE-BLOCK*
 710 SB-C::*NEXT-LOCATION*
 711 SB-C::*ELSEWHERE-LABEL*
 712 SB-C::*SOURCE-PATHS*
 713 SB-C::*CONSTANTS*
 714 SB-C::*DEFAULT-NTHCDR-OPEN-CODE-LIMIT*
 715 SB-C::*ALWAYS-OPTIMIZED-AWAY*
 716 SB-C::*CURRENT-PATH*
 717 SB-C::*LABEL-ID*
 718 SB-C::*ENTRY-POINTS*
 719 SB-C::*COMPILER-TRACE-OUTPUT*
 720 SB-C::*CONSTRAINT-NUMBER*
 721 SB-C::*RESULT-FIXUPS*
 722 SB-C::*REPACK-BLOCKS*
 723 SB-C::IR1-CONVERT-LET*
 724 SB-C::*CODE-VECTOR*
 725 SB-C::*FREE-VARS*
 726 SB-C::*SOURCE-CONTEXT-METHODS*
 727 SB-C::*VOP-ATTRIBUTE-TRANSLATIONS*
 728 SB-C::*COMPILER-ERROR-PRINT-LINES*
 729 SB-C::*LIVE-VOP*
 730 SB-C::*POLICY-QUALITIES*
 731 SB-C::*NO-LOADS*
 732 SB-C::*TRACE-TABLE-INFO*
 733 SB-C::*UNDEFINED-WARNINGS*
 734 SB-C::*BLOCK-ATTRIBUTE-TRANSLATIONS*
 735 SB-C::*EVENT-INFO*
 736 SB-C::*BURP-ACTION*
 737 SB-C::*UNWINNAGE-DETECTED*
 738 SB-C::*ID-TNS*
 739
 740 = fasloader
 741
 742 SB-FASL:*STATIC-FOREIGN-SYMBOLS*
 743 SB-FASL:*ASSEMBLER-ROUTINES*
 744 SB-FASL:*FASL-FILE-TYPE*
 745 SB-FASL::FOP-LIST*-4
 746 SB-FASL::*COLD-LOAD-DUMP*
 747 SB-FASL::FOP-LIST*-7
 748 SB-FASL::FOP-LIST*-8
 749 SB-FASL::FOP-LIST*-1
 750 SB-FASL::FOP-LIST*-2
 751 SB-FASL::*FASL-INPUT-STREAM*
 752 SB-FASL::*FOP-STACK*
 753 SB-FASL::*LOAD-DEPTH*
 754 SB-FASL::*FEATURES-AFFECTING-FASL-FORMAT*
 755 SB-FASL::*DUMP-ONLY-VALID-STRUCTURES*
 756 SB-FASL::*CURRENT-FOP-TABLE-SIZE*
 757 SB-FASL::*FOP-STACK-POINTER-ON-ENTRY*
 758 SB-FASL::*FREE-FOP-TABLES*
 759 SB-FASL::*LOAD-SYMBOL-BUFFER*
 760 SB-FASL::*FASL-HEADER-STRING-START-STRING*
 761 SB-FASL::DUMP-FOP*
 762 SB-FASL::FOP-LIST*
 763 SB-FASL::*CIRCULARITIES-DETECTED*
 764 SB-FASL::*LOAD-CODE-VERBOSE*
 765 SB-FASL::*FEATURES-POTENTIALLY-AFFECTING-FASL-FORMAT*
 766 SB-FASL::*LOAD-SYMBOL-BUFFER-SIZE*
 767 SB-FASL::*CURRENT-FOP-TABLE*
 768 SB-FASL::*FOP-STACK-POINTER*
 769 SB-FASL::*CURRENT-FOP-TABLE-INDEX*
 770 SB-FASL::*FOP-FUNS*
 771 SB-FASL::*CURRENT-UNWIND-PROTECT-BLOCK*
 772 SB-FASL::FOP-LIST*-5
 773 SB-FASL::*FOP-NAMES*
 774 SB-FASL::FOP-LIST*-6
 775 SB-FASL::FOP-LIST*-3
 776
 777
 778 = runtime stuff
 779
 780
 781 SB-VM:*STATIC-SPACE-FREE-POINTER*
 782 SB-VM:*INITIAL-DYNAMIC-SPACE-FREE-POINTER*
 783 SB-VM:*CURRENT-CATCH-BLOCK* ; bound at thread entry (in C)
 784 SB-VM:*STATIC-SYMBOLS*
 785 SB-VM:*CONTROL-STACK-START* ; safe, bound at thread entry
 786 SB-VM:*READ-ONLY-SPACE-FREE-POINTER*
 787 SB-VM:*BINDING-STACK-START* ; safe, bound at thread entry
 788 SB-VM:*CONTROL-STACK-END* ; safe, bound at thread entry
 789 SB-VM::*CURRENT-UNWIND-PROTECT-BLOCK*  ; bound at thread entry (in C)
 790 SB-VM::*FREE-TLS-INDEX*
 791 SB-VM::*BINDING-STACK-POINTER*
 792 SB-VM::*ALLOCATION-POINTER*    ; may be mostly unused ?
 793 SB-KERNEL:*PSEUDO-ATOMIC-ATOMIC*  ; bound
 794 SB-KERNEL:*CONTROL-STACK-EXHAUSTION-SAP*
 795 SB-KERNEL:*FREE-INTERRUPT-CONTEXT-INDEX*   ; bound
 796 SB-KERNEL:*GC-INHIBIT*  ; do not touch directly.  accessors may be broke too
 797 SB-KERNEL:*NEED-TO-COLLECT-GARBAGE*
 798 SB-KERNEL:*ALREADY-MAYBE-GCING*
 799 SB-KERNEL:*PSEUDO-ATOMIC-INTERRUPTED* ; bound
 800 SB-KERNEL::*GC-TRIGGER*  ; I think this is dead, check
 801 SB-IMPL::*CURRENT-UNWIND-PROTECT-BLOCK* ; thread-local
 802 SB-IMPL::*READ-ONLY-SPACE-FREE-POINTER*
 803 SB-VM::*ALIEN-STACK*  ; bound in create_thread_struct()
 804
 805 SB-IMPL::*OBJECTS-PENDING-FINALIZATION*  ; needs locking for writers
 806
 807 *AFTER-GC-HOOKS*     ; must be global
 808 *GC-RUN-TIME*
 809 SB-INT:*N-BYTES-FREED-OR-PURIFIED*
 810
 811 Note also the following may need attention
 812 SB-PROFILE::TOTAL-CONSED
 813 GET-BYTES-CONSED (fbound)
 814 BYTES-CONSED-BETWEEN-GCS (fbound)
 815
 816
 817 = backend constants
 818
 819 These are believed to be constant (in the general sense, not necessarily
 820 eligible for defconstant).  Mostly they're attributes of the backend machine
 821
 822
 823 SB-C:*BACKEND-REGISTER-SAVE-PENALTY*
 824 SB-C:*BACKEND-BYTE-ORDER*
 825 SB-VM:*PRIMITIVE-OBJECTS*
 826 SB-VM:*ASSEMBLY-UNIT-LENGTH*
 827 SB-VM::*FP-CONSTANT-L2E*
 828 SB-VM::*FLOAT-REGISTER-NAMES*
 829 SB-VM::*FP-CONSTANT-1L0*
 830 SB-VM::*BYTE-REGISTER-NAMES*
 831 SB-VM::*DWORD-SC-NAMES*
 832 SB-VM::*FP-CONSTANT-1F0*
 833 SB-VM::*WORD-REGS*
 834 SB-VM::*BYTE-SC-NAMES*
 835 SB-VM::*DEFAULT-ADDRESS-SIZE*
 836 SB-VM::*FP-CONSTANT-0D0*
 837 SB-VM::*FP-CONSTANT-LG2*
 838 SB-VM::*FP-CONSTANT-L2T*
 839 SB-VM::*DWORD-REGS*
 840 SB-VM::*WORD-REGISTER-NAMES*
 841 SB-VM::*FP-CONSTANT-0F0*
 842 SB-VM::*FLOAT-SC-NAMES*
 843 SB-VM::*FLOAT-REGS*
 844 SB-VM::*DWORD-REGISTER-NAMES*
 845 SB-VM::*WORD-SC-NAMES*
 846 SB-VM::*FP-CONSTANT-PI*
 847 SB-VM::*BYTE-REGS*
 848 SB-VM::*FP-CONSTANT-1D0*
 849 SB-VM::*DOUBLE-SC-NAMES*
 850 SB-VM::*FP-CONSTANT-0L0*
 851 SB-VM::*REGISTER-ARG-OFFSETS*
 852 SB-VM::*FLOAT-TRAP-ALIST*
 853 SB-VM::*DWORD-REG-NAMES*
 854 SB-VM::*BYTE-REG-NAMES*
 855 SB-VM::*ROUNDING-MODE-ALIST*
 856 SB-VM::*REGISTER-ARG-NAMES*
 857 SB-VM::*FUN-HEADER-WIDETAGS*
 858 SB-VM::*FIXNUM-PRIMITIVE-TYPE*
 859 SB-VM:*STATIC-FUNS*
 860 SB-VM::*FP-CONSTANT-LN2*
 861 SB-VM::*WORD-REG-NAMES*
 862 SB-KERNEL::*BUILT-IN-CLASSES*
 863
 864 = dead stuff
 865
 866 ------------------------------------------------------------------------
 867
 868 = unclassified
 869
 870 SB-ALIEN-INTERNALS:*VALUES-TYPE-OKAY*
 871 SB-ALIEN::ALIEN-*-TYPE-TRANSLATOR
 872 SB-ALIEN::*DSO-LINKER*
 873 SB-ALIEN::*HANDLES-FROM-DLOPEN*
 874 SB-ALIEN::*ALIEN-TYPE-CLASSES*
 875 SB-ALIEN::*RECORD-TYPES-ALREADY-UNPARSED*
 876 SB-ALIEN::*NEW-AUXILIARY-TYPES*
 877 SB-ALIEN::*DSO-LINKER-OPTIONS*
 878 SB-ALIEN::*METHOD-SLOT-ALIST*
 879
 880 SB-VM::*SIGNED-IMM-BYTE-PREFILTER-WRAPPER*
 881 SB-VM::*DISPLACEMENT-PRINTER-WRAPPER*
 882 SB-VM::*ACCUM-PRINTER-WRAPPER*
 883 SB-VM::*WIDTH-PRINTER-WRAPPER*
 884 SB-VM::*LABEL-1-PREFILTER-WRAPPER*
 885 SB-VM::*WORD-ACCUM-PRINTER-WRAPPER*
 886 SB-VM::*NUM-FIXUPS*
 887 SB-VM::*SIGNED-IMM-DATA-PREFILTER-WRAPPER*
 888 SB-VM::*FIXNUM-PRIMITIVE-TYPE*
 889 SB-VM::*CONDITIONS*
 890 SB-VM::*IGNORE-AFTER*
 891 SB-VM::*IMM-WORD-PREFILTER-WRAPPER*
 892 SB-VM::*REGISTER-ARG-TNS*
 893 SB-VM::*IMM-DATA-PREFILTER-WRAPPER*
 894 SB-VM::*PRIMITIVE-TYPE-AUX-CACHE-VECTOR* ; threadsafe
 895 SB-VM::*LABEL-2-PREFILTER-WRAPPER*
 896 SB-VM::*ROOM-INFO*
 897 SB-VM::*ADJUSTABLE-VECTORS* ; under **WORLD-LOCK** - should be done better
 898 SB-VM::*CONDITION-NAME-VEC*
 899 SB-VM::*IMM-WORD-16-PREFILTER-WRAPPER*
 900 SB-VM::*SIMPLE-ARRAY-PRIMITIVE-TYPES*
 901 SB-VM::*MAYBE-USE-INLINE-ALLOCATION*
 902 SB-VM::*SIGNED-IMM-DWORD-PREFILTER-WRAPPER*
 903 SB-VM::*IMMEDIATE-TYPES*
 904
 905 SB-KERNEL:*WILD-TYPE*                                   ; readonly
 906 SB-KERNEL:*UNPARSE-FUN-TYPE-SIMPLIFY*
 907 SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*
 908 SB-KERNEL:*UNIVERSAL-FUN-TYPE*
 909 SB-KERNEL:*COLD-INIT-COMPLETE-P*
 910 SB-KERNEL:*UNIVERSAL-TYPE*                              ; readonly
 911 SB-KERNEL:*HANDLER-CLUSTERS*                            ; bound per-thread
 912 SB-KERNEL:*EMPTY-TYPE*                                  ; readonly
 913 SB-KERNEL:*MAXIMUM-ERROR-DEPTH*
 914 SB-KERNEL:*CONDITION-RESTARTS*                                  ; bound per-thread
 915 SB-KERNEL:*TYPE-SYSTEM-INITIALIZED*
 916 SB-KERNEL:*RESTART-CLUSTERS*                            ; bound per-thread
 917 SB-KERNEL::*MAKE-VALUES-TYPE-CACHED-CACHE-VECTOR*       ; threadsafe
 918 SB-KERNEL::*BUILT-IN-CLASS-CODES*                       ; readonly
 919 SB-KERNEL::*DEF!STRUCT-TYPE-MAKE-LOAD-FORM-FUN*
 920 SB-KERNEL::*LAYOUT-CLOS-HASH-RANDOM-STATE*
 921 SB-KERNEL::*TYPE-TEST-ORDERING*
 922 SB-KERNEL::*COMMON-TYPESPECS*
 923 SB-KERNEL::*TYPE=-CACHE-VECTOR*                         ; threadsafe
 924 SB-KERNEL::*VALUES-SUBTYPEP-CACHE-VECTOR*               ; threadsafe
 925 SB-KERNEL::*TYPECHECKFUNS*
 926 SB-KERNEL::*%TYPE-INTERSECTION-CACHE-VECTOR*            ; threadsafe
 927 SB-KERNEL::*TYPE-INTERSECTION2-CACHE-VECTOR*            ; threadsafe
 928 SB-KERNEL::*COLD-INIT-FORMS*
 929 SB-KERNEL::*DEFAULT-DEFAULT*
 930 SB-KERNEL::*RAW-SLOT-DATA-LIST*
 931 SB-KERNEL::*SPECIALIZED-ARRAY-ELEMENT-TYPES*            ; readonly
 932 SB-KERNEL::*DEFSTRUCT-HOOKS*
 933 SB-KERNEL::*VALUES-TYPE-UNION-CACHE-VECTOR*             ; threadsafe
 934 SB-KERNEL::*INTERNAL-ERRORS*
 935 SB-KERNEL::*VALUES-TYPE-INTERSECTION-CACHE-VECTOR*      ; threadsafe
 936 SB-KERNEL::*FORWARD-REFERENCED-LAYOUTS*
 937 SB-KERNEL::*SYSTEM-LETS*                                ; bound
 938 SB-KERNEL::*%COERCE-TO-VALUES-CACHE-VECTOR*             ; threadsafe
 939 SB-KERNEL::*IGNORABLE-VARS*
 940 SB-KERNEL::*ENV-VAR*                                    ; bound
 941 SB-KERNEL::|*%%MAKE-UNION-TYPE-cached-CACHE-VECTOR*|    ; threadsafe
 942 SB-KERNEL::*CSUBTYPEP-CACHE-VECTOR*                     ; threadsafe
 943 SB-KERNEL::*EMPTY-CONDITION-SLOT*
 944 SB-KERNEL::*TYPE-UNION2-CACHE-VECTOR*                   ; threadsafe
 945 SB-KERNEL::*TYPE-CLASS-FUN-SLOTS*
 946 SB-KERNEL::*ARG-TESTS*                                  ; bound
 947 SB-KERNEL::*USER-LETS*                                  ; bound
 948 SB-KERNEL::|*%%MAKE-ARRAY-TYPE-cached-CACHE-VECTOR*|    ; threadsafe
 949 SB-KERNEL::*FINDING-NAME*
 950 SB-KERNEL::*TYPE-CLASSES*
 951 SB-KERNEL::*VALUES-SPECIFIER-TYPE-CACHE-VECTOR*         ; threadsafe
 952 SB-KERNEL::*FLOAT-FORMATS*                              ; readonly
 953 SB-KERNEL::*INTERNAL-ERROR-ARGS*
 954 SB-KERNEL::*DEF!STRUCT-SUPERTYPE*
 955 SB-KERNEL::*%TYPE-UNION-CACHE-VECTOR*                   ; threadsafe
 956 SB-KERNEL::*CTYPE-OF-CACHE-VECTOR*                      ; threadsafe
 957
 958 SB-IMPL::*READ-BUFFER*  ; safe when used via WITH-READ-BUFFER
 959 SB-IMPL::*SECONDARY-ATTRIBUTE-TABLE* ; now *CONSTITUENT-TRAIT-TABLE*, constant
 960 SB-IMPL::*STANDARD-READTABLE*
 961 SB-IMPL::*ERROR-ERROR-DEPTH*
 962 SB-IMPL::*CURRENT-ERROR-DEPTH*
 963 SB-IMPL::*INTERNAL-REAL-TIME-BASE-SECONDS*
 964 SB-IMPL::*DAYLIGHT-TABLE*
 965 SB-IMPL::*OFFENDING-DATUM*
 966 SB-IMPL::*HANDLERS-INSTALLED*
 967 SB-IMPL::*HASH-TABLE-TESTS*
 968 SB-IMPL::*ATTRIBUTE-NAMES*
 969 SB-IMPL::*DAYS-BEFORE-MONTH*                            ; readonly
 970 SB-IMPL::*CHARACTER-ATTRIBUTES*
 971 SB-IMPL::*UNIX-HOST*
 972 SB-IMPL::*DESCRIPTOR-HANDLERS*
 973 SB-IMPL::*STRING-OUTPUT-STREAMS*
 974 SB-IMPL::*CLOSE-ON-ERROR*
 975 SB-IMPL::*TIMEZONE-TABLE*
 976 SB-IMPL::*BQ-COMMA-FLAG*                                ; readonly
 977 SB-IMPL::*PROFILE-HASH-CACHE* ; not threadsafe, but don't care- debug only
 978 SB-IMPL::*FIXNUM-POWER--1*
 979 SB-IMPL::*SHARP-EQUAL-CIRCLE-TABLE*
 980 SB-IMPL::*SOFTWARE-INTERRUPT-VECTOR*        ; suspect unused
 981 SB-IMPL::*INSPECT-UNBOUND-OBJECT-MARKER*
 982 SB-IMPL::*IN-PACKAGE-INIT*
 983 SB-IMPL::*DELAYED-DEF!METHOD-ARGS*
 984 SB-IMPL::*GENTEMP-COUNTER*
 985 SB-IMPL::*CLOSE-IN-PARENT*
 986 SB-IMPL::*IN-COMPILATION-UNIT*
 987 SB-IMPL::*CIRCULARITY-HASH-TABLE*
 988 SB-IMPL::*LOAD-PRINT-STUFF*
 989 SB-IMPL::*ACTIVE-PROCESSES*
 990 SB-IMPL::*SHARP-SHARP-ALIST*
 991 SB-IMPL::*LOGICAL-PATHNAME-DEFAULTS*
 992 SB-IMPL::*AVAILABLE-BUFFERS*
 993 SB-IMPL::*BQ-DOT-FLAG*                          ; readonly
 994 SB-IMPL::*CIRCULARITY-COUNTER*
 995 SB-IMPL::*DIGITS*
 996 SB-IMPL::*BQ-VECTOR-FLAG*                       ; readonly
 997 SB-IMPL::*ABBREV-WEEKDAY-TABLE*
 998 SB-IMPL::*LOGICAL-HOSTS*
 999 SB-IMPL::*PACKAGE-NAMES*
1000 SB-IMPL::*INSPECT-FUN*
1001 SB-IMPL::*ABBREV-MONTH-TABLE*
1002 SB-IMPL::*OUTPUT-ROUTINES*
1003 SB-IMPL::*CHAR-NAME-ALIST*
1004 SB-IMPL::*VALID-FUN-NAMES-ALIST*
1005 SB-IMPL::*PERIODIC-POLLING-FUNCTION*
1006 SB-IMPL::*ABORTED-COMPILATION-UNIT-COUNT*
1007 SB-IMPL::*LONG-WEEKDAY-TABLE*
1008 SB-IMPL::*INTERNAL-SYMBOL-OUTPUT-FUN* ; FIXME: printer not threadsafe
1009 SB-IMPL::*BACKQUOTE-COUNT*                      ; bound
1010 SB-IMPL::*DIGIT-BASES*
1011 SB-IMPL::*PREVIOUS-DRIBBLE-STREAMS*
1012 SB-IMPL::*MAX-EVENT-TO-USEC*
1013 SB-IMPL::*INPUT-ROUTINES*
1014 SB-IMPL::*MAX-EVENT-TO-SEC*
1015 SB-IMPL::*LONG-MONTH-TABLE*
1016 SB-IMPL::*OLD-PACKAGE*
1017 SB-IMPL::*ERROR-THROW-UP-COUNT*
1018 SB-IMPL::*BQ-AT-FLAG*                           ; readonly
1019 SB-IMPL::*MACHINE-VERSION*   ; unset/unbound ?  are we using this?
1020 SB-IMPL::*IGNORE-WILDCARDS*
1021 SB-IMPL::*SHARP-EQUAL-ALIST*
1022
1023 *INLINE-EXPANSION-LIMIT*
1024 *DERIVE-FUNCTION-TYPES*
1025 *ENCLOSING-SOURCE-CUTOFF*
1026 *INSPECTED*
1027 *UNDEFINED-WARNING-LIMIT*
1028 *EFFICIENCY-NOTE-COST-THRESHOLD*
1029 *EFFICIENCY-NOTE-LIMIT*
1030 *USE-IMPLEMENTATION-TYPES*
1031 *INTEXP-MAXIMUM-EXPONENT*
1032 *GENSYM-COUNTER*
1033 *MACROEXPAND-HOOK*
1034 *RANDOM-STATE*
1035
1036 SB-INT:*CL-PACKAGE*                     ; readonly
1037 SB-INT:*KEYWORD-PACKAGE*                ; readonly
1038 SB-INT:*SETF-FDEFINITION-HOOK*
1039 SB-INT:*DEFAULT-INIT-CHAR-FORM*
1040 SB-INT:*EOF-OBJECT*                     ; readonly
1041 SB-INT:*AFTER-SAVE-INITIALIZATIONS*
1042 SB-INT:*LOAD-SOURCE-DEFAULT-TYPE*
1043 SB-INT:*BEFORE-SAVE-INITIALIZATIONS*
1044 SB-INT:*INFO-ENVIRONMENT*               ; threadsafe