anchor.diff:                (clobbers (make-hash-table :test 'eq :synchronized nil)))
             (dolist (inst order)
               (setf (gethash inst clobbers) (instruction-all-clobbers inst architecture mv-flow live-in live-out)))
  -          (make-instance 'linear-allocator
  -                         :function backend-function
  -                         :ordering order
  -                         :architecture architecture
  -                         :live-in live-in
  -                         :live-out live-out
  -                         :mv-flow mv-flow
  -                         :cfg-preds bb-preds
  -                         :instruction-clobbers clobbers
  -                         :debug-variable-value-map debug-map
  -                         :max-debug-p (= (sys.c::optimize-quality (ir::ast backend-function) 'debug) 3)))))))
  +          (multiple-value-bind (vreg-to-id id-to-vreg)
  +              (number-virtual-registers backend-function)
  +            (make-instance 'linear-allocator
  +                           :function backend-function
  +                           :ordering order
  +                           :architecture architecture
  +                           :live-in live-in
  +                           :live-out live-out
  +                           :mv-flow mv-flow
  +                           :cfg-preds bb-preds
  +                           :instruction-clobbers clobbers
  +                           :debug-variable-value-map debug-map
  +                           :max-debug-p (= (sys.c::optimize-quality (ir::ast backend-function) 'debug) 3)
  +                           :vreg-to-id vreg-to-id
  +                           :id-to-vreg id-to-vreg)))))))
   
   (defun virtual-registers-used-by-debug-info (allocator inst)
     (if (max-debug-p allocator)
  
positive.code: 
  (defclass live-range ()
    ((%vreg :initarg :vreg :reader live-range-vreg)
     ;; Start & end (inclusive) of this range, in allocator order.
     (%start :initarg :start :reader live-range-start)
     (%end :initarg :end :reader live-range-end)
  
negative.code:              (dolist (r live)
                 (format t "   ~S~%" r))))
           (let ((current-range-start (live-range-start range))
                 (current-vreg (live-range-vreg-id range)))
             (insert-into-vreg-set spilled-vregs current-vreg)
             ;; Expire old ranges.
             (setf live (remove-if (lambda (x)
                                     (< (live-range-end x) current-range-start))
                                   live))
             ;; Add new interference edges.
             (dolist (range live)
               (flet ((insert (vreg other)
                        (let ((interference (aref result vreg)))
                          (when (not interference)
                            (setf interference (make-vreg-set)
                                  (aref result vreg) interference))
                          (insert-into-vreg-set interference other))))
                 (let ((other-vreg (live-range-vreg-id range)))
                   (when (and (not (eql other-vreg current-vreg))
                              (not (vreg-set-contains (aref result other-vreg) current-vreg)))
                     (insert current-vreg other-vreg)
                     (insert other-vreg current-vreg)))))
             (push range live)))
      (values result spilled-vregs)))
  
  (defun assign-stack-slots (allocator interference-graph spilled-vregs)
    (let ((slots (make-array 8 :adjustable t :fill-pointer 0 :initial-element '()))
          (slot-classes (make-array 8 :adjustable t :fill-pointer 0 :initial-element '()))
          (locations (make-hash-table))
          (id-to-vreg-table (allocator-id-to-vreg-table allocator)))
      (loop
         for vreg-id across spilled-vregs
         for vreg = (aref id-to-vreg-table vreg-id)
         do
           (dotimes (i (length slots)
                     (progn
                       ;; SSE slots are 2 wide.
                       ;; TODO: Force 16-byte alignment.
                       (when (eql (ir:virtual-register-kind vreg) :sse)
                         (vector-push-extend (list vreg-id) slots)
                         (vector-push-extend :pad slot-classes))
                       (setf (gethash vreg locations) (length slots))
                       (vector-push-extend (list vreg-id) slots)
                       (vector-push-extend (ir:virtual-register-kind vreg) slot-classes)))
             (when (and (eql (aref slot-classes i) (ir:virtual-register-kind vreg))
                        (not (dolist (entry (aref slots i) nil)
                               (when (vreg-set-contains (aref interference-graph entry) vreg-id)
                                 (return t)))))
               ;; Does not interfere with any register in this slot.
               (push vreg-id (aref slots i))
               (setf (gethash vreg locations) i)
               (return))))
      (values locations slot-classes)))
  
  (defun allocate-registers (backend-function arch &key ordering)
    (sys.c:with-metering (:backend-register-allocation)
  