anchor.diff:                        (push (make-report-entry :id id
                                                  :self (if on-top-p 1 0)
                                                  :cumul 1
  -                                               :name name
  +                                               :fn-name fn-name
  +                                               :obj-name obj-name
                                                  :known known)
                               report))))))
                
  
positive.code:   "Accepts a process map PROCMAP and an ADDRESS and returns three values:
     1) a begining of the function the ADDRESS belongs to (or just the ADDRESS
     if function is not present in symbol table)
     2) String representation of the function
     3) T if function is present in symbol table, NIL otherwise"
    (multiple-value-bind (reg-start path)
        (address-container procmap address)
      (if path
          (multiple-value-bind (funcs were-scanned)
              (gethash reg-start func-table)
            (let* ((libraryp (libraryp path))
                   (funcs (if were-scanned funcs
                              (setf (gethash reg-start func-table)
                                    (get-funcs (read-elf path)
                                               :dynamicp libraryp))))
                   (named-function
                    (flet ((address-inside (addr% func)
                             (and (>= addr% (named-region-start func))
                                  (<  addr% (named-region-end func)))))
                      (find (if libraryp (- address reg-start) address)
                            funcs :test #'address-inside))))
            
              (if named-function
                  (return-from address=>func-name
                    (values (+ (if libraryp reg-start 0)
                               (named-region-start named-function))
                            (format nil "~A in ~A"
                                    (named-region-name named-function)
                                    path)
                            t)))))))
    (values address
            (format nil "<Unknown function at address ~X>" address)
            nil))
  
  ;; Flat report without building the call graph is the only
  ;; kind of report currently supported.
  
negative.code:         report)
      
      (labels ((populate-report (address &key on-top-p)
                 (multiple-value-bind (id fn-name obj-name known)
                     (address=>func-name procmap address)
                   (let ((rep-entry (find id report
                                          :test #'(lambda (id rep-entry) (= id (report-entry-id rep-entry))))))
  