doc/internals-notes/threading-specials

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