anchor.diff:             (gc-trace ,object-sym #\< ,prefix))
            ,result-sym))))
   
  -#+nil(defmacro with-gc-trace ((object prefix) &body body)
  +(defmacro with-gc-trace ((object prefix) &body body)
     (declare (ignore object prefix))
     `(progn ,@body))
   
  
positive.code:      t)
      (t nil)))
  
  (defmacro with-gc-trace ((object prefix) &body body)
    (let ((object-sym (gensym))
          (result-sym (gensym)))
      `(let ((,object-sym ,object))
  
negative.code:         (scavenge-many binding-stack-pointer
                         (ash (- (+ bs-base bs-size) binding-stack-pointer) -3))))))
  
  (defun scan-array-like (object)
    (let* ((address (ash (%pointer-field object) 4))
           (header (memref-unsigned-byte-64 address 0))
           (length (ldb (byte 56 8) header))
           (type (ldb (byte 5 3) header)))
      ;; Dispatch again based on the type.
      (cond ((member type '(#.+array-type-t+
                            #.+array-type-std-instance+
                            #.+array-type-struct+))
             ;; simple-vector, std-instance or structure-object.
             (when (hash-table-p object)
               (setf (hash-table-rehash-required object) 't))
             ;; 1+ to account for the header word.
             (scan-generic object (1+ length)))
            ((eql type +array-type-stack-group+)
             (scan-stack-group object))
            ;; Ignore numeric arrays and bignums.
            ;; Array-type 0 is simple-vector, but that's handled above.
            ((or (<= type +last-array-type+)
                 (eql type +array-type-bignum+)))
            (t (scan-error object)))))
  
  (defun scan-function (object)
    ;; Scan the constant pool.
  