anchor.diff:             (mezzano.supervisor:with-pseudo-atomic
                (tagbody
                 INNER-LOOP
  -                (when (> (+ sys.int::*general-area-bump* (* words 8)) sys.int::*general-area-limit*)
  -                  (go EXPAND-AREA))
  -                ;; Enough size, allocate here.
  -                (let ((addr (logior (ash sys.int::+address-tag-general+ sys.int::+address-tag-shift+)
  -                                    sys.int::*general-area-bump*
  -                                    sys.int::*dynamic-mark-bit*)))
  -                  (incf sys.int::*general-area-bump* (* words 8))
  -                  ;; Write array header.
  -                  (set-allocated-object-header addr tag data 0)
  -                  (return-from %slow-allocate-from-general-area
  -                    (sys.int::%%assemble-value addr sys.int::+tag-object+)))
  -              EXPAND-AREA
  +                (multiple-value-bind (result ignore1 ignore2 failurep)
  +                    (%do-allocate-from-general-area tag data words)
  +                  (declare (ignore ignore1 ignore2))
  +                  (when (not failurep)
  +                    (return-from %slow-allocate-from-general-area
  +                      result)))
                   ;; No memory. If there's memory available, then expand the area, otherwise run the GC.
                   ;; Running the GC cannot be done when pseudo-atomic.
                   (cond ((expand-allocation-area "general"
  
positive.code:   (:d64/le #.(logior (ash sys.int::+address-tag-general+ sys.int::+address-tag-shift+)
                       sys.int::+tag-object+)))
  
  #-(or x86-64 arm64)
  (defun %allocate-from-general-area (tag data words)
    (sys.int::%atomic-fixnum-add-symbol '*general-allocation-count* 1)
    (%slow-allocate-from-general-area tag data words))
  
  (defun expand-allocation-area-1 (name granularity limit-symbol address-tag)
    (let ((current-limit (sys.int::symbol-global-value limit-symbol))
  
negative.code:   (:gc :no-frame :layout #*0)
    ;; Done. Return everything.
    (sys.lap-x86:mov64 :r8 :rbx)
    (sys.lap-x86:mov32 :ecx #.(ash 1 #.sys.int::+n-fixnum-bits+))
    (sys.lap-x86:ret)
    SLOW-PATH
    (sys.lap-x86:mov64 :r11 t)
    (sys.lap-x86:mov32 :ecx #.(ash 4 #.sys.int::+n-fixnum-bits+))
    (sys.lap-x86:ret))
  
  #+x86-64
  (sys.int::define-lap-function %allocate-from-general-area ((tag data words))
    (:gc :no-frame :layout #*0)
    ;; Attempt to quickly allocate from the general area. Will call
    ;; %SLOW-ALLOCATE-FROM-GENERAL-AREA if things get too hairy.
    ;; R8 = tag; R9 = data; R10 = words
    ;; Check argument count.
    (sys.lap-x86:cmp64 :rcx #.(ash 3 #.sys.int::+n-fixnum-bits+))
    (sys.lap-x86:jne SLOW-PATH)
    ;; Update allocation meter.
    ;; *BYTES-CONSED* is updated elsewhere.
    (sys.lap-x86:mov64 :rbx (:constant *general-allocation-count*))
    (sys.lap-x86:mov64 :rbx (:object :rbx #.sys.int::+symbol-value+))
    (sys.lap-x86:add64 (:object :rbx #.sys.int::+symbol-value-cell-value+) #.(ash 1 sys.int::+n-fixnum-bits+))
    ;; Check *ENABLE-ALLOCATION-PROFILING*
    ;; FIXME: This only tests the global value.
    (sys.lap-x86:mov64 :rbx (:constant *enable-allocation-profiling*))
    (sys.lap-x86:mov64 :rbx (:object :rbx #.sys.int::+symbol-value+))
    (sys.lap-x86:cmp64 (:object :rbx #.sys.int::+symbol-value-cell-value+) nil)
    (sys.lap-x86:jne SLOW-PATH)
    ;; Check *GC-IN-PROGRESS*.
    (sys.lap-x86:mov64 :rbx (:constant sys.int::*gc-in-progress*))
    (sys.lap-x86:mov64 :rbx (:object :rbx #.sys.int::+symbol-value+))
    (sys.lap-x86:cmp64 (:object :rbx #.sys.int::+symbol-value-cell-value+) nil)
    (sys.lap-x86:jne SLOW-PATH)
    ;; Try the real fast allocator.
    (sys.lap-x86:mov64 :r13 (:function %do-allocate-from-general-area))
    (sys.lap-x86:call (:object :r13 #.sys.int::+fref-entry-point+))
    (sys.lap-x86:cmp64 :rcx #.(ash 1 #.sys.int::+n-fixnum-bits+))
    (sys.lap-x86:jne SLOW-PATH)
    ;; Done. Return everything.
    (sys.lap-x86:mov64 :rbx (:constant *general-fast-path-hits*))
    (sys.lap-x86:mov64 :rbx (:object :rbx #.sys.int::+symbol-value+))
    (sys.lap-x86:lock)
    (sys.lap-x86:add64 (:object :rbx #.sys.int::+symbol-value-cell-value+) #.(ash 1 sys.int::+n-fixnum-bits+))
    (sys.lap-x86:mov32 :ecx #.(ash 1 #.sys.int::+n-fixnum-bits+))
    (sys.lap-x86:ret)
    SLOW-PATH
    ;; Tail call into %SLOW-ALLOCATE-FROM-GENERAL-AREA.
    (sys.lap-x86:mov64 :r13 (:function %slow-allocate-from-general-area))
    (sys.lap-x86:mov32 :ecx #.(ash 3 #.sys.int::+n-fixnum-bits+))
    (sys.lap-x86:jmp (:object :r13 #.sys.int::+fref-entry-point+)))
  
  #+(and arm64 (or))
  (sys.int::define-lap-function %allocate-from-general-area ((tag data words))
    (:gc :no-frame :layout #*)
    ;; Attempt to quickly allocate from the general area. Will call
  