From 4b40e52c287ccedb008d4b026c85acb0650193f2 Mon Sep 17 00:00:00 2001 From: Chris Fallin Date: Wed, 30 Nov 2022 23:36:00 -0800 Subject: [PATCH] Fix regalloc issue --- src/backend/localify.rs | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/src/backend/localify.rs b/src/backend/localify.rs index 777f7ae..f284936 100644 --- a/src/backend/localify.rs +++ b/src/backend/localify.rs @@ -58,7 +58,7 @@ impl<'a> Context<'a> { let mut point = 0; let mut live: HashMap = HashMap::default(); - let mut block_ends: HashMap = HashMap::default(); + let mut block_starts: HashMap = HashMap::default(); for &block in &self.cfg.postorder { self.body.blocks[block].terminator.visit_uses(|u| { self.handle_use(&mut live, &mut point, u); @@ -75,7 +75,7 @@ impl<'a> Context<'a> { } point += 1; - block_ends.insert(block, point); + block_starts.insert(block, point); // If there were any in-edges from blocks numbered earlier // in postorder ("loop backedges"), extend the start of @@ -84,12 +84,12 @@ impl<'a> Context<'a> { // extend the *end* of the liverange down to the end of // the loop.) // - // Note that we do this *after* inserting our own end + // Note that we do this *after* inserting our own start // above, so we handle self-loops properly. for &pred in self.cfg.preds(block) { - if let Some(&end) = block_ends.get(&pred) { - for live_end in live.values_mut() { - *live_end = end; + if let Some(&start) = block_starts.get(&pred) { + for live_start in live.values_mut() { + *live_start = std::cmp::min(*live_start, start); } } } @@ -101,12 +101,15 @@ impl<'a> Context<'a> { fn handle_def(&mut self, live: &mut HashMap, point: &mut usize, value: Value) { // If the value was not live, make it so just for this // point. Otherwise, end the liverange. + log::trace!("localify: point {}: live {:?}: def {}", point, live, value); match live.entry(value) { Entry::Vacant(_) => { + log::trace!(" -> was dead; use {}..{}", *point, *point + 1); self.ranges.insert(value, *point..(*point + 1)); } Entry::Occupied(o) => { let start = o.remove(); + log::trace!(" -> was live; use {}..{}", start, *point + 1); self.ranges.insert(value, start..(*point + 1)); } } @@ -114,7 +117,9 @@ impl<'a> Context<'a> { fn handle_use(&mut self, live: &mut HashMap, point: &mut usize, value: Value) { let value = self.body.resolve_alias(value); + log::trace!("localify: point {}: live {:?}: use {}", point, live, value); if self.trees.owner.contains_key(&value) { + log::trace!(" -> treeified, going to inst"); // If this is a treeified value, then don't process the use, // but process the instruction directly here. self.handle_inst(live, point, value, /* root = */ false); @@ -133,16 +138,25 @@ impl<'a> Context<'a> { root: bool, ) { let value = self.body.resolve_alias(value); + log::trace!( + "localify: point {}: live {:?}: handling inst {} root {}", + point, + live, + value, + root + ); // If this is an instruction... if let ValueDef::Operator(_, ref args, _) = &self.body.values[value] { // Handle uses. for &arg in args { + log::trace!(" -> arg {}", arg); self.handle_use(live, point, arg); } // If root, we need to process the def. if root { *point += 1; + log::trace!(" -> def {}", value); self.handle_def(live, point, value); } }