public Statement Map(Statement stmt)
{
Statement result;
if (!_map.TryGetValue(stmt, out result))
result = stmt;
return result;
}
public void Map(Statement oldStmt, Statement newStmt)
{
_map[oldStmt] = newStmt;
}
public virtual void InlineCall(Statement stmt)
{
Variable returnVariable;
Statement inlined = stmt.RemoveRets(out returnVariable);
_cstack.Peek().Statements.Add(inlined);
}
/// <summary>
/// Analyzes the statement tree and determines the <c>Successor</c> property of each statement.
/// </summary>
/// <param name="stmt">statement to complete</param>
public static void Link(Statement stmt)
{
stmt.Accept(new Visitor());
}
public IntegerIndexTransformer(Statement root)
{
_root = root;
}
public ConcurrentStatementExtractor(Statement root)
{
_root = root;
Success = true;
Statements = new List<ConcurrentStatement>();
}
public CoStateAssigner(AsyncMethodDecompiler me, IList<Variable> activeVars, Statement body, int ownState)
{
_me = me;
_activeVars = activeVars;
_body = body;
_ownState = ownState;
}
/// <summary>
/// Decompiles the method to an explicit state machine representation
/// </summary>
/// <returns>decopmiled method</returns>
public IDecompilationResult DecompileToFSM()
{
InitializeCFGs();
int numILStates = _stateCFGs.Length;
var design = _code.GetDesign();
var owner = _code.Owner as ComponentDescriptor;
var myps = _code as ProcessDescriptor;
// Decompile state handlers
_stateInfos = new Dictionary<StateInfo, StateInfo>();
var decomp = new MSILDecompiler(_code, _stateCFGs[1], _fsmInstance);
_curTempl = decomp.Template;
_curTempl.AddAttribute(this);
_curTempl.DisallowReturnStatements = true;
_curTempl.DisallowConditionals = true;
_curTempl.DisallowLoops = true;
var lvState = _curTempl.ExportLocalVariableState();
var startSI = new StateInfo(0);
foreach (var kvp in _locFields)
startSI.LVState[kvp.Key] = kvp.Value.Type.GetSampleInstance(ETypeCreationOptions.ForceCreation);
_stateInfos[startSI] = startSI;
_curSI = startSI;
var stateList = new List<StateInfo>();
stateList.Add(startSI);
_stateQ = new Queue<StateInfo>();
startSI.Result = decomp.Decompile();
while (_stateQ.Any())
{
var nextSI = _stateQ.Dequeue();
_curSI = nextSI.Fork(nextSI.ILState);
decomp = new MSILDecompiler(_code, _stateCFGs[nextSI.ILState + 1], _fsmInstance);
_curTempl = decomp.Template;
_curTempl.AddAttribute(this);
_curTempl.DisallowReturnStatements = true;
_curTempl.DisallowConditionals = true;
_curTempl.DisallowLoops = true;
_curSI.Result = decomp.Decompile();
stateList.Add(_curSI);
_stateInfos[_curSI] = _curSI;
}
// Create enumeration type for state
string prefix = _code.Name;
string enumName = "t_" + prefix + "_state";
var stateNames = new List<string>();
for (int i = 0; i < stateList.Count; i++)
{
string name;
if (stateList[i].HasWaitState)
{
name = enumName + "_await_" + i;
stateNames.Add(name);
}
name = enumName + "_" + i;
stateNames.Add(name);
}
int numStates = stateNames.Count;
Statement[] states;
SignalDescriptor stateSignal = null;
if (numStates > 1)
{
var enumType = design.CreateEnum(enumName, stateNames);
_stateValues = enumType.CILType.GetEnumValues();
var enumDefault = _stateValues.GetValue(0);
int j = 0;
for (int i = 0; i < stateList.Count; i++)
{
if (stateList[i].HasWaitState)
stateList[i].WaitStateValue = _stateValues.GetValue(j++);
stateList[i].StateValue = _stateValues.GetValue(j++);
}
// Create signals for state
string stateSignalName = prefix + "_state";
stateSignal = owner.CreateSignalInstance(stateSignalName, enumDefault);
_nextStateSignal = stateSignal;
// Implement state joins
states = new Statement[numStates];
j = 0;
for (int i = 0; i < stateList.Count; i++)
{
if (stateList[i].HasWaitState)
{
var wsb = new DefaultAlgorithmBuilder();
ImplementJoin(stateList[i].JP, wsb, stateList[i]);
var join = wsb.Complete();
states[j++] = join.Body;
}
states[j++] = stateList[i].Result.Decompiled.Body;
}
// Replace ProceedWithState calls with actual states
for (j = 0; j < states.Length; j++)
{
var orgBody = states[j];
var xform = new StateAssigner(this, orgBody);
var state = xform.GetAlgorithm();
states[j] = state.Body;
}
}
else
{
// Implement state joins
states = new Statement[1];
// Replace ProceedWithState calls with actual states
var xform = new StateAssigner(this, stateList[0].Result.Decompiled.Body, true);
var state = xform.GetAlgorithm();
states[0] = state.Body;
}
var calledMethods = stateList
.SelectMany(b => b.Result.CalledMethods)
.Distinct()
.ToList();
var calledSyncMethods = calledMethods
.Where(mci => !mci.Method.IsAsync())
.ToList();
var referencedFields = stateList
.SelectMany(b => b.Result.ReferencedFields)
.Distinct()
.ToList();
var referencedLocals = stateList
.SelectMany(b => b.Result.Decompiled.LocalVariables)
.Distinct();
_coFSMs = DecompileCoFSMs(calledMethods);
// Extract clock edge
var predFunc = _context.CurrentProcess.Predicate;
var predInstRef = LiteralReference.CreateConstant(predFunc.Target);
var arg = new StackElement(predInstRef, predFunc.Target, EVariability.ExternVariable);
var edge = _curTempl.GetCallExpression(predFunc.Method, arg).Expr;
// Synchronous process
var alg = new DefaultAlgorithmBuilder();
foreach (var v in referencedLocals)
{
alg.DeclareLocal(v);
}
alg.If(edge);
// Co state machines
foreach (var cofsm in _coFSMs.Order)
{
foreach (var argv in cofsm.Arguments)
alg.DeclareLocal(argv);
alg.DeclareLocal(cofsm.DoneVar);
if (cofsm.ResultVar != null)
alg.DeclareLocal(cofsm.ResultVar);
_curCoFSM = cofsm;
var weaver = new StateWeaver(this, cofsm.HandlerBody);
alg.InlineCall(weaver.GetAlgorithm().Body);
}
// Main state machine switch statement
if (numStates > 1)
{
var switchStmt = alg.Switch(
SignalRef.Create(stateSignal, SignalRef.EReferencedProperty.Cur));
{
for (int i = 0; i < states.Length; i++)
{
var stateValue = _stateValues.GetValue(i);
alg.Case(LiteralReference.CreateConstant(stateValue));
var weaver = new StateWeaver(this, states[i]);
alg.InlineCall(weaver.GetAlgorithm().Body);
alg.Break(switchStmt);
alg.EndCase();
}
}
alg.EndSwitch();
}
else
{
var weaver = new StateWeaver(this, states[0]);
alg.InlineCall(weaver.GetAlgorithm().Body);
}
alg.EndIf();
var syncPS = alg.Complete();
syncPS.Name = prefix + "$sync";
myps.Kind = Process.EProcessKind.Triggered;
myps.Sensitivity = new ISignalOrPortDescriptor[] { ((SignalBase)predFunc.Target).Descriptor };
return new Result(syncPS, calledSyncMethods, referencedFields);
}
public void AcceptGotoCase(GotoCaseStatement stmt)
{
_execLeaf = stmt;
}
public void AcceptBreakCase(BreakCaseStatement stmt)
{
_execLeaf = stmt;
}
public void AcceptNop(NopStatement stmt)
{
_execLeaf = stmt;
}
public void AcceptStore(StoreStatement stmt)
{
object value = stmt.Value.Eval(Evaluator);
_varValues[stmt.Container] = value;
_execLeaf = stmt;
}
public void AcceptContinueLoop(ContinueLoopStatement stmt)
{
_execLeaf = stmt;
}
public void AcceptBreakLoop(BreakLoopStatement stmt)
{
_execLeaf = stmt;
}
public void AcceptGoto(GotoStatement stmt)
{
_execLeaf = stmt;
}
private CoFSM DecompileToCoFSM(string prefix)
{
ImplStyle = EAsyncImplStyle.FSM;
InjectAttributes(prefix);
InitializeCFGs();
CoFSM cofsm = new CoFSM();
var args = _code.AsyncMethod.GetParameters();
cofsm.Arguments = new Variable[args.Length];
_argFields = new Dictionary<string, Variable>();
for (int i = 0; i < args.Length; i++)
{
string name = prefix + "_" + args[i].Name;
var argv = new Variable(TypeDescriptor.GetTypeOf(_arguments[i]))
{
Name = name
};
_argFields[args[i].Name] = argv;
cofsm.Arguments[i] = argv;
}
int numILStates = _stateCFGs.Length;
var mym = _code as MethodDescriptor;
cofsm.Method = mym;
cofsm.Dependencies = new HashSet<Task>();
// Create result variable and done flag
cofsm.DoneVar = new Variable(typeof(bool)) {
Name = prefix + "_$done"
};
if (_code.AsyncMethod.ReturnType.IsGenericType &&
_code.AsyncMethod.ReturnType.GetGenericTypeDefinition().Equals(typeof(Task<>)))
{
var resultType = _code.AsyncMethod.ReturnType.GetGenericArguments()[0];
if (!resultType.Equals(typeof(void)))
{
cofsm.ResultVar = new Variable(resultType)
{
Name = prefix + "_$result"
};
var builderType = typeof(AsyncTaskMethodBuilder<>).MakeGenericType(resultType);
AttributeInjector.Inject(builderType,
new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType));
var aoc1 = builderType.GetMethod("AwaitOnCompleted");
var aoc2 = builderType.GetMethod("AwaitUnsafeOnCompleted");
var rwc = new AwaitOnCompletedRewriter();
AttributeInjector.Inject(aoc1, rwc);
AttributeInjector.Inject(aoc2, rwc);
var sr = builderType.GetMethod("SetResult");
var rwsr = new SetResultRewriter();
AttributeInjector.Inject(sr, rwsr);
var se = builderType.GetMethod("SetException");
var serw = new SetExceptionRewriter();
AttributeInjector.Inject(se, serw);
AttributeInjector.Inject(builderType, new HideDeclaration());
var awaiterType = typeof(TaskAwaiter<>).MakeGenericType(resultType);
AttributeInjector.Inject(awaiterType,
new MapToIntrinsicType(Meta.EIntrinsicTypes.IllegalRuntimeType));
AttributeInjector.Inject(awaiterType.GetMethod("get_IsCompleted"), new RewriteIsCompleted());
AttributeInjector.Inject(awaiterType.GetMethod("OnCompleted"), new AwaitOnCompletedRewriter());
AttributeInjector.Inject(awaiterType.GetMethod("UnsafeOnCompleted"), new AwaitOnCompletedRewriter());
AttributeInjector.Inject(awaiterType.GetMethod("GetResult"), new RewriteGetResult());
AttributeInjector.Inject(awaiterType, new HideDeclaration());
}
}
// Decompile state handlers
_stateInfos = new Dictionary<StateInfo, StateInfo>();
var decomp = new MSILDecompiler(_code, _stateCFGs[0], _fsmInstance);
_curTempl = decomp.Template;
_curTempl.AddAttribute(this);
_curTempl.DisallowReturnStatements = true;
_curTempl.DisallowConditionals = true;
_curTempl.DisallowLoops = true;
var lvState = _curTempl.ExportLocalVariableState();
var startSI = new StateInfo(-1);
foreach (var kvp in _locFields)
startSI.LVState[kvp.Key] = kvp.Value.Type.GetSampleInstance(ETypeCreationOptions.ForceCreation);
_stateInfos[startSI] = startSI;
_curSI = startSI;
var stateList = new List<StateInfo>();
stateList.Add(startSI);
_stateQ = new Queue<StateInfo>();
_curCoFSM = cofsm;
startSI.Result = decomp.Decompile();
while (_stateQ.Any())
{
var nextSI = _stateQ.Dequeue();
_curSI = nextSI.Fork(nextSI.ILState);
decomp = new MSILDecompiler(_code, _stateCFGs[nextSI.ILState + 1], _fsmInstance);
_curTempl = decomp.Template;
_curTempl.AddAttribute(this);
_curTempl.DisallowReturnStatements = true;
_curTempl.DisallowConditionals = true;
_curTempl.DisallowLoops = true;
_curSI.Result = decomp.Decompile();
stateList.Add(_curSI);
_stateInfos[_curSI] = _curSI;
}
// Create state active variables
cofsm.StateActiveVars = new List<Variable>();
int j = 0;
for (int i = 0; i < stateList.Count; i++)
{
if (stateList[i].HasWaitState)
{
cofsm.StateActiveVars.Add(new Variable(typeof(bool))
{
Name = prefix + "_$waitStateActive" + i
});
stateList[i].WaitStateValue = j++;
}
cofsm.StateActiveVars.Add(new Variable(typeof(bool))
{
Name = prefix + "_$stateActive" + i
});
stateList[i].StateValue = j++;
}
int numStates = j;
// Replace ProceedWithState calls with actual states
var states = new Statement[numStates];
j = 0;
for (int i = 0; i < stateList.Count; i++)
{
if (stateList[i].HasWaitState)
{
var wsb = new DefaultAlgorithmBuilder();
ImplementJoin(stateList[i].JP, wsb, stateList[i]);
//wsb.Call(stateList[i].JoinSpec, new Expression[0]);
var join = wsb.Complete();
states[j++] = join.Body;
}
states[j++] = stateList[i].Result.Decompiled.Body;
}
for (j = 0; j < states.Length; j++)
{
var orgBody = states[j];
var xform = new CoStateAssigner(this, cofsm.StateActiveVars, orgBody, j);
var state = xform.GetAlgorithm();
states[j] = state.Body;
}
var calledMethods = stateList
.SelectMany(b => b.Result.CalledMethods)
.Distinct()
.ToList();
var calledSyncMethods = calledMethods
.Where(mci => !mci.Method.IsAsync())
.ToList();
cofsm.CalledMethods = calledSyncMethods;
// State handlers
var alg = new DefaultAlgorithmBuilder();
alg.Store(cofsm.DoneVar, LiteralReference.CreateConstant(false));
for (int i = states.Length - 1; i >= 1; i--)
{
var lrsa = (LiteralReference)cofsm.StateActiveVars[i];
alg.If(lrsa);
alg.InlineCall(states[i]);
alg.EndIf();
}
var handlerAlg = alg.Complete();
cofsm.HandlerBody = handlerAlg.Body;
alg = new DefaultAlgorithmBuilder();
alg.Store(cofsm.DoneVar, LiteralReference.CreateConstant(false));
alg.InlineCall(states[0]);
cofsm.InitialHandler = alg.Complete().Body;
return cofsm;
}
public void AcceptReturn(ReturnStatement stmt)
{
if (stmt.ReturnValue != null)
ReturnValue = stmt.ReturnValue.Eval(Evaluator);
_execLeaf = stmt;
}
public StateAssigner(AsyncMethodDecompiler me, Statement body, bool singleState = false)
{
_me = me;
_body = body;
_singleState = singleState;
}
public void AcceptThrow(ThrowStatement stmt)
{
_execLeaf = stmt;
}
public StateWeaver(AsyncMethodDecompiler me, Statement body)
{
_me = me;
_body = body;
}
private void GenerateComments(Statement stmt)
{
string comment = stmt.Comment;
if (comment == null)
return;
string[] lines = comment.Split(new string[] { System.Environment.NewLine }, StringSplitOptions.None);
foreach (string line in lines)
{
_tw.WriteLine("-- " + line);
}
}