anchor.diff:    (emit-gc-info :multiple-values 0)
     (call-argument-teardown (call-arguments instruction)))
   
  +(defmethod emit-lap (backend-function (instruction x86-tail-call-instruction) uses defs)
  +  (call-argument-setup (call-arguments instruction))
  +  (emit `(lap:mov64 :r13 (:function ,(call-function instruction)))
  +        `(lap:leave)
  +        ;; Don't use emit-gc-info, using a custom layout.
  +        `(:gc :no-frame :layout #*0)
  +        `(lap:jmp (:object :r13 ,sys.int::+fref-entry-point+))))
  +
  +(defmethod emit-lap (backend-function (instruction x86-tail-funcall-instruction) uses defs)
  +  (call-argument-setup (call-arguments instruction))
  +  (emit `(lap:leave)
  +        ;; Don't use emit-gc-info, using a custom layout.
  +        `(:gc :no-frame :layout #*0)
  +        `(lap:jmp (:object :rbx ,sys.int::+function-entry-point+))))
  +
   (defmethod emit-lap (backend-function (instruction funcall-instruction) uses defs)
     (call-argument-setup (call-arguments instruction))
     (emit `(lap:call (:object :rbx ,sys.int::+function-entry-point+)))
  
positive.code: (defmethod mezzano.compiler.backend::print-instruction ((instruction x86-branch-instruction))
    (format t "   ~S~%"
            `(:x86-branch ,(x86-instruction-opcode instruction) ,(x86-branch-target instruction))))
  
  (defun resolve-constant (register defs)
    (let ((register-defs (gethash register defs)))
  
negative.code:                                :operands (list result `((:rbp ,(ash 1 sys.int::+n-fixnum-bits+))))
                                 :inputs (list)
                                 :outputs (list result)))
                 (mezzano.compiler.backend::remove-instruction backend-function inst)))
              ((and sys.c::*perform-tce*
                    (typep inst 'call-multiple-instruction)
                    (typep next-inst 'return-multiple-instruction)
                    (<= (length (call-arguments inst)) 5))
               ;; (call-multiple ...) (return-multiple) => (tail-call ...)
               (mezzano.compiler.backend::insert-before
                backend-function inst
                (make-instance 'x86-tail-call-instruction
                               :function (call-function inst)
                               :arguments (call-arguments inst)))
               (let ((return-inst next-inst))
                 ;; Point next to the instruction after the return.
                 (setf next-inst (mezzano.compiler.backend::next-instruction backend-function next-inst))
                 ;; Remove the old call & return.
                 (mezzano.compiler.backend::remove-instruction backend-function inst)
                 (mezzano.compiler.backend::remove-instruction backend-function return-inst)))
              ((and sys.c::*perform-tce*
                    (typep inst 'funcall-multiple-instruction)
                    (typep next-inst 'return-multiple-instruction)
                    (<= (length (call-arguments inst)) 5))
               ;; (funcall-multiple ...) (return-multiple) => (tail-funcall ...)
               (mezzano.compiler.backend::insert-before
                backend-function inst
                (make-instance 'x86-tail-funcall-instruction
                               :function (call-function inst)
                               :arguments (call-arguments inst)))
               (let ((return-inst next-inst))
                 ;; Point next to the instruction after the return.
                 (setf next-inst (mezzano.compiler.backend::next-instruction backend-function next-inst))
                 ;; Remove the old call & return.
                 (mezzano.compiler.backend::remove-instruction backend-function inst)
                 (mezzano.compiler.backend::remove-instruction backend-function return-inst)))))))
  
  (defun peephole (backend-function)
    (do* ((inst (mezzano.compiler.backend::first-instruction backend-function) next-inst)
  