puts "  Compute available exprs at merge point $b"
    }

    # A merge point may need to have phi's inserted. Start with the values
    # that are available from the dominator.

    set avail_in [lindex $pre_avail_out [lindex $bbidom $b]]
    my debug-pre {
	puts "Available from dominator [lindex $bbidom $b]:\
              [dict keys $avail_in]"
    }
    
    # Merge in any values that arrive from all predecessors but
    # do not originate in the dominator
    set firsttime 1
    set newphis {}
    dict for {p -} $preds {
	set avout_p [lindex $pre_avail_out $p]
	my debug-pre {

		} else {
		    dict set newphis $v [list bb $p] [dict get $avout_p $v]
		}
	    }
	}
    }

    if {[dict size $newphis] > 0} {



	# Create any speculative phis
	set newbb {}
	dict for {v argl} $newphis {
	    dict for {- var} $argl break
	    set var [my newVarInstance $var]
	    dict for {frombb in} $argl {
		my addUse $in $b
	    }
	    set insn [linsert $argl 0 phi $var]
	    my debug-pre {
		puts "  Speculative: $b:[llength $newbb]: $insn"
	    }
	    dict set udchain $var $b
	    lappend newbb $insn
	    my pre_gvn_add [list {} $var] $v
	    dict set avail_in $v $var
	}
	set bb [linsert $bb[set bb ""] 0 {*}$newbb]
    }
	
    my debug-pre {
	puts "  Available on entry to $b: [dict keys $avail_in]"
    }
    return $avail_in
    
}


# quadcode::transformer method pre_buildsets2 --
#

	my debug-pre {
	    puts "  Reify $eprime in block $p"
	}
	set argl [lassign $eprime opcode]
	if {$opcode ne {}} {

	    set avail_out_p [lindex $pre_avail_out $p]
	    my debug-pre {
		puts "   Avail values in $p before this mod are\
                         [dict keys $avail_out_p]"
	    }
	    lset pre_avail_out $p {}

	    # A complex expression actually needs to be evaluated
	    # in the predecessor block. Make the instruction and update
	    # ud- and du-chains
	    my debug-pre {
		puts "    Need to find temporary for value $v"

	    my debug-pre {
		puts "  Add $insn before end of block $p"
	    }
	    set pb [linsert $pb[set pb ""] end-1 $insn]
	    lset bbcontent $p $pb
	    
	    # Make the value available at exit from the predecessor
	    my debug-pre {
		puts "  Add value $tv: $t to the avail set on output from $p"
	    }
	    dict set avail_out_p $tv $t
	    lset pre_avail_out $p $avail_out_p
	    my debug-pre {
		puts "  ... which is now [dict keys [lindex $pre_avail_out $p]]"
	    }
	    
	} else {

	    # A simple value is already available and just needs to go
	    # on the phi being constructed
	    
	    set t [lindex $argl 0]

	    set cname [lindex $c 1]
	    if {[lindex $cname 0] eq "var" || [lindex $tempname 0] ne "var"} {
		set tempname $cname
	    }
	}
    }

    return [my newVarInstance $tempname]
}

# quadcode::transformer method pre_phi_translate --
#
#	Translates a set of expressions that are valid in a successor
#	block to ones that are valid in the predecessor block
#



# bbidom --
#
#	Compute the immediate dominators of the basic blocks
#
# Results:
#	Returns zero.
#
# Side effects:
#	Sets 'bbidom' to a list of immediate dominators, indexed by
#	basic block number.
#	Sets 'bbkids' to a list indexed by basic block numbers of the
#	blocks that are immediately dominated by the block.
#

    my debug-ssa {
	puts "after computing dominance relations:"
	set i -1
	foreach id $bbidom kid $bbkids {
	    puts "[incr i]: idom $id kids $kid"
	}
    }
    return 0
}

# quadcode::transformer method bblevel -
#
#	Calculate level numbering in the dominance tree
#
# Preconditions:
#	The 'bbkids' relation must contain the lists of blocks immediately
#	dominated (the inverse of the 'idom' relationship).
#
# Results:
#	Returns zero.
#
# Side effects:
#	'bblevel' is updated for the current block's subtree

oo::define quadcode::transformer method bblevel {} {
    set bblevel [lrepeat [llength $bbkids] -1]
    set bbnlevels -1
    my bblevel-worker 0 0
    my debug-ssa {
	puts "bblevel $bblevel"
    }
    return 0
}
oo::define quadcode::transformer method bblevel-worker {blk level} {
    lset bblevel $blk $level
    if {$level > $bbnlevels} {
	set bbnlevels $level
    }
    incr level

	    cleanupCallFrameUse
	    cleanupNarrow
	    deadjump
	    deadbb
	    deadvars
	    uselessphis
	    constfold
	    bbidom
	    bblevel
	    partialredundancy
	} {
	    set cmd [string map [list @pass $pass] {
		set result [my @pass]
	    }]
	    lappend timings $pass [lindex [time $cmd] 0]
	    if {$result} {