anchor.diff:                       (when sys.int::*gc-enable-logging*
                          (mezzano.supervisor:debug-print-line "Expanded pinned area by " grow-by))
                        ;; Success.
  -                     (finish-expand-pinned-area grow-by)
  +                     (finish-expand-freelist-area grow-by 'sys.int::*pinned-area-bump* sys.int::*pinned-area-free-bins*)
                        (setf inhibit-gc t))))))))
          (when (> i *maximum-allocation-attempts*)
            (cerror "Retry allocation" 'storage-condition))
  
positive.code:             (when address
                (sys.int::%%assemble-value address sys.int::+tag-object+))))))))
  
  (defun finish-expand-pinned-area (grow-by)
    (let ((len (truncate grow-by 8))
          (final-entry (sys.int::base-address-of-internal-pointer
                        (- sys.int::*pinned-area-bump* 16)))
          (new-address sys.int::*pinned-area-bump*))
      (cond ((eql (ash (sys.int::memref-unsigned-byte-8 final-entry) (- sys.int::+object-type-shift+))
                  sys.int::+object-tag-freelist-entry+)
             ;; Final entry in the area is a freelist entry, extend it by the new amount.
  
negative.code:   ;; Force 32-byte alignment.
    (setf words (sys.int::align-up words 4))
    (loop
       with inhibit-gc = nil
       for i from 0 do
         (let ((result (%allocate-function-1 tag data words wiredp)))
           (when result
             (return result)))
         (when (not (eql i 0))
           ;; The GC has been run at least once.
           (when wiredp
             ;; TODO: Implement expanding the wired function area.
             (error 'storage-condition))
           ;; Try enlarging the area.
           (let ((grow-by (* words 8)))
             (incf grow-by (1- sys.int::+allocation-minimum-alignment+))
             (setf grow-by (logand (lognot (1- sys.int::+allocation-minimum-alignment+))
                                   grow-by))
             (when sys.int::*gc-enable-logging*
               (mezzano.supervisor:debug-print-line
                "Expanding FUNCTION area by " grow-by))
             (mezzano.supervisor:without-footholds
               (mezzano.supervisor:inhibit-thread-pool-blocking-hijack
                 (mezzano.supervisor:with-mutex (*allocator-lock*)
                   (mezzano.supervisor:with-pseudo-atomic
                     (when (mezzano.supervisor:allocate-memory-range
                            sys.int::*function-area-limit*
                            grow-by
                            (logior sys.int::+block-map-present+
                                    sys.int::+block-map-writable+
                                    sys.int::+block-map-zero-fill+
                                    sys.int::+block-map-track-dirty+))
                       (when sys.int::*gc-enable-logging*
                         (mezzano.supervisor:debug-print-line "Expanded function area by " grow-by))
                       ;; Success.
                       (finish-expand-freelist-area grow-by 'sys.int::*function-area-limit* sys.int::*function-area-free-bins*)
                       (setf inhibit-gc t))))))))
         (when (> i *maximum-allocation-attempts*)
           (cerror "Retry allocation" 'storage-condition))
         (cond (inhibit-gc
                (setf inhibit-gc nil))
               (t
                (when sys.int::*gc-enable-logging*
                  (mezzano.supervisor:debug-print-line "Full GC due to function allocation."))
                (sys.int::gc :full t)))))
  
  (defun sys.int::make-function (tag machine-code fixups constants gc-info &optional wired)
    (let* ((mc-size (ceiling (+ (length machine-code) 16) 16))
  