anchor.diff:           (rest-head nil)
            (rest-tail nil)
            (reg-save-done (gensym "REG-SAVE-DONE")))
  +    (when dx-rest
  +      (setf *used-dynamic-extent* t))
       (setf rest-head (find-stack-slot)
             (aref *stack-values* rest-head) (cons :rest-head :home))
       (setf rest-tail (find-stack-slot)
  
positive.code: (defvar *trailers* nil)
  (defvar *current-lambda-name* nil)
  (defvar *gc-info-fixups* nil)
  
  (defconstant +binding-stack-gs-offset+ (- (* 1 8) sys.int::+tag-array-like+))
  (defconstant +tls-base-offset+ (- sys.int::+tag-array-like+))
  
negative.code:            (let ((tagbody-tag (let ((*for-value* t))
                                  (cg-form (third form)))))
               (load-in-reg :rax tagbody-tag t)
               ;; Data registers must be flushed unconditionally here.
               ;; If this closure was called from a function with DX values
               ;; then there might still be livish DX values left over.
               (flush-data-registers nil)
               ;; RAX holds the tagbody info.
               (emit
                ;; Get R8 as well.
                `(sys.lap-x86:xor32 :r8d :r8d)
                ;; GO GO GO!
                `(sys.lap-x86:mov64 :rdx (:rax 0))
                `(sys.lap-x86:add64 :rdx (:rdx ,(* (position (second form)
                                                             (tagbody-information-go-tags
                                                              (go-tag-tagbody (second form))))
                                                   8)))
                `(sys.lap-x86:jmp :rdx)))))
      'nil))
  
  (defun branch-to (label))
  