anchor.diff:      (setf (function-reference-function fref) value)))
   
   (defun fboundp (name)
  -  (not (null (function-reference-function (function-reference name)))))
  +  ;; Avoid allocating a fref just for the test.
  +  (let ((fref (function-reference name nil)))
  +    (and fref
  +         (not (null (function-reference-function fref))))))
   
   (defun fmakunbound (name)
  -  ;; Check for and update any existing TRACE-WRAPPER.
  -  ;; This is not very thread-safe, but if the user is tracing it shouldn't matter much.
  -  (let* ((fref (function-reference name))
  -         (existing (function-reference-function fref)))
  -    (when (locally
  -              (declare (notinline typep)) ; bootstrap hack.
  -            (typep existing 'trace-wrapper))
  -      ;; Untrace the function.
  -      (%untrace (function-reference-name fref)))
  -    (setf (function-reference-function (function-reference name)) nil)
  -    name))
  +  (let ((fref (function-reference name nil)))
  +    ;; Don't allocate a new fref if the function is already unbound.
  +    (when fref
  +      ;; Check for and update any existing TRACE-WRAPPER.
  +      ;; This is not very thread-safe, but if the user is tracing it shouldn't matter much.
  +      (let ((existing (function-reference-function fref)))
  +        (when (locally
  +                  (declare (notinline typep)) ; bootstrap hack.
  +                (typep existing 'trace-wrapper))
  +          ;; Untrace the function.
  +          (%untrace (function-reference-name fref)))
  +        (setf (function-reference-function (function-reference name)) nil))))
  +  name)
   
   (defun symbol-function (symbol)
     (check-type symbol symbol)
  
positive.code:                   :expected-type 'function-name
                    :datum name))))
  
  (defun function-reference (name)
    "Convert a function name to a function reference."
    (multiple-value-bind (name-root location)
        (decode-function-name name)
      (ecase location
        (symbol
         (or (%object-ref-t name-root +symbol-function+)
             ;; No fref, create one and add it to the function.
             (let ((new-fref (make-function-reference name-root)))
               ;; Try to atomically update the function cell.
               (multiple-value-bind (successp old-value)
                   (%cas-object name-root +symbol-function+ nil new-fref)
                 (if successp
                     new-fref
                     old-value)))))
        (setf
         (let ((fref (gethash name-root *setf-fref-table*)))
           (unless fref
             (let ((new-fref (make-function-reference name)))
               (setf fref (or (cas (gethash name-root *setf-fref-table*) nil new-fref)
                              new-fref))))
           fref))
        (cas
         (let ((fref (gethash name-root *cas-fref-table*)))
           (unless fref
             (let ((new-fref (make-function-reference name)))
               (setf fref (or (cas (gethash name-root *cas-fref-table*) nil new-fref)
                              new-fref))))
  
negative.code:   value)
  
  (defun fdefinition (name)
    (let* ((fref (function-reference name nil))
           (fn (and fref (function-reference-function fref))))
      (when (not fn)
        (error 'undefined-function :name name))
      ;; Hide trace wrappers. Makes defining methods on traced generic functions work.
  