control flow graph to structured control flow

Author: gga0wp

language/evm/move-to-yul/src/generator.rs

@@ -22,6 +22,7 @@ use move_stackless_bytecode::{
     reaching_def_analysis::ReachingDefProcessor,
     stackless_bytecode::{Bytecode, Constant, Label, Operation},
     stackless_control_flow_graph::{BlockContent, BlockId, StacklessControlFlowGraph},
+    stackless_structured_control_flow::{StacklessStructuredControlFlow},
 };
 
 use crate::{
@@ -32,6 +33,7 @@ use crate::{
 const CONTRACT_ATTR: &str = "contract";
 const CREATE_ATTR: &str = "create";
 const CALLABLE_ATTR: &str = "callable";
+const CFG_TO_SCF: bool = false;
 
 /// Immutable context passed through the compilation.
 struct Context<'a> {
@@ -144,10 +146,7 @@ impl Generator {
     fn objects(&mut self, ctx: &Context) {
         emitln!(
             ctx.writer,
-            "\
-/* =======================================
- * Generated by Move-To-Yul compiler v{}
- * ======================================= */",
+            "{}",
             ctx.options.version(),
         );
         emitln!(ctx.writer);
@@ -321,43 +320,58 @@ impl Generator {
         // Compute control flow graph, entry block, and label map
         let code = target.data.code.as_slice();
         let cfg = StacklessControlFlowGraph::new_forward(code);
-        let entry_bb = Self::get_actual_entry_block(&cfg);
-        let label_map = Self::compute_label_map(&cfg, code);
-
-        // Emit state machine to represent control flow.
-        // TODO: Eliminate the need for this, see also
-        //    https://medium.com/leaningtech/solving-the-structured-control-flow-problem-once-and-for-all-5123117b1ee2
-        if cfg.successors(entry_bb).iter().all(|b| cfg.is_dummmy(*b)) {
-            // In this trivial case, we have only one block and can omit the state machine
-            if let BlockContent::Basic { lower, upper } = cfg.content(entry_bb) {
-                for offs in *lower..*upper + 1 {
-                    self.bytecode(ctx, &target, &label_map, &code[offs as usize], false);
+
+        if !CFG_TO_SCF {
+            let entry_bb = Self::get_actual_entry_block(&cfg);
+            let label_map = Self::compute_label_map(&cfg, code);
+
+            // Emit state machine to represent control flow.
+            // TODO: Eliminate the need for this, see also
+            //    https://medium.com/leaningtech/solving-the-structured-control-flow-problem-once-and-for-all-5123117b1ee2
+            if cfg.successors(entry_bb).iter().all(|b| cfg.is_dummmy(*b)) {
+                // In this trivial case, we have only one block and can omit the state machine
+                if let BlockContent::Basic { lower, upper } = cfg.content(entry_bb) {
+                    for offs in *lower..*upper + 1 {
+                        self.bytecode(ctx, &target, &label_map, &code[offs as usize], false);
+                    }
+                } else {
+                    panic!("effective entry block is not basic")
                 }
             } else {
-                panic!("effective entry block is not basic")
-            }
-        } else {
-            emitln!(ctx.writer, "let $block := {}", entry_bb);
-            emitln!(ctx.writer, "for {} true {} {");
-            ctx.writer.indent();
-            emitln!(ctx.writer, "switch $block");
-            for blk_id in &cfg.blocks() {
-                if let BlockContent::Basic { lower, upper } = cfg.content(*blk_id) {
-                    // Emit code for this basic block.
-                    emitln!(ctx.writer, "case {} {{", blk_id);
-                    ctx.writer.indent();
-                    for offs in *lower..*upper + 1 {
-                        self.bytecode(ctx, &target, &label_map, &code[offs as usize], true);
+                emitln!(ctx.writer, "let $block := {}", entry_bb);
+                emitln!(ctx.writer, "for {} true {} {");
+                ctx.writer.indent();
+                emitln!(ctx.writer, "switch $block");
+                for blk_id in &cfg.blocks() {
+                    if let BlockContent::Basic { lower, upper } = cfg.content(*blk_id) {
+                        // Emit code for this basic block.
+                        emitln!(ctx.writer, "case {} {{", blk_id);
+                        ctx.writer.indent();
+                        for offs in *lower..*upper + 1 {
+                            self.bytecode(ctx, &target, &label_map, &code[offs as usize], true);
+                        }
+                        ctx.writer.unindent();
+                        emitln!(ctx.writer, "}")
                     }
-                    ctx.writer.unindent();
-                    emitln!(ctx.writer, "}")
                 }
+                ctx.writer.unindent();
+                emitln!(ctx.writer, "}"); // for
             }
             ctx.writer.unindent();
-            emitln!(ctx.writer, "}"); // for
+            emitln!(ctx.writer, "}\n"); // function            
+        } else {
+            let scf_top_sort = StacklessStructuredControlFlow::new(cfg).top_sort;
+
+            while let block_id_vec = scf_top_sort.pop() {
+                let blocks = block_id_vec.unwrap();
+                let block_contents: Vec<BlockContent> = blocks.iter().map(|block_id| cfg.content(*block_id)).collect();
+    
+                
+            }
+
+            // TODO emit new style of codes based on the transformed structured control flow
+            // based on while, if/else and block
         }
-        ctx.writer.unindent();
-        emitln!(ctx.writer, "}\n"); // function
     }
 
     /// Get the actual entry block, skipping trailing dummy blocks.

language/move-prover/bytecode/Cargo.toml

@@ -31,6 +31,7 @@ once_cell = "1.7.2"
 paste = "1.0.5"
 petgraph = "0.5.1"
 workspace-hack = { version = "0.1", path = "../../../crates/workspace-hack" }
+topological-sort = "0.1"
 
 [dev-dependencies]
 move-stdlib = { path = "../../move-stdlib" }

language/move-prover/bytecode/src/lib.rs

@@ -38,9 +38,11 @@ pub mod pipeline_factory;
 pub mod reaching_def_analysis;
 pub mod read_write_set_analysis;
 pub mod spec_instrumentation;
+pub mod stackifier_topological_sort;
 pub mod stackless_bytecode;
 pub mod stackless_bytecode_generator;
 pub mod stackless_control_flow_graph;
+pub mod stackless_structured_control_flow;
 pub mod usage_analysis;
 pub mod verification_analysis;
 pub mod verification_analysis_v2;

language/move-prover/bytecode/src/stackifier_topological_sort.rs

@@ -0,0 +1,157 @@
+
+use std::collections::{HashMap, HashSet};
+use std::collections::hash_map::Entry;
+use crate::stackless_control_flow_graph::BlockId;
+
+#[derive(Clone, Debug)]
+pub struct StackifierDependency {
+    pub num_prec: usize,
+    pub succ_set: HashSet<BlockId>,
+}
+
+#[derive(Clone, Debug)]
+pub struct StackifierTopologicalSort {
+    pub last_popped_block: Option<BlockId>,
+    top: HashMap<BlockId, StackifierDependency>,
+    /// complete topology will not change while popping
+    complete_top: HashMap<BlockId, StackifierDependency>,
+}
+
+impl StackifierDependency {
+    pub fn new() -> StackifierDependency {
+        StackifierDependency {
+            num_prec: 0,
+            succ_set: HashSet::new(),
+        }
+    }
+}
+
+impl StackifierTopologicalSort {
+    #[inline]
+    pub fn new() -> StackifierTopologicalSort {
+        StackifierTopologicalSort {
+            last_popped_block: Option::None,
+            top: HashMap::new(),
+            complete_top: HashMap::new(),
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.top.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.top.is_empty()
+    }
+
+    pub fn add_dependency(&self, prec: BlockId, succ: BlockId) {
+        Self::add_dependency_impl(&mut self.top, prec, succ);
+        Self::add_dependency_impl(&mut self.complete_top, prec, succ);
+    }
+
+    fn add_dependency_impl(top: &mut HashMap<BlockId, StackifierDependency>, prec: BlockId, succ: BlockId) {
+        match top.entry(prec) {
+            Entry::Vacant(e) => {
+                let mut dep = StackifierDependency::new();
+                dep.succ_set.insert(succ);
+                e.insert(dep);
+            }
+            Entry::Occupied(e) => {
+                if !e.into_mut().succ_set.insert(succ) {
+                    return;
+                }
+            }
+        }
+    }
+
+    /// Here is the main difference of this topological sort,
+    /// instead of picking random node w/o precessor after popping the last node,
+    /// we prioritize nodes with last popped node as their only precessor.
+    /// Also if the prioritized node is also the only successor of last popped node,
+    /// we will keep popping until either condition becomes false.
+    pub fn pop(&mut self) -> Option<Vec<BlockId>> {
+        let peek_blocks = self.peek();
+        match self.peek() {
+            Some(peek_blocks) => {
+                for peek_block in peek_blocks {
+                    self.remove(peek_block);
+                    self.last_popped_block = Some(peek_block);
+                }
+            },
+            None => {}
+        }
+        peek_blocks
+    }
+
+    pub fn remove(&mut self, prec: BlockId) -> Option<StackifierDependency> {
+        let result = self.top.remove(&prec);
+        if let Some(ref p) = result {
+            for s in &p.succ_set {
+                if let Some(y) = self.top.get_mut(s) {
+                    y.num_prec -= 1;
+                }
+            }
+        }
+        result
+    }
+
+    pub fn peek(&self) -> Option<Vec<BlockId>> {
+        let priority_succ = None;
+        if let last_block = self.last_popped_block {
+            priority_succ = self.find_priority_succ(last_block.unwrap());
+        }
+        // if last_popped_block has no other successor other than 
+        let nested_blocks = vec![];
+        if let curr_block_option = priority_succ {
+            let curr_block = curr_block_option.unwrap();
+            nested_blocks.push(curr_block);
+            if let curr_dependency = self.complete_top.get(&curr_block) {
+                let succ_set = curr_dependency.unwrap().succ_set;
+                let next_priority_succ = self.find_priority_succ(curr_block);
+                // nest blocks when 1. curr_block has only one succ;
+                // && 2. the succ has only one precessor
+                while succ_set.len() == 1 && next_priority_succ.is_some() {
+                    nested_blocks.push(next_priority_succ.unwrap());
+                    curr_block = next_priority_succ.unwrap();
+                    priority_succ = next_priority_succ;
+
+                    if let dependency = self.complete_top.get(&curr_block) {
+                        succ_set = dependency.unwrap().succ_set;
+                        next_priority_succ = self.find_priority_succ(curr_block);
+                    }
+                }
+            }
+        } else {
+            let next_succ = self.top
+                .iter()
+                .filter(|&(_, v)| v.num_prec == 0)
+                .map(|(k, _)| k)
+                .next()
+                .cloned();
+            if next_succ.is_none() {
+                return None;
+            } else {
+                nested_blocks.push(next_succ.unwrap());
+            }
+        }
+        Some(nested_blocks)
+    }
+
+    pub fn find_priority_succ(&self, last_block: BlockId) -> Option<BlockId> {
+        let priority_succ = None;
+        if let last_block_dependency = self.complete_top.get(&last_block) {
+            for succ in last_block_dependency.unwrap().succ_set {
+                if let complete_succ_dependency = self.complete_top.get(&succ) {
+                    let succ_prec_num = complete_succ_dependency.unwrap().num_prec;
+                    if succ_prec_num > 1 {continue}
+                } else {continue}
+                // priority succ is a block whose only precessor is last_popped_block
+                priority_succ = Some(succ);
+                break;
+            }
+        }
+        priority_succ
+    }
+}

language/move-prover/bytecode/src/stackless_control_flow_graph.rs

@@ -7,6 +7,7 @@
 use crate::{
     function_target::FunctionTarget,
     stackless_bytecode::{Bytecode, Label},
+    graph::Graph as ProverGraph,
 };
 use move_binary_format::file_format::CodeOffset;
 use petgraph::{dot::Dot, graph::Graph};
@@ -17,9 +18,9 @@ type Set<V> = BTreeSet<V>;
 pub type BlockId = CodeOffset;
 
 #[derive(Debug)]
-struct Block {
-    successors: Vec<BlockId>,
-    content: BlockContent,
+pub struct Block {
+    pub successors: Vec<BlockId>,
+    pub content: BlockContent,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -32,9 +33,10 @@ pub enum BlockContent {
 }
 
 pub struct StacklessControlFlowGraph {
-    entry_block_id: BlockId,
-    blocks: Map<BlockId, Block>,
-    backward: bool,
+    // TODO: think if we should leave them as public
+    pub entry_block_id: BlockId,
+    pub blocks: Map<BlockId, Block>,
+    pub backward: bool,
 }
 
 const DUMMY_ENTRANCE: BlockId = 0;
@@ -232,6 +234,16 @@ impl StacklessControlFlowGraph {
     }
 }
 
+impl StacklessControlFlowGraph {
+    pub fn to_prover_graph(&self) -> Option<ProverGraph<BlockId>> {
+
+    }
+
+    pub fn from_prover_graph(graph: ProverGraph<BlockId>) -> Self {
+
+    }
+}
+
 // CFG dot graph generation
 struct DotCFGBlock<'env> {
     block_id: BlockId,