anchor.diff:  (defvar *current-deferred-function* nil)
   
   (defun add-to-llf (action &rest objects)
  -  (if *current-deferred-function*
  -      (push (list* action objects)
  -            (deferred-function-additional-commands
  -                *current-deferred-function*))
  -      (push (list* action objects) *llf-forms*)))
  +  (cond (*current-deferred-function*
  +         ;; Running in a worker thread to compile a function.
  +         (push (list* action objects)
  +               (deferred-function-additional-commands
  +                   *current-deferred-function*)))
  +        (*compiling-make-load-form*
  +         ;; Compiling a call to make-load-form.
  +         ;; This occurs when saving objects, so the work must not be deferred.
  +         (dolist (o objects)
  +           (save-object o (car *compiling-make-load-form*) (cdr *compiling-make-load-form*)))
  +         (when (and action (not *llf-dry-run*))
  +           (write-byte action (cdr *compiling-make-load-form*))))
  +        (t
  +         ;; Normal operation, save the forms in the command list.
  +         (push (list* action objects) *llf-forms*))))
   
   (defun compile-file-load-time-value (form read-only-p)
     (declare (ignore read-only-p))
  
positive.code:                omap stream)
    (write-byte +llf-instance-header+ stream))
  
  (defmethod save-one-object (object omap stream)
    ;; Use COMPILE-LAMBDA here instead of COMPILE to get the correct L-T-V behaviour.
    (let ((mezzano.compiler::*load-time-value-hook*
           (lambda (form read-only-p)
             (declare (ignore read-only-p))
             (let ((ltv-sym (gensym "LOAD-TIME-VALUE-CELL")))
               (save-object (mezzano.compiler::compile-lambda
                             `(lambda ()
                                (declare (special ,ltv-sym))
                                (setq ,ltv-sym ,form))
                             nil)
                            omap stream)
               (save-object 0 omap stream)
               (write-byte +llf-funcall-n+ stream)
               (write-byte +llf-drop+ stream)
               `(sys.int::symbol-global-value ',ltv-sym)))))
      (multiple-value-bind (creation-form initialization-form)
          (make-load-form object)
        (save-object (mezzano.compiler::compile-lambda
                      `(lambda ()
                         (declare (sys.int::lambda-name creation-form))
                         (progn ,creation-form))
                      nil)
                     omap stream)
        (save-object 0 omap stream)
        (write-byte +llf-funcall-n+ stream)
        (when initialization-form
          (write-object-backlink object omap stream)
          (save-object (mezzano.compiler::compile-lambda
                        `(lambda ()
                           (declare (sys.int::lambda-name initialization-form))
                           (progn ,initialization-form))
                        nil)
                       omap stream)
          (save-object 0 omap stream)
          (write-byte +llf-funcall-n+ stream)
          (write-byte +llf-drop+ stream)))))
  
  (defun write-object-backlink (object omap stream)
    (when (not *llf-dry-run*)
  
negative.code:                                        :if-exists :supersede
                                         :direction :output)
            (write-llf-header output-stream input-file)
            (let ((*llf-dry-run* nil))
              (dolist (cmd commands)
                (dolist (o (cdr cmd))
  