Skip to content

Commit

Permalink
control flow graph to structured control flow
Browse files Browse the repository at this point in the history
  • Loading branch information
@gga0wp
gga0wp committed Mar 16, 2022
1 parent 2ef5169 commit 7b95692
Show file tree
Hide file tree
Showing 9 changed files with 1,005 additions and 68 deletions.
5 changes: 5 additions & 0 deletions language/evm/move-to-yul/src/experiments.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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";
}
217 changes: 156 additions & 61 deletions language/evm/move-to-yul/src/functions.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@ 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::{compute_label_map, generate_scg_vec, StacklessSCG, StacklessSCGBlockKind},
};
use sha3::{Digest, Keccak256};
use std::collections::{btree_map::Entry, BTreeMap};
Expand Down Expand Up @@ -107,48 +108,153 @@ 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);
}
} else {
panic!("effective entry block is not basic")
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 = 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 {
emitln!(ctx.writer, "let $block := {}", entry_bb);
emit!(ctx.writer, "for {} true {} ");
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 scg_vec = generate_scg_vec(cfg, code);
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 = compute_label_map(cfg, code);
match scg {
StacklessSCG::BasicBlock {
start_offset,
end_offset,
kind,
} => {
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,
);
}
match kind {
StacklessSCGBlockKind::Break => {
emitln!(ctx.writer, "break");
}
StacklessSCGBlockKind::Continue => {
emitln!(ctx.writer, "continue");
}
_ => {}
}
})
});
}
});
emitln!(ctx.writer)
StacklessSCG::IfBlock {
cond,
if_true,
if_false,
} => {
emitln!(ctx.writer, "switch $t{} ", cond);
emit!(ctx.writer, "case 0 ");
self.emit_scg(if_false, cfg, code, ctx, fun_id, target);
emit!(ctx.writer, "default ");
self.emit_scg(if_true, cfg, code, ctx, fun_id, target);
}
// 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);
emit!(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);
}
});
}
}
}

/// Compute the locals in the given function which are borrowed from and which are not
Expand Down Expand Up @@ -179,22 +285,6 @@ impl<'a> FunctionGenerator<'a> {
}
entry_bb
}

/// Compute a map from labels to block ids which those labels start.
fn compute_label_map(
cfg: &StacklessControlFlowGraph,
code: &[Bytecode],
) -> BTreeMap<Label, BlockId> {
let mut map = BTreeMap::new();
for id in cfg.blocks() {
if let BlockContent::Basic { lower, .. } = cfg.content(id) {
if let Bytecode::Label(_, l) = &code[*lower as usize] {
map.insert(*l, id);
}
}
}
map
}
}

// ================================================================================================
Expand All @@ -210,6 +300,7 @@ impl<'a> FunctionGenerator<'a> {
label_map: &BTreeMap<Label, BlockId>,
bc: &Bytecode,
has_flow: bool,
skip_block: bool,
) {
use Bytecode::*;
emitln!(
Expand Down Expand Up @@ -283,19 +374,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();
Expand Down
5 changes: 5 additions & 0 deletions language/evm/move-to-yul/src/options.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}
}
Loading

0 comments on commit 7b95692

Please sign in to comment.