# Nonexistent variables
    nextest1
    nextest2
    nextest3
    nextest4
    # Array operations
    wordcounter1
    wordcounter2
    wordcounter3
    # Calls of uncompiled code
    calltest
    calltest2
    calltest3
    # The interprocedural tests
    mrtest::*
    coscaller
    xsum
    xsum2	
    # Miscellaneous other tests
    bctest
    asmtest
    # Combined feature tests
    lcmRange
    bug-0616bcf08e::*
    qsort
    impure
    # impure2					BUG FAIL IMPURE
    comps
    linesearch::colinear
    linesearch::sameline
    linesearch::getAllLines1			BUG
    linesearch::getAllLines2
    # flightawarebench::*
}

#########################################################################
#
# Support procedures for the demonstration runner.

    if {[dict exists $duchain $v]} {
	set uses [dict get $duchain $v]
	
	if {[dict size $uses] > 1} {
	    
	    # The variable appears in more than one block, so ipso facto
	    # is not local.

	    return 1
	}
	dict for {k count} $uses break
	
	if {$k != $b} {
	    
	    # All uses are in some other block, so variable isn't local
	    # to this block.
	    
	    return 1
	}
	
	# Scan the phi's in this block for a use.
	
	foreach q [lindex $bbcontent $b] {
	    if {[lindex $q 0 0] ne "phi"} {
		break
	    }
	    foreach {from what} [lrange $q 2 end] {
		if {$v eq $what} {
		    return 1;	# used in a phi in the current block
		}
	    }
	}
    }

    my variable bbcontent

    set retval {}
    set bb [lindex $bbcontent $b]
    foreach q $bb {
	set res [lindex $q 1]
	if {[lindex $res 0] in {"var" "temp"}} {
	    if {[my usedElsewhere $res $b]} {
#		dict set retval [lrange $res 0 1] $res
		lappend retval $res
	    }
	}
    }
#   return [dict values $retval]
    return $retval
}

	puts "param types: $ptype"
	puts "var types:"
	foreach {v type} [lsort -dictionary -index 0 -stride 2 $newtypes] {
	    puts "  $v: $type ([nameOfType $type])"
	}
	my dump-quadcode
    }
    puts "[llength $quads] quads after flattening"
    return [list [dict get $types return] $ptype $newtypes $quads]
}

oo::define quadcode::specializer method makeInstance {procName argTypes} {

    # Run type widening on the instance, and record its new dependencies.
    unset -nocomplain instanceBeingAnalyzed
    set instance [list $procName $argTypes]
    set inf [dict get $typeInf $instance]
    puts ${procName}([lmap ty $argTypes {nameOfType $ty}]);		# TEMP

    return [$inf getFlattenedQuads]
}

# quadcode::specializer method PrecedenceWorker --
#
#	Method that visits each node of a call graph to assign precedence.
#

    #
    # Side effects:
    #	Infers types one final time, eliminates any redundant type checks,
    #	and runs the cleanup optimizations.

    method retransform {} {
	foreach pass {






	    typeunroll
	    inferTypes
	} {
	    dict set timings $pass [lindex [time [list my $pass]] 0]
	}
	my debug-timings {
	    dict for {pass usec} $timings {

    #
    # Results:
    #	Returns a four-element list: return type, list of parameter types,
    #	list of variable types, list of quadcode instructions.

    method getFlattenedQuads {} {

	# Do a final pass of type inference and perform loop transformations
	my retransform

	# Insert instructions to widen types at phis.
	my widen

	# Perform the analysis of live ranges, inserting instructions
	# as needed to adjust reference counts at phis and to free

    
    my debug-inferTypes {
	puts "Before type inference:"
	my dump-bb
    }

    namespace upvar ::quadcode::dataType BOTTOM BOTTOM FAIL FAIL

    # Initialize all types to BOTTOM
    set types {}
    dict for {v -} $udchain {
	dict set types $v $BOTTOM
    }
    dict set types return $BOTTOM
    
    # Put all basic blocks on the worklist for processing in depth-first
    # order

	    }
	}
    }
    my debug-inferTypes {
	puts "Types inferred:"
	foreach {v type} [lsort -dictionary -index 0 -stride 2 $types] {
	    puts [format "%s: %#x (%s)" $v: $type [nameOfType $type]]
	    if {$type < 0} {
		puts "                ~[nameOfType [expr {~$type}]]"
	    }
	}
    }
}

# typeOfResult --
#
#	Computes the type of the result of an operation

    my debug-typeunroll {
	puts "Before unrolling loops for data types:"
	my dump-bb
    }

    set done 1

    # FIXME: It would be better to track down the source of runaways and
    #        resolve the underlying problem. For now, defend against runaways
    #	     by limiting the number of splits that we will perform

    set maxSplits [llength $bbcontent]
    if {$maxSplits > 100} {
	set maxSplits 100
    }
    set maxSplits 20; # for now... just to keep runaways in check
    puts "limit splits to $maxSplits"
    set splitCount 0

    while {$done} {

	incr splitCount
	puts "SPLIT $splitCount"

	if {$splitCount > $maxSplits} break

	# The preceding few rounds of optimization have made various changes
	# to the flow graph without keeping bbidom, bbkids, bbnlevels, bblevel
	# in sync. Rebuild them now.
	
	my inferTypes
	my cleanupNarrow

	foreach b [my bborder] {
	    set bb [lindex $bbcontent $b]
	    set pc -1
	    foreach q $bb {
		set done 0
		incr pc
		if {[lindex $q 0] ne "phi"} break
		# FIXME: Find out where runaways are coming from before
		#        just putting in an arbitrary safety limit
		# Safety: Limit number of predecessors to curb runaways
		if {[llength $q] > 18} {
		    puts "Bail out: too many predecessors to split"
		    break
		}
		set v1 [lindex $q 3]
		set t1 [typeOfOperand $types $v1]
		if {$t1 == 0} {
		    error "NOTHING ends up in $v1 at $b:$pc: $q"
		}
		foreach {origin v2} [lrange $q 4 end] {
		    set t2 [typeOfOperand $types $v2]

		    if {$t2 == 0} {
			error "NOTHING ends up in $v2 at $b:$pc: $q"
		    }

		    # Split if one value is IMPURE, EMPTY or OTHERSTRING,
		    # while the other value is none of the above.

		    set expensive1 \
			[expr {($t1 & ($IMPURE | $EMPTY | $OTHERSTRING)) != 0}]
		    set expensive2 \

		    if {!$done && ($t2 & $OTHERSTRING)
			&& [::quadcode::dataType::isa $t1 \
				[expr {$IMPURE | $NUMERIC | $BOOLEAN}]]} {
			set done 1
		    }

		    if {$done} {
			puts "split block $b: [llength $bb] quads and\
                              [expr {([llength $q] - 1)/2}] predecessors"
			my debug-typeunroll {
			    puts "$b:$pc: $q"
			    puts [format "\tis a candidate for node splitting\
			                  %s = %#llx %s" \
				      $v1 $t1 [nameOfType $t1]]
			    if {$t1 < 0} {
				puts "       ~[nameOfType [expr {~$t1}]]"
			    }
			    puts [format "%s = %#llx %s" \
				      $v2 $t2 [nameOfType $t2]]
			    if {$t2 < 0} {
				puts "       ~[nameOfType [expr {~$t2}]]"
			    }
			}
			break
		    } else {
			my debug-typeunroll {

	    my tu_cloneBB $b
	    my debug-typeunroll {
		puts "After splitting:"
		my dump-bb
	    }
	}
    }

    # Final cleanup

    my inferTypes
    my cleanupNarrow
    my deadjump
    my deadbb
    my deadvars
    my deadphis

}
    
# quadcode::transformer method tu_cloneBB --
#
#	Clones a basic block that has been identified as a candidate
#	for splitting.
#

    set commandList {}
    if {$specializer ne {}} {
	set commandList [$specializer commandList]
    }

    # Walk through all the quadcodes


    set b -1
    foreach content $bbcontent {
	incr b
	set newcontent {}
	set pc -1
	foreach q $content {
	    incr pc

	    # Begin by handling 'args'. Construct a list of the arguments
	    # that will fill 'args', and add it to the 'invoke'.
	    # NOTE: This means that compiled-to-compiled 'invoke' MUST NOT
	    # call the thunk, which will expect the list to be flattened.

	    set argl $argv
	    if {[lindex $argv end] eq "args"} {
		set args [my newVarInstance {temp args}]
		set newq1 \
		    [lreplace $q 0 [expr {[llength $argv] + 1}] "list" $args]
		if {[llength $q] > [llength $argl] + 3} {
		    set newq2 [lreplace $q [expr {[llength $argl] + 2}] end]
		} else {
		    set newq2 $q
		}