T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace some uses of layout::Cursor with FuncCursor.

Browse Source 
The layout::Cursor is unfortunate because it doesn't reference the whole
function.
This commit is contained in:
Jakob Stoklund Olesen
2017-09-21 11:21:23 -07:00
parent ed6630dc02
commit 03dee5e442
3 changed files with 31 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
lib/cretonne/src/flowgraph.rs
View File

@@ -152,7 +152,8 @@ impl ControlFlowGraph {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use ir::{Function, InstBuilder, Cursor, CursorBase, types}; use cursor::{Cursor, FuncCursor};
use ir::{Function, InstBuilder, types};
#[test] #[test]
fn empty() { fn empty() {
@@ -194,16 +195,15 @@ mod tests {
let jmp_ebb1_ebb2; let jmp_ebb1_ebb2;
{ {
let dfg = &mut func.dfg; let cur = &mut FuncCursor::new(&mut func);
let cur = &mut Cursor::new(&mut func.layout);
cur.insert_ebb(ebb0); cur.insert_ebb(ebb0);
br_ebb0_ebb2 = dfg.ins(cur).brnz(cond, ebb2, &[]); br_ebb0_ebb2 = cur.ins().brnz(cond, ebb2, &[]);
jmp_ebb0_ebb1 = dfg.ins(cur).jump(ebb1, &[]); jmp_ebb0_ebb1 = cur.ins().jump(ebb1, &[]);
cur.insert_ebb(ebb1); cur.insert_ebb(ebb1);
br_ebb1_ebb1 = dfg.ins(cur).brnz(cond, ebb1, &[]); br_ebb1_ebb1 = cur.ins().brnz(cond, ebb1, &[]);
jmp_ebb1_ebb2 = dfg.ins(cur).jump(ebb2, &[]); jmp_ebb1_ebb2 = cur.ins().jump(ebb2, &[]);
cur.insert_ebb(ebb2); cur.insert_ebb(ebb2);
} }

24
lib/cretonne/src/licm.rs
View File

@@ -1,6 +1,7 @@
//! A Loop Invariant Code Motion optimization pass //! A Loop Invariant Code Motion optimization pass
use ir::{Function, Ebb, Inst, Value, Cursor, CursorBase, Type, InstBuilder, Layout}; use cursor::{Cursor, FuncCursor};
use ir::{Function, Ebb, Inst, Value, Type, InstBuilder, Layout};
use flowgraph::ControlFlowGraph; use flowgraph::ControlFlowGraph;
use std::collections::HashSet; use std::collections::HashSet;
use dominator_tree::DominatorTree; use dominator_tree::DominatorTree;
@@ -33,12 +34,12 @@ pub fn do_licm(
None => { None => {
let pre_header = let pre_header =
create_pre_header(loop_analysis.loop_header(lp), func, cfg, domtree); create_pre_header(loop_analysis.loop_header(lp), func, cfg, domtree);
pos = Cursor::new(&mut func.layout).at_last_inst(pre_header); pos = FuncCursor::new(func).at_last_inst(pre_header);
} }
// If there is a natural pre-header we insert new instructions just before the // If there is a natural pre-header we insert new instructions just before the
// related jumping instruction (which is not necessarily at the end). // related jumping instruction (which is not necessarily at the end).
Some((_, last_inst)) => { Some((_, last_inst)) => {
pos = Cursor::new(&mut func.layout).at_inst(last_inst); pos = FuncCursor::new(func).at_inst(last_inst);
} }
}; };
// The last instruction of the pre-header is the termination instruction (usually // The last instruction of the pre-header is the termination instruction (usually
@@ -80,14 +81,11 @@ fn create_pre_header(
} }
} }
{ {
let mut pos = Cursor::new(&mut func.layout).at_top(header); let mut pos = FuncCursor::new(func).at_top(header);
// Inserts the pre-header at the right place in the layout. // Inserts the pre-header at the right place in the layout.
pos.insert_ebb(pre_header); pos.insert_ebb(pre_header);
pos.next_inst(); pos.next_inst();
func.dfg.ins(&mut pos).jump( pos.ins().jump(header, pre_header_args_value.as_slice(pool));
header,
pre_header_args_value.as_slice(pool),
);
} }
pre_header pre_header
} }
@@ -141,17 +139,17 @@ fn remove_loop_invariant_instructions(
) -> Vec<Inst> { ) -> Vec<Inst> {
let mut loop_values: HashSet<Value> = HashSet::new(); let mut loop_values: HashSet<Value> = HashSet::new();
let mut invariant_inst: Vec<Inst> = Vec::new(); let mut invariant_inst: Vec<Inst> = Vec::new();
let mut pos = Cursor::new(&mut func.layout); let mut pos = FuncCursor::new(func);
// We traverse the loop EBB in reverse post-order. // We traverse the loop EBB in reverse post-order.
for ebb in postorder_ebbs_loop(loop_analysis, cfg, lp).iter().rev() { for ebb in postorder_ebbs_loop(loop_analysis, cfg, lp).iter().rev() {
// Arguments of the EBB are loop values // Arguments of the EBB are loop values
for val in func.dfg.ebb_args(*ebb) { for val in pos.func.dfg.ebb_args(*ebb) {
loop_values.insert(*val); loop_values.insert(*val);
} }
pos.goto_top(*ebb); pos.goto_top(*ebb);
while let Some(inst) = pos.next_inst() { while let Some(inst) = pos.next_inst() {
if func.dfg.has_results(inst) && if pos.func.dfg.has_results(inst) &&
func.dfg.inst_args(inst).into_iter().all(|arg| { pos.func.dfg.inst_args(inst).into_iter().all(|arg| {
!loop_values.contains(arg) !loop_values.contains(arg)
}) })
{ {
@@ -163,7 +161,7 @@ fn remove_loop_invariant_instructions(
} else { } else {
// If the instruction is not loop-invariant we push its results in the set of // If the instruction is not loop-invariant we push its results in the set of
// loop values // loop values
for out in func.dfg.inst_results(inst) { for out in pos.func.dfg.inst_results(inst) {
loop_values.insert(*out); loop_values.insert(*out);
} }
} }

25
lib/cretonne/src/simple_gvn.rs
View File

@@ -1,8 +1,9 @@
//! A simple GVN pass. //! A simple GVN pass.
use cursor::{Cursor, FuncCursor};
use flowgraph::ControlFlowGraph; use flowgraph::ControlFlowGraph;
use dominator_tree::DominatorTree; use dominator_tree::DominatorTree;
use ir::{Cursor, CursorBase, InstructionData, Function, Inst, Opcode, Type}; use ir::{InstructionData, Function, Inst, Opcode, Type};
use scoped_hash_map::ScopedHashMap; use scoped_hash_map::ScopedHashMap;
/// Test whether the given opcode is unsafe to even consider for GVN. /// Test whether the given opcode is unsafe to even consider for GVN.
@@ -22,13 +23,13 @@ pub fn do_simple_gvn(func: &mut Function, cfg: &mut ControlFlowGraph, domtree: &
let mut scope_stack: Vec<Inst> = Vec::new(); let mut scope_stack: Vec<Inst> = Vec::new();
// Visit EBBs in a reverse post-order. // Visit EBBs in a reverse post-order.
let mut pos = Cursor::new(&mut func.layout); let mut pos = FuncCursor::new(func);
for &ebb in domtree.cfg_postorder().iter().rev() { for &ebb in domtree.cfg_postorder().iter().rev() {
// Pop any scopes that we just exited. // Pop any scopes that we just exited.
loop { loop {
if let Some(current) = scope_stack.last() { if let Some(current) = scope_stack.last() {
if domtree.dominates(*current, ebb, &pos.layout) { if domtree.dominates(*current, ebb, &pos.func.layout) {
break; break;
} }
} else { } else {
@@ -39,38 +40,38 @@ pub fn do_simple_gvn(func: &mut Function, cfg: &mut ControlFlowGraph, domtree: &
} }
// Push a scope for the current block. // Push a scope for the current block.
scope_stack.push(pos.layout.first_inst(ebb).unwrap()); scope_stack.push(pos.func.layout.first_inst(ebb).unwrap());
visible_values.increment_depth(); visible_values.increment_depth();
pos.goto_top(ebb); pos.goto_top(ebb);
while let Some(inst) = pos.next_inst() { while let Some(inst) = pos.next_inst() {
// Resolve aliases, particularly aliases we created earlier. // Resolve aliases, particularly aliases we created earlier.
func.dfg.resolve_aliases_in_arguments(inst); pos.func.dfg.resolve_aliases_in_arguments(inst);
let opcode = func.dfg[inst].opcode(); let opcode = pos.func.dfg[inst].opcode();
if opcode.is_branch() && !opcode.is_terminator() { if opcode.is_branch() && !opcode.is_terminator() {
scope_stack.push(pos.layout.next_inst(inst).unwrap()); scope_stack.push(pos.func.layout.next_inst(inst).unwrap());
visible_values.increment_depth(); visible_values.increment_depth();
} }
if trivially_unsafe_for_gvn(opcode) { if trivially_unsafe_for_gvn(opcode) {
continue; continue;
} }
let ctrl_typevar = func.dfg.ctrl_typevar(inst); let ctrl_typevar = pos.func.dfg.ctrl_typevar(inst);
let key = (func.dfg[inst].clone(), ctrl_typevar); let key = (pos.func.dfg[inst].clone(), ctrl_typevar);
let entry = visible_values.entry(key); let entry = visible_values.entry(key);
use scoped_hash_map::Entry::*; use scoped_hash_map::Entry::*;
match entry { match entry {
Occupied(entry) => { Occupied(entry) => {
debug_assert!(domtree.dominates(*entry.get(), inst, pos.layout)); debug_assert!(domtree.dominates(*entry.get(), inst, &pos.func.layout));
// If the redundant instruction is representing the current // If the redundant instruction is representing the current
// scope, pick a new representative. // scope, pick a new representative.
let old = scope_stack.last_mut().unwrap(); let old = scope_stack.last_mut().unwrap();
if *old == inst { if *old == inst {
*old = pos.layout.next_inst(inst).unwrap(); *old = pos.func.layout.next_inst(inst).unwrap();
} }
// Replace the redundant instruction and remove it. // Replace the redundant instruction and remove it.
func.dfg.replace_with_aliases(inst, *entry.get()); pos.func.dfg.replace_with_aliases(inst, *entry.get());
pos.remove_inst_and_step_back(); pos.remove_inst_and_step_back();
} }
Vacant(entry) => { Vacant(entry) => {