2022 abstract int multi branch context (#2024)

* WI #2022 Introduce IMultiBranchContext.cs interface

* WI #2022 Adding a comment

* WI #2022 Handling SubContexts

* WI #2022 Handle redirection on PERFORM AFTER branch

* WI #2022 Change Review

* WI #2022 Change review

* WI #2022 replace builder by cfg argument

* WI #2022 Move GetTerminalSuccessorEdges into CFG class

Co-authored-by: fm-117 <milletfl@e-i.com>

Author: mayanje

TypeCobol.Analysis/Cfg/ControlFlowGraphBuilder.BasicBlockForNodeGroup.cs

@@ -29,10 +29,10 @@ public int GroupIndex
             /// <summary>
             /// Terminal blocks within this Group.
             /// </summary>
-            internal List<BasicBlockForNode> TerminalBlocks
+            public IList<BasicBlock<Node, D>> TerminalBlocks
             {
                 get;
-                set;
+                internal set;
             }
 
             /// <summary>

TypeCobol.Analysis/Cfg/ControlFlowGraphBuilder.CfgAfterIterativePerformProcedureTransformer.cs

@@ -47,6 +47,12 @@ private bool Callback(BasicBlock<Node, D> block, int incomingEdge, BasicBlock<No
                     int entranceEdge = cfg.SuccessorEdges.Count;
                     cfg.SuccessorEdges.Add(iterativeGroup.Group.First.Value);
                     block.SuccessorEdges.Add(entranceEdge);
+                    System.Diagnostics.Debug.Assert(block.Context == null);
+                    //If the assert above fails (it should not be case), then it will be necessary to exeute the commented code below.
+                    //if(block.Context != null)
+                    //{
+                    //    ((MultiBranchContext)block.Context).ChangeSuccessor(_cfg, iterativeGroup, iterativeGroup.Group.First.Value);
+                    //}
                 }
 
                 //If the current block is a group, we must also traverse blocks of the group

TypeCobol.Analysis/Cfg/ControlFlowGraphBuilder.MultiBranchContext.cs

@@ -9,7 +9,7 @@ public partial class ControlFlowGraphBuilder<D>
         /// <summary>
         /// The context of a Multi Branch instruction like IF or Evaluate.
         /// </summary>
-        internal class MultiBranchContext
+        internal class MultiBranchContext : IMultiBranchContext<Node, D>
         {
             /// <summary>
             /// Origin block before multi branches
@@ -18,15 +18,11 @@ internal class MultiBranchContext
             /// <summary>
             /// List of multi branch blocks
             /// </summary>
-            internal List<BasicBlockForNode> Branches;
-            /// <summary>
-            /// The Target Control Flow Graph Builder
-            /// </summary>
-            internal ControlFlowGraphBuilder<D> Builder;
+            public IList<BasicBlock<Node, D>> Branches { get; internal set; }
             /// <summary>
             /// Indices in the SuccessorEdges of all blocks in Branches
             /// </summary>
-            internal List<int> BranchIndices;
+            public IList<int> BranchIndices { get; internal set; }
             /// <summary>
             /// Root Block of the multi branches
             /// </summary>
@@ -35,28 +31,45 @@ internal class MultiBranchContext
             /// The Index in the SuccessorEdge of the RootBlock if any, -1 otherwise.
             /// </summary>
             internal int RootBlockSuccessorIndex;
-
+            /// <summary>
+            /// Terminals block associated to Multi branch Context if any.
+            /// Terminals blocks are block that have as successor NextFlowBlock or
+            /// a branching to the beginning of a loop instruction block.
+            /// </summary>
+            public IList<BasicBlock<Node, D>> Terminals { get; internal set; }
             /// <summary>
             /// The instruction associated to this context.
             /// </summary>
-            internal Node Instruction;
-
+            public Node Instruction { get; internal set; }
             /// <summary>
             /// List to hold When, WhenOther, WhenSearch and AtEnd nodes
             /// encountered in Evaluate or Search statements.
             /// </summary>
             internal List<Node> ConditionNodes;
+            /// <summary>
+            /// Block of the next flow
+            /// </summary>
+            public BasicBlock<Node, D> NextFlowBlock { get; internal set; }
+            /// <summary>
+            /// Any Sub context if any, null otherwise.
+            /// For instance in COBOL EVALUATE Context has all WHEN and WHENOTHER as sub contexts.
+            /// </summary>
+            public IList<IMultiBranchContext<Node, D>> SubContexts { get; internal set; }
+
+            private BasicBlock<Node, D> RootBlockForEnd;
+
+            BasicBlock<Node, D> IMultiBranchContext<Node, D>.OriginBlock => this.OriginBlock;
+
+            BasicBlock<Node, D> IMultiBranchContext<Node, D>.RootBlock => this.RootBlock;
 
             /// <summary>
             /// Constructor
-            /// </summary>
-            /// <param name="currentProgramCfgBuilder">The related CFG Builder</param>
+            /// </summary>            
             /// <param name="instruction">The instruction associated to this context </param>
-            internal MultiBranchContext(ControlFlowGraphBuilder<D> currentProgramCfgBuilder, Node instruction)
+            internal MultiBranchContext(Node instruction)
             {
-                Branches = new List<BasicBlockForNode>();
+                Branches = new List<BasicBlock<Node, D>>();
                 BranchIndices = new List<int>();
-                Builder = currentProgramCfgBuilder;
                 Instruction = instruction;
                 RootBlockSuccessorIndex = -1;
             }
@@ -68,44 +81,94 @@ internal MultiBranchContext(ControlFlowGraphBuilder<D> currentProgramCfgBuilder,
             internal void Start(BasicBlockForNode originBlock)
             {
                 this.OriginBlock = originBlock;
+                this.OriginBlock.Context = this;
             }
 
             /// <summary>
             /// End the multi branching.
             /// </summary>
+            /// <param name="cfg">The related CFG Graph</param>
             /// <param name="branchToNext">True if the CurrentBlock must be linked to the next branch also, false otherwise</param>
             /// <param name="nextBlock">The next block for all branches</param>
-            internal void End(bool branchToNext, BasicBlockForNode nextBlock)
+            internal void End(ControlFlowGraph<Node, D> cfg, bool branchToNext, BasicBlockForNode nextBlock)
             {
-                End(branchToNext, OriginBlock, nextBlock);
+                End(cfg, branchToNext, OriginBlock, nextBlock);
             }
             /// <summary>
             /// End the multi branching.
             /// </summary>
+            /// <param name="cfg">The related CFG Graph</param>
             /// <param name="branchToNext">True if the CurrentBlock must be linked to the next branch also, false otherwise</param>
             /// <param name="rootBlock">Root block of the multi branch</param>
             /// <param name="nextBlock">The next block for all branches</param>
-            internal void End(bool branchToNext, BasicBlockForNode rootBlock, BasicBlockForNode nextBlock)
+            internal void End(ControlFlowGraph<Node, D> cfg, bool branchToNext, BasicBlockForNode rootBlock, BasicBlockForNode nextBlock)
             {
-                System.Diagnostics.Debug.Assert(Builder != null);
                 System.Diagnostics.Debug.Assert(rootBlock != null);
                 System.Diagnostics.Debug.Assert(nextBlock != null);
+
+                Terminals = new List<BasicBlock<Node, D>>();
                 //Add the next block to the successors.
-                int nbIndex = Builder.Cfg.SuccessorEdges.Count;
-                Builder.Cfg.SuccessorEdges.Add(nextBlock);
+                int nbIndex = cfg.SuccessorEdges.Count;
+                cfg.SuccessorEdges.Add(nextBlock);
                 //Link current block to all branches.
                 foreach (var b in Branches)
                 {
                     //Add branch to the successors
-                    BranchIndices.Add(Builder.Cfg.SuccessorEdges.Count);
-                    rootBlock.SuccessorEdges.Add(Builder.Cfg.SuccessorEdges.Count);
-                    Builder.Cfg.SuccessorEdges.Add(b);
+                    BranchIndices.Add(cfg.SuccessorEdges.Count);
+                    rootBlock.SuccessorEdges.Add(cfg.SuccessorEdges.Count);
+                    cfg.SuccessorEdges.Add(b);
                     //Next Block is a successor of the branch.
-                    AddTerminalSuccessorEdge(b, nbIndex);
+                    AddTerminalSuccessorEdge(cfg, b, nbIndex);
                 }
                 if (branchToNext)
                 {
                     rootBlock.SuccessorEdges.Add(nbIndex);
+                    Terminals.Add(rootBlock);
+                }
+                RootBlockForEnd = rootBlock;
+                NextFlowBlock = nextBlock;                
+            }
+
+            /// <summary>
+            /// Change the successors
+            /// </summary>
+            /// <param name="cfg">The target CFG graph</param>
+            /// <param name="currentSucc">The current Successor</param>
+            /// <param name="newSucc">The new Successor</param>
+            internal void ChangeSuccessor(ControlFlowGraph<Node, D> cfg, BasicBlock<Node, D> currentSucc, BasicBlock<Node, D> newSucc)
+            {
+                if (NextFlowBlock == currentSucc)
+                    NextFlowBlock = newSucc;
+                if (RootBlockForEnd != null)
+                {
+                    List<BasicBlock<Node, D>> branches = (List<BasicBlock<Node, D>>)Branches;
+                    List<int> branchIndices = (List<int>)BranchIndices;
+                    System.Diagnostics.Debug.Assert(branches.Count == branchIndices.Count);
+                    for (int i = 0; i < branches.Count; i++)
+                    {
+                        if (branches[i] == currentSucc)
+                        {
+                            System.Diagnostics.Debug.Assert(cfg.SuccessorEdges[branchIndices[i]] == currentSucc);
+                            branches[i] = newSucc;
+                            RootBlockForEnd.SuccessorEdges.Remove(branchIndices[i]);
+                            branchIndices[i] = cfg.SuccessorEdges.Count;
+                            RootBlockForEnd.SuccessorEdges.Add(cfg.SuccessorEdges.Count);
+                            cfg.SuccessorEdges.Add(newSucc);
+                            break;
+                        }
+                    }
+                }
+                if (Terminals != null)
+                {
+                    List<BasicBlock<Node, D>> terminals = (List<BasicBlock<Node, D>>)Terminals;
+                    for (int i = 0; i < terminals.Count; i++)
+                    {
+                        if (terminals[i] == currentSucc)
+                        {
+                            terminals[i] = newSucc;
+                            break;
+                        }
+                    }
                 }
             }
 
@@ -121,10 +184,11 @@ internal void AddBranch(BasicBlockForNode block)
             /// <summary>
             /// Add to all terminal block, from a given block b, a given successor index.
             /// </summary>
+            /// <param name="cfg">The related CFG Graph</param>
             /// <param name="b">The starting block</param>
             /// <param name="nbIndex">The terminal successor index</param>
             /// <param name="visitedBlockIndex">Set of already visited Block Index</param>
-            internal void AddTerminalSuccessorEdge(BasicBlockForNode b, int nbIndex, HashSet<int> visitedBlockIndex = null)
+            internal void AddTerminalSuccessorEdge(ControlFlowGraph<Node, D> cfg, BasicBlock<Node, D> b, int nbIndex, HashSet<int> visitedBlockIndex = null)
             {
                 if (visitedBlockIndex == null)
                 {
@@ -139,46 +203,21 @@ internal void AddTerminalSuccessorEdge(BasicBlockForNode b, int nbIndex, HashSet
                     //Ending block has no successors.
                     if (!b.HasFlag(BasicBlock<Node, D>.Flags.Ending))
                     {
-                        if (b != Builder.Cfg.SuccessorEdges[nbIndex])
+                        if (b != cfg.SuccessorEdges[nbIndex])
                         {//Don't create recursion to ourselves
                             b.SuccessorEdges.Add(nbIndex);
+                            Terminals?.Add(b);
                         }
                     }
                 }
                 else
                 {
                     foreach (var s in b.SuccessorEdges)
                     {
-                        AddTerminalSuccessorEdge((BasicBlockForNode)Builder.Cfg.SuccessorEdges[s], nbIndex, visitedBlockIndex);
+                        AddTerminalSuccessorEdge(cfg, (BasicBlockForNode)cfg.SuccessorEdges[s], nbIndex, visitedBlockIndex);
                     }
                 }
             }
-
-            /// <summary>
-            /// Get all terminal blocks from the given block.
-            /// </summary>
-            /// <param name="b">The starting block</param>
-            /// <param name="accumulator">Accumulator of  terminal blocks</param>
-            /// <param name="visitedBlockIndex">Set of already visited Block Index</param>
-            internal void GetTerminalSuccessorEdges(BasicBlockForNode b, List<BasicBlockForNode> accumulator, HashSet<int> visitedBlockIndex = null)
-            {
-                if (visitedBlockIndex == null)
-                {
-                    visitedBlockIndex = new HashSet<int>();
-                }
-                if (visitedBlockIndex.Contains(b.Index))
-                    return;
-                visitedBlockIndex.Add(b.Index);
-                if (b.SuccessorEdges.Count == 0)
-                {
-                    accumulator.Add(b);
-                }
-                else foreach (var s in b.SuccessorEdges)
-                {
-                    GetTerminalSuccessorEdges((BasicBlockForNode)Builder.Cfg.SuccessorEdges[s], accumulator, visitedBlockIndex);
-                }
-            }
-
         }
     }
-}
+}