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:          (dotimes (slot layout-length)
             (multiple-value-bind (offset bit)
                 (%truncate slot 8) ; ### FIXME: compiler refuses to inline truncate.
               #+(or)(progn
                 (mumble-hex slot "ss: ")
                 (mumble-hex offset " ")
                 (mumble-hex bit ":")
                 (mumble-hex (memref-unsigned-byte-8 layout-address offset) "  " t))
               (when (logbitp bit (memref-unsigned-byte-8 layout-address offset))
                 (cond (framep
                        #+(or)(progn
                          (mumble-hex (- -1 slot) "Scav stack slot ")
                          (mumble-hex (lisp-object-address (memref-t frame-pointer (- -1 slot))) "  " t))
                        (setf (memref-t frame-pointer (- -1 slot))
                              (scavenge-object (memref-t frame-pointer (- -1 slot)))))
                       (t
                        #+(or)(progn
                          (mumble-hex slot "Scav no-frame stack slot ")
                          (mumble-hex (lisp-object-address (memref-t stack-pointer slot)) "  " t))
                        (setf (memref-t stack-pointer slot)
  
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)
  