control flow graph to structured control flow

Author: gga0wp

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

@@ -24,4 +24,9 @@ impl Experiment {
     /// during tests this is off.
     /// Retention: permanent
     pub const CAPTURE_SOURCE_INFO: &'static str = "capture-source-info";
+
+    /// Transform control flow graph to structured control flow.
+    /// This is off by default for now, we might want to make it default
+    /// if the performance improvement is significant.
+    pub const APPLY_CFG_TO_SCF: &'static str = "apply-cfg-to-scf";
 }

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

@@ -14,9 +14,10 @@ use move_stackless_bytecode::{
     function_target_pipeline::FunctionVariant,
     stackless_bytecode::{Bytecode, Constant, Label, Operation},
     stackless_control_flow_graph::{BlockContent, BlockId, StacklessControlFlowGraph},
+    stackless_structured_control_flow::{StacklessSCG, StacklessStructuredControlFlow},
 };
 use sha3::{Digest, Keccak256};
-use std::collections::{btree_map::Entry, BTreeMap};
+use std::collections::{btree_map::Entry, BTreeMap, BTreeSet};
 
 /// Mutable state of the function generator.
 pub(crate) struct FunctionGenerator<'a> {
@@ -107,48 +108,260 @@ impl<'a> FunctionGenerator<'a> {
             // 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, fun_id, target, &label_map, &code[offs as usize], false);
+
+            if !ctx.options.apply_cfg_to_scf() {
+                self.emit_cfg(&cfg, code, ctx, fun_id, target);
+            } else {
+                self.emit_scf_from_cfg(&cfg, code, ctx, fun_id, target);
+            }
+        });
+        emitln!(ctx.writer)
+    }
+
+    fn emit_cfg(
+        &mut self,
+        cfg: &StacklessControlFlowGraph,
+        code: &[Bytecode],
+        ctx: &Context,
+        fun_id: &QualifiedInstId<FunId>,
+        target: &FunctionTarget,
+    ) {
+        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,
+                        fun_id,
+                        target,
+                        &label_map,
+                        &code[offs as usize],
+                        false,
+                        false,
+                    );
+                }
+            } else {
+                panic!("effective entry block is not basic")
+            }
+        } else {
+            emitln!(ctx.writer, "let $block := {}", entry_bb);
+            emit!(ctx.writer, "for {} true {} ");
+            ctx.emit_block(|| {
+                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.
+                        emit!(ctx.writer, "case {} ", blk_id);
+                        ctx.emit_block(|| {
+                            for offs in *lower..*upper + 1 {
+                                self.bytecode(
+                                    ctx,
+                                    fun_id,
+                                    target,
+                                    &label_map,
+                                    &code[offs as usize],
+                                    true,
+                                    false,
+                                );
+                            }
+                        })
                     }
+                }
+            })
+        }
+    }
+
+    fn emit_scf_from_cfg(
+        &mut self,
+        cfg: &StacklessControlFlowGraph,
+        code: &[Bytecode],
+        ctx: &Context,
+        fun_id: &QualifiedInstId<FunId>,
+        target: &FunctionTarget,
+    ) {
+        let prover_graph = cfg.to_prover_graph();
+        let mut reduced_cfg = cfg.clone();
+        let loop_map = reduced_cfg.reduce_cfg_loop(&prover_graph);
+
+        let mut scf_top_sort = StacklessStructuredControlFlow::new(&reduced_cfg).top_sort;
+
+        let mut scg_vec = vec![];
+        let mut visited_blocks = BTreeSet::new();
+
+        while let Some(blocks) = scf_top_sort.pop() {
+            for blk_id in &blocks {
+                if visited_blocks.contains(blk_id) {
+                    continue;
+                }
+                if let Some(one_loop) = loop_map.get(&blk_id) {
+                    let mut loop_scg_vec = vec![];
+                    let mut loop_visited_blocks = BTreeSet::new();
+                    for loop_body_blk_id in &one_loop.loop_body {
+                        if loop_visited_blocks.contains(loop_body_blk_id) {
+                            continue;
+                        }
+                        Self::push_non_loop_scg(
+                            &mut loop_scg_vec,
+                            *loop_body_blk_id,
+                            &cfg,
+                            &mut loop_visited_blocks,
+                            code,
+                        );
+                    }
+                    scg_vec.push(StacklessSCG::LoopBlock {
+                        loop_header: Box::new(StacklessSCG::new(one_loop.loop_header, &cfg)),
+                        loop_body: loop_scg_vec,
+                    });
                 } else {
-                    panic!("effective entry block is not basic")
+                    Self::push_non_loop_scg(&mut scg_vec, *blk_id, &cfg, &mut visited_blocks, code);
                 }
-            } else {
-                emitln!(ctx.writer, "let $block := {}", entry_bb);
-                emit!(ctx.writer, "for {} true {} ");
+            }
+        }
+
+        for scg in scg_vec {
+            self.emit_scg(&scg, &cfg, code, ctx, fun_id, target);
+        }
+    }
+
+    pub fn emit_scg(
+        &mut self,
+        scg: &StacklessSCG,
+        cfg: &StacklessControlFlowGraph,
+        code: &[Bytecode],
+        ctx: &Context,
+        fun_id: &QualifiedInstId<FunId>,
+        target: &FunctionTarget,
+    ) {
+        let label_map = Self::compute_label_map(cfg, code);
+        match scg {
+            StacklessSCG::BasicBlock {
+                start_offset,
+                end_offset,
+            } => {
                 ctx.emit_block(|| {
-                    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.
-                            emit!(ctx.writer, "case {} ", blk_id);
-                            ctx.emit_block(|| {
-                                for offs in *lower..*upper + 1 {
-                                    self.bytecode(
-                                        ctx,
-                                        fun_id,
-                                        target,
-                                        &label_map,
-                                        &code[offs as usize],
-                                        true,
-                                    );
-                                }
-                            })
+                    for offs in *start_offset..*end_offset + 1 {
+                        self.bytecode(
+                            ctx,
+                            fun_id,
+                            target,
+                            &label_map,
+                            &code[offs as usize],
+                            false,
+                            true,
+                        );
+                    }
+                });
+            }
+            StacklessSCG::IfBlock {
+                cond,
+                if_true,
+                if_false,
+            } => {
+                emitln!(ctx.writer, "switch $t{} ", cond);
+                emit!(ctx.writer, "case 0 ");
+                if let StacklessSCG::BasicBlock {
+                    start_offset,
+                    end_offset,
+                } = **if_false
+                {
+                    ctx.emit_block(|| {
+                        for offs in start_offset..end_offset + 1 {
+                            self.bytecode(
+                                ctx,
+                                fun_id,
+                                target,
+                                &label_map,
+                                &code[offs as usize],
+                                false,
+                                true,
+                            );
+                        }
+                    });
+                }
+                emit!(ctx.writer, "default ");
+                if let StacklessSCG::BasicBlock {
+                    start_offset,
+                    end_offset,
+                } = **if_true
+                {
+                    ctx.emit_block(|| {
+                        for offs in start_offset..end_offset + 1 {
+                            self.bytecode(
+                                ctx,
+                                fun_id,
+                                target,
+                                &label_map,
+                                &code[offs as usize],
+                                false,
+                                true,
+                            );
                         }
+                    });
+                }
+            }
+            // TODO: need to emit codes of loops based on StacklessSCG::LoopBlock
+            // based on new bytecodes of Break and Continue
+            StacklessSCG::LoopBlock {
+                loop_header,
+                loop_body,
+            } => {
+                self.emit_scg(&*loop_header, &cfg, code, ctx, fun_id, target);
+                emitln!(ctx.writer, "for {} true {} ");
+                ctx.emit_block(|| {
+                    for loop_body_scg in loop_body {
+                        self.emit_scg(loop_body_scg, &cfg, code, ctx, fun_id, target);
                     }
-                })
+                });
             }
-        });
-        emitln!(ctx.writer)
+        }
+    }
+
+    pub fn push_non_loop_scg(
+        scg_vec: &mut Vec<StacklessSCG>,
+        blk_id: BlockId,
+        cfg: &StacklessControlFlowGraph,
+        visited_blocks: &mut BTreeSet<BlockId>,
+        code: &[Bytecode],
+    ) {
+        let label_map = Self::compute_label_map(cfg, code);
+        let get_block = |l| label_map.get(l).expect("label has corresponding block");
+        if let BlockContent::Basic { lower, upper } = cfg.content(blk_id) {
+            let mut start = *lower;
+            for offs in *lower..*upper + 1 {
+                match &code[offs as usize] {
+                    Bytecode::Branch(_, if_t, if_f, cond) => {
+                        scg_vec.push(StacklessSCG::BasicBlock {
+                            start_offset: start as usize,
+                            end_offset: offs as usize,
+                        });
+                        start = offs;
+
+                        let if_block_id = get_block(if_t);
+                        let else_block_id = get_block(if_f);
+                        let if_else_scg = StacklessSCG::IfBlock {
+                            cond: *cond,
+                            if_true: Box::new(StacklessSCG::new(*if_block_id, &cfg)),
+                            if_false: Box::new(StacklessSCG::new(*else_block_id, &cfg)),
+                        };
+                        visited_blocks.insert(*if_block_id);
+                        visited_blocks.insert(*else_block_id);
+                        scg_vec.push(if_else_scg);
+                    }
+                    _ => {}
+                }
+            }
+            if start != *upper {
+                scg_vec.push(StacklessSCG::BasicBlock {
+                    start_offset: start as usize,
+                    end_offset: *upper as usize,
+                });
+            }
+        }
     }
 
     /// Compute the locals in the given function which are borrowed from and which are not
@@ -210,6 +423,7 @@ impl<'a> FunctionGenerator<'a> {
         label_map: &BTreeMap<Label, BlockId>,
         bc: &Bytecode,
         has_flow: bool,
+        skip_block: bool,
     ) {
         use Bytecode::*;
         emitln!(
@@ -283,19 +497,23 @@ impl<'a> FunctionGenerator<'a> {
         match bc {
             Jump(_, l) => {
                 print_loc();
-                emitln!(ctx.writer, "$block := {}", get_block(l))
+                if !skip_block {
+                    emitln!(ctx.writer, "$block := {}", get_block(l))
+                }
             }
             Branch(_, if_t, if_f, cond) => {
                 print_loc();
-                emitln!(
-                    ctx.writer,
-                    "switch {}\n\
-                     case 0  {{ $block := {} }}\n\
-                     default {{ $block := {} }}",
-                    local(cond),
-                    get_block(if_f),
-                    get_block(if_t),
-                )
+                if !skip_block {
+                    emitln!(
+                        ctx.writer,
+                        "switch {}\n\
+                         case 0  {{ $block := {} }}\n\
+                         default {{ $block := {} }}",
+                        local(cond),
+                        get_block(if_f),
+                        get_block(if_t),
+                    )
+                }
             }
             Assign(_, dest, src, _) => {
                 print_loc();

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

@@ -62,4 +62,9 @@ impl Options {
     pub fn generate_source_info(&self) -> bool {
         !self.testing || self.experiment_on(Experiment::CAPTURE_SOURCE_INFO)
     }
+
+    /// Returns true if control flow graph to structured control flow is applied.
+    pub fn apply_cfg_to_scf(&self) -> bool {
+        self.experiment_on(Experiment::APPLY_CFG_TO_SCF)
+    }
 }