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

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

@@ -1,6 +1,7 @@
//! 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 std::collections::HashSet;
use dominator_tree::DominatorTree;
@@ -33,12 +34,12 @@ pub fn do_licm(
None => {
let pre_header =
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
// related jumping instruction (which is not necessarily at the end).
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
@@ -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.
pos.insert_ebb(pre_header);
pos.next_inst();
func.dfg.ins(&mut pos).jump(
header,
pre_header_args_value.as_slice(pool),
);
pos.ins().jump(header, pre_header_args_value.as_slice(pool));
}
pre_header
}
@@ -141,17 +139,17 @@ fn remove_loop_invariant_instructions(
) -> Vec<Inst> {
let mut loop_values: HashSet<Value> = HashSet::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.
for ebb in postorder_ebbs_loop(loop_analysis, cfg, lp).iter().rev() {
// 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);
}
pos.goto_top(*ebb);
while let Some(inst) = pos.next_inst() {
if func.dfg.has_results(inst) &&
func.dfg.inst_args(inst).into_iter().all(|arg| {
if pos.func.dfg.has_results(inst) &&
pos.func.dfg.inst_args(inst).into_iter().all(|arg| {
!loop_values.contains(arg)
})
{
@@ -163,7 +161,7 @@ fn remove_loop_invariant_instructions(
} else {
// If the instruction is not loop-invariant we push its results in the set of
// loop values
for out in func.dfg.inst_results(inst) {
for out in pos.func.dfg.inst_results(inst) {
loop_values.insert(*out);
}
}

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

@@ -1,8 +1,9 @@
//! A simple GVN pass.
use cursor::{Cursor, FuncCursor};
use flowgraph::ControlFlowGraph;
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;
/// 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();
// 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() {
// Pop any scopes that we just exited.
loop {
if let Some(current) = scope_stack.last() {
if domtree.dominates(*current, ebb, &pos.layout) {
if domtree.dominates(*current, ebb, &pos.func.layout) {
break;
}
} else {
@@ -39,38 +40,38 @@ pub fn do_simple_gvn(func: &mut Function, cfg: &mut ControlFlowGraph, domtree: &
}
// 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();
pos.goto_top(ebb);
while let Some(inst) = pos.next_inst() {
// 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() {
scope_stack.push(pos.layout.next_inst(inst).unwrap());
scope_stack.push(pos.func.layout.next_inst(inst).unwrap());
visible_values.increment_depth();
}
if trivially_unsafe_for_gvn(opcode) {
continue;
}
let ctrl_typevar = func.dfg.ctrl_typevar(inst);
let key = (func.dfg[inst].clone(), ctrl_typevar);
let ctrl_typevar = pos.func.dfg.ctrl_typevar(inst);
let key = (pos.func.dfg[inst].clone(), ctrl_typevar);
let entry = visible_values.entry(key);
use scoped_hash_map::Entry::*;
match 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
// scope, pick a new representative.
let old = scope_stack.last_mut().unwrap();
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.
func.dfg.replace_with_aliases(inst, *entry.get());
pos.func.dfg.replace_with_aliases(inst, *entry.get());
pos.remove_inst_and_step_back();
}
Vacant(entry) => {