예제 #1
0
        public void BuildProcedureStructure()
        {
            var cfgs = new ProcedureStructureBuilder(proc);

            ProcedureStructure = cfgs.Build();
            cfgs.AnalyzeGraph();
        }
예제 #2
0
        public ProcedureStructure Build()
        {
            BuildNodes();
            DefineEdges();

            curProc = CreateProcedureStructure();
            SetTimeStamps();
            BuildDerivedSequences(curProc);
            return(curProc);
        }
예제 #3
0
 public void GenerateCode(ProcedureStructure proc, List <AbsynStatement> stms)
 {
     nodesToRender.Enqueue(new NodeEmitter(proc.EntryNode, new AbsynStatementEmitter(stms)));
     while (nodesToRender.Count > 0)
     {
         NodeEmitter ne = nodesToRender.Dequeue();
         if (IsVisited(ne.Node))
         {
             EmitGotoAndForceLabel(ne.Predecessor, ne.Node, ne.Emitter);
         }
         GenerateCode(ne.Node, null, ne.Emitter);
     }
 }
예제 #4
0
        public ProcedureStructure CreateProcedureStructure()
        {
            List <StructureNode> nodes = new List <StructureNode>();

            foreach (StructureNode node in blockNodes.Values)
            {
                nodes.Add(node);
            }

            var newProc = new ProcedureStructure(proc.Name, nodes);

            newProc.EntryNode = blockNodes[proc.EntryBlock];
            newProc.ExitNode  = blockNodes[proc.ExitBlock];
            this.curProc      = newProc;
            return(newProc);
        }
예제 #5
0
        public DerivedSequenceBuilder(ProcedureStructure proc)
        {
            this.graphs = proc.DerivedGraphs;
            this.ib     = new IntervalBuilder();
            var gr = BuildDerivedGraph(proc.Nodes, proc.EntryNode);

            graphs.Add(gr);
            while (gr.Graph.Nodes.Count > 1)
            {
                DerivedGraph newGr = BuildNextOrderGraph(gr);
                if (newGr.Graph.Nodes.Count == gr.Graph.Nodes.Count)
                {
                    return;
                }
                graphs.Add(newGr);
                gr = newGr;
            }
        }
예제 #6
0
        private void StructureLoops(ProcedureStructure curProc)
        {
            for (int gLevel = 0; gLevel < curProc.DerivedGraphs.Count; ++gLevel)
            {
                var curGraph = curProc.DerivedGraphs[gLevel];
                foreach (Interval curInt in curGraph.Intervals)
                {
                    var headNode = IntervalHeaderNode(curInt);
                    var intNodes = curInt.FindIntervalNodes(gLevel);
                    var latch    = FindGreatestEnclosingBackEdgeInInterval(headNode, intNodes);

                    // If a latch was found and it doesn't belong to another loop,
                    // tag the loop nodes and classify it.
                    if (latch != null && latch.Loop == null)
                    {
                        CreateLoop(curProc, headNode, intNodes, latch);
                    }
                }
            }
        }
예제 #7
0
        private void CreateLoop(ProcedureStructure curProc, StructureNode headNode, HashSet <StructureNode> intervalNodes, StructureNode latch)
        {
            Debug.WriteLine(string.Format("Creating loop {0}-{1}", headNode.Name, latch.Name));

            // if the head node has already been determined as a loop header then the nodes
            // within this loop have to be untagged and the latch reset to its original type
            if (headNode.Loop != null && headNode.Loop.Latch != null)
            {
                StructureNode oldLatch = headNode.Loop.Latch;

                // reset the latch node's structured class. Only need to do this for a 2 way latch
//                if (oldLatch.BlockType == bbType.cBranch)
//                    oldLatch.SetStructType(structType.Cond);

                // untag the nodes
                for (int i = headNode.Order - 1; i >= oldLatch.Order; i--)
                {
                    if (curProc.Ordering[i].Loop.Header == headNode)
                    {
                        curProc.Ordering[i].Loop = null;
                    }
                }
            }


            // the latching node will already have been structured as a conditional header. If it is not
            // also the loop header (i.e. the loop is over more than one block) then reset
            // it to be a sequential node otherwise it will be correctly set as a loop header only later
//            if (latch != headNode)
//                latch.SetStructType(structType.Seq);


            var lf        = new LoopFinder(headNode, latch, curProc.Ordering);
            var loopNodes = lf.FindNodesInLoop(intervalNodes);
            var loop      = lf.DetermineLoopType(loopNodes);
        }
예제 #8
0
 // Build the sequence of derived graphs for each procedure
 public void BuildDerivedSequences(ProcedureStructure curProc)
 {
     DerivedSequenceBuilder d = new DerivedSequenceBuilder(curProc);
 }
예제 #9
0
 public UnstructuredConditionalAnalysis(ProcedureStructure curProc)
 {
     this.curProc = curProc;
 }