Ejemplo n.º 1
0
 public Statement Map(Statement stmt)
 {
     Statement result;
     if (!_map.TryGetValue(stmt, out result))
         result = stmt;
     return result;
 }
Ejemplo n.º 2
0
 public void Map(Statement oldStmt, Statement newStmt)
 {
     _map[oldStmt] = newStmt;
 }
Ejemplo n.º 3
0
 public virtual void InlineCall(Statement stmt)
 {
     Variable returnVariable;
     Statement inlined = stmt.RemoveRets(out returnVariable);
     _cstack.Peek().Statements.Add(inlined);
 }
Ejemplo n.º 4
0
 /// <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());
 }
Ejemplo n.º 5
0
 public IntegerIndexTransformer(Statement root)
 {
     _root = root;
 }
 public ConcurrentStatementExtractor(Statement root)
 {
     _root = root;
     Success = true;
     Statements = new List<ConcurrentStatement>();
 }
Ejemplo n.º 7
0
 public CoStateAssigner(AsyncMethodDecompiler me, IList<Variable> activeVars, Statement body, int ownState)
 {
     _me = me;
     _activeVars = activeVars;
     _body = body;
     _ownState = ownState;
 }
Ejemplo n.º 8
0
        /// <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;
 }
Ejemplo n.º 10
0
 public void AcceptBreakCase(BreakCaseStatement stmt)
 {
     _execLeaf = stmt;
 }
Ejemplo n.º 11
0
 public void AcceptNop(NopStatement stmt)
 {
     _execLeaf = stmt;
 }
Ejemplo n.º 12
0
 public void AcceptStore(StoreStatement stmt)
 {
     object value = stmt.Value.Eval(Evaluator);
     _varValues[stmt.Container] = value;
     _execLeaf = stmt;
 }
Ejemplo n.º 13
0
 public void AcceptContinueLoop(ContinueLoopStatement stmt)
 {
     _execLeaf = stmt;
 }
Ejemplo n.º 14
0
 public void AcceptBreakLoop(BreakLoopStatement stmt)
 {
     _execLeaf = stmt;
 }
Ejemplo n.º 15
0
 public void AcceptGoto(GotoStatement stmt)
 {
     _execLeaf = stmt;
 }
Ejemplo n.º 16
0
        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;
        }
Ejemplo n.º 17
0
 public void AcceptReturn(ReturnStatement stmt)
 {
     if (stmt.ReturnValue != null)
         ReturnValue = stmt.ReturnValue.Eval(Evaluator);
     _execLeaf = stmt;
 }
Ejemplo n.º 18
0
 public StateAssigner(AsyncMethodDecompiler me, Statement body, bool singleState = false)
 {
     _me = me;
     _body = body;
     _singleState = singleState;
 }
Ejemplo n.º 19
0
 public void AcceptThrow(ThrowStatement stmt)
 {
     _execLeaf = stmt;
 }
Ejemplo n.º 20
0
 public StateWeaver(AsyncMethodDecompiler me, Statement body)
 {
     _me = me;
     _body = body;
 }
Ejemplo n.º 21
0
 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);
     }
 }