anchor.diff:  ;;;
   ;;; Dominance frontiers.
   
  +;;; Compute a hash table that maps every node in a dominance tree to a
  +;;; list of its children in that tree.
   (defun children (dominance-tree)
     (let ((result (make-hash-table :test #'eq)))
       (loop for node being each hash-key of dominance-tree
  
positive.code: ;;;
  ;;; Although advertised as working on flowgraphs (i.e. a graph where
  ;;; the nodes are basic blocks), it works for any types of graph with
  ;;; similar characteristics, and in particular for flowchars (i.e., w
  ;;; graph where the nodes are individual instructions).  All that we
  ;;; require is that the nodes in the graph can be compared using EQ,
  ;;; and that a function is supplied that returns a list of successors
  
negative.code: ;;;
  ;;; We have tested this implementation on randomly generated graphs by
  ;;; comparing it to the result of a trivial algorithm for computing
  ;;; dominators (see the file test-dominance.lisp).
  ;;;
  ;;; The result is returned as an EQ hash table where the keys
  ;;; represent each node in the graph, and the value associated with
  ;;; the key is the immediate dominator of the node that is the key.
  ;;;
  ;;; The name of this function is not exported, because there is no
  ;;; reason for client code to use it directly.  It is used as a
  ;;; subroutine for computing the dominance tree and the dominance
  ;;; frontiers.
  
  (defun immediate-dominators (start-node successor-fun)
    (let* ((pred (make-hash-table :test #'eq))
  