anchor.diff:           ;; Scan incoming arguments.
            (when incoming-arguments
              ;; Stored as fixnum on the stack.
  +           #+(or)(mumble-hex (- -1 incoming-arguments) "IA in slot ")
              (let* ((n-args (if framep
                                 (memref-t frame-pointer (- -1 incoming-arguments))
                                 (memref-t stack-pointer incoming-arguments)))
                     (n-values (max 0 (- n-args 5))))
  +             #+(or)(mumble-hex n-args "  n-args" t)
                ;; There are N-VALUES values above the return address.
                (if framep
                    (dotimes (slot n-values)
  +                   (when *gc-debug-scavenge-stack*
  +                     (mumble-hex (+ 2 slot) "Scav arg slot ")
  +                     (mumble-hex (lisp-object-address (memref-t frame-pointer (+ 2 slot))) "  " t))
                      (setf (memref-t frame-pointer (+ 2 slot))
                            (scavenge-object (memref-t frame-pointer (+ 2 slot)))))
                    (dotimes (slot n-values)
  +                   (when *gc-debug-scavenge-stack*
  +                     (mumble-hex (+ 1 layout-length slot) "Scav arg slot ")
  +                     (mumble-hex (lisp-object-address (memref-t frame-pointer (+ 1 layout-length slot))) "  " t))
                      (setf (memref-t stack-pointer (+ 1 layout-length slot))
                            (scavenge-object (memref-t stack-pointer (+ 1 layout-length slot))))))))
            ;; Stop after seeing a zerop frame pointer.
  
positive.code:   "Scavenge SIZE words pointed to by OBJECT."
    (scavenge-many (ash (%pointer-field object) 4) size))
  
  (defun scavenge-stack (stack-pointer frame-pointer return-address)
    (loop
       #+(or)(progn
       (mumble-hex stack-pointer "SP: " t)
       (mumble-hex frame-pointer "FP: " t)
       (mumble-hex return-address "RA: " t))
       (let* ((fn-address (base-address-of-internal-pointer return-address))
              (fn-offset (- return-address fn-address))
              (fn (%%assemble-value fn-address +tag-function+)))
         #+(or)(progn
           (mumble-hex fn-address "fn: " t)
           (mumble-hex fn-offset "fnoffs: " t))
         (scavenge-object fn)
  
negative.code:                                     layout-address layout-length
                                      multiple-values incoming-arguments block-or-tagbody-thunk)
             (gc-info-for-function-offset fn fn-offset)
           (when *gc-debug-scavenge-stack*
             (if framep
                 (mumble "frame")
                 (mumble "no-frame"))
             (if interruptp
                 (mumble "interrupt")
                 (mumble "no-interrupt"))
             (mumble-hex pushed-values "pv: " t)
             (mumble-hex (lisp-object-address pushed-values-register) "pvr: " t)
             (if multiple-values
                 (mumble-hex multiple-values "mv: " t)
                 (mumble "no-multiple-values"))
             (mumble-hex layout-address "Layout addr: ")
             (mumble-hex layout-length "  Layout len: " t)
             (cond ((integerp incoming-arguments)
                    (mumble-hex incoming-arguments "ia: " t))
                   (incoming-arguments
                    (mumble-hex (lisp-object-address incoming-arguments) "ia: " t))
                   (t (mumble "no-incoming-arguments")))
             (if block-or-tagbody-thunk
                 (mumble-hex (lisp-object-address block-or-tagbody-thunk) "btt: " t)
                 (mumble "no-btt")))
           (when (or interruptp (not (eql pushed-values 0)) pushed-values-register
                     (and multiple-values (not (eql multiple-values 0)))
                     (or (keywordp incoming-arguments)
  