anchor.diff:        (panic "Stopping world while pseudo-atomic!"))
       (ensure-interrupts-enabled)
       (inhibit-thread-pool-blocking-hijack
  -      (with-world-stop-lock ()
  -        ;; First, try to position ourselves as the next thread to stop the world.
  -        ;; This prevents any more threads from becoming PA.
  -        (loop
  -           (when (null *world-stop-pending*)
  -             (setf *world-stop-pending* self)
  -             (return))
  -           ;; Wait for the world to unstop.
  -           ;; FIXME: This can still cause deadlocks when reacquiring the lock.
  -           (condition-wait *world-stop-cvar* *world-stop-lock*))
  -        ;; Now wait for any PA threads to finish.
  -        (loop
  -           (when (zerop *pseudo-atomic-thread-count*)
  -             (return))
  -           ;; FIXME: Same here.
  -           (condition-wait *world-stop-cvar* *world-stop-lock*))
  -        (safe-without-interrupts (self)
  -                                 (acquire-global-thread-lock)
  -                                 (setf *world-stopper* self
  -                                       *world-stop-pending* nil)
  -                                 (release-global-thread-lock))
  -        (quiesce-cpus-for-world-stop))
  -      (unwind-protect
  -           (funcall thunk)
  -        (with-world-stop-lock ()
  -          ;; Release the dogs!
  -          (safe-without-interrupts ()
  -                                   (acquire-global-thread-lock)
  -                                   (setf *world-stopper* nil)
  -                                   (release-global-thread-lock))
  -          (condition-notify *world-stop-cvar* t)
  -          (broadcast-wakeup-ipi))))))
  +     (%call-on-wired-stack-without-interrupts #'%stop-the-world nil)
  +     (unwind-protect
  +          (progn
  +            (quiesce-cpus-for-world-stop)
  +            (funcall thunk))
  +       (%call-on-wired-stack-without-interrupts #'%resume-the-world nil)
  +       (broadcast-wakeup-ipi)))))
   
   (defmacro with-world-stopped (&body body)
     `(call-with-world-stopped (dx-lambda () ,@body)))
  
positive.code:   ;; The initial thread must finish with no values on the special stack.
    ;; This is required by INITIALIZE-INITIAL-THREAD.
    (let ((thread (current-thread)))
      (setf *world-stopper* nil)
      (%disable-interrupts)
      (acquire-global-thread-lock)
      (setf (thread-wait-item thread) "The start of a new world"
  
negative.code:     ;; Default timeslice is 10ms/0.01s.
      ;; Work at read-time to avoid floats at runtime.
      (setf *timeslice-length* #.(truncate (* 0.01 internal-time-units-per-second)))
      (setf *pseudo-atomic-thread-count* 0
            *pending-world-stoppers* (make-wait-queue :name '*pending-world-stoppers*)
            *pending-pseudo-atomics* (make-wait-queue :name '*pending-pseudo-atomics*))
      (setf *all-threads* sys.int::*snapshot-thread*
            (thread-global-next sys.int::*snapshot-thread*) sys.int::*pager-thread*
            (thread-global-prev sys.int::*snapshot-thread*) nil
  