# 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} {
	set arguments [lassign $operation opcode tgt thecallframe origname]
	set vname [my LocalVarName $tgt]

	set called [my ResolveInvoke \
			[dict get $vtypes $tgt] $origname $arguments]
	if {$called ne {}} {
	    set argvals [lmap arg $arguments {my LoadOrLiteral $arg}]
	    my IssueInvokeFunction $tgt $called $argvals $vname
	    return {}
	} else {

    #
    # Results:
    #	Returns the set of arguments that might have been consumed in the
    #	call (for cleanup by the caller of this method).

    method IssueNREReturnFromInvoke {callframe operation} {



	set arguments [lassign $operation opcode tgt corohandle origname]
	set rettype [dict get $vtypes $tgt]
	set vname [my LocalVarName $tgt]
	set called [my ResolveInvoke $rettype $origname $arguments]
	puts "IssueNREReturnFromInvoke:"
	puts "  tgt = $tgt"
	puts "  rettype = $rettype = [nameOfType $rettype]"
	puts "  origname = $origname"
	puts "  vname = $vname"
	puts "  called = $called"
	if {$called ne {}} {
	    my IssueNREReturnFromInvokedFunction \
		$rettype $tgt $corohandle $callframe $called $arguments $vname
	    return {}
	} else {
	    set arguments [linsert $arguments[set arguments ""] 0 $origname]
	    set i -1
	    my IssueNREReturnFromInvokedCommand \
		$rettype $tgt $corohandle $callframe $arguments $vname
	    ;				# objc will still contain
	    ;				# argument values
	    return $arguments
	    ;				# FIXME: gotta work through the
	    ;			 	# refcounting 
	}
    }

    # TclCompiler:IssueNREReturnFromInvokedFunction --
    #
    #	Generates code to return from compiled NRE code.
    #
    # Parameters:
    #	rettype - Return type of the function
    #   tgt - Quadcode value representing the return value
    #	corohandle - Coroutine handle of the function that's just returned
    #	callframe - The current callframe
    #	called - Quadcode value giving the name of the function that was called
    #   arguments - List of quadcode values representing the arguments
    #	vname - LLVM name to assign to the result of the call
    #
    # Results:
    #	None.

    method IssueNREReturnFromInvokedFunction {rettype tgt corohandle callframe
					      called arguments vname} {

	# Built-in types that are handled here.
	set BASETYPES {ZEROONE INT DOUBLE NUMERIC STRING}
	set ts [lmap t $BASETYPES {Type $t?}]
	set tgttype [my ValueTypes $tgt]

	# Get the name of the function to call
	set callee [my GenerateFunctionName $tgt arguments $arguments]

	# Emit the sequence that destroys the LLVM coroutine and returns the
	# result as 'retval'
	lassign [my returnedFromCoro $rettype $callee $corohandle] \
	    retcode retval

	# Handle the return

	if {$tgttype eq "FAIL"} {
	    # This procedure only ever fails.
	    $b store $retval $errorCode
	    my SetErrorLine $errorCode
	} else {
	    set restype [TypeOf $retval]; # LLVM type ref of the return val
	    puts "Result type is $restype and target type is $tgttype"
	    puts "How could they be different?"
	    if {$restype in $ts} {
		puts "The called function returns a known type"
		$b store [$b extract $retval 0] $errorCode
	    } elseif {[Type $restype?] eq [Type $tgttype]} {
		puts "The called function returns a MAYBE"
		set retval [$b ok $reval]
	    }
	    if {"FAIL" in $tgttype} {
		puts "Result might have failed, set error line"
		my SetErrorLine $errorCode [$b maybe $retval]
	    }
	}

	# Pack a callframe reference with the return if needed

	if {"CALLFRAME" in $tgttype} {
	    puts "Result includes an updated callframe"
	    set result [$b frame.pack $callframe $result]
	}
    }

    # TclCompiler:ResolveInvoke --
    #
    #	Determines whether an invoked command is known as a compiled
    #	function, and resolves it if it is.
    #
    # Parameters:

	    switch [lindex $quads $search 0] {
		"free" {
		    if {[lindex $quads $search 2] eq $var} {
			return $search
		    }
		}
		"jump" - "jumpFalse" - "jumpTrue" - "return" -
		"jumpMaybe" - "jumpMaybeNot" - "NRE.suspend" {
		    return 0
		}
		default {
		    if {$var in [lindex $quads $search]} {
			return 0
		    }
		}


oo::define Builder {

    # Implementation of various support functions needed to support Tcl's
    # coroutines

    variable tcl.coro.runner
    variable tcl.coro.addCallbackToCoroRunner

}

# Builder method @coroFunctions --
#
#	Defines support functions for LLVM coroutines that need to be in
#	LLVM assembly language.

}

# TclCompiler method CoroPromiseType --
#
#	Generates the LLVM type that represents the coroutine promise for
#	the current NRE function

oo::define TclCompiler method CoroPromiseType {{rettype {}} {realname {}}} {
    if {$realname eq {}} {
	set realname [my GenerateFunctionName $cmd typecodes $paramTypes]
    }
    if {$rettype eq {}} {
	set rettype $returnType
    }
    set typestr named 
    append typestr \{ $realname .promise
    append typestr , status:int32
    append typestr , retval: [nameOfType $rettype]
    append typestr \}
    return [Type $typestr]

}

# Builder method launchCoroRunner --
#
#	Generates code to launch the Tcl_NRAddCallback chain that executes
#	the LLVM coroutine representing a Tcl command invocation.
#
# Parameters:
#	handle - LLVM value reference specifying the LLVM coroutine handle

oo::define Builder method launchCoroRunner {handle} {
    my call ${tcl.coro.addCallbackToCoroRunner} $handle
}

# TclCompiler method returnFromCoro --
#
#	Generates code to retrieve the status and return value from
#	a coroutine that has done the final suspend.
#
# Parameters:
#	rettype - The function's return type
#	callee - The name of the function that has been called
#
# Results:
#	Returns a list of two LLVM value refs: the status code and the
#	return value.

oo::define TclCompiler method returnedFromCoro {rettype callee corohandle} {

    # Retrieve the coroutine promise from the coroutine handle

    set handle [my LoadOrLiteral $corohandle]
    set ptype [my CoroPromiseType $rettype $callee]
    set alignment [$b cast(int) [AlignOf $ptype] "alignment"]
    set paddr_raw [$b call [$m intrinsic coro.promise] \
		       [list $handle $alignment [Const false bool]] \
		       "promise.addr.raw"]
    set paddr [$b cast(ptr) $paddr_raw $ptype "promise.addr"]

    # Retrieve the return code and return value of the called procedure

    set rcodeaddr [$b gep $paddr 0 0]
    set rcode [$b load $rcodeaddr "return.code"]
    set rvaladdr [$b gep $paddr 0 1]
    set rval [$b load $rvaladdr "return.value"]

    # Destroy the coroutine - we're done with it now.

    $b call [$m intrinsic coro.destroy] [list $handle]

    # Return the status and result

    return [list $rcode $rval]
}

# TclCompiler method CoroSuspend --
#
#	Generates code to suspend the current coroutine and resume at a
#	specified basic block.
#
# Parameters: