# Parameters:
    #	arguments -
    #		The arguments as an LLVM vector value reference. Note that
    #		this includes the function name as the first argument.
    #	havecf -
    #		Tcl boolean indicating if we have a valid callframe.
    #	cf -	The reference to the current callframe if 'havecf' is true.
    #	ns -	The official current namespace, as Namespace*.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	resultName (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	An LLVM value reference.

    method invoke {arguments havecf cf ns ec {resultName ""}} {
	my ExtractVector $arguments
	if {!$havecf} {
	    set cf {}
	}
	my call ${tcl.invoke.command} [list $len $ary $cf $ns $ec] $resultName
    }

    # Builder:invokeExpanded --
    #
    #	Generate code to call a Tcl command while doing argument expansion.
    #	Quadcode implementation ('invokeExpanded').
    #
    # Parameters:
    #	arguments -
    #		The arguments as an LLVM vector value reference. Note that
    #		this includes the function name as the first argument.
    #	flags -	LLVM bit array indicating which arguments to expand.
    #	ns -	The official current namespace, as Namespace*.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	resultName (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	An LLVM value reference.

    method invokeExpanded {arguments flags ns ec {resultName ""}} {
	my ExtractVector $arguments
	my call ${tcl.invoke.expanded} [list $len $ary $flags $ns $ec] $resultName
    }

    # Builder:isBoolean(INT BOOLEAN) --
    #
    #	Test if a value is a boolean. Quadcode implementation ('isBoolean').
    #
    # Parameters:

	    #

	    try {
	    $b @location $currentline
	    switch -exact -- [lindex $l 0 0] {
		"entry" {
		    lassign [my IssueEntry $l] \
			theframe thevarmap thens syntheticargs
		}
		"confluence" - "unset" {
		    # Do nothing; required for SSA computations only
		}
		"@debug-line" {
		    lassign $l opcode - srcfrom
		    set currentline [lindex $srcfrom 1]

			foreach {name value} $phiAnnotations {
			    my AnnotateAssignment $name $value
			}
			set phiAnnotations {}
		    }
		}
		"invoke" {
		    set arguments [my IssueInvoke $theframe $l $thens]
		    foreach aa $arguments {
			set arguments [lassign $arguments a]
			if {$a ni $arguments && consumed($a, $pc + 1)} {
			    lappend consumed $a
			}
		    }
		}
		"invokeExpanded" {
		    set arguments [my IssueInvokeExpanded $theframe $l $thens]
		    foreach aa $arguments {
			set arguments [lassign $arguments a]
			if {$a ni $arguments && consumed($a, $pc + 1)} {
			    lappend consumed $a
			}
		    }
		}

    #	exit.

    method IssueEntry {quad} {
	lassign $quad opcode tgt vars

	# When no frame is wanted
	if {$tgt eq {}} {
	    # FIXME: get namespace
	    set ns {}
	    return [list [$b null CALLFRAME] {} $ns {}]
	}

	# Store the fact that we must generate complex metadata for this
	# function/command, and the variable where this metadata will be
	# stored.
	if {![dict exists $bytecode procmeta]} {
	    dict set bytecode procmeta \

	set procmeta [dict get $bytecode procmeta]
	set localcache [dict get $bytecode localcache]
	lassign [$b frame.create $varmeta $argc $argv \
			[$b load $procmeta "proc.metadata"] \
			[$b load $localcache "proc.localcache"]] \
	    theframe thevarmap
	my StoreResult $tgt $theframe
	set thens [$b dereference $theframe 0 CallFrame.nsPtr]
	return [list $theframe $thevarmap $thens $drop]
    }

    # TclCompiler:IssueInvoke --
    #
    #	Generate the code for invoking another Tcl command. Must only be
    #	called from the 'compile' method.
    #
    # Parameters:
    #	callframe -
    #		The callframe.
    #	operation -
    #		The quadcode descriptor for the instruction.
    #	thens -	The current namespace, used for command resolution.
    #
    # Results:
    #	The set of arguments that might have been consumed in the operation
    #	(for cleanup by the caller of this method).

    method IssueInvoke {callframe operation thens} {
	set arguments [lassign $operation opcode tgt thecallframe origname]
	set vname [my LocalVarName $tgt]
	set BASETYPES {ZEROONE INT DOUBLE NUMERIC STRING}


	# Is this a literal name for a function we already know the signature
	# of? If so, we can use a direct call. To work this out, we need to
	# resolve the command within the namespace context of the procedure.

	if {literal($origname)} {
	    # Resolve the name.
	    set name [my FuncName [lindex $origname 1]]
	    set fullname [my GenerateFunctionName $name arguments \
			      [lrange $arguments 1 end]]
	    if {[$m function.defined $fullname]} {
		set called [[$m function.get $fullname] ref]
		set argvals [lmap arg [lrange $arguments 1 end] {
		    my LoadOrLiteral $arg
		}]
		my IssueInvokeFunction $tgt $called $argvals $vname
		return {}
	    }
	    if {[dict exist $vtypes $tgt]} {
		set type [nameOfType [dict get $vtypes $tgt]]
		if {"FAIL" ni $type || "STRING" ni $type} {
		    my Warn "didn't find implementation of '$fullname'"
		}
	    }



	}



	set argvals [lmap s $arguments {my LoadOrLiteral $s}]

	# Dynamic dispatch via direct call is OK, *provided* someone has
	# fetched the function reference for us.

	if {[TypeOf [lindex $argvals 0]] ne [Type STRING]} {
	    set argvals [lassign $argvals called]
	    my IssueInvokeFunction $tgt $called $argvals $vname
	    return {}
	}

	# Must dispatch via the Tcl command API. This is the slowest option
	# with the least type inference possible (everything goes as a
	# STRING) but it is a reasonable fallback if nothing else works.

	my IssueInvokeCommand $tgt $arguments $argvals $thens $vname
	return $arguments
    }

    method IssueInvokeFunction {tgt func arguments vname} {
	upvar 1 callframe callframe thecallframe thecallframe
	set BASETYPES {ZEROONE INT DOUBLE NUMERIC STRING}

	if {callframe($thecallframe)} {
	    set result [$b frame.pack $callframe $result]
	}
	my StoreResult $tgt $result
    }

    method IssueInvokeCommand {tgt arguments argvals thens vname} {
	upvar 1 callframe callframe thecallframe thecallframe

	set types [lmap s $arguments {my ValueTypes $s}]




	set vector [$b buildVector $types $argvals]
	set result [$b invoke $vector \
			[expr {callframe($thecallframe)}] $callframe \
			$thens $errorCode $vname]
	$b clearVector $arguments $vector $types
	# Result type is now FAIL STRING, always.
	my SetErrorLine $errorCode [$b maybe $result]
	if {callframe($thecallframe)} {
	    set result [$b frame.pack $callframe $result]
	}
	my StoreResult $tgt $result
    }

    # TclCompiler:IssueInvokeExpanded --
    #
    #	Generate the code for invoking another Tcl command with expansion.
    #	Must only be called from the 'compile' method.
    #
    # Parameters:
    #	callframe -
    #		The callframe.
    #	operation -
    #		The quadcode descriptor for the instruction.
    #	thens -	The current namespace, used for command resolution.
    #
    # Results:
    #	The set of arguments that might have been consumed in the operation
    #	(for cleanup by the caller of this method).

    method IssueInvokeExpanded {callframe operation thens} {
	set arguments [lassign $operation opcode tgt thecallframe]
	set vname [my LocalVarName $tgt]
	set expandPositions [lmap s $arguments {
	    expr {"EXPANDED" in [my OperandType $s]}
	}]
	set argvals [lmap s $arguments {my LoadOrLiteral $s}]
	set types [lmap s $arguments {my ValueTypes $s}]
	set vector [$b buildVector $types $argvals]
	set flags [$b buildBitArray $expandPositions]
	set result [$b invokeExpanded $vector $flags $thens $errorCode $vname]
	my SetErrorLine $errorCode [$b maybe $result]
	my StoreResult $tgt [$b frame.pack $callframe $result]
	$b clearVector $arguments $vector $types
	return $arguments
    }

    # TclCompiler:IssueWiden --

	    set NULL [my null Interp*]
	    set code [my setFromAny [$api tclBooleanType] $NULL $objPtr]
	    my ret [my eq $code $0]
	}

	##### Function tcl.invoke.command #####
	#
	# Type signature: objc:int * objv:STRING* * nsptr:Namespace*
	#			* ecvar:int* -> STRING?
	#
	# Calls the Tcl interpreter to invoke a Tcl command, and packs the
	# result into a STRING FAIL.

	set f [$module local "tcl.invoke.command" \
		   STRING?<-int,STRING*,CALLFRAME,Namespace*,int*]
	params objc objv frame nsptr ecvar
	build {
	    noalias $objv $frame $nsptr $ecvar
	    nonnull $objv $nsptr $ecvar
	    set interp [$api tclInterp]
	    my storeInStruct $interp Interp.lookupNsPtr $nsptr
	    my condBr [my nonnull $frame] $frameInvoke $stdInvoke
	label stdInvoke "invoke.standard"
	    set code1 [$api Tcl_EvalObjv $interp $objc $objv $0]
	    my condBr [my eq $code1 $0] $ok $fail
	label frameInvoke "invoke.with.callframe"
	    set vfp [my gep $interp 0 Interp.varFramePtr]
	    set vf [my load $vfp]

	    set code [my phi [list $code1 $code2] [list $stdInvoke $frameInvoke] "code"]
	    my store $code $ecvar
	    my ret [my fail STRING $code]
	}

	##### Function tcl.invoke.expanded #####
	#
	# Type signature: objc:int * objv:STRING* * flags:bool*
	#			* nsptr:Namespace* * ecvar:int* -> STRING?
	#
	# Calls the Tcl interpreter to invoke a Tcl command, first expanding
	# the arguments indicate by the flags array (which will have objc
	# elements in it), and packs the result into a STRING FAIL.

	set f [$module local "tcl.invoke.expanded" \
		   STRING?<-int,STRING*,bool*,Namespace*,int*]
	params objc objv flags nsptr ecvar
	build {
	    noalias $objv $flags $nsptr $ecvar
	    nonnull $objv $flags $nsptr $ecvar
	    set tclobjSize [my cast(int) [my sizeof STRING]]
	    set interp [$api tclInterp]
	    set iPtr [my alloc int "i"]
	    set jPtr [my alloc int "j"]
	    set lenPtr [my alloc int "len"]
	    set objcPtr [my alloc int "objcPtr"]
	    set objvPtr [my alloc STRING* "objvPtr"]

	    my store $obj $target
	    my store [my add $j $1] $jPtr
	    my br $expansionNext
	label expansionNext "next.expansion"
	    my store [my add $i $1] $iPtr
	    my br $expansionTest
	label invoke:
	    my storeInStruct $interp Interp.lookupNsPtr $nsptr
	    set code [$api Tcl_EvalObjv $interp $len $ary $0]
	    $api ckfree $ary
	    my condBr [my eq $code $0] $ok $fail
	label ok:
	    set result [$api Tcl_GetObjResult $interp]
	    my addReference(STRING) $result
	    my ret [my ok $result]

# Results:
#	Returns the frame effect.

oo::define quadcode::specializer method frameEffect___lsort {q} {

    if {[lindex $q 0] eq "invokeExpanded"} {
	# lsort with {*} for the args - punt
	return {
	    reads 0 writes 0 readsNonLocal {} writesNonLocal {}
	    error "lsort with argument expansion is not supported yet"
	}
    }

    # Only [lsort -command] has an interesting frame effect

    # Only [lsort -command] might use callframe data

    lassign [my parse___lsort $q] usesCommand command
    if {!$usesCommand} {
	return {killable Inf noCallFrame {} pure {}}
    }

    # TODO: We can't analyze [lsort -command] yet, but we could.
    #       What it would take is to generate bytecode for the
    #	    command prefix with two dummy arguments, and then
    #	    determine the effect of the bytecode on the callframe.

    return {
	reads 0 writes 0 readsNonLocal {} writesNonLocal {}
	error "lsort -command is not supported yet"
    }

}

# quadcode::specializer method frameEffect___regexp --
#
#	Determines the callframe effect of the [regexp] command
#
# Parameters:
#	q - The quadcode instruction that invokes 'regexp'
#
# Results:
#	Returns the frame effect.

oo::define quadcode::specializer method frameEffect___regexp {q} {
    # 0  - 'invoke'
    # 1  - result callframe
    # 2  - input callframe
    # 3  - ::regexp
    # 4  - regexp
    # 5+ - remaining args

    if {[lindex $q 0] eq "invokeExpanded"} {
	# can't figure out what vars are written, but we know there are
	# no other untoward side effects

	return {reads 0 writes 0}
    }

    # Skip over the command line switches

    set ind 5
    while {$ind < [llength $q] - 2} {
	if {[lindex $q $ind 0] ne "literal"} {
	    return {writes 0}
	}
	switch -exact -- [lindex $q $ind 1] {
	    -about -
	    -expanded -

oo::define quadcode::specializer method frameEffect___regsub {q} {

    # 0  - 'invoke'
    # 1  - result callframe
    # 2  - input callframe
    # 3  - ::regsub
    # 4  - regsub
    # 5+ - remaining args

    if {[lindex $q 0] eq "invokeExpanded"} {
	# can't figure out variable effects but otherwise the command is benign

	return {reads 0 writes 0}
    }

    # Skip over the command line switches

    set ind 5
    while {$ind < [llength $q]} {
	if {[lindex $q $ind 0] ne "literal"} {
	    if {$ind + 3 == [llength $q]} {
		return {killable Inf noCallFrame {} pure {}}
	    } else {
		return [dict create writes $ind]
	    }

#
# Results:
#	Returns a two-element list. The first element is a flag for
#	whether -command is present; the second is the command provided.

oo::define quadcode::specializer method parse___lsort {q} {

    set ind 5
    while {$ind + 1 < [llength $q]} {
	if {[lindex $q $ind 0] eq "literal"} {
	    set opt [lindex $q $ind 1]
	} else {
	    error "substitution in lsort flags is not supported."
	}
	switch -exact -- $opt {

		    "invoke" - "invokeExpanded" {

			# The variables altered by the 'invoke', plus
			# all aliases, are potentially changed.

			set aliases {}
			set atypes [lmap x [my invoke-args $producer] {
			    typeOfOperand $types $x
			}]
			lassign [my variablesProducedBy $producer $atypes] \
			    known wlist
			if {$known} {
			    foreach v $wlist {
				dict set aliases $v {}

		}
		lset bbcontent $b [incr outpc] $q
		continue
	    }

	    # Determine argument types of the consuming call, which always
	    # begins with some output and a callframe input
	    set atypes [lmap x [my invoke-args $consumer] {
		typeOfOperand $types $x
	    }]

	    # Find out what variables that the consumer potentially reads.
	    # Because potentially changed variables may also be unchanged,
	    # list them also.

	    # A callframe is always in a temporary
	    if {[lindex $toCF 0] ne "temp"} continue

	    # Is the result a callframe, and can we eliminate it?
	    set toCFType [typeOfOperand $types $toCF]
	    if {$opcode in {"invoke" "invokeExpanded"}} {
		set atypes [lmap x [my invoke-args $q] {
		    typeOfOperand $types $x
		}]
	    } else {
		set atypes {}
	    }
	    if {($toCFType & $CALLFRAME)
		    && [my canEliminateCallFrame $q $atypes]} {

    # name in the next outer callframe, so can't be done safely.

    # If none of the above conditions hold, the callframe reference and
    # definition can be removed safely from the quad.

    return 1
}

# quadcode::transformer method invoke-args --
#
#	Get the real arguments (other than the command name) that will
#	be used with the invocation.
#
# Parameters:
#	q - Quadcode instruction that produces a callframe.
#
# Results:
#	Returns the list of arguments (quadcode values) if they are
#	meaningful, otherwise produces an error..

oo::define quadcode::transformer method invoke-args {q} {
    switch [lindex $q 0 0] {
	"invoke" {
	    return [lrange $q 5 end]
	}
	"invokeExpanded" {
	    return [lrange $q 4 end]
	}
	"" {
	    # What is going on here?
	    return
	}
	default {
	    return -code error "cannot get invoke arguments from non-invoke\
		opcode '$q'"
	}
    }
}

oo::define quadcode::transformer method fqcmd {} {
    set b 0
    foreach content $bbcontent {
	set i 0
	foreach q $content {
	    if {[lindex $q 0 0] in {"invoke" "invokeExpanded"}
		    && [lindex $q 3 0] eq "literal"} {
		set cmdname [lindex $q 3 1]
		set resolved \
		    [namespace eval $ns [list namespace which $cmdname]]
		if {$resolved ne {}} {
		    set cmdname $resolved
		}
		if {![catch {
		    namespace eval $ns [list namespace origin $cmdname]
		} resolved]} {
		    set cmdname $resolved
		}
		lset bbcontent $b $i 3 1 $cmdname
	    }
	    incr i
	}
	incr b
    }
}

		#	  the invoked procedure raises an error
		set qd [list [list temp [expr {$depth + $acount}]]]
		for {set i $rcount} {$i < $acount} {incr i} {
		    lappend qd [list temp [expr {$depth + $i}]]
		}
		my generate-function-param-check $pc $qd
		# generate the call itself
		my quads invoke {temp @callframe} {temp @callframe} \
		    [lindex $qd 0] {*}$qd
		my quads retrieveResult $result {temp @callframe}
		my quads extractCallFrame {temp @callframe} {temp @callframe}
		my generate-jump [my exception-target $pc catch] maybe $result
		my quads extractMaybe $result $result
	    }
	    invokeStk1 - invokeStk4 {
		set acount [lindex $insn 1]
		set depth [expr {$depth - $acount}]
		set result [list temp $depth]
		set qd {}
		for {set i 0} {$i < $acount} {incr i} {
		    lappend qd [list temp [expr {$depth + $i}]]
		}
		my generate-function-param-check $pc $qd
		# generate the call itself
		my quads invoke {temp @callframe} {temp @callframe} \
		    [lindex $qd 0] {*}$qd
		my quads retrieveResult $result {temp @callframe}
		my quads extractCallFrame {temp @callframe} {temp @callframe}
		my generate-jump [my exception-target $pc catch] maybe $result
		my quads extractMaybe $result $result
	    }
	    jump1 - jump4 {
		switch -exact -- [lindex $insn 1 0] {

			    # must do: dict unset result killable;
			}
		    }
		}

		"invoke" {
		    set did 1
		    set argList [lassign $q opcode cfout cfin resolvedcCmdName orignalCmdName]
		    set typeList [lmap arg $argList {typeOfOperand $types $arg}]
		    if {[catch {
			$specializer frameEffect $q $typeList
		    } attrs]} {
			my diagnostic error $b $pc $attrs
			set attrs {readsAny 1 readsNonLocal 1 \
				       writesAny 1 writesNonLocal 1}
		    }
		    foreach dgtype {error warning} {
			if {[dict exists $attrs $dgtype]} {
			    my diagnostic $dgtype $b $pc [dict get $attrs $dgtype]
			    dict unset attrs $dgtype
			}
		    }
		    my upvarInvoke result $aliasInfo $attrs $q $typeList
		}

	    }

	    my debug-upvar {

#	None.
#
# Side effects:
#	Records the effect of the 'invoke' on the current callframe.

oo::define quadcode::transformer method upvarInvoke {resultV aliasInfo
						     effect q typeList} {


    upvar 1 $resultV result

    set callframe [lindex $q 1]

    # Record purity

    if {![dict exists $effect pure]} {
	dict unset result pure
    }

#       Updates ud- and du-chains.

oo::define quadcode::transformer method varargsRewriteInvoke {b pc q} {

    set newqds {}

    # Take apart the quad
    set argv [lassign $q opcode cfout cfin calleeLit origCallee]

    # We care only about 'invoke' instructions where the procedure name
    # is known a priori, the expected args are known, and the
    # target procedure is compiled.
    if {[lindex $calleeLit 0] ne "literal"
        || [catch {
            set callee [lindex $calleeLit 1]

        #    compilation going.
        return
    }

    # Make a new quad that passes all supplied params that
    # don't go in 'args'. Set 'paramsLeft' to the list of
    # parameters that weren't filled.
    set newq [list invoke $cfout $cfin $calleeLit $origCallee \
                  {*}[lrange $argv 0 [expr {$nonargs-1}]]]
    set paramsleft [lrange $arginfo [llength $argv] [expr {$nonargs-1}]]

    # If we need to fill in optional parameters, do that now
    foreach param $paramsleft {
        if {![info default $callee $param defaultv]} {
            my diagnostic error "Too few args provided to $callee"

    my debug-varargs {
        puts "[my full-name]: $b:$pc: $q"
    }

    # Make the first part of the 'invoke' instruction that will
    # replace the 'invokeExpanded'

    set newq [list invoke $cfout $cfin $calleeLit $calleeLit]

    # We are going to be doing major surgery on the basic block.
    # Remove the 'invokeExpanded' and all following instructions
    # from the block. Unlink the block from its successors, and
    # remove ud- and du-chaining for the removed instructions.

    lassign [my varargsUnlinkTail $b $pc] bb tail