Exemple #1
0
        /// <summary>
        /// ---- Test 5
        /// </summary>
        /// <returns></returns>
        public bool Test5()
        {
            // -------------------------------------------------------------------
            // Создание базового блока
            // -------------------------------------------------------------------
            var a = new Var("a");
            var b = new Var("b");
            var c = new Var("c");

            BasicBlock B = new BasicBlock(new List <Node> {
                AssignC(a, new IntConst(2), IsLabeled: false),   // 0:       a = 2
                AssignC(b, new IntConst(3), IsLabeled: false),   // 1:       b = 3
                AssignC(c, a, b, OpCode.Plus),                   // 2: (1) : c = a + b
                AssignC(a, new IntConst(3)),                     // 3: (2) : a = 3
                AssignC(b, new IntConst(4), IsLabeled: false),   // 4:       b = 4
                AssignC(c, a),                                   // 5: (3) : c = a
                PrintC(c, IsLabeled: false)                      // 6:       print(c)
            });

            // -------------------------------------------------------------------
            // Тест для удаления мертвого кода в CFG
            // -------------------------------------------------------------------

            var TA = new TACode();

            TA.CodeList = B.CodeList.ToList();
            var RCFG = new RemoveDeadVariablesCFG(TA);

            // Результат
            var newCode = RCFG.CodeNew;

            // Должна получиться истина
            return(true);
        }
Exemple #2
0
        /// <summary>
        /// ---- Test 4
        /// </summary>
        /// <returns></returns>
        public bool Test4()
        {
            // -------------------------------------------------------------------
            // Создание базового блока
            // -------------------------------------------------------------------
            var a = new Var("a");
            var b = new Var("b");
            var c = new Var("c");

            BasicBlock B = new BasicBlock(new List <Node> {
                AssignC(a, new IntConst(2), IsLabeled: false),   // 0:       a = 2
                AssignC(b, new IntConst(3), IsLabeled: false),   // 1:       b = 3
                AssignC(c, a, b, OpCode.Plus),                   // 2: (1) : c = a + b
                AssignC(a, new IntConst(3)),                     // 3: (2) : a = 3
                AssignC(b, new IntConst(4), IsLabeled: false),   // 4:       b = 4
                AssignC(c, a),                                   // 5: (3) : c = a
            });

            // -------------------------------------------------------------------
            // Тест для итерационного алогритма Активных Переменных
            // -------------------------------------------------------------------

            var TA = new TACode();

            TA.CodeList = B.CodeList.ToList();
            var CFG = new ControlFlowGraph(TA);
            IterativeAlgorithmAV ItAV = new IterativeAlgorithmAV(CFG);

            // Должна получиться истина
            return(true);
        }
        /// <summary>
        /// Удаление мертвого кода в CFG
        /// </summary>
        /// <returns></returns>
        private TACode RemoveDeadCodeInCFG()
        {
            var code = new TACode();

            code.CodeList = CodeIN.CodeList.ToList();
            ControlFlowGraph cfg;
            int countRemove;

            do
            {
                // Вычисляем CFG
                cfg = new ControlFlowGraph(code);
                // Вычисляем IN и OUT переменные для всех блоков в CFG
                this.OUT    = (new IterativeAlgorithmAV(cfg)).OUT;
                countRemove = 0;

                // Для каждого блока в cfg
                foreach (var B in cfg.CFGNodes)
                {
                    // Удаляем мертвые строки кода
                    var newB        = RemoveDeadCodeInBlock(B);
                    var curCountRem = B.CodeList.Count() - newB.CodeList.Count();

                    if (curCountRem != 0)
                    {
                        var idxStart = CalculateIdxStart(B, code.CodeList);
                        var len      = B.CodeList.Count();
                        code         = ReplaceCode(code, newB.CodeList.ToList(), idxStart, len);
                        countRemove += curCountRem;
                    }
                }
            }while (countRemove != 0);

            return(code);
        }
Exemple #4
0
        /// <summary>
        /// Класс для итеративного алгоритма
        /// активных переменных
        /// </summary>
        /// <param name="CFG"></param>
        public IterativeAlgorithmAV(List <Node> listNode)
        {
            var TA = new TACode();

            TA.CodeList = listNode;
            this.CFG    = new ControlFlowGraph(TA);
            StartSettings();
            Algorithm();
        }
        /// <summary>
        /// Заменияет код
        /// </summary>
        /// <returns></returns>
        private TACode ReplaceCode(TACode code, List <Node> nodes, int idxStart, int len)
        {
            var newCode = new List <Node>();

            newCode.AddRange(code.CodeList.Take(idxStart));
            newCode.AddRange(nodes);
            newCode.AddRange(code.CodeList.Skip(idxStart + len));

            var TA = new TACode();

            TA.CodeList = newCode;

            return(TA);
        }
 /// <summary>
 /// Класс для удаления мертвого кода
 /// в CFG
 /// </summary>
 /// <param name="CFG"></param>
 public RemoveDeadVariablesCFG(TACode code)
 {
     this.CodeIN     = code;
     this.removeVars = new List <Guid>();
     this.CodeNew    = RemoveDeadCodeInCFG();
 }