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

Convert all log::debug to log::trace.

Browse Source
This commit is contained in:
Chris Fallin
2021-08-12 12:05:19 -07:00
parent 38323e0c27
commit 3e1e0f39b6
14 changed files with 282 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
fuzz/fuzz_targets/ion.rs
View File

@@ -10,7 +10,7 @@ use regalloc2::fuzzing::func::Func;
fuzz_target!(|func: Func| { fuzz_target!(|func: Func| {
let _ = env_logger::try_init(); let _ = env_logger::try_init();
log::debug!("func:\n{:?}", func); log::trace!("func:\n{:?}", func);
let env = regalloc2::fuzzing::func::machine_env(); let env = regalloc2::fuzzing::func::machine_env();
let _out = regalloc2::fuzzing::ion::run(&func, &env, false).expect("regalloc did not succeed"); let _out = regalloc2::fuzzing::ion::run(&func, &env, false).expect("regalloc did not succeed");
}); });

2
fuzz/fuzz_targets/ion_checker.rs
View File

@@ -38,7 +38,7 @@ impl Arbitrary for TestCase {
fuzz_target!(|testcase: TestCase| { fuzz_target!(|testcase: TestCase| {
let func = testcase.func; let func = testcase.func;
let _ = env_logger::try_init(); let _ = env_logger::try_init();
log::debug!("func:\n{:?}", func); log::trace!("func:\n{:?}", func);
let env = regalloc2::fuzzing::func::machine_env(); let env = regalloc2::fuzzing::func::machine_env();
let out = regalloc2::fuzzing::ion::run(&func, &env, true).expect("regalloc did not succeed"); let out = regalloc2::fuzzing::ion::run(&func, &env, true).expect("regalloc did not succeed");

62
src/checker.rs
View File

@@ -66,8 +66,8 @@
#![allow(dead_code)] #![allow(dead_code)]
use crate::{ use crate::{
Allocation, AllocationKind, Block, Edit, Function, Inst, InstPosition, Operand, OperandKind, Allocation, AllocationKind, Block, Edit, Function, Inst, InstPosition, Operand,
OperandConstraint, OperandPos, Output, PReg, ProgPoint, SpillSlot, VReg, OperandConstraint, OperandKind, OperandPos, Output, PReg, ProgPoint, SpillSlot, VReg,
}; };
use std::collections::{HashMap, HashSet, VecDeque}; use std::collections::{HashMap, HashSet, VecDeque};
@@ -75,8 +75,6 @@ use std::default::Default;
use std::hash::Hash; use std::hash::Hash;
use std::result::Result; use std::result::Result;
use log::debug;
/// A set of errors detected by the regalloc checker. /// A set of errors detected by the regalloc checker.
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct CheckerErrors { pub struct CheckerErrors {
@@ -182,7 +180,7 @@ impl CheckerValue {
CheckerValue::Reg(r1, ref1) CheckerValue::Reg(r1, ref1)
} }
_ => { _ => {
log::debug!("{:?} and {:?} meet to Conflicted", self, other); log::trace!("{:?} and {:?} meet to Conflicted", self, other);
CheckerValue::Conflicted CheckerValue::Conflicted
} }
} }
@@ -313,9 +311,12 @@ impl CheckerState {
.get(alloc) .get(alloc)
.cloned() .cloned()
.unwrap_or(Default::default()); .unwrap_or(Default::default());
debug!( log::trace!(
"checker: checkinst {:?}: op {:?}, alloc {:?}, checker value {:?}", "checker: checkinst {:?}: op {:?}, alloc {:?}, checker value {:?}",
checkinst, op, alloc, val checkinst,
op,
alloc,
val
); );
self.check_val(inst, *op, *alloc, val, allocs)?; self.check_val(inst, *op, *alloc, val, allocs)?;
} }
@@ -328,9 +329,11 @@ impl CheckerState {
.get(&alloc) .get(&alloc)
.cloned() .cloned()
.unwrap_or(Default::default()); .unwrap_or(Default::default());
debug!( log::trace!(
"checker: checkinst {:?}: safepoint slot {}, checker value {:?}", "checker: checkinst {:?}: safepoint slot {}, checker value {:?}",
checkinst, slot, val checkinst,
slot,
val
); );
match val { match val {
@@ -359,9 +362,12 @@ impl CheckerState {
.get(&from) .get(&from)
.cloned() .cloned()
.unwrap_or(Default::default()); .unwrap_or(Default::default());
debug!( log::trace!(
"checker: checkinst {:?} updating: move {:?} -> {:?} val {:?}", "checker: checkinst {:?} updating: move {:?} -> {:?} val {:?}",
checkinst, from, into, val checkinst,
from,
into,
val
); );
self.allocations.insert(into, val); self.allocations.insert(into, val);
} }
@@ -529,7 +535,7 @@ impl<'a, F: Function> Checker<'a, F> {
/// Build the list of checker instructions based on the given func /// Build the list of checker instructions based on the given func
/// and allocation results. /// and allocation results.
pub fn prepare(&mut self, out: &Output) { pub fn prepare(&mut self, out: &Output) {
debug!("checker: out = {:?}", out); log::trace!("checker: out = {:?}", out);
// Preprocess safepoint stack-maps into per-inst vecs. // Preprocess safepoint stack-maps into per-inst vecs.
let mut safepoint_slots: HashMap<Inst, Vec<SpillSlot>> = HashMap::new(); let mut safepoint_slots: HashMap<Inst, Vec<SpillSlot>> = HashMap::new();
for &(progpoint, slot) in &out.safepoint_slots { for &(progpoint, slot) in &out.safepoint_slots {
@@ -574,7 +580,7 @@ impl<'a, F: Function> Checker<'a, F> {
allocs, allocs,
clobbers, clobbers,
}; };
debug!("checker: adding inst {:?}", checkinst); log::trace!("checker: adding inst {:?}", checkinst);
self.bb_insts.get_mut(&block).unwrap().push(checkinst); self.bb_insts.get_mut(&block).unwrap().push(checkinst);
} }
@@ -591,7 +597,7 @@ impl<'a, F: Function> Checker<'a, F> {
if edit_pos < pos { if edit_pos < pos {
continue; continue;
} }
debug!("checker: adding edit {:?} at pos {:?}", edit, pos); log::trace!("checker: adding edit {:?} at pos {:?}", edit, pos);
match edit { match edit {
&Edit::Move { from, to, to_vreg } => { &Edit::Move { from, to, to_vreg } => {
self.bb_insts self.bb_insts
@@ -640,10 +646,10 @@ impl<'a, F: Function> Checker<'a, F> {
let block = queue.pop_front().unwrap(); let block = queue.pop_front().unwrap();
queue_set.remove(&block); queue_set.remove(&block);
let mut state = self.bb_in.get(&block).cloned().unwrap(); let mut state = self.bb_in.get(&block).cloned().unwrap();
debug!("analyze: block {} has state {:?}", block.index(), state); log::trace!("analyze: block {} has state {:?}", block.index(), state);
for inst in self.bb_insts.get(&block).unwrap() { for inst in self.bb_insts.get(&block).unwrap() {
state.update(inst, self); state.update(inst, self);
debug!("analyze: inst {:?} -> state {:?}", inst, state); log::trace!("analyze: inst {:?} -> state {:?}", inst, state);
} }
for &succ in self.f.block_succs(block) { for &succ in self.f.block_succs(block) {
@@ -652,7 +658,7 @@ impl<'a, F: Function> Checker<'a, F> {
new_state.meet_with(cur_succ_in); new_state.meet_with(cur_succ_in);
let changed = &new_state != cur_succ_in; let changed = &new_state != cur_succ_in;
if changed { if changed {
debug!( log::trace!(
"analyze: block {} state changed from {:?} to {:?}; pushing onto queue", "analyze: block {} state changed from {:?} to {:?}; pushing onto queue",
succ.index(), succ.index(),
cur_succ_in, cur_succ_in,
@@ -677,12 +683,12 @@ impl<'a, F: Function> Checker<'a, F> {
let mut state = input.clone(); let mut state = input.clone();
for inst in self.bb_insts.get(block).unwrap() { for inst in self.bb_insts.get(block).unwrap() {
if let Err(e) = state.check(InstPosition::Before, inst) { if let Err(e) = state.check(InstPosition::Before, inst) {
debug!("Checker error: {:?}", e); log::trace!("Checker error: {:?}", e);
errors.push(e); errors.push(e);
} }
state.update(inst, self); state.update(inst, self);
if let Err(e) = state.check(InstPosition::After, inst) { if let Err(e) = state.check(InstPosition::After, inst) {
debug!("Checker error: {:?}", e); log::trace!("Checker error: {:?}", e);
errors.push(e); errors.push(e);
} }
} }
@@ -701,20 +707,20 @@ impl<'a, F: Function> Checker<'a, F> {
self.analyze(); self.analyze();
let result = self.find_errors(); let result = self.find_errors();
debug!("=== CHECKER RESULT ==="); log::trace!("=== CHECKER RESULT ===");
fn print_state(state: &CheckerState) { fn print_state(state: &CheckerState) {
let mut s = vec![]; let mut s = vec![];
for (alloc, state) in &state.allocations { for (alloc, state) in &state.allocations {
s.push(format!("{} := {}", alloc, state)); s.push(format!("{} := {}", alloc, state));
} }
debug!(" {{ {} }}", s.join(", ")) log::trace!(" {{ {} }}", s.join(", "))
} }
for vreg in self.f.reftype_vregs() { for vreg in self.f.reftype_vregs() {
debug!(" REF: {}", vreg); log::trace!(" REF: {}", vreg);
} }
for bb in 0..self.f.blocks() { for bb in 0..self.f.blocks() {
let bb = Block::new(bb); let bb = Block::new(bb);
debug!("block{}:", bb.index()); log::trace!("block{}:", bb.index());
let insts = self.bb_insts.get(&bb).unwrap(); let insts = self.bb_insts.get(&bb).unwrap();
let mut state = self.bb_in.get(&bb).unwrap().clone(); let mut state = self.bb_in.get(&bb).unwrap().clone();
print_state(&state); print_state(&state);
@@ -726,7 +732,7 @@ impl<'a, F: Function> Checker<'a, F> {
ref allocs, ref allocs,
ref clobbers, ref clobbers,
} => { } => {
debug!( log::trace!(
" inst{}: {:?} ({:?}) clobbers:{:?}", " inst{}: {:?} ({:?}) clobbers:{:?}",
inst.index(), inst.index(),
operands, operands,
@@ -735,7 +741,7 @@ impl<'a, F: Function> Checker<'a, F> {
); );
} }
&CheckerInst::Move { from, into } => { &CheckerInst::Move { from, into } => {
debug!(" {} -> {}", from, into); log::trace!(" {} -> {}", from, into);
} }
&CheckerInst::BlockParams { &CheckerInst::BlockParams {
ref vregs, ref vregs,
@@ -746,17 +752,17 @@ impl<'a, F: Function> Checker<'a, F> {
for (vreg, alloc) in vregs.iter().zip(allocs.iter()) { for (vreg, alloc) in vregs.iter().zip(allocs.iter()) {
args.push(format!("{}:{}", vreg, alloc)); args.push(format!("{}:{}", vreg, alloc));
} }
debug!(" blockparams: {}", args.join(", ")); log::trace!(" blockparams: {}", args.join(", "));
} }
&CheckerInst::DefAlloc { alloc, vreg } => { &CheckerInst::DefAlloc { alloc, vreg } => {
debug!(" defalloc: {}:{}", vreg, alloc); log::trace!(" defalloc: {}:{}", vreg, alloc);
} }
&CheckerInst::Safepoint { ref slots, .. } => { &CheckerInst::Safepoint { ref slots, .. } => {
let mut slotargs = vec![]; let mut slotargs = vec![];
for &slot in slots { for &slot in slots {
slotargs.push(format!("{}", slot)); slotargs.push(format!("{}", slot));
} }
debug!(" safepoint: {}", slotargs.join(", ")); log::trace!(" safepoint: {}", slotargs.join(", "));
} }
} }
state.update(inst, &self); state.update(inst, &self);

17
src/fuzzing/func.rs
View File

@@ -5,7 +5,7 @@
use crate::{ use crate::{
domtree, postorder, Allocation, Block, Function, Inst, InstRange, MachineEnv, Operand, domtree, postorder, Allocation, Block, Function, Inst, InstRange, MachineEnv, Operand,
OperandKind, OperandConstraint, OperandPos, PReg, RegClass, VReg, OperandConstraint, OperandKind, OperandPos, PReg, RegClass, VReg,
}; };
use arbitrary::Result as ArbitraryResult; use arbitrary::Result as ArbitraryResult;
@@ -407,7 +407,12 @@ impl Func {
} else { } else {
OperandPos::After OperandPos::After
}; };
let mut operands = vec![Operand::new(vreg, def_constraint, OperandKind::Def, def_pos)]; let mut operands = vec![Operand::new(
vreg,
def_constraint,
OperandKind::Def,
def_pos,
)];
let mut allocations = vec![Allocation::none()]; let mut allocations = vec![Allocation::none()];
for _ in 0..u.int_in_range(0..=3)? { for _ in 0..u.int_in_range(0..=3)? {
let vreg = if avail.len() > 0 let vreg = if avail.len() > 0
@@ -456,8 +461,12 @@ impl Func {
); );
// Make sure reused input is a Reg. // Make sure reused input is a Reg.
let op = operands[reused]; let op = operands[reused];
operands[reused] = operands[reused] = Operand::new(
Operand::new(op.vreg(), OperandConstraint::Reg, op.kind(), OperandPos::Before); op.vreg(),
OperandConstraint::Reg,
op.kind(),
OperandPos::Before,
);
} else if opts.fixed_regs && bool::arbitrary(u)? { } else if opts.fixed_regs && bool::arbitrary(u)? {
let mut fixed = vec![]; let mut fixed = vec![];
for _ in 0..u.int_in_range(0..=operands.len() - 1)? { for _ in 0..u.int_in_range(0..=operands.len() - 1)? {

18
src/ion/dump.rs
View File

@@ -5,16 +5,16 @@ use crate::{Block, Function, ProgPoint};
impl<'a, F: Function> Env<'a, F> { impl<'a, F: Function> Env<'a, F> {
pub fn dump_state(&self) { pub fn dump_state(&self) {
log::debug!("Bundles:"); log::trace!("Bundles:");
for (i, b) in self.bundles.iter().enumerate() { for (i, b) in self.bundles.iter().enumerate() {
log::debug!( log::trace!(
"bundle{}: spillset={:?} alloc={:?}", "bundle{}: spillset={:?} alloc={:?}",
i, i,
b.spillset, b.spillset,
b.allocation b.allocation
); );
for entry in &b.ranges { for entry in &b.ranges {
log::debug!( log::trace!(
" * range {:?} -- {:?}: range{}", " * range {:?} -- {:?}: range{}",
entry.range.from, entry.range.from,
entry.range.to, entry.range.to,
@@ -22,11 +22,11 @@ impl<'a, F: Function> Env<'a, F> {
); );
} }
} }
log::debug!("VRegs:"); log::trace!("VRegs:");
for (i, v) in self.vregs.iter().enumerate() { for (i, v) in self.vregs.iter().enumerate() {
log::debug!("vreg{}:", i); log::trace!("vreg{}:", i);
for entry in &v.ranges { for entry in &v.ranges {
log::debug!( log::trace!(
" * range {:?} -- {:?}: range{}", " * range {:?} -- {:?}: range{}",
entry.range.from, entry.range.from,
entry.range.to, entry.range.to,
@@ -34,9 +34,9 @@ impl<'a, F: Function> Env<'a, F> {
); );
} }
} }
log::debug!("Ranges:"); log::trace!("Ranges:");
for (i, r) in self.ranges.iter().enumerate() { for (i, r) in self.ranges.iter().enumerate() {
log::debug!( log::trace!(
"range{}: range={:?} vreg={:?} bundle={:?} weight={}", "range{}: range={:?} vreg={:?} bundle={:?} weight={}",
i, i,
r.range, r.range,
@@ -45,7 +45,7 @@ impl<'a, F: Function> Env<'a, F> {
r.uses_spill_weight(), r.uses_spill_weight(),
); );
for u in &r.uses { for u in &r.uses {
log::debug!(" * use at {:?} (slot {}): {:?}", u.pos, u.slot, u.operand); log::trace!(" * use at {:?} (slot {}): {:?}", u.pos, u.slot, u.operand);
} }
} }
} }

95
src/ion/liveranges.rs
View File

@@ -20,7 +20,7 @@ use super::{
}; };
use crate::bitvec::BitVec; use crate::bitvec::BitVec;
use crate::{ use crate::{
Allocation, Block, Function, Inst, InstPosition, Operand, OperandKind, OperandConstraint, Allocation, Block, Function, Inst, InstPosition, Operand, OperandConstraint, OperandKind,
OperandPos, PReg, ProgPoint, RegAllocError, VReg, OperandPos, PReg, ProgPoint, RegAllocError, VReg,
}; };
use fxhash::FxHashSet; use fxhash::FxHashSet;
@@ -29,7 +29,11 @@ use std::collections::{HashSet, VecDeque};
use std::convert::TryFrom; use std::convert::TryFrom;
#[inline(always)] #[inline(always)]
pub fn spill_weight_from_constraint(constraint: OperandConstraint, loop_depth: usize, is_def: bool) -> u32 { pub fn spill_weight_from_constraint(
constraint: OperandConstraint,
loop_depth: usize,
is_def: bool,
) -> u32 {
// A bonus of 1000 for one loop level, 4000 for two loop levels, // A bonus of 1000 for one loop level, 4000 for two loop levels,
// 16000 for three loop levels, etc. Avoids exponentiation. // 16000 for three loop levels, etc. Avoids exponentiation.
// Bound `loop_depth` at 2 so that `hot_bonus` is at most 16000. // Bound `loop_depth` at 2 so that `hot_bonus` is at most 16000.
@@ -127,7 +131,7 @@ impl<'a, F: Function> Env<'a, F> {
/// ///
/// Returns the liverange that contains the given range. /// Returns the liverange that contains the given range.
pub fn add_liverange_to_vreg(&mut self, vreg: VRegIndex, range: CodeRange) -> LiveRangeIndex { pub fn add_liverange_to_vreg(&mut self, vreg: VRegIndex, range: CodeRange) -> LiveRangeIndex {
log::debug!("add_liverange_to_vreg: vreg {:?} range {:?}", vreg, range); log::trace!("add_liverange_to_vreg: vreg {:?} range {:?}", vreg, range);
// Invariant: as we are building liveness information, we // Invariant: as we are building liveness information, we
// *always* process instructions bottom-to-top, and as a // *always* process instructions bottom-to-top, and as a
@@ -187,11 +191,14 @@ impl<'a, F: Function> Env<'a, F> {
let constraint = operand.constraint(); let constraint = operand.constraint();
let block = self.cfginfo.insn_block[u.pos.inst().index()]; let block = self.cfginfo.insn_block[u.pos.inst().index()];
let loop_depth = self.cfginfo.approx_loop_depth[block.index()] as usize; let loop_depth = self.cfginfo.approx_loop_depth[block.index()] as usize;
let weight = let weight = spill_weight_from_constraint(
spill_weight_from_constraint(constraint, loop_depth, operand.kind() != OperandKind::Use); constraint,
loop_depth,
operand.kind() != OperandKind::Use,
);
u.weight = u16::try_from(weight).expect("weight too large for u16 field"); u.weight = u16::try_from(weight).expect("weight too large for u16 field");
log::debug!( log::trace!(
"insert use {:?} into lr {:?} with weight {}", "insert use {:?} into lr {:?} with weight {}",
u, u,
into, into,
@@ -206,7 +213,7 @@ impl<'a, F: Function> Env<'a, F> {
// Update stats. // Update stats.
self.ranges[into.index()].uses_spill_weight_and_flags += weight; self.ranges[into.index()].uses_spill_weight_and_flags += weight;
log::debug!( log::trace!(
" -> now range has weight {}", " -> now range has weight {}",
self.ranges[into.index()].uses_spill_weight(), self.ranges[into.index()].uses_spill_weight(),
); );
@@ -226,7 +233,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
pub fn add_liverange_to_preg(&mut self, range: CodeRange, reg: PReg) { pub fn add_liverange_to_preg(&mut self, range: CodeRange, reg: PReg) {
log::debug!("adding liverange to preg: {:?} to {}", range, reg); log::trace!("adding liverange to preg: {:?} to {}", range, reg);
let preg_idx = PRegIndex::new(reg.index()); let preg_idx = PRegIndex::new(reg.index());
self.pregs[preg_idx.index()] self.pregs[preg_idx.index()]
.allocations .allocations
@@ -259,12 +266,12 @@ impl<'a, F: Function> Env<'a, F> {
let block = workqueue.pop_front().unwrap(); let block = workqueue.pop_front().unwrap();
workqueue_set.remove(&block); workqueue_set.remove(&block);
log::debug!("computing liveins for block{}", block.index()); log::trace!("computing liveins for block{}", block.index());
self.stats.livein_iterations += 1; self.stats.livein_iterations += 1;
let mut live = self.liveouts[block.index()].clone(); let mut live = self.liveouts[block.index()].clone();
log::debug!(" -> initial liveout set: {:?}", live); log::trace!(" -> initial liveout set: {:?}", live);
for inst in self.func.block_insns(block).rev().iter() { for inst in self.func.block_insns(block).rev().iter() {
if let Some((src, dst)) = self.func.is_move(inst) { if let Some((src, dst)) = self.func.is_move(inst) {
@@ -276,7 +283,7 @@ impl<'a, F: Function> Env<'a, F> {
for op in self.func.inst_operands(inst) { for op in self.func.inst_operands(inst) {
if op.pos() == *pos { if op.pos() == *pos {
let was_live = live.get(op.vreg().vreg()); let was_live = live.get(op.vreg().vreg());
log::debug!("op {:?} was_live = {}", op, was_live); log::trace!("op {:?} was_live = {}", op, was_live);
match op.kind() { match op.kind() {
OperandKind::Use | OperandKind::Mod => { OperandKind::Use | OperandKind::Mod => {
live.set(op.vreg().vreg(), true); live.set(op.vreg().vreg(), true);
@@ -302,7 +309,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
} }
log::debug!("computed liveins at block{}: {:?}", block.index(), live); log::trace!("computed liveins at block{}: {:?}", block.index(), live);
self.liveins[block.index()] = live; self.liveins[block.index()] = live;
} }
@@ -314,7 +321,7 @@ impl<'a, F: Function> Env<'a, F> {
.next() .next()
.is_some() .is_some()
{ {
log::debug!( log::trace!(
"non-empty liveins to entry block: {:?}", "non-empty liveins to entry block: {:?}",
self.liveins[self.func.entry_block().index()] self.liveins[self.func.entry_block().index()]
); );
@@ -354,7 +361,7 @@ impl<'a, F: Function> Env<'a, F> {
from: self.cfginfo.block_entry[block.index()], from: self.cfginfo.block_entry[block.index()],
to: self.cfginfo.block_exit[block.index()].next(), to: self.cfginfo.block_exit[block.index()].next(),
}; };
log::debug!( log::trace!(
"vreg {:?} live at end of block --> create range {:?}", "vreg {:?} live at end of block --> create range {:?}",
VRegIndex::new(vreg), VRegIndex::new(vreg),
range range
@@ -426,7 +433,7 @@ impl<'a, F: Function> Env<'a, F> {
// We can completely skip the move if it is // We can completely skip the move if it is
// trivial (vreg to same vreg). // trivial (vreg to same vreg).
if src.vreg() != dst.vreg() { if src.vreg() != dst.vreg() {
log::debug!(" -> move inst{}: src {} -> dst {}", inst.index(), src, dst); log::trace!(" -> move inst{}: src {} -> dst {}", inst.index(), src, dst);
assert_eq!(src.class(), dst.class()); assert_eq!(src.class(), dst.class());
assert_eq!(src.kind(), OperandKind::Use); assert_eq!(src.kind(), OperandKind::Use);
@@ -488,7 +495,7 @@ impl<'a, F: Function> Env<'a, F> {
else if self.vregs[src.vreg().vreg()].is_pinned else if self.vregs[src.vreg().vreg()].is_pinned
|| self.vregs[dst.vreg().vreg()].is_pinned || self.vregs[dst.vreg().vreg()].is_pinned
{ {
log::debug!( log::trace!(
" -> exactly one of src/dst is pinned; converting to ghost use" " -> exactly one of src/dst is pinned; converting to ghost use"
); );
let (preg, vreg, pinned_vreg, kind, pos, progpoint) = let (preg, vreg, pinned_vreg, kind, pos, progpoint) =
@@ -516,7 +523,7 @@ impl<'a, F: Function> Env<'a, F> {
let constraint = OperandConstraint::FixedReg(preg); let constraint = OperandConstraint::FixedReg(preg);
let operand = Operand::new(vreg, constraint, kind, pos); let operand = Operand::new(vreg, constraint, kind, pos);
log::debug!( log::trace!(
concat!( concat!(
" -> preg {:?} vreg {:?} kind {:?} ", " -> preg {:?} vreg {:?} kind {:?} ",
"pos {:?} progpoint {:?} constraint {:?} operand {:?}" "pos {:?} progpoint {:?} constraint {:?} operand {:?}"
@@ -543,9 +550,9 @@ impl<'a, F: Function> Env<'a, F> {
VRegIndex::new(vreg.vreg()), VRegIndex::new(vreg.vreg()),
CodeRange { from, to }, CodeRange { from, to },
); );
log::debug!(" -> dead; created LR"); log::trace!(" -> dead; created LR");
} }
log::debug!(" -> LR {:?}", lr); log::trace!(" -> LR {:?}", lr);
self.insert_use_into_liverange( self.insert_use_into_liverange(
lr, lr,
@@ -579,7 +586,7 @@ impl<'a, F: Function> Env<'a, F> {
// (this is the last use), start it // (this is the last use), start it
// before. // before.
if kind == OperandKind::Def { if kind == OperandKind::Def {
log::debug!(" -> src on pinned vreg {:?}", pinned_vreg); log::trace!(" -> src on pinned vreg {:?}", pinned_vreg);
// The *other* vreg is a def, so the pinned-vreg // The *other* vreg is a def, so the pinned-vreg
// mention is a use. If already live, // mention is a use. If already live,
// end the existing LR just *after* // end the existing LR just *after*
@@ -593,7 +600,7 @@ impl<'a, F: Function> Env<'a, F> {
if live.get(pinned_vreg.vreg()) { if live.get(pinned_vreg.vreg()) {
let pinned_lr = vreg_ranges[pinned_vreg.vreg()]; let pinned_lr = vreg_ranges[pinned_vreg.vreg()];
let orig_start = self.ranges[pinned_lr.index()].range.from; let orig_start = self.ranges[pinned_lr.index()].range.from;
log::debug!( log::trace!(
" -> live with LR {:?}; truncating to start at {:?}", " -> live with LR {:?}; truncating to start at {:?}",
pinned_lr, pinned_lr,
progpoint.next() progpoint.next()
@@ -607,7 +614,7 @@ impl<'a, F: Function> Env<'a, F> {
}, },
); );
vreg_ranges[pinned_vreg.vreg()] = new_lr; vreg_ranges[pinned_vreg.vreg()] = new_lr;
log::debug!(" -> created LR {:?} with remaining range from {:?} to {:?}", new_lr, orig_start, progpoint); log::trace!(" -> created LR {:?} with remaining range from {:?} to {:?}", new_lr, orig_start, progpoint);
// Add an edit right now to indicate that at // Add an edit right now to indicate that at
// this program point, the given // this program point, the given
@@ -641,7 +648,7 @@ impl<'a, F: Function> Env<'a, F> {
); );
vreg_ranges[pinned_vreg.vreg()] = new_lr; vreg_ranges[pinned_vreg.vreg()] = new_lr;
live.set(pinned_vreg.vreg(), true); live.set(pinned_vreg.vreg(), true);
log::debug!( log::trace!(
" -> was not live; created new LR {:?}", " -> was not live; created new LR {:?}",
new_lr new_lr
); );
@@ -661,7 +668,7 @@ impl<'a, F: Function> Env<'a, F> {
); );
} }
} else { } else {
log::debug!(" -> dst on pinned vreg {:?}", pinned_vreg); log::trace!(" -> dst on pinned vreg {:?}", pinned_vreg);
// The *other* vreg is a use, so the pinned-vreg // The *other* vreg is a use, so the pinned-vreg
// mention is a def. Truncate its LR // mention is a def. Truncate its LR
// just *after* the `progpoint` // just *after* the `progpoint`
@@ -669,7 +676,7 @@ impl<'a, F: Function> Env<'a, F> {
if live.get(pinned_vreg.vreg()) { if live.get(pinned_vreg.vreg()) {
let pinned_lr = vreg_ranges[pinned_vreg.vreg()]; let pinned_lr = vreg_ranges[pinned_vreg.vreg()];
self.ranges[pinned_lr.index()].range.from = progpoint.next(); self.ranges[pinned_lr.index()].range.from = progpoint.next();
log::debug!( log::trace!(
" -> was live with LR {:?}; truncated start to {:?}", " -> was live with LR {:?}; truncated start to {:?}",
pinned_lr, pinned_lr,
progpoint.next() progpoint.next()
@@ -769,14 +776,14 @@ impl<'a, F: Function> Env<'a, F> {
VRegIndex::new(dst.vreg().vreg()), VRegIndex::new(dst.vreg().vreg()),
CodeRange { from, to }, CodeRange { from, to },
); );
log::debug!(" -> invalid LR for def; created {:?}", dst_lr); log::trace!(" -> invalid LR for def; created {:?}", dst_lr);
} }
log::debug!(" -> has existing LR {:?}", dst_lr); log::trace!(" -> has existing LR {:?}", dst_lr);
// Trim the LR to start here. // Trim the LR to start here.
if self.ranges[dst_lr.index()].range.from if self.ranges[dst_lr.index()].range.from
== self.cfginfo.block_entry[block.index()] == self.cfginfo.block_entry[block.index()]
{ {
log::debug!(" -> started at block start; trimming to {:?}", pos); log::trace!(" -> started at block start; trimming to {:?}", pos);
self.ranges[dst_lr.index()].range.from = pos; self.ranges[dst_lr.index()].range.from = pos;
} }
self.ranges[dst_lr.index()].set_flag(LiveRangeFlag::StartsAtDef); self.ranges[dst_lr.index()].set_flag(LiveRangeFlag::StartsAtDef);
@@ -803,7 +810,7 @@ impl<'a, F: Function> Env<'a, F> {
vreg_ranges[src.vreg().vreg()] vreg_ranges[src.vreg().vreg()]
}; };
log::debug!(" -> src LR {:?}", src_lr); log::trace!(" -> src LR {:?}", src_lr);
// Add to live-set. // Add to live-set.
let src_is_dead_after_move = !live.get(src.vreg().vreg()); let src_is_dead_after_move = !live.get(src.vreg().vreg());
@@ -863,7 +870,7 @@ impl<'a, F: Function> Env<'a, F> {
continue; continue;
} }
log::debug!( log::trace!(
"processing inst{} operand at {:?}: {:?}", "processing inst{} operand at {:?}: {:?}",
inst.index(), inst.index(),
pos, pos,
@@ -872,14 +879,14 @@ impl<'a, F: Function> Env<'a, F> {
match operand.kind() { match operand.kind() {
OperandKind::Def | OperandKind::Mod => { OperandKind::Def | OperandKind::Mod => {
log::debug!("Def of {} at {:?}", operand.vreg(), pos); log::trace!("Def of {} at {:?}", operand.vreg(), pos);
// Fill in vreg's actual data. // Fill in vreg's actual data.
self.vreg_regs[operand.vreg().vreg()] = operand.vreg(); self.vreg_regs[operand.vreg().vreg()] = operand.vreg();
// Get or create the LiveRange. // Get or create the LiveRange.
let mut lr = vreg_ranges[operand.vreg().vreg()]; let mut lr = vreg_ranges[operand.vreg().vreg()];
log::debug!(" -> has existing LR {:?}", lr); log::trace!(" -> has existing LR {:?}", lr);
// If there was no liverange (dead def), create a trivial one. // If there was no liverange (dead def), create a trivial one.
if !live.get(operand.vreg().vreg()) { if !live.get(operand.vreg().vreg()) {
let from = match operand.kind() { let from = match operand.kind() {
@@ -896,7 +903,7 @@ impl<'a, F: Function> Env<'a, F> {
VRegIndex::new(operand.vreg().vreg()), VRegIndex::new(operand.vreg().vreg()),
CodeRange { from, to }, CodeRange { from, to },
); );
log::debug!(" -> invalid; created {:?}", lr); log::trace!(" -> invalid; created {:?}", lr);
vreg_ranges[operand.vreg().vreg()] = lr; vreg_ranges[operand.vreg().vreg()] = lr;
live.set(operand.vreg().vreg(), true); live.set(operand.vreg().vreg(), true);
} }
@@ -913,7 +920,7 @@ impl<'a, F: Function> Env<'a, F> {
if self.ranges[lr.index()].range.from if self.ranges[lr.index()].range.from
== self.cfginfo.block_entry[block.index()] == self.cfginfo.block_entry[block.index()]
{ {
log::debug!( log::trace!(
" -> started at block start; trimming to {:?}", " -> started at block start; trimming to {:?}",
pos pos
); );
@@ -945,7 +952,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
assert!(lr.is_valid()); assert!(lr.is_valid());
log::debug!("Use of {:?} at {:?} -> {:?}", operand, pos, lr,); log::trace!("Use of {:?} at {:?} -> {:?}", operand, pos, lr,);
self.insert_use_into_liverange(lr, Use::new(operand, pos, i as u8)); self.insert_use_into_liverange(lr, Use::new(operand, pos, i as u8));
@@ -957,11 +964,11 @@ impl<'a, F: Function> Env<'a, F> {
} }
if self.func.is_safepoint(inst) { if self.func.is_safepoint(inst) {
log::debug!("inst{} is safepoint", inst.index()); log::trace!("inst{} is safepoint", inst.index());
self.safepoints.push(inst); self.safepoints.push(inst);
for vreg in live.iter() { for vreg in live.iter() {
if let Some(safepoints) = self.safepoints_per_vreg.get_mut(&vreg) { if let Some(safepoints) = self.safepoints_per_vreg.get_mut(&vreg) {
log::debug!("vreg v{} live at safepoint inst{}", vreg, inst.index()); log::trace!("vreg v{} live at safepoint inst{}", vreg, inst.index());
safepoints.insert(inst); safepoints.insert(inst);
} }
} }
@@ -1054,7 +1061,7 @@ impl<'a, F: Function> Env<'a, F> {
OperandPos::Before, OperandPos::Before,
); );
log::debug!( log::trace!(
"Safepoint-induced stack use of {:?} at {:?} -> {:?}", "Safepoint-induced stack use of {:?} at {:?} -> {:?}",
operand, operand,
pos, pos,
@@ -1095,7 +1102,7 @@ impl<'a, F: Function> Env<'a, F> {
for range_idx in 0..self.vregs[vreg].ranges.len() { for range_idx in 0..self.vregs[vreg].ranges.len() {
let entry = self.vregs[vreg].ranges[range_idx]; let entry = self.vregs[vreg].ranges[range_idx];
let range = entry.index; let range = entry.index;
log::debug!( log::trace!(
"multi-fixed-reg cleanup: vreg {:?} range {:?}", "multi-fixed-reg cleanup: vreg {:?} range {:?}",
VRegIndex::new(vreg), VRegIndex::new(vreg),
range, range,
@@ -1119,7 +1126,7 @@ impl<'a, F: Function> Env<'a, F> {
if let OperandConstraint::FixedReg(preg) = op.constraint() { if let OperandConstraint::FixedReg(preg) = op.constraint() {
let vreg_idx = VRegIndex::new(op.vreg().vreg()); let vreg_idx = VRegIndex::new(op.vreg().vreg());
let preg_idx = PRegIndex::new(preg.index()); let preg_idx = PRegIndex::new(preg.index());
log::debug!( log::trace!(
"at pos {:?}, vreg {:?} has fixed constraint to preg {:?}", "at pos {:?}, vreg {:?} has fixed constraint to preg {:?}",
pos, pos,
vreg_idx, vreg_idx,
@@ -1129,7 +1136,7 @@ impl<'a, F: Function> Env<'a, F> {
{ {
let orig_preg = first_preg[idx]; let orig_preg = first_preg[idx];
if orig_preg != preg_idx { if orig_preg != preg_idx {
log::debug!(" -> duplicate; switching to constraint Reg"); log::trace!(" -> duplicate; switching to constraint Reg");
fixups.push((pos, orig_preg, preg_idx, slot)); fixups.push((pos, orig_preg, preg_idx, slot));
*op = Operand::new( *op = Operand::new(
op.vreg(), op.vreg(),
@@ -1137,7 +1144,7 @@ impl<'a, F: Function> Env<'a, F> {
op.kind(), op.kind(),
op.pos(), op.pos(),
); );
log::debug!( log::trace!(
" -> extra clobber {} at inst{}", " -> extra clobber {} at inst{}",
preg, preg,
pos.inst().index() pos.inst().index()
@@ -1182,8 +1189,8 @@ impl<'a, F: Function> Env<'a, F> {
self.prog_move_srcs.sort_unstable_by_key(|(pos, _)| *pos); self.prog_move_srcs.sort_unstable_by_key(|(pos, _)| *pos);
self.prog_move_dsts.sort_unstable_by_key(|(pos, _)| *pos); self.prog_move_dsts.sort_unstable_by_key(|(pos, _)| *pos);
log::debug!("prog_move_srcs = {:?}", self.prog_move_srcs); log::trace!("prog_move_srcs = {:?}", self.prog_move_srcs);
log::debug!("prog_move_dsts = {:?}", self.prog_move_dsts); log::trace!("prog_move_dsts = {:?}", self.prog_move_dsts);
self.stats.initial_liverange_count = self.ranges.len(); self.stats.initial_liverange_count = self.ranges.len();
self.stats.blockparam_ins_count = self.blockparam_ins.len(); self.stats.blockparam_ins_count = self.blockparam_ins.len();

48
src/ion/merge.rs
View File

@@ -26,7 +26,7 @@ impl<'a, F: Function> Env<'a, F> {
// Merge bundle into self -- trivial merge. // Merge bundle into self -- trivial merge.
return true; return true;
} }
log::debug!( log::trace!(
"merging from bundle{} to bundle{}", "merging from bundle{} to bundle{}",
from.index(), from.index(),
to.index() to.index()
@@ -36,7 +36,7 @@ impl<'a, F: Function> Env<'a, F> {
let from_rc = self.spillsets[self.bundles[from.index()].spillset.index()].class; let from_rc = self.spillsets[self.bundles[from.index()].spillset.index()].class;
let to_rc = self.spillsets[self.bundles[to.index()].spillset.index()].class; let to_rc = self.spillsets[self.bundles[to.index()].spillset.index()].class;
if from_rc != to_rc { if from_rc != to_rc {
log::debug!(" -> mismatching reg classes"); log::trace!(" -> mismatching reg classes");
return false; return false;
} }
@@ -44,7 +44,7 @@ impl<'a, F: Function> Env<'a, F> {
if !self.bundles[from.index()].allocation.is_none() if !self.bundles[from.index()].allocation.is_none()
|| !self.bundles[to.index()].allocation.is_none() || !self.bundles[to.index()].allocation.is_none()
{ {
log::debug!("one of the bundles is already assigned (pinned)"); log::trace!("one of the bundles is already assigned (pinned)");
return false; return false;
} }
@@ -71,7 +71,7 @@ impl<'a, F: Function> Env<'a, F> {
while idx_from < ranges_from.len() && idx_to < ranges_to.len() { while idx_from < ranges_from.len() && idx_to < ranges_to.len() {
range_count += 1; range_count += 1;
if range_count > 200 { if range_count > 200 {
log::debug!( log::trace!(
"reached merge complexity (range_count = {}); exiting", "reached merge complexity (range_count = {}); exiting",
range_count range_count
); );
@@ -85,7 +85,7 @@ impl<'a, F: Function> Env<'a, F> {
idx_from += 1; idx_from += 1;
} else { } else {
// Overlap -- cannot merge. // Overlap -- cannot merge.
log::debug!( log::trace!(
" -> overlap between {:?} and {:?}, exiting", " -> overlap between {:?} and {:?}, exiting",
ranges_from[idx_from].index, ranges_from[idx_from].index,
ranges_to[idx_to].index ranges_to[idx_to].index
@@ -104,12 +104,12 @@ impl<'a, F: Function> Env<'a, F> {
.compute_requirement(from) .compute_requirement(from)
.merge(self.compute_requirement(to)); .merge(self.compute_requirement(to));
if req == Requirement::Conflict { if req == Requirement::Conflict {
log::debug!(" -> conflicting requirements; aborting merge"); log::trace!(" -> conflicting requirements; aborting merge");
return false; return false;
} }
} }
log::debug!(" -> committing to merge"); log::trace!(" -> committing to merge");
// If we reach here, then the bundles do not overlap -- merge // If we reach here, then the bundles do not overlap -- merge
// them! We do this with a merge-sort-like scan over both // them! We do this with a merge-sort-like scan over both
@@ -117,13 +117,13 @@ impl<'a, F: Function> Env<'a, F> {
// `to` when we're done. // `to` when we're done.
if ranges_from.is_empty() { if ranges_from.is_empty() {
// `from` bundle is empty -- trivial merge. // `from` bundle is empty -- trivial merge.
log::debug!(" -> from bundle{} is empty; trivial merge", from.index()); log::trace!(" -> from bundle{} is empty; trivial merge", from.index());
return true; return true;
} }
if ranges_to.is_empty() { if ranges_to.is_empty() {
// `to` bundle is empty -- just move the list over from // `to` bundle is empty -- just move the list over from
// `from` and set `bundle` up-link on all ranges. // `from` and set `bundle` up-link on all ranges.
log::debug!(" -> to bundle{} is empty; trivial merge", to.index()); log::trace!(" -> to bundle{} is empty; trivial merge", to.index());
let list = std::mem::replace(&mut self.bundles[from.index()].ranges, smallvec![]); let list = std::mem::replace(&mut self.bundles[from.index()].ranges, smallvec![]);
for entry in &list { for entry in &list {
self.ranges[entry.index.index()].bundle = to; self.ranges[entry.index.index()].bundle = to;
@@ -153,7 +153,7 @@ impl<'a, F: Function> Env<'a, F> {
return true; return true;
} }
log::debug!( log::trace!(
"merging: ranges_from = {:?} ranges_to = {:?}", "merging: ranges_from = {:?} ranges_to = {:?}",
ranges_from, ranges_from,
ranges_to ranges_to
@@ -174,7 +174,7 @@ impl<'a, F: Function> Env<'a, F> {
.sort_unstable_by_key(|entry| entry.range.from); .sort_unstable_by_key(|entry| entry.range.from);
if self.annotations_enabled { if self.annotations_enabled {
log::debug!("merging: merged = {:?}", self.bundles[to.index()].ranges); log::trace!("merging: merged = {:?}", self.bundles[to.index()].ranges);
let mut last_range = None; let mut last_range = None;
for i in 0..self.bundles[to.index()].ranges.len() { for i in 0..self.bundles[to.index()].ranges.len() {
let entry = self.bundles[to.index()].ranges[i]; let entry = self.bundles[to.index()].ranges[i];
@@ -196,7 +196,7 @@ impl<'a, F: Function> Env<'a, F> {
); );
} }
log::debug!( log::trace!(
" -> merged result for bundle{}: range{}", " -> merged result for bundle{}: range{}",
to.index(), to.index(),
entry.index.index(), entry.index.index(),
@@ -229,7 +229,7 @@ impl<'a, F: Function> Env<'a, F> {
pub fn merge_vreg_bundles(&mut self) { pub fn merge_vreg_bundles(&mut self) {
// Create a bundle for every vreg, initially. // Create a bundle for every vreg, initially.
log::debug!("merge_vreg_bundles: creating vreg bundles"); log::trace!("merge_vreg_bundles: creating vreg bundles");
for vreg in 0..self.vregs.len() { for vreg in 0..self.vregs.len() {
let vreg = VRegIndex::new(vreg); let vreg = VRegIndex::new(vreg);
if self.vregs[vreg.index()].ranges.is_empty() { if self.vregs[vreg.index()].ranges.is_empty() {
@@ -255,9 +255,9 @@ impl<'a, F: Function> Env<'a, F> {
let bundle = self.create_bundle(); let bundle = self.create_bundle();
self.bundles[bundle.index()].ranges = self.vregs[vreg.index()].ranges.clone(); self.bundles[bundle.index()].ranges = self.vregs[vreg.index()].ranges.clone();
log::debug!("vreg v{} gets bundle{}", vreg.index(), bundle.index()); log::trace!("vreg v{} gets bundle{}", vreg.index(), bundle.index());
for entry in &self.bundles[bundle.index()].ranges { for entry in &self.bundles[bundle.index()].ranges {
log::debug!( log::trace!(
" -> with LR range{}: {:?}", " -> with LR range{}: {:?}",
entry.index.index(), entry.index.index(),
entry.range entry.range
@@ -318,7 +318,7 @@ impl<'a, F: Function> Env<'a, F> {
continue; continue;
} }
log::debug!( log::trace!(
"trying to merge reused-input def: src {} to dst {}", "trying to merge reused-input def: src {} to dst {}",
src_vreg, src_vreg,
dst_vreg dst_vreg
@@ -337,7 +337,7 @@ impl<'a, F: Function> Env<'a, F> {
// Attempt to merge blockparams with their inputs. // Attempt to merge blockparams with their inputs.
for i in 0..self.blockparam_outs.len() { for i in 0..self.blockparam_outs.len() {
let (from_vreg, _, _, to_vreg) = self.blockparam_outs[i]; let (from_vreg, _, _, to_vreg) = self.blockparam_outs[i];
log::debug!( log::trace!(
"trying to merge blockparam v{} with input v{}", "trying to merge blockparam v{} with input v{}",
to_vreg.index(), to_vreg.index(),
from_vreg.index() from_vreg.index()
@@ -347,7 +347,7 @@ impl<'a, F: Function> Env<'a, F> {
let from_bundle = let from_bundle =
self.ranges[self.vregs[from_vreg.index()].ranges[0].index.index()].bundle; self.ranges[self.vregs[from_vreg.index()].ranges[0].index.index()].bundle;
assert!(from_bundle.is_valid()); assert!(from_bundle.is_valid());
log::debug!( log::trace!(
" -> from bundle{} to bundle{}", " -> from bundle{} to bundle{}",
from_bundle.index(), from_bundle.index(),
to_bundle.index() to_bundle.index()
@@ -358,10 +358,10 @@ impl<'a, F: Function> Env<'a, F> {
// Attempt to merge move srcs/dsts. // Attempt to merge move srcs/dsts.
for i in 0..self.prog_move_merges.len() { for i in 0..self.prog_move_merges.len() {
let (src, dst) = self.prog_move_merges[i]; let (src, dst) = self.prog_move_merges[i];
log::debug!("trying to merge move src LR {:?} to dst LR {:?}", src, dst); log::trace!("trying to merge move src LR {:?} to dst LR {:?}", src, dst);
let src = self.resolve_merged_lr(src); let src = self.resolve_merged_lr(src);
let dst = self.resolve_merged_lr(dst); let dst = self.resolve_merged_lr(dst);
log::debug!( log::trace!(
"resolved LR-construction merging chains: move-merge is now src LR {:?} to dst LR {:?}", "resolved LR-construction merging chains: move-merge is now src LR {:?} to dst LR {:?}",
src, src,
dst dst
@@ -397,7 +397,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
} }
log::debug!("done merging bundles"); log::trace!("done merging bundles");
} }
pub fn resolve_merged_lr(&self, mut lr: LiveRangeIndex) -> LiveRangeIndex { pub fn resolve_merged_lr(&self, mut lr: LiveRangeIndex) -> LiveRangeIndex {
@@ -421,14 +421,14 @@ impl<'a, F: Function> Env<'a, F> {
pub fn queue_bundles(&mut self) { pub fn queue_bundles(&mut self) {
for bundle in 0..self.bundles.len() { for bundle in 0..self.bundles.len() {
log::debug!("enqueueing bundle{}", bundle); log::trace!("enqueueing bundle{}", bundle);
if self.bundles[bundle].ranges.is_empty() { if self.bundles[bundle].ranges.is_empty() {
log::debug!(" -> no ranges; skipping"); log::trace!(" -> no ranges; skipping");
continue; continue;
} }
let bundle = LiveBundleIndex::new(bundle); let bundle = LiveBundleIndex::new(bundle);
let prio = self.compute_bundle_prio(bundle); let prio = self.compute_bundle_prio(bundle);
log::debug!(" -> prio {}", prio); log::trace!(" -> prio {}", prio);
self.bundles[bundle.index()].prio = prio; self.bundles[bundle.index()].prio = prio;
self.recompute_bundle_properties(bundle); self.recompute_bundle_properties(bundle);
self.allocation_queue self.allocation_queue

92
src/ion/moves.rs
View File

@@ -20,10 +20,9 @@ use super::{
use crate::moves::ParallelMoves; use crate::moves::ParallelMoves;
use crate::{ use crate::{
Allocation, Block, Edit, Function, Inst, InstPosition, OperandKind, OperandConstraint, OperandPos, Allocation, Block, Edit, Function, Inst, InstPosition, OperandConstraint, OperandKind,
ProgPoint, RegClass, VReg, OperandPos, ProgPoint, RegClass, VReg,
}; };
use log::debug;
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
use std::fmt::Debug; use std::fmt::Debug;
@@ -45,9 +44,12 @@ impl<'a, F: Function> Env<'a, F> {
to_alloc: Allocation, to_alloc: Allocation,
to_vreg: Option<VReg>, to_vreg: Option<VReg>,
) { ) {
debug!( log::trace!(
"insert_move: pos {:?} prio {:?} from_alloc {:?} to_alloc {:?}", "insert_move: pos {:?} prio {:?} from_alloc {:?} to_alloc {:?}",
pos, prio, from_alloc, to_alloc pos,
prio,
from_alloc,
to_alloc
); );
match (from_alloc.as_reg(), to_alloc.as_reg()) { match (from_alloc.as_reg(), to_alloc.as_reg()) {
(Some(from), Some(to)) => { (Some(from), Some(to)) => {
@@ -75,16 +77,16 @@ impl<'a, F: Function> Env<'a, F> {
} }
pub fn get_alloc_for_range(&self, range: LiveRangeIndex) -> Allocation { pub fn get_alloc_for_range(&self, range: LiveRangeIndex) -> Allocation {
log::debug!("get_alloc_for_range: {:?}", range); log::trace!("get_alloc_for_range: {:?}", range);
let bundle = self.ranges[range.index()].bundle; let bundle = self.ranges[range.index()].bundle;
log::debug!(" -> bundle: {:?}", bundle); log::trace!(" -> bundle: {:?}", bundle);
let bundledata = &self.bundles[bundle.index()]; let bundledata = &self.bundles[bundle.index()];
log::debug!(" -> allocation {:?}", bundledata.allocation); log::trace!(" -> allocation {:?}", bundledata.allocation);
if bundledata.allocation != Allocation::none() { if bundledata.allocation != Allocation::none() {
bundledata.allocation bundledata.allocation
} else { } else {
log::debug!(" -> spillset {:?}", bundledata.spillset); log::trace!(" -> spillset {:?}", bundledata.spillset);
log::debug!( log::trace!(
" -> spill slot {:?}", " -> spill slot {:?}",
self.spillsets[bundledata.spillset.index()].slot self.spillsets[bundledata.spillset.index()].slot
); );
@@ -93,9 +95,9 @@ impl<'a, F: Function> Env<'a, F> {
} }
pub fn apply_allocations_and_insert_moves(&mut self) { pub fn apply_allocations_and_insert_moves(&mut self) {
log::debug!("apply_allocations_and_insert_moves"); log::trace!("apply_allocations_and_insert_moves");
log::debug!("blockparam_ins: {:?}", self.blockparam_ins); log::trace!("blockparam_ins: {:?}", self.blockparam_ins);
log::debug!("blockparam_outs: {:?}", self.blockparam_outs); log::trace!("blockparam_outs: {:?}", self.blockparam_outs);
// Now that all splits are done, we can pay the cost once to // Now that all splits are done, we can pay the cost once to
// sort VReg range lists and update with the final ranges. // sort VReg range lists and update with the final ranges.
@@ -191,7 +193,7 @@ impl<'a, F: Function> Env<'a, F> {
.map(|preg| Allocation::reg(preg)) .map(|preg| Allocation::reg(preg))
.unwrap_or_else(|| self.get_alloc_for_range(entry.index)); .unwrap_or_else(|| self.get_alloc_for_range(entry.index));
let range = entry.range; let range = entry.range;
log::debug!( log::trace!(
"apply_allocations: vreg {:?} LR {:?} with range {:?} has alloc {:?} (pinned {:?})", "apply_allocations: vreg {:?} LR {:?} with range {:?} has alloc {:?} (pinned {:?})",
vreg, vreg,
entry.index, entry.index,
@@ -258,7 +260,7 @@ impl<'a, F: Function> Env<'a, F> {
&& !self.is_start_of_block(range.from) && !self.is_start_of_block(range.from)
&& !first_is_def && !first_is_def
{ {
log::debug!( log::trace!(
"prev LR {} abuts LR {} in same block; moving {} -> {} for v{}", "prev LR {} abuts LR {} in same block; moving {} -> {} for v{}",
prev.index(), prev.index(),
entry.index.index(), entry.index.index(),
@@ -292,9 +294,9 @@ impl<'a, F: Function> Env<'a, F> {
if range.to < self.cfginfo.block_exit[block.index()].next() { if range.to < self.cfginfo.block_exit[block.index()].next() {
break; break;
} }
log::debug!("examining block with end in range: block{}", block.index()); log::trace!("examining block with end in range: block{}", block.index());
for &succ in self.func.block_succs(block) { for &succ in self.func.block_succs(block) {
log::debug!( log::trace!(
" -> has succ block {} with entry {:?}", " -> has succ block {} with entry {:?}",
succ.index(), succ.index(),
self.cfginfo.block_entry[succ.index()] self.cfginfo.block_entry[succ.index()]
@@ -302,9 +304,9 @@ impl<'a, F: Function> Env<'a, F> {
if range.contains_point(self.cfginfo.block_entry[succ.index()]) { if range.contains_point(self.cfginfo.block_entry[succ.index()]) {
continue; continue;
} }
log::debug!(" -> out of this range, requires half-move if live"); log::trace!(" -> out of this range, requires half-move if live");
if self.is_live_in(succ, vreg) { if self.is_live_in(succ, vreg) {
log::debug!(" -> live at input to succ, adding halfmove"); log::trace!(" -> live at input to succ, adding halfmove");
half_moves.push(HalfMove { half_moves.push(HalfMove {
key: half_move_key(block, succ, vreg, HalfMoveKind::Source), key: half_move_key(block, succ, vreg, HalfMoveKind::Source),
alloc, alloc,
@@ -315,7 +317,7 @@ impl<'a, F: Function> Env<'a, F> {
// Scan forward in `blockparam_outs`, adding all // Scan forward in `blockparam_outs`, adding all
// half-moves for outgoing values to blockparams // half-moves for outgoing values to blockparams
// in succs. // in succs.
log::debug!( log::trace!(
"scanning blockparam_outs for v{} block{}: blockparam_out_idx = {}", "scanning blockparam_outs for v{} block{}: blockparam_out_idx = {}",
vreg.index(), vreg.index(),
block.index(), block.index(),
@@ -328,7 +330,7 @@ impl<'a, F: Function> Env<'a, F> {
break; break;
} }
if (from_vreg, from_block) == (vreg, block) { if (from_vreg, from_block) == (vreg, block) {
log::debug!( log::trace!(
" -> found: from v{} block{} to v{} block{}", " -> found: from v{} block{} to v{} block{}",
from_vreg.index(), from_vreg.index(),
from_block.index(), from_block.index(),
@@ -380,7 +382,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
// Add half-moves for blockparam inputs. // Add half-moves for blockparam inputs.
log::debug!( log::trace!(
"scanning blockparam_ins at vreg {} block {}: blockparam_in_idx = {}", "scanning blockparam_ins at vreg {} block {}: blockparam_in_idx = {}",
vreg.index(), vreg.index(),
block.index(), block.index(),
@@ -402,7 +404,7 @@ impl<'a, F: Function> Env<'a, F> {
), ),
alloc, alloc,
}); });
log::debug!( log::trace!(
"match: blockparam_in: v{} in block{} from block{} into {}", "match: blockparam_in: v{} in block{} from block{} into {}",
to_vreg.index(), to_vreg.index(),
to_block.index(), to_block.index(),
@@ -433,7 +435,7 @@ impl<'a, F: Function> Env<'a, F> {
continue; continue;
} }
log::debug!( log::trace!(
"scanning preds at vreg {} block {} for ends outside the range", "scanning preds at vreg {} block {} for ends outside the range",
vreg.index(), vreg.index(),
block.index() block.index()
@@ -442,7 +444,7 @@ impl<'a, F: Function> Env<'a, F> {
// Now find any preds whose ends are not in the // Now find any preds whose ends are not in the
// same range, and insert appropriate moves. // same range, and insert appropriate moves.
for &pred in self.func.block_preds(block) { for &pred in self.func.block_preds(block) {
log::debug!( log::trace!(
"pred block {} has exit {:?}", "pred block {} has exit {:?}",
pred.index(), pred.index(),
self.cfginfo.block_exit[pred.index()] self.cfginfo.block_exit[pred.index()]
@@ -450,7 +452,7 @@ impl<'a, F: Function> Env<'a, F> {
if range.contains_point(self.cfginfo.block_exit[pred.index()]) { if range.contains_point(self.cfginfo.block_exit[pred.index()]) {
continue; continue;
} }
log::debug!(" -> requires half-move"); log::trace!(" -> requires half-move");
half_moves.push(HalfMove { half_moves.push(HalfMove {
key: half_move_key(pred, block, vreg, HalfMoveKind::Dest), key: half_move_key(pred, block, vreg, HalfMoveKind::Dest),
alloc, alloc,
@@ -479,7 +481,7 @@ impl<'a, F: Function> Env<'a, F> {
// Scan over def/uses and apply allocations. // Scan over def/uses and apply allocations.
for use_idx in 0..self.ranges[entry.index.index()].uses.len() { for use_idx in 0..self.ranges[entry.index.index()].uses.len() {
let usedata = self.ranges[entry.index.index()].uses[use_idx]; let usedata = self.ranges[entry.index.index()].uses[use_idx];
log::debug!("applying to use: {:?}", usedata); log::trace!("applying to use: {:?}", usedata);
debug_assert!(range.contains_point(usedata.pos)); debug_assert!(range.contains_point(usedata.pos));
let inst = usedata.pos.inst(); let inst = usedata.pos.inst();
let slot = usedata.slot; let slot = usedata.slot;
@@ -508,7 +510,7 @@ impl<'a, F: Function> Env<'a, F> {
// covers only prev inst's After; so includes move // covers only prev inst's After; so includes move
// srcs to (exclusive) inst. // srcs to (exclusive) inst.
let move_src_end = (vreg, range.to.inst()); let move_src_end = (vreg, range.to.inst());
log::debug!( log::trace!(
"vreg {:?} range {:?}: looking for program-move sources from {:?} to {:?}", "vreg {:?} range {:?}: looking for program-move sources from {:?} to {:?}",
vreg, vreg,
range, range,
@@ -518,13 +520,13 @@ impl<'a, F: Function> Env<'a, F> {
while prog_move_src_idx < self.prog_move_srcs.len() while prog_move_src_idx < self.prog_move_srcs.len()
&& self.prog_move_srcs[prog_move_src_idx].0 < move_src_start && self.prog_move_srcs[prog_move_src_idx].0 < move_src_start
{ {
log::debug!(" -> skipping idx {}", prog_move_src_idx); log::trace!(" -> skipping idx {}", prog_move_src_idx);
prog_move_src_idx += 1; prog_move_src_idx += 1;
} }
while prog_move_src_idx < self.prog_move_srcs.len() while prog_move_src_idx < self.prog_move_srcs.len()
&& self.prog_move_srcs[prog_move_src_idx].0 < move_src_end && self.prog_move_srcs[prog_move_src_idx].0 < move_src_end
{ {
log::debug!( log::trace!(
" -> setting idx {} ({:?}) to alloc {:?}", " -> setting idx {} ({:?}) to alloc {:?}",
prog_move_src_idx, prog_move_src_idx,
self.prog_move_srcs[prog_move_src_idx].0, self.prog_move_srcs[prog_move_src_idx].0,
@@ -551,7 +553,7 @@ impl<'a, F: Function> Env<'a, F> {
} else { } else {
(vreg, range.to.inst().next()) (vreg, range.to.inst().next())
}; };
log::debug!( log::trace!(
"vreg {:?} range {:?}: looking for program-move dests from {:?} to {:?}", "vreg {:?} range {:?}: looking for program-move dests from {:?} to {:?}",
vreg, vreg,
range, range,
@@ -561,13 +563,13 @@ impl<'a, F: Function> Env<'a, F> {
while prog_move_dst_idx < self.prog_move_dsts.len() while prog_move_dst_idx < self.prog_move_dsts.len()
&& self.prog_move_dsts[prog_move_dst_idx].0 < move_dst_start && self.prog_move_dsts[prog_move_dst_idx].0 < move_dst_start
{ {
log::debug!(" -> skipping idx {}", prog_move_dst_idx); log::trace!(" -> skipping idx {}", prog_move_dst_idx);
prog_move_dst_idx += 1; prog_move_dst_idx += 1;
} }
while prog_move_dst_idx < self.prog_move_dsts.len() while prog_move_dst_idx < self.prog_move_dsts.len()
&& self.prog_move_dsts[prog_move_dst_idx].0 < move_dst_end && self.prog_move_dsts[prog_move_dst_idx].0 < move_dst_end
{ {
log::debug!( log::trace!(
" -> setting idx {} ({:?}) to alloc {:?}", " -> setting idx {} ({:?}) to alloc {:?}",
prog_move_dst_idx, prog_move_dst_idx,
self.prog_move_dsts[prog_move_dst_idx].0, self.prog_move_dsts[prog_move_dst_idx].0,
@@ -585,7 +587,7 @@ impl<'a, F: Function> Env<'a, F> {
// from-vreg) tuple, find the from-alloc and all the // from-vreg) tuple, find the from-alloc and all the
// to-allocs, and insert moves on the block edge. // to-allocs, and insert moves on the block edge.
half_moves.sort_unstable_by_key(|h| h.key); half_moves.sort_unstable_by_key(|h| h.key);
log::debug!("halfmoves: {:?}", half_moves); log::trace!("halfmoves: {:?}", half_moves);
self.stats.halfmoves_count = half_moves.len(); self.stats.halfmoves_count = half_moves.len();
let mut i = 0; let mut i = 0;
@@ -608,7 +610,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
let last_dest = i; let last_dest = i;
log::debug!( log::trace!(
"halfmove match: src {:?} dests {:?}", "halfmove match: src {:?} dests {:?}",
src, src,
&half_moves[first_dest..last_dest] &half_moves[first_dest..last_dest]
@@ -687,7 +689,7 @@ impl<'a, F: Function> Env<'a, F> {
for (progpoint, from_preg, to_preg, slot) in for (progpoint, from_preg, to_preg, slot) in
std::mem::replace(&mut self.multi_fixed_reg_fixups, vec![]) std::mem::replace(&mut self.multi_fixed_reg_fixups, vec![])
{ {
log::debug!( log::trace!(
"multi-fixed-move constraint at {:?} from p{} to p{}", "multi-fixed-move constraint at {:?} from p{} to p{}",
progpoint, progpoint,
from_preg.index(), from_preg.index(),
@@ -761,7 +763,7 @@ impl<'a, F: Function> Env<'a, F> {
input_reused.push(input_idx); input_reused.push(input_idx);
let input_alloc = self.get_alloc(inst, input_idx); let input_alloc = self.get_alloc(inst, input_idx);
let output_alloc = self.get_alloc(inst, output_idx); let output_alloc = self.get_alloc(inst, output_idx);
log::debug!( log::trace!(
"reuse-input inst {:?}: output {} has alloc {:?}, input {} has alloc {:?}", "reuse-input inst {:?}: output {} has alloc {:?}, input {} has alloc {:?}",
inst, inst,
output_idx, output_idx,
@@ -808,7 +810,7 @@ impl<'a, F: Function> Env<'a, F> {
for (&((_, from_inst), from_alloc), &((to_vreg, to_inst), to_alloc)) in for (&((_, from_inst), from_alloc), &((to_vreg, to_inst), to_alloc)) in
prog_move_srcs.iter().zip(prog_move_dsts.iter()) prog_move_srcs.iter().zip(prog_move_dsts.iter())
{ {
log::debug!( log::trace!(
"program move at inst {:?}: alloc {:?} -> {:?} (v{})", "program move at inst {:?}: alloc {:?} -> {:?} (v{})",
from_inst, from_inst,
from_alloc, from_alloc,
@@ -947,10 +949,10 @@ impl<'a, F: Function> Env<'a, F> {
// that can be done one at a time. // that can be done one at a time.
let scratch = self.env.scratch_by_class[regclass as u8 as usize]; let scratch = self.env.scratch_by_class[regclass as u8 as usize];
let mut parallel_moves = ParallelMoves::new(Allocation::reg(scratch)); let mut parallel_moves = ParallelMoves::new(Allocation::reg(scratch));
log::debug!("parallel moves at pos {:?} prio {:?}", pos, prio); log::trace!("parallel moves at pos {:?} prio {:?}", pos, prio);
for m in moves { for m in moves {
if (m.from_alloc != m.to_alloc) || m.to_vreg.is_some() { if (m.from_alloc != m.to_alloc) || m.to_vreg.is_some() {
log::debug!(" {} -> {}", m.from_alloc, m.to_alloc,); log::trace!(" {} -> {}", m.from_alloc, m.to_alloc,);
parallel_moves.add(m.from_alloc, m.to_alloc, m.to_vreg); parallel_moves.add(m.from_alloc, m.to_alloc, m.to_vreg);
} }
} }
@@ -981,7 +983,7 @@ impl<'a, F: Function> Env<'a, F> {
let mut scratch_used_yet = false; let mut scratch_used_yet = false;
for (src, dst, to_vreg) in resolved { for (src, dst, to_vreg) in resolved {
log::debug!(" resolved: {} -> {} ({:?})", src, dst, to_vreg); log::trace!(" resolved: {} -> {} ({:?})", src, dst, to_vreg);
let action = redundant_moves.process_move(src, dst, to_vreg); let action = redundant_moves.process_move(src, dst, to_vreg);
if !action.elide { if !action.elide {
if dst == Allocation::reg(scratch) { if dst == Allocation::reg(scratch) {
@@ -1058,10 +1060,10 @@ impl<'a, F: Function> Env<'a, F> {
); );
} }
} else { } else {
log::debug!(" -> redundant move elided"); log::trace!(" -> redundant move elided");
} }
if let Some((alloc, vreg)) = action.def_alloc { if let Some((alloc, vreg)) = action.def_alloc {
log::debug!( log::trace!(
" -> converted to DefAlloc: alloc {} vreg {}", " -> converted to DefAlloc: alloc {} vreg {}",
alloc, alloc,
vreg vreg
@@ -1072,7 +1074,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
for m in &self_moves { for m in &self_moves {
log::debug!( log::trace!(
"self move at pos {:?} prio {:?}: {} -> {} to_vreg {:?}", "self move at pos {:?} prio {:?}: {} -> {} to_vreg {:?}",
pos, pos,
prio, prio,
@@ -1083,7 +1085,7 @@ impl<'a, F: Function> Env<'a, F> {
let action = redundant_moves.process_move(m.from_alloc, m.to_alloc, m.to_vreg); let action = redundant_moves.process_move(m.from_alloc, m.to_alloc, m.to_vreg);
assert!(action.elide); assert!(action.elide);
if let Some((alloc, vreg)) = action.def_alloc { if let Some((alloc, vreg)) = action.def_alloc {
log::debug!(" -> DefAlloc: alloc {} vreg {}", alloc, vreg); log::trace!(" -> DefAlloc: alloc {} vreg {}", alloc, vreg);
self.add_edit(pos, prio, Edit::DefAlloc { alloc, vreg }); self.add_edit(pos, prio, Edit::DefAlloc { alloc, vreg });
} }
} }

128
src/ion/process.rs
View File

@@ -19,7 +19,7 @@ use super::{
Requirement, UseList, Requirement, UseList,
}; };
use crate::{ use crate::{
Allocation, Function, Inst, InstPosition, OperandKind, OperandConstraint, PReg, ProgPoint, Allocation, Function, Inst, InstPosition, OperandConstraint, OperandKind, PReg, ProgPoint,
RegAllocError, RegAllocError,
}; };
use fxhash::FxHashSet; use fxhash::FxHashSet;
@@ -56,7 +56,7 @@ impl<'a, F: Function> Env<'a, F> {
// `AllocRegResult::ConflictHighCost`. // `AllocRegResult::ConflictHighCost`.
max_allowable_cost: Option<u32>, max_allowable_cost: Option<u32>,
) -> AllocRegResult { ) -> AllocRegResult {
log::debug!("try_to_allocate_bundle_to_reg: {:?} -> {:?}", bundle, reg); log::trace!("try_to_allocate_bundle_to_reg: {:?} -> {:?}", bundle, reg);
let mut conflicts = smallvec![]; let mut conflicts = smallvec![];
let mut conflict_set = FxHashSet::default(); let mut conflict_set = FxHashSet::default();
let mut max_conflict_weight = 0; let mut max_conflict_weight = 0;
@@ -83,7 +83,7 @@ impl<'a, F: Function> Env<'a, F> {
.btree .btree
.range(from_key..) .range(from_key..)
.peekable(); .peekable();
log::debug!( log::trace!(
"alloc map for {:?} in range {:?}..: {:?}", "alloc map for {:?} in range {:?}..: {:?}",
reg, reg,
from_key, from_key,
@@ -92,19 +92,19 @@ impl<'a, F: Function> Env<'a, F> {
let mut first_conflict: Option<ProgPoint> = None; let mut first_conflict: Option<ProgPoint> = None;
'ranges: for entry in bundle_ranges { 'ranges: for entry in bundle_ranges {
log::debug!(" -> range LR {:?}: {:?}", entry.index, entry.range); log::trace!(" -> range LR {:?}: {:?}", entry.index, entry.range);
let key = LiveRangeKey::from_range(&entry.range); let key = LiveRangeKey::from_range(&entry.range);
let mut skips = 0; let mut skips = 0;
'alloc: loop { 'alloc: loop {
log::debug!(" -> PReg range {:?}", preg_range_iter.peek()); log::trace!(" -> PReg range {:?}", preg_range_iter.peek());
// Advance our BTree traversal until it is >= this bundle // Advance our BTree traversal until it is >= this bundle
// range (i.e., skip PReg allocations in the BTree that // range (i.e., skip PReg allocations in the BTree that
// are completely before this bundle range). // are completely before this bundle range).
if preg_range_iter.peek().is_some() && *preg_range_iter.peek().unwrap().0 < key { if preg_range_iter.peek().is_some() && *preg_range_iter.peek().unwrap().0 < key {
log::debug!( log::trace!(
"Skipping PReg range {:?}", "Skipping PReg range {:?}",
preg_range_iter.peek().unwrap().0 preg_range_iter.peek().unwrap().0
); );
@@ -129,13 +129,13 @@ impl<'a, F: Function> Env<'a, F> {
// If there are no more PReg allocations, we're done! // If there are no more PReg allocations, we're done!
if preg_range_iter.peek().is_none() { if preg_range_iter.peek().is_none() {
log::debug!(" -> no more PReg allocations; so no conflict possible!"); log::trace!(" -> no more PReg allocations; so no conflict possible!");
break 'ranges; break 'ranges;
} }
// If the current PReg range is beyond this range, there is no conflict; continue. // If the current PReg range is beyond this range, there is no conflict; continue.
if *preg_range_iter.peek().unwrap().0 > key { if *preg_range_iter.peek().unwrap().0 > key {
log::debug!( log::trace!(
" -> next PReg allocation is at {:?}; moving to next VReg range", " -> next PReg allocation is at {:?}; moving to next VReg range",
preg_range_iter.peek().unwrap().0 preg_range_iter.peek().unwrap().0
); );
@@ -147,13 +147,13 @@ impl<'a, F: Function> Env<'a, F> {
assert_eq!(preg_key, key); // Assert that this range overlaps. assert_eq!(preg_key, key); // Assert that this range overlaps.
let preg_range = preg_range_iter.next().unwrap().1; let preg_range = preg_range_iter.next().unwrap().1;
log::debug!(" -> btree contains range {:?} that overlaps", preg_range); log::trace!(" -> btree contains range {:?} that overlaps", preg_range);
if preg_range.is_valid() { if preg_range.is_valid() {
log::debug!(" -> from vreg {:?}", self.ranges[preg_range.index()].vreg); log::trace!(" -> from vreg {:?}", self.ranges[preg_range.index()].vreg);
// range from an allocated bundle: find the bundle and add to // range from an allocated bundle: find the bundle and add to
// conflicts list. // conflicts list.
let conflict_bundle = self.ranges[preg_range.index()].bundle; let conflict_bundle = self.ranges[preg_range.index()].bundle;
log::debug!(" -> conflict bundle {:?}", conflict_bundle); log::trace!(" -> conflict bundle {:?}", conflict_bundle);
if !conflict_set.contains(&conflict_bundle) { if !conflict_set.contains(&conflict_bundle) {
conflicts.push(conflict_bundle); conflicts.push(conflict_bundle);
conflict_set.insert(conflict_bundle); conflict_set.insert(conflict_bundle);
@@ -164,7 +164,7 @@ impl<'a, F: Function> Env<'a, F> {
if max_allowable_cost.is_some() if max_allowable_cost.is_some()
&& max_conflict_weight > max_allowable_cost.unwrap() && max_conflict_weight > max_allowable_cost.unwrap()
{ {
log::debug!(" -> reached high cost, retrying early"); log::trace!(" -> reached high cost, retrying early");
return AllocRegResult::ConflictHighCost; return AllocRegResult::ConflictHighCost;
} }
} }
@@ -176,7 +176,7 @@ impl<'a, F: Function> Env<'a, F> {
))); )));
} }
} else { } else {
log::debug!(" -> conflict with fixed reservation"); log::trace!(" -> conflict with fixed reservation");
// range from a direct use of the PReg (due to clobber). // range from a direct use of the PReg (due to clobber).
return AllocRegResult::ConflictWithFixed( return AllocRegResult::ConflictWithFixed(
max_conflict_weight, max_conflict_weight,
@@ -192,7 +192,7 @@ impl<'a, F: Function> Env<'a, F> {
// We can allocate! Add our ranges to the preg's BTree. // We can allocate! Add our ranges to the preg's BTree.
let preg = self.pregs[reg.index()].reg; let preg = self.pregs[reg.index()].reg;
log::debug!(" -> bundle {:?} assigned to preg {:?}", bundle, preg); log::trace!(" -> bundle {:?} assigned to preg {:?}", bundle, preg);
self.bundles[bundle.index()].allocation = Allocation::reg(preg); self.bundles[bundle.index()].allocation = Allocation::reg(preg);
for entry in &self.bundles[bundle.index()].ranges { for entry in &self.bundles[bundle.index()].ranges {
self.pregs[reg.index()] self.pregs[reg.index()]
@@ -205,7 +205,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
pub fn evict_bundle(&mut self, bundle: LiveBundleIndex) { pub fn evict_bundle(&mut self, bundle: LiveBundleIndex) {
log::debug!( log::trace!(
"evicting bundle {:?}: alloc {:?}", "evicting bundle {:?}: alloc {:?}",
bundle, bundle,
self.bundles[bundle.index()].allocation self.bundles[bundle.index()].allocation
@@ -213,7 +213,7 @@ impl<'a, F: Function> Env<'a, F> {
let preg = match self.bundles[bundle.index()].allocation.as_reg() { let preg = match self.bundles[bundle.index()].allocation.as_reg() {
Some(preg) => preg, Some(preg) => preg,
None => { None => {
log::debug!( log::trace!(
" -> has no allocation! {:?}", " -> has no allocation! {:?}",
self.bundles[bundle.index()].allocation self.bundles[bundle.index()].allocation
); );
@@ -223,14 +223,14 @@ impl<'a, F: Function> Env<'a, F> {
let preg_idx = PRegIndex::new(preg.index()); let preg_idx = PRegIndex::new(preg.index());
self.bundles[bundle.index()].allocation = Allocation::none(); self.bundles[bundle.index()].allocation = Allocation::none();
for entry in &self.bundles[bundle.index()].ranges { for entry in &self.bundles[bundle.index()].ranges {
log::debug!(" -> removing LR {:?} from reg {:?}", entry.index, preg_idx); log::trace!(" -> removing LR {:?} from reg {:?}", entry.index, preg_idx);
self.pregs[preg_idx.index()] self.pregs[preg_idx.index()]
.allocations .allocations
.btree .btree
.remove(&LiveRangeKey::from_range(&entry.range)); .remove(&LiveRangeKey::from_range(&entry.range));
} }
let prio = self.bundles[bundle.index()].prio; let prio = self.bundles[bundle.index()].prio;
log::debug!(" -> prio {}; back into queue", prio); log::trace!(" -> prio {}; back into queue", prio);
self.allocation_queue self.allocation_queue
.insert(bundle, prio as usize, PReg::invalid()); .insert(bundle, prio as usize, PReg::invalid());
} }
@@ -240,22 +240,22 @@ impl<'a, F: Function> Env<'a, F> {
} }
pub fn maximum_spill_weight_in_bundle_set(&self, bundles: &LiveBundleVec) -> u32 { pub fn maximum_spill_weight_in_bundle_set(&self, bundles: &LiveBundleVec) -> u32 {
log::debug!("maximum_spill_weight_in_bundle_set: {:?}", bundles); log::trace!("maximum_spill_weight_in_bundle_set: {:?}", bundles);
let m = bundles let m = bundles
.iter() .iter()
.map(|&b| { .map(|&b| {
let w = self.bundles[b.index()].cached_spill_weight(); let w = self.bundles[b.index()].cached_spill_weight();
log::debug!("bundle{}: {}", b.index(), w); log::trace!("bundle{}: {}", b.index(), w);
w w
}) })
.max() .max()
.unwrap_or(0); .unwrap_or(0);
log::debug!(" -> max: {}", m); log::trace!(" -> max: {}", m);
m m
} }
pub fn recompute_bundle_properties(&mut self, bundle: LiveBundleIndex) { pub fn recompute_bundle_properties(&mut self, bundle: LiveBundleIndex) {
log::debug!("recompute bundle properties: bundle {:?}", bundle); log::trace!("recompute bundle properties: bundle {:?}", bundle);
let minimal; let minimal;
let mut fixed = false; let mut fixed = false;
@@ -267,18 +267,18 @@ impl<'a, F: Function> Env<'a, F> {
self.bundles[bundle.index()].prio = self.compute_bundle_prio(bundle); self.bundles[bundle.index()].prio = self.compute_bundle_prio(bundle);
if first_range_data.vreg.is_invalid() { if first_range_data.vreg.is_invalid() {
log::debug!(" -> no vreg; minimal and fixed"); log::trace!(" -> no vreg; minimal and fixed");
minimal = true; minimal = true;
fixed = true; fixed = true;
} else { } else {
for u in &first_range_data.uses { for u in &first_range_data.uses {
log::debug!(" -> use: {:?}", u); log::trace!(" -> use: {:?}", u);
if let OperandConstraint::FixedReg(_) = u.operand.constraint() { if let OperandConstraint::FixedReg(_) = u.operand.constraint() {
log::debug!(" -> fixed use at {:?}: {:?}", u.pos, u.operand); log::trace!(" -> fixed use at {:?}: {:?}", u.pos, u.operand);
fixed = true; fixed = true;
} }
if let OperandConstraint::Stack = u.operand.constraint() { if let OperandConstraint::Stack = u.operand.constraint() {
log::debug!(" -> stack use at {:?}: {:?}", u.pos, u.operand); log::trace!(" -> stack use at {:?}: {:?}", u.pos, u.operand);
stack = true; stack = true;
} }
if stack && fixed { if stack && fixed {
@@ -289,7 +289,7 @@ impl<'a, F: Function> Env<'a, F> {
// that it could cover just one ProgPoint, // that it could cover just one ProgPoint,
// i.e. X.Before..X.After, or two ProgPoints, // i.e. X.Before..X.After, or two ProgPoints,
// i.e. X.Before..X+1.Before. // i.e. X.Before..X+1.Before.
log::debug!(" -> first range has range {:?}", first_range_data.range); log::trace!(" -> first range has range {:?}", first_range_data.range);
let bundle_start = self.bundles[bundle.index()] let bundle_start = self.bundles[bundle.index()]
.ranges .ranges
.first() .first()
@@ -298,22 +298,22 @@ impl<'a, F: Function> Env<'a, F> {
.from; .from;
let bundle_end = self.bundles[bundle.index()].ranges.last().unwrap().range.to; let bundle_end = self.bundles[bundle.index()].ranges.last().unwrap().range.to;
minimal = bundle_start.inst() == bundle_end.prev().inst(); minimal = bundle_start.inst() == bundle_end.prev().inst();
log::debug!(" -> minimal: {}", minimal); log::trace!(" -> minimal: {}", minimal);
} }
let spill_weight = if minimal { let spill_weight = if minimal {
if fixed { if fixed {
log::debug!(" -> fixed and minimal: spill weight 2000000"); log::trace!(" -> fixed and minimal: spill weight 2000000");
2_000_000 2_000_000
} else { } else {
log::debug!(" -> non-fixed and minimal: spill weight 1000000"); log::trace!(" -> non-fixed and minimal: spill weight 1000000");
1_000_000 1_000_000
} }
} else { } else {
let mut total = 0; let mut total = 0;
for entry in &self.bundles[bundle.index()].ranges { for entry in &self.bundles[bundle.index()].ranges {
let range_data = &self.ranges[entry.index.index()]; let range_data = &self.ranges[entry.index.index()];
log::debug!( log::trace!(
" -> uses spill weight: +{}", " -> uses spill weight: +{}",
range_data.uses_spill_weight() range_data.uses_spill_weight()
); );
@@ -321,7 +321,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
if self.bundles[bundle.index()].prio > 0 { if self.bundles[bundle.index()].prio > 0 {
log::debug!( log::trace!(
" -> dividing by prio {}; final weight {}", " -> dividing by prio {}; final weight {}",
self.bundles[bundle.index()].prio, self.bundles[bundle.index()].prio,
total / self.bundles[bundle.index()].prio total / self.bundles[bundle.index()].prio
@@ -349,7 +349,7 @@ impl<'a, F: Function> Env<'a, F> {
let mut w = 0; let mut w = 0;
for u in &rangedata.uses { for u in &rangedata.uses {
w += u.weight as u32; w += u.weight as u32;
log::debug!("range{}: use {:?}", range.index(), u); log::trace!("range{}: use {:?}", range.index(), u);
} }
rangedata.set_uses_spill_weight(w); rangedata.set_uses_spill_weight(w);
if rangedata.uses.len() > 0 && rangedata.uses[0].operand.kind() == OperandKind::Def { if rangedata.uses.len() > 0 && rangedata.uses[0].operand.kind() == OperandKind::Def {
@@ -413,7 +413,7 @@ impl<'a, F: Function> Env<'a, F> {
reg_hint: PReg, reg_hint: PReg,
) { ) {
self.stats.splits += 1; self.stats.splits += 1;
log::debug!( log::trace!(
"split bundle {:?} at {:?} and requeue with reg hint (for first part) {:?}", "split bundle {:?} at {:?} and requeue with reg hint (for first part) {:?}",
bundle, bundle,
split_at, split_at,
@@ -451,7 +451,7 @@ impl<'a, F: Function> Env<'a, F> {
break 'outer; break 'outer;
} }
} }
log::debug!(" -> first use loc is {:?}", first_use); log::trace!(" -> first use loc is {:?}", first_use);
split_at = match first_use { split_at = match first_use {
Some(pos) => { Some(pos) => {
if pos.inst() == bundle_start.inst() { if pos.inst() == bundle_start.inst() {
@@ -471,7 +471,7 @@ impl<'a, F: Function> Env<'a, F> {
.next(), .next(),
), ),
}; };
log::debug!( log::trace!(
"split point is at bundle start; advancing to {:?}", "split point is at bundle start; advancing to {:?}",
split_at split_at
); );
@@ -493,7 +493,7 @@ impl<'a, F: Function> Env<'a, F> {
// which LR we need to split down the middle, then update the // which LR we need to split down the middle, then update the
// current bundle, create a new one, and (re)-queue both. // current bundle, create a new one, and (re)-queue both.
log::debug!(" -> LRs: {:?}", self.bundles[bundle.index()].ranges); log::trace!(" -> LRs: {:?}", self.bundles[bundle.index()].ranges);
let mut last_lr_in_old_bundle_idx = 0; // last LR-list index in old bundle let mut last_lr_in_old_bundle_idx = 0; // last LR-list index in old bundle
let mut first_lr_in_new_bundle_idx = 0; // first LR-list index in new bundle let mut first_lr_in_new_bundle_idx = 0; // first LR-list index in new bundle
@@ -508,11 +508,11 @@ impl<'a, F: Function> Env<'a, F> {
} }
} }
log::debug!( log::trace!(
" -> last LR in old bundle: LR {:?}", " -> last LR in old bundle: LR {:?}",
self.bundles[bundle.index()].ranges[last_lr_in_old_bundle_idx] self.bundles[bundle.index()].ranges[last_lr_in_old_bundle_idx]
); );
log::debug!( log::trace!(
" -> first LR in new bundle: LR {:?}", " -> first LR in new bundle: LR {:?}",
self.bundles[bundle.index()].ranges[first_lr_in_new_bundle_idx] self.bundles[bundle.index()].ranges[first_lr_in_new_bundle_idx]
); );
@@ -539,7 +539,7 @@ impl<'a, F: Function> Env<'a, F> {
to: new_lr_list[0].range.to, to: new_lr_list[0].range.to,
}); });
self.ranges[new_lr.index()].vreg = self.ranges[orig_lr.index()].vreg; self.ranges[new_lr.index()].vreg = self.ranges[orig_lr.index()].vreg;
log::debug!(" -> splitting LR {:?} into {:?}", orig_lr, new_lr); log::trace!(" -> splitting LR {:?} into {:?}", orig_lr, new_lr);
let first_use = self.ranges[orig_lr.index()] let first_use = self.ranges[orig_lr.index()]
.uses .uses
.iter() .iter()
@@ -576,7 +576,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
let new_bundle = self.create_bundle(); let new_bundle = self.create_bundle();
log::debug!(" -> creating new bundle {:?}", new_bundle); log::trace!(" -> creating new bundle {:?}", new_bundle);
self.bundles[new_bundle.index()].spillset = spillset; self.bundles[new_bundle.index()].spillset = spillset;
for entry in &new_lr_list { for entry in &new_lr_list {
self.ranges[entry.index.index()].bundle = new_bundle; self.ranges[entry.index.index()].bundle = new_bundle;
@@ -598,7 +598,7 @@ impl<'a, F: Function> Env<'a, F> {
let spill = self let spill = self
.get_or_create_spill_bundle(bundle, /* create_if_absent = */ true) .get_or_create_spill_bundle(bundle, /* create_if_absent = */ true)
.unwrap(); .unwrap();
log::debug!( log::trace!(
" -> bundle {:?} range {:?}: no uses; moving to spill bundle {:?}", " -> bundle {:?} range {:?}: no uses; moving to spill bundle {:?}",
bundle, bundle,
entry.index, entry.index,
@@ -643,13 +643,13 @@ impl<'a, F: Function> Env<'a, F> {
range, range,
index: empty_lr, index: empty_lr,
}); });
log::debug!( log::trace!(
" -> bundle {:?} range {:?}: last use implies split point {:?}", " -> bundle {:?} range {:?}: last use implies split point {:?}",
bundle, bundle,
entry.index, entry.index,
split split
); );
log::debug!( log::trace!(
" -> moving trailing empty region to new spill bundle {:?} with new LR {:?}", " -> moving trailing empty region to new spill bundle {:?} with new LR {:?}",
spill, spill,
empty_lr empty_lr
@@ -668,7 +668,7 @@ impl<'a, F: Function> Env<'a, F> {
let spill = self let spill = self
.get_or_create_spill_bundle(new_bundle, /* create_if_absent = */ true) .get_or_create_spill_bundle(new_bundle, /* create_if_absent = */ true)
.unwrap(); .unwrap();
log::debug!( log::trace!(
" -> bundle {:?} range {:?}: no uses; moving to spill bundle {:?}", " -> bundle {:?} range {:?}: no uses; moving to spill bundle {:?}",
new_bundle, new_bundle,
entry.index, entry.index,
@@ -713,13 +713,13 @@ impl<'a, F: Function> Env<'a, F> {
range, range,
index: empty_lr, index: empty_lr,
}); });
log::debug!( log::trace!(
" -> bundle {:?} range {:?}: first use implies split point {:?}", " -> bundle {:?} range {:?}: first use implies split point {:?}",
bundle, bundle,
entry.index, entry.index,
first_use, first_use,
); );
log::debug!( log::trace!(
" -> moving leading empty region to new spill bundle {:?} with new LR {:?}", " -> moving leading empty region to new spill bundle {:?} with new LR {:?}",
spill, spill,
empty_lr empty_lr
@@ -754,7 +754,7 @@ impl<'a, F: Function> Env<'a, F> {
} else { } else {
self.spillsets[self.bundles[bundle.index()].spillset.index()].reg_hint self.spillsets[self.bundles[bundle.index()].spillset.index()].reg_hint
}; };
log::debug!("process_bundle: bundle {:?} hint {:?}", bundle, hint_reg,); log::trace!("process_bundle: bundle {:?} hint {:?}", bundle, hint_reg,);
if let Requirement::Conflict = req { if let Requirement::Conflict = req {
// We have to split right away. We'll find a point to // We have to split right away. We'll find a point to
@@ -797,7 +797,7 @@ impl<'a, F: Function> Env<'a, F> {
let mut attempts = 0; let mut attempts = 0;
loop { loop {
attempts += 1; attempts += 1;
log::debug!("attempt {}, req {:?}", attempts, req); log::trace!("attempt {}, req {:?}", attempts, req);
debug_assert!(attempts < 100 * self.func.insts()); debug_assert!(attempts < 100 * self.func.insts());
let (class, fixed_preg) = match req { let (class, fixed_preg) = match req {
@@ -851,7 +851,7 @@ impl<'a, F: Function> Env<'a, F> {
) { ) {
self.stats.process_bundle_reg_probes_any += 1; self.stats.process_bundle_reg_probes_any += 1;
let preg_idx = PRegIndex::new(preg.index()); let preg_idx = PRegIndex::new(preg.index());
log::debug!("trying preg {:?}", preg_idx); log::trace!("trying preg {:?}", preg_idx);
let scan_limit_cost = match ( let scan_limit_cost = match (
lowest_cost_evict_conflict_cost, lowest_cost_evict_conflict_cost,
@@ -863,13 +863,13 @@ impl<'a, F: Function> Env<'a, F> {
match self.try_to_allocate_bundle_to_reg(bundle, preg_idx, scan_limit_cost) { match self.try_to_allocate_bundle_to_reg(bundle, preg_idx, scan_limit_cost) {
AllocRegResult::Allocated(alloc) => { AllocRegResult::Allocated(alloc) => {
self.stats.process_bundle_reg_success_any += 1; self.stats.process_bundle_reg_success_any += 1;
log::debug!(" -> allocated to any {:?}", preg_idx); log::trace!(" -> allocated to any {:?}", preg_idx);
self.spillsets[self.bundles[bundle.index()].spillset.index()].reg_hint = self.spillsets[self.bundles[bundle.index()].spillset.index()].reg_hint =
alloc.as_reg().unwrap(); alloc.as_reg().unwrap();
return Ok(()); return Ok(());
} }
AllocRegResult::Conflict(bundles, first_conflict_point) => { AllocRegResult::Conflict(bundles, first_conflict_point) => {
log::debug!( log::trace!(
" -> conflict with bundles {:?}, first conflict at {:?}", " -> conflict with bundles {:?}, first conflict at {:?}",
bundles, bundles,
first_conflict_point first_conflict_point
@@ -901,7 +901,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
} }
AllocRegResult::ConflictWithFixed(max_cost, point) => { AllocRegResult::ConflictWithFixed(max_cost, point) => {
log::debug!(" -> conflict with fixed alloc; cost of other bundles up to point is {}, conflict at {:?}", max_cost, point); log::trace!(" -> conflict with fixed alloc; cost of other bundles up to point is {}, conflict at {:?}", max_cost, point);
let loop_depth = self.cfginfo.approx_loop_depth let loop_depth = self.cfginfo.approx_loop_depth
[self.cfginfo.insn_block[point.inst().index()].index()]; [self.cfginfo.insn_block[point.inst().index()].index()];
@@ -932,12 +932,12 @@ impl<'a, F: Function> Env<'a, F> {
// any with current bundle assignments. Hence, we will need // any with current bundle assignments. Hence, we will need
// to either split or attempt to evict some bundles. // to either split or attempt to evict some bundles.
log::debug!( log::trace!(
" -> lowest cost evict: set {:?}, cost {:?}", " -> lowest cost evict: set {:?}, cost {:?}",
lowest_cost_evict_conflict_set, lowest_cost_evict_conflict_set,
lowest_cost_evict_conflict_cost, lowest_cost_evict_conflict_cost,
); );
log::debug!( log::trace!(
" -> lowest cost split: cost {:?}, point {:?}, reg {:?}", " -> lowest cost split: cost {:?}, point {:?}, reg {:?}",
lowest_cost_split_conflict_cost, lowest_cost_split_conflict_cost,
lowest_cost_split_conflict_point, lowest_cost_split_conflict_point,
@@ -951,7 +951,7 @@ impl<'a, F: Function> Env<'a, F> {
); );
let our_spill_weight = self.bundle_spill_weight(bundle); let our_spill_weight = self.bundle_spill_weight(bundle);
log::debug!(" -> our spill weight: {}", our_spill_weight); log::trace!(" -> our spill weight: {}", our_spill_weight);
// We detect the "too-many-live-registers" case here and // We detect the "too-many-live-registers" case here and
// return an error cleanly, rather than panicking, because // return an error cleanly, rather than panicking, because
@@ -966,7 +966,7 @@ impl<'a, F: Function> Env<'a, F> {
if let Requirement::Register(class) = req { if let Requirement::Register(class) = req {
// Check if this is a too-many-live-registers situation. // Check if this is a too-many-live-registers situation.
let range = self.bundles[bundle.index()].ranges[0].range; let range = self.bundles[bundle.index()].ranges[0].range;
log::debug!("checking for too many live regs"); log::trace!("checking for too many live regs");
let mut min_bundles_assigned = 0; let mut min_bundles_assigned = 0;
let mut fixed_assigned = 0; let mut fixed_assigned = 0;
let mut total_regs = 0; let mut total_regs = 0;
@@ -974,7 +974,7 @@ impl<'a, F: Function> Env<'a, F> {
.iter() .iter()
.chain(self.env.non_preferred_regs_by_class[class as u8 as usize].iter()) .chain(self.env.non_preferred_regs_by_class[class as u8 as usize].iter())
{ {
log::debug!(" -> PR {:?}", preg); log::trace!(" -> PR {:?}", preg);
let start = LiveRangeKey::from_range(&CodeRange { let start = LiveRangeKey::from_range(&CodeRange {
from: range.from.prev(), from: range.from.prev(),
to: range.from.prev(), to: range.from.prev(),
@@ -989,19 +989,19 @@ impl<'a, F: Function> Env<'a, F> {
} }
if lr.is_valid() { if lr.is_valid() {
if self.minimal_bundle(self.ranges[lr.index()].bundle) { if self.minimal_bundle(self.ranges[lr.index()].bundle) {
log::debug!(" -> min bundle {:?}", lr); log::trace!(" -> min bundle {:?}", lr);
min_bundles_assigned += 1; min_bundles_assigned += 1;
} else { } else {
log::debug!(" -> non-min bundle {:?}", lr); log::trace!(" -> non-min bundle {:?}", lr);
} }
} else { } else {
log::debug!(" -> fixed bundle"); log::trace!(" -> fixed bundle");
fixed_assigned += 1; fixed_assigned += 1;
} }
} }
total_regs += 1; total_regs += 1;
} }
log::debug!( log::trace!(
" -> total {}, fixed {}, min {}", " -> total {}, fixed {}, min {}",
total_regs, total_regs,
fixed_assigned, fixed_assigned,
@@ -1033,7 +1033,7 @@ impl<'a, F: Function> Env<'a, F> {
|| lowest_cost_evict_conflict_cost.is_none() || lowest_cost_evict_conflict_cost.is_none()
|| our_spill_weight <= lowest_cost_evict_conflict_cost.unwrap()) || our_spill_weight <= lowest_cost_evict_conflict_cost.unwrap())
{ {
log::debug!( log::trace!(
" -> deciding to split: our spill weight is {}", " -> deciding to split: our spill weight is {}",
self.bundle_spill_weight(bundle) self.bundle_spill_weight(bundle)
); );
@@ -1066,7 +1066,7 @@ impl<'a, F: Function> Env<'a, F> {
// Evict all bundles in `conflicting bundles` and try again. // Evict all bundles in `conflicting bundles` and try again.
self.stats.evict_bundle_event += 1; self.stats.evict_bundle_event += 1;
for &bundle in &lowest_cost_evict_conflict_set.unwrap() { for &bundle in &lowest_cost_evict_conflict_set.unwrap() {
log::debug!(" -> evicting {:?}", bundle); log::trace!(" -> evicting {:?}", bundle);
self.evict_bundle(bundle); self.evict_bundle(bundle);
self.stats.evict_bundle_count += 1; self.stats.evict_bundle_count += 1;
} }

22
src/ion/redundant_moves.rs
View File

@@ -40,13 +40,13 @@ impl RedundantMoveEliminator {
.map(|&p| p) .map(|&p| p)
.unwrap_or(RedundantMoveState::None); .unwrap_or(RedundantMoveState::None);
log::debug!( log::trace!(
" -> redundant move tracker: from {} to {} to_vreg {:?}", " -> redundant move tracker: from {} to {} to_vreg {:?}",
from, from,
to, to,
to_vreg to_vreg
); );
log::debug!( log::trace!(
" -> from_state {:?} to_state {:?}", " -> from_state {:?} to_state {:?}",
from_state, from_state,
to_state to_state
@@ -67,29 +67,29 @@ impl RedundantMoveEliminator {
RedundantMoveState::Orig(r) => Some(r), RedundantMoveState::Orig(r) => Some(r),
_ => None, _ => None,
}; };
log::debug!(" -> src_vreg {:?}", src_vreg); log::trace!(" -> src_vreg {:?}", src_vreg);
let dst_vreg = to_vreg.or(src_vreg); let dst_vreg = to_vreg.or(src_vreg);
log::debug!(" -> dst_vreg {:?}", dst_vreg); log::trace!(" -> dst_vreg {:?}", dst_vreg);
let existing_dst_vreg = match to_state { let existing_dst_vreg = match to_state {
RedundantMoveState::Copy(_, opt_r) => opt_r, RedundantMoveState::Copy(_, opt_r) => opt_r,
RedundantMoveState::Orig(r) => Some(r), RedundantMoveState::Orig(r) => Some(r),
_ => None, _ => None,
}; };
log::debug!(" -> existing_dst_vreg {:?}", existing_dst_vreg); log::trace!(" -> existing_dst_vreg {:?}", existing_dst_vreg);
let elide = match (from_state, to_state) { let elide = match (from_state, to_state) {
(_, RedundantMoveState::Copy(orig_alloc, _)) if orig_alloc == from => true, (_, RedundantMoveState::Copy(orig_alloc, _)) if orig_alloc == from => true,
(RedundantMoveState::Copy(new_alloc, _), _) if new_alloc == to => true, (RedundantMoveState::Copy(new_alloc, _), _) if new_alloc == to => true,
_ => false, _ => false,
}; };
log::debug!(" -> elide {}", elide); log::trace!(" -> elide {}", elide);
let def_alloc = if dst_vreg != existing_dst_vreg && dst_vreg.is_some() { let def_alloc = if dst_vreg != existing_dst_vreg && dst_vreg.is_some() {
Some((to, dst_vreg.unwrap())) Some((to, dst_vreg.unwrap()))
} else { } else {
None None
}; };
log::debug!(" -> def_alloc {:?}", def_alloc); log::trace!(" -> def_alloc {:?}", def_alloc);
// Invalidate all existing copies of `to` if `to` actually changed value. // Invalidate all existing copies of `to` if `to` actually changed value.
if !elide { if !elide {
@@ -100,7 +100,7 @@ impl RedundantMoveEliminator {
if from.is_reg() || to.is_reg() { if from.is_reg() || to.is_reg() {
self.allocs self.allocs
.insert(to, RedundantMoveState::Copy(from, dst_vreg)); .insert(to, RedundantMoveState::Copy(from, dst_vreg));
log::debug!( log::trace!(
" -> create mapping {} -> {:?}", " -> create mapping {} -> {:?}",
to, to,
RedundantMoveState::Copy(from, dst_vreg) RedundantMoveState::Copy(from, dst_vreg)
@@ -115,16 +115,16 @@ impl RedundantMoveEliminator {
} }
pub fn clear(&mut self) { pub fn clear(&mut self) {
log::debug!(" redundant move eliminator cleared"); log::trace!(" redundant move eliminator cleared");
self.allocs.clear(); self.allocs.clear();
self.reverse_allocs.clear(); self.reverse_allocs.clear();
} }
pub fn clear_alloc(&mut self, alloc: Allocation) { pub fn clear_alloc(&mut self, alloc: Allocation) {
log::debug!(" redundant move eliminator: clear {:?}", alloc); log::trace!(" redundant move eliminator: clear {:?}", alloc);
if let Some(ref mut existing_copies) = self.reverse_allocs.get_mut(&alloc) { if let Some(ref mut existing_copies) = self.reverse_allocs.get_mut(&alloc) {
for to_inval in existing_copies.iter() { for to_inval in existing_copies.iter() {
log::debug!(" -> clear existing copy: {:?}", to_inval); log::trace!(" -> clear existing copy: {:?}", to_inval);
if let Some(val) = self.allocs.get_mut(to_inval) { if let Some(val) = self.allocs.get_mut(to_inval) {
match val { match val {
RedundantMoveState::Copy(_, Some(vreg)) => { RedundantMoveState::Copy(_, Some(vreg)) => {

14
src/ion/requirement.rs
View File

@@ -66,7 +66,9 @@ impl Requirement {
pub fn from_operand(op: Operand) -> Requirement { pub fn from_operand(op: Operand) -> Requirement {
match op.constraint() { match op.constraint() {
OperandConstraint::FixedReg(preg) => Requirement::Fixed(preg), OperandConstraint::FixedReg(preg) => Requirement::Fixed(preg),
OperandConstraint::Reg | OperandConstraint::Reuse(_) => Requirement::Register(op.class()), OperandConstraint::Reg | OperandConstraint::Reuse(_) => {
Requirement::Register(op.class())
}
OperandConstraint::Stack => Requirement::Stack(op.class()), OperandConstraint::Stack => Requirement::Stack(op.class()),
_ => Requirement::Any(op.class()), _ => Requirement::Any(op.class()),
} }
@@ -76,17 +78,17 @@ impl Requirement {
impl<'a, F: Function> Env<'a, F> { impl<'a, F: Function> Env<'a, F> {
pub fn compute_requirement(&self, bundle: LiveBundleIndex) -> Requirement { pub fn compute_requirement(&self, bundle: LiveBundleIndex) -> Requirement {
let mut req = Requirement::Unknown; let mut req = Requirement::Unknown;
log::debug!("compute_requirement: {:?}", bundle); log::trace!("compute_requirement: {:?}", bundle);
for entry in &self.bundles[bundle.index()].ranges { for entry in &self.bundles[bundle.index()].ranges {
log::debug!(" -> LR {:?}", entry.index); log::trace!(" -> LR {:?}", entry.index);
for u in &self.ranges[entry.index.index()].uses { for u in &self.ranges[entry.index.index()].uses {
log::debug!(" -> use {:?}", u); log::trace!(" -> use {:?}", u);
let r = Requirement::from_operand(u.operand); let r = Requirement::from_operand(u.operand);
req = req.merge(r); req = req.merge(r);
log::debug!(" -> req {:?}", req); log::trace!(" -> req {:?}", req);
} }
} }
log::debug!(" -> final: {:?}", req); log::trace!(" -> final: {:?}", req);
req req
} }
} }

14
src/ion/spill.rs
View File

@@ -21,7 +21,7 @@ use crate::{Allocation, Function, SpillSlot};
impl<'a, F: Function> Env<'a, F> { impl<'a, F: Function> Env<'a, F> {
pub fn try_allocating_regs_for_spilled_bundles(&mut self) { pub fn try_allocating_regs_for_spilled_bundles(&mut self) {
log::debug!("allocating regs for spilled bundles"); log::trace!("allocating regs for spilled bundles");
for i in 0..self.spilled_bundles.len() { for i in 0..self.spilled_bundles.len() {
let bundle = self.spilled_bundles[i]; // don't borrow self let bundle = self.spilled_bundles[i]; // don't borrow self
@@ -39,7 +39,7 @@ impl<'a, F: Function> Env<'a, F> {
for preg in for preg in
RegTraversalIter::new(self.env, class, hint, PReg::invalid(), bundle.index(), None) RegTraversalIter::new(self.env, class, hint, PReg::invalid(), bundle.index(), None)
{ {
log::debug!("trying bundle {:?} to preg {:?}", bundle, preg); log::trace!("trying bundle {:?} to preg {:?}", bundle, preg);
let preg_idx = PRegIndex::new(preg.index()); let preg_idx = PRegIndex::new(preg.index());
if let AllocRegResult::Allocated(_) = if let AllocRegResult::Allocated(_) =
self.try_to_allocate_bundle_to_reg(bundle, preg_idx, None) self.try_to_allocate_bundle_to_reg(bundle, preg_idx, None)
@@ -50,7 +50,7 @@ impl<'a, F: Function> Env<'a, F> {
} }
} }
if !success { if !success {
log::debug!( log::trace!(
"spilling bundle {:?}: marking spillset {:?} as required", "spilling bundle {:?}: marking spillset {:?} as required",
bundle, bundle,
self.bundles[bundle.index()].spillset self.bundles[bundle.index()].spillset
@@ -88,14 +88,14 @@ impl<'a, F: Function> Env<'a, F> {
for i in 0..self.spillsets[spillset.index()].vregs.len() { for i in 0..self.spillsets[spillset.index()].vregs.len() {
// don't borrow self // don't borrow self
let vreg = self.spillsets[spillset.index()].vregs[i]; let vreg = self.spillsets[spillset.index()].vregs[i];
log::debug!( log::trace!(
"spillslot {:?} alloc'ed to spillset {:?}: vreg {:?}", "spillslot {:?} alloc'ed to spillset {:?}: vreg {:?}",
spillslot, spillslot,
spillset, spillset,
vreg, vreg,
); );
for entry in &self.vregs[vreg.index()].ranges { for entry in &self.vregs[vreg.index()].ranges {
log::debug!( log::trace!(
"spillslot {:?} getting range {:?} from LR {:?} from vreg {:?}", "spillslot {:?} getting range {:?} from LR {:?} from vreg {:?}",
spillslot, spillslot,
entry.range, entry.range,
@@ -112,7 +112,7 @@ impl<'a, F: Function> Env<'a, F> {
pub fn allocate_spillslots(&mut self) { pub fn allocate_spillslots(&mut self) {
for spillset in 0..self.spillsets.len() { for spillset in 0..self.spillsets.len() {
log::debug!("allocate spillslot: {}", spillset); log::trace!("allocate spillslot: {}", spillset);
let spillset = SpillSetIndex::new(spillset); let spillset = SpillSetIndex::new(spillset);
if !self.spillsets[spillset.index()].required { if !self.spillsets[spillset.index()].required {
continue; continue;
@@ -197,7 +197,7 @@ impl<'a, F: Function> Env<'a, F> {
self.spillslots[i].alloc = self.allocate_spillslot(self.spillslots[i].class); self.spillslots[i].alloc = self.allocate_spillslot(self.spillslots[i].class);
} }
log::debug!("spillslot allocator done"); log::trace!("spillslot allocator done");
} }
pub fn allocate_spillslot(&mut self, class: RegClass) -> Allocation { pub fn allocate_spillslot(&mut self, class: RegClass) -> Allocation {

12
src/ion/stackmap.rs
View File

@@ -31,10 +31,10 @@ impl<'a, F: Function> Env<'a, F> {
// safepoints; and for each safepoint in the current range, // safepoints; and for each safepoint in the current range,
// emit the allocation into the `safepoint_slots` list. // emit the allocation into the `safepoint_slots` list.
log::debug!("safepoints_per_vreg = {:?}", self.safepoints_per_vreg); log::trace!("safepoints_per_vreg = {:?}", self.safepoints_per_vreg);
for vreg in self.func.reftype_vregs() { for vreg in self.func.reftype_vregs() {
log::debug!("generating safepoint info for vreg {}", vreg); log::trace!("generating safepoint info for vreg {}", vreg);
let vreg = VRegIndex::new(vreg.vreg()); let vreg = VRegIndex::new(vreg.vreg());
let mut safepoints: Vec<ProgPoint> = self let mut safepoints: Vec<ProgPoint> = self
.safepoints_per_vreg .safepoints_per_vreg
@@ -44,19 +44,19 @@ impl<'a, F: Function> Env<'a, F> {
.map(|&inst| ProgPoint::before(inst)) .map(|&inst| ProgPoint::before(inst))
.collect(); .collect();
safepoints.sort_unstable(); safepoints.sort_unstable();
log::debug!(" -> live over safepoints: {:?}", safepoints); log::trace!(" -> live over safepoints: {:?}", safepoints);
let mut safepoint_idx = 0; let mut safepoint_idx = 0;
for entry in &self.vregs[vreg.index()].ranges { for entry in &self.vregs[vreg.index()].ranges {
let range = entry.range; let range = entry.range;
let alloc = self.get_alloc_for_range(entry.index); let alloc = self.get_alloc_for_range(entry.index);
log::debug!(" -> range {:?}: alloc {}", range, alloc); log::trace!(" -> range {:?}: alloc {}", range, alloc);
while safepoint_idx < safepoints.len() && safepoints[safepoint_idx] < range.to { while safepoint_idx < safepoints.len() && safepoints[safepoint_idx] < range.to {
if safepoints[safepoint_idx] < range.from { if safepoints[safepoint_idx] < range.from {
safepoint_idx += 1; safepoint_idx += 1;
continue; continue;
} }
log::debug!(" -> covers safepoint {:?}", safepoints[safepoint_idx]); log::trace!(" -> covers safepoint {:?}", safepoints[safepoint_idx]);
let slot = alloc let slot = alloc
.as_stack() .as_stack()
@@ -68,6 +68,6 @@ impl<'a, F: Function> Env<'a, F> {
} }
self.safepoint_slots.sort_unstable(); self.safepoint_slots.sort_unstable();
log::debug!("final safepoint slots info: {:?}", self.safepoint_slots); log::trace!("final safepoint slots info: {:?}", self.safepoint_slots);
} }
} }

7
src/lib.rs
View File

@@ -228,7 +228,12 @@ pub struct Operand {
impl Operand { impl Operand {
#[inline(always)] #[inline(always)]
pub fn new(vreg: VReg, constraint: OperandConstraint, kind: OperandKind, pos: OperandPos) -> Self { pub fn new(
vreg: VReg,
constraint: OperandConstraint,
kind: OperandKind,
pos: OperandPos,
) -> Self {
let (preg_field, constraint_field): (u32, u32) = match constraint { let (preg_field, constraint_field): (u32, u32) = match constraint {
OperandConstraint::Any => (0, 0), OperandConstraint::Any => (0, 0),
OperandConstraint::Reg => (0, 1), OperandConstraint::Reg => (0, 1),