anchor.diff:  ;;;
   ;;; The conflicts are computed in the same way as for the register
   ;;; allocator.  For now, we use a very crude estimate of the number of
  -;;; definitions/uses.  We just count the number of assigning and using
  +;;; definitions/uses.  We just count the number of using and using
   ;;; instructions, except that if an instruction is part of a loop, we
   ;;; count it as 10 instead of as 1.  We could do much better here, by
   ;;; counting nested loops and by taking branches into account.
  
positive.code:   (setf (owner (find-datum-info datum))
  	new))
  
  (defmethod assigning-instructions ((datum sicl-mir:lexical-location))
    (assigning-instructions (find-datum-info datum)))
  
  (defmethod (setf assigning-instructions)
      (new (datum sicl-mir:lexical-location))
    (setf (assigning-instructions (find-datum-info datum))
  	new))
  
  (defmethod using-instructions ((datum sicl-mir:datum))
    (using-instructions (find-datum-info datum)))
  
  (defmethod (setf using-instructions) (new (datum sicl-mir:datum))
    (setf (using-instructions (find-datum-info datum))
  	new))
  
  (defmethod required-register ((datum sicl-mir:datum))
  
negative.code: (defun simplify-instructions (program)
    (let ((*program* program))
      (loop for location in (find-unused-lexical-locations program)
  	  do (loop for instruction in (defining-instructions location)
  		   do (simplify-instruction instruction)))))
  
  (set-processor 'simplified-instructions 'simplify-instructions)
  