anchor.diff:  (defvar *current-lambda-name* nil)
   (defvar *gc-info-fixups* nil)
   (defvar *active-nl-exits* nil)
  +(defvar *literal-pool*)
   
   (defconstant +binding-stack-gs-offset+ (- (* 7 8) sys.int::+tag-object+))
   
  
positive.code:     (setf *x0-value* nil)))
  
  (defun load-literal (register value)
    (cond ((zerop value)
           (emit `(lap:orr ,register :wzr 0)))
          (t
           (emit `(lap:ldr ,register (:literal ,value))))))
  
  (defun load-constant (register value)
    (cond ((eq value 'nil)
           (emit `(lap:orr ,register :wzr :x26)))
          ((fixnump value)
           (load-literal register (fixnum-to-raw value)))
          ((characterp value)
  
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))
  