anchor.diff:                                                        fn))
                                                  call-counts
                                                  0))
  +                                (let ((tbl (gethash fn callers)))
  +                                  (when (not tbl)
  +                                    (setf tbl (make-hash-table :synchronized nil)
  +                                          (gethash fn callers) tbl))
  +                                  (incf (gethash prev-fn tbl 0)))
  +                                (let ((tbl (gethash prev-fn callees)))
  +                                  (when (not tbl)
  +                                    (setf tbl (make-hash-table :synchronized nil)
  +                                          (gethash prev-fn callees) tbl))
  +                                  (incf (gethash fn tbl 0)))
                                   (cond (trace-call-mode
                                          (write-char #\>)
                                          (write-char #\Space)
  
positive.code:          (entry-sp nil)
           (fundamental-function (mezzano.disassemble::peel-function function))
           (call-counts (make-hash-table :synchronized nil))
           (execution-counts (make-hash-table :synchronized nil)))
      (mezzano.supervisor::stop-thread thread)
      (setf stopped t)
      (unwind-protect
  
negative.code:                  call-counts)
          (setf counts (sort counts #'< :key #'cdr))
          (loop for (fn . count) in counts do (format t "~S: ~D~%" fn count)))
        (format t "Caller counts:~%")
        (maphash (lambda (fn callers)
                   (format t "~S:~%" fn)
                   (maphash (lambda (caller count)
                              (format t "  ~S: ~D~%" caller count))
                            callers))
                 callers)
        (format t "Callee counts:~%")
        (maphash (lambda (fn callees)
                   (format t "~S:~%" fn)
                   (maphash (lambda (callee count)
                              (format t "  ~S: ~D~%" callee count))
                            callees))
                 callees)
        (format t "Instruction counts:~%")
        (let ((counts '()))
          (maphash (lambda (fn count)
                     (push (cons fn count) counts))
                   execution-counts)
          (setf counts (sort counts #'< :key #'cdr))
          (loop
             for (fn . count) in counts
             do (format t "~S: ~D ~D% ~D per call~%"
                        fn count
                        (* (/ count instructions-stepped) 100.0)
                        (float (/ count (gethash fn call-counts 1)))))))))
  
  (defun profile-execution (function &key (sample-interval 1/100))
    (check-type function function)
  