anchor.diff:                                         (write-char #\Space)
                                          (write (mezzano.supervisor:thread-state-rsp thread) :base 16)
                                          (write-char #\Space)
  -                                       (write (function-name fn))
  +                                       (write (function-like-name fn))
                                          (terpri))
                                         (print-instructions
                                          (format t "Entered function ~S with arguments ~:A.~%"
                                                  (cond ((eql fn *funcallable-instance-trampoline*)
                                                         (mezzano.supervisor:thread-state-rbx-value thread))
                                                        (t
  -                                                      (or (function-name fn) fn)))
  +                                                      (or (function-like-name fn) fn)))
                                                  (mapcar #'print-safely-to-string
                                                          (fetch-thread-function-arguments thread))))))
                                  (t
  
positive.code:                                        (write-char #\Space)
                                         (write (mezzano.supervisor:thread-state-rsp thread) :base 16)
                                         (write-char #\Space)
                                         (write (function-name prev-fn))
                                         (terpri))
                                        (print-instructions
                                         (format t "Returning from function ~S to ~S with results ~:A.~%"
                                                 (or (function-name prev-fn) prev-fn)
                                                 (or (function-name fn) fn)
                                                 (mapcar #'print-safely-to-string
                                                         (fetch-thread-return-values thread))))))))
                         (when print-instructions
                           (when (not (eql fn (mezzano.disassemble:disassembler-context-function disassembler-context)))
                             (setf disassembler-context (mezzano.disassemble:make-disassembler-context fn)))
                           (let ((inst (mezzano.disassemble:instruction-at disassembler-context offset)))
                             (format t "~8,'0X: ~S + ~D " rip (or (function-name fn) fn) offset)
                             (when inst
                               (mezzano.disassemble:print-instruction disassembler-context inst :print-annotations nil :print-labels nil))
                             (terpri)))
  
negative.code:                (+ sp (* i 8))
                 (memref-unsigned-byte-64 sp i)
                 (memref-unsigned-byte-64 sp (1+ i)))))
  
  (defun function-like-name (function)
    (typecase function
      (function (function-name function))
      (function-reference `(function-reference ,(function-reference-name function)))
      (t function)))
  
  (defun trace-execution (function &key full-dump run-forever (print-instructions t) trace-call-mode (trim-stepper-noise t) report-call-counts)
    "Trace the execution of FUNCTION.
  