RETURN (standard)
Effect on state

	was:
		gct_writelog(""), return <instrumented-expr>
	is:
		1.  return T=<expr>, gct_writelog, T
	or	2.  return gct_writelog, <expr>


Data structures:
	The expr being modified
		Original "self" node
			simple token.
			complex expr.
			call to fun with instrumentation (from bug report)
		Modified node.
			multicondition return
			Any other (descent instrumentation)
	"self" itself
		As original.
		Relationship to parent changed (race coverage)
	return has an argument
	return has no argument

Operations
Specification:
	Return from main & writelog on 
		(changed code has some effect)
	NOT return from main, writelog on
		(nothing should be done)
UNDONE	return from main, writelog OFF

==================

EXIT (standard)
Effect on state
	was:
		gct_writelog(), exit(x);
	now:
		exit(gct_writelog(), x)
	or	exit(T=x,gct_writelog(),T)

Data structures
	call coverage for exit node
	no call coverage for exit node (relationship to parent unchanged)
	Argument has coverage
	Argument is simple (no coverage)
	Argument is function call to function with coverage (bug report)
	Argument is complex, but no coverage.
Operations
Specification
	exit function & writelog on 
		(changed code has some effect)
	NOT exit function, writelog on
		(nothing should be done)
	exit function, writelog OFF
	Exit routine is exit();
	exit routine is abort();
	exit routine takes two arguments.


Easy thing to do is duplicate for race coverage.
(Just checking for catastrophic failures.)
