anchor.diff:                                '(:unboxed . :home))
                             *stack-values*))))
   
  +(defun kill-value (tag)
  +  (setf *load-list* (delete tag *load-list*)))
  +
   (defun value-location (tag &optional kill)
     (when kill
  -    (setf *load-list* (delete tag *load-list*)))
  +    (kill-value tag))
     (cond ((eq (car tag) 'quote)
            (values (if (and (consp *x0-value*)
                             (eq (car *x0-value*) 'quote)
  
positive.code:          (*trailers* '())
           (arg-registers '(:x0 :x1 :x2 :x3 :x4))
           (*gc-info-fixups* '())
           (*active-nl-exits* '()))
      ;; Check some assertions.
      ;; No keyword arguments, no special arguments, no non-constant
      ;; &optional init-forms and no non-local arguments.
  
negative.code:                      (when (eq best tag)
                         (return nil)))))))))
  
  (defun cg-go (form)
    (let ((tag (assoc (ast-target form) *rename-list*)))
      (smash-x0)
      (cond (tag ;; Local jump.
             (emit `(lap:b ,(second tag))))
            (t ;; Non-local exit.
             (let ((tagbody-tag (let ((*for-value* t))
                                  (cg-form (ast-info form)))))
               (load-in-reg :x9 tagbody-tag t)
               ;; RAX holds the tagbody info.
               (emit
                ;; Get X0 as well.
                `(lap:orr :x0 :xzr :xzr)
                ;; GO GO GO!
                `(lap:ldr :x10 (:x9 0))
                `(lap:ldr :x11 (:x10 ,(* (position (ast-target form)
                                                   (tagbody-information-go-tags
                                                    (go-tag-tagbody (ast-target form))))
                                         8)))
                `(lap:add :x10 :x10 :x11)
                `(lap:br :x10)))))
      'nil))
  
  (defun branch-to (label) (declare (ignore label)))
  (defun emit-label (label)
    (emit label))
  