anchor.diff:    (if (and *compile-parallel*
              ;; If true, then this is a worker thread compiling something.
              ;; Don't schedule more work, just do it here.
  -           (not *current-deferred-function*))
  +           (not *current-deferred-function*)
  +           ;; If true then a make-load-form is actively being compiled
  +           ;; and is running in the context of save-object, now long past
  +           ;; the time that parallel compilation can be done.
  +           (not *compiling-make-load-form*))
         (let ((fn (make-instance 'deferred-function
                                  :ast (mezzano.compiler::pass1-lambda lambda env)
                                  :tlf-number *top-level-form-number*)))
  
positive.code: (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*)))
  
  (defun compile-file-load-time-value (form read-only-p)
    (declare (ignore read-only-p))
  
negative.code:                omap stream)
    (write-byte +llf-instance-header+ stream))
  
  (defvar *compiling-make-load-form* nil)
  
  (defmethod save-one-object (object omap stream)
    ;; Use COMPILE-LAMBDA here instead of COMPILE to get the correct L-T-V behaviour.
    (let* ((*compiling-make-load-form* (cons omap stream))
           (mezzano.compiler::*load-time-value-hook*
            (lambda (form read-only-p)
              (declare (ignore read-only-p))
              (let ((ltv-sym (gensym "LOAD-TIME-VALUE-CELL")))
                (compile-top-level-form `(locally
                                             (declare (special ,ltv-sym))
                                           (setq ,ltv-sym ,form))
                                        nil)
                `(sys.int::symbol-global-value ',ltv-sym)))))
      (multiple-value-bind (creation-form initialization-form)
          (make-load-form object)
        (compile-top-level-form-for-value creation-form nil)
        (when initialization-form
          (write-object-backlink object omap stream)
          (compile-top-level-form initialization-form nil)))))
  
  (defun write-object-backlink (object omap stream)
    (when (not *llf-dry-run*)
  