Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-04-26 13:01:27 +03:00
Code Issues Packages Projects Releases Wiki Activity

Use a simpler condition set in jump threading.

Browse Source
This commit is contained in:
Camille GILLOT
2025-06-19 22:42:05 +00:00
committed by Camille Gillot
parent 4f24d70395
commit d67e3e6c5a
5 changed files with 262 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/rustc_mir_transform/src/jump_threading.rs
+148 -101
View File
@@ -38,7 +38,7 @@
use rustc_arena::DroplessArena;
use rustc_const_eval::const_eval::DummyMachine;
use rustc_const_eval::interpret::{ImmTy, Immediate, InterpCx, OpTy, Projectable};
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_index::IndexVec;
use rustc_index::bit_set::DenseBitSet;
use rustc_middle::bug;
@@ -47,7 +47,7 @@
use rustc_middle::mir::*;
use rustc_middle::ty::{self, ScalarInt, TyCtxt};
use rustc_mir_dataflow::lattice::HasBottom;
use rustc_mir_dataflow::value_analysis::{Map, PlaceIndex, State, TrackElem};
use rustc_mir_dataflow::value_analysis::{Map, PlaceIndex, TrackElem, ValueIndex};
use rustc_span::DUMMY_SP;
use tracing::{debug, instrument, trace};
@@ -134,6 +134,7 @@ struct TOFinder<'a, 'tcx> {
/// to `value`, jump to `target`.
#[derive(Copy, Clone, Debug)]
struct Condition {
place: ValueIndex,
value: ScalarInt,
polarity: Polarity,
target: BasicBlock,
@@ -146,8 +147,14 @@ enum Polarity {
}
impl Condition {
fn matches(&self, value: ScalarInt) -> bool {
(self.value == value) == (self.polarity == Polarity::Eq)
fn matches(&self, place: ValueIndex, value: ScalarInt) -> bool {
self.place == place && (self.value == value) == (self.polarity == Polarity::Eq)
}
fn into_opportunity(self, match_bb: Option<BasicBlock>) -> ThreadingOpportunity {
trace!(?self, "registering");
let chain = match_bb.into_iter().collect();
ThreadingOpportunity { chain, target: self.target }
}
}
@@ -163,29 +170,50 @@ fn is_bottom(&self) -> bool {
}
impl<'a> ConditionSet<'a> {
fn is_empty(self) -> bool {
self.0.is_empty()
}
fn iter(self) -> impl Iterator<Item = Condition> {
self.0.iter().copied()
}
fn iter_matches(self, value: ScalarInt) -> impl Iterator<Item = Condition> {
self.iter().filter(move |c| c.matches(value))
fn iter_matches(self, place: ValueIndex, value: ScalarInt) -> impl Iterator<Item = Condition> {
self.iter().filter(move |c| c.matches(place, value))
}
fn map(
fn register_matches(
&self,
place: ValueIndex,
value: ScalarInt,
match_bb: Option<BasicBlock>,
opportunities: &mut Vec<ThreadingOpportunity>,
) {
self.iter_matches(place, value)
.for_each(|cond| opportunities.push(cond.into_opportunity(match_bb)))
}
fn filter(self, arena: &'a DroplessArena, f: impl Fn(Condition) -> bool) -> ConditionSet<'a> {
let set = arena.alloc_from_iter(self.iter().filter(|&c| f(c)));
ConditionSet(set)
}
fn filter_map(
self,
arena: &'a DroplessArena,
f: impl Fn(Condition) -> Option<Condition>,
) -> Option<ConditionSet<'a>> {
let set = arena.try_alloc_from_iter(self.iter().map(|c| f(c).ok_or(()))).ok()?;
Some(ConditionSet(set))
) -> ConditionSet<'a> {
let set = arena.alloc_from_iter(self.iter().filter_map(|c| f(c)));
ConditionSet(set)
}
fn map(self, arena: &'a DroplessArena, f: impl Fn(Condition) -> Condition) -> ConditionSet<'a> {
let set = arena.alloc_from_iter(self.iter().map(|c| f(c)));
ConditionSet(set)
}
}
impl<'a, 'tcx> TOFinder<'a, 'tcx> {
fn is_empty(&self, state: &State<ConditionSet<'a>>) -> bool {
state.all_bottom()
}
/// Recursion entry point to find threading opportunities.
#[instrument(level = "trace", skip(self))]
fn start_from_switch(&mut self, bb: BasicBlock) {
@@ -200,27 +228,24 @@ fn start_from_switch(&mut self, bb: BasicBlock) {
let discr_ty = discr.ty(self.body, self.tcx).ty;
let Ok(discr_layout) = self.ecx.layout_of(discr_ty) else { return };
let Some(discr) = self.map.find(discr.as_ref()) else { return };
let Some(discr) = self.map.find_value(discr.as_ref()) else { return };
debug!(?discr);
let cost = CostChecker::new(self.tcx, self.typing_env, None, self.body);
let mut state = State::new_reachable();
let conds = if let Some((value, then, else_)) = targets.as_static_if() {
let Some(value) = ScalarInt::try_from_uint(value, discr_layout.size) else { return };
self.arena.alloc_from_iter([
Condition { value, polarity: Polarity::Eq, target: then },
Condition { value, polarity: Polarity::Ne, target: else_ },
Condition { place: discr, value, polarity: Polarity::Eq, target: then },
Condition { place: discr, value, polarity: Polarity::Ne, target: else_ },
])
} else {
self.arena.alloc_from_iter(targets.iter().filter_map(|(value, target)| {
let value = ScalarInt::try_from_uint(value, discr_layout.size)?;
Some(Condition { value, polarity: Polarity::Eq, target })
Some(Condition { place: discr, value, polarity: Polarity::Eq, target })
}))
};
let conds = ConditionSet(conds);
state.insert_value_idx(discr, conds, &self.map);
let state = ConditionSet(conds);
self.find_opportunity(bb, state, cost, 0)
}
@@ -230,7 +255,7 @@ fn start_from_switch(&mut self, bb: BasicBlock) {
fn find_opportunity(
&mut self,
bb: BasicBlock,
mut state: State<ConditionSet<'a>>,
mut state: ConditionSet<'a>,
mut cost: CostChecker<'_, 'tcx>,
depth: usize,
) {
@@ -243,7 +268,7 @@ fn find_opportunity(
for (statement_index, stmt) in
self.body.basic_blocks[bb].statements.iter().enumerate().rev()
{
if self.is_empty(&state) {
if state.is_empty() {
return;
}
@@ -260,11 +285,11 @@ fn find_opportunity(
// _1 = 5 // Whatever happens here, it won't change the result of a `SwitchInt`.
// _1 = 6
if let Some((lhs, tail)) = self.mutated_statement(stmt) {
state.flood_with_tail_elem(lhs.as_ref(), tail, &self.map, ConditionSet::BOTTOM);
self.flood_state(lhs, tail, &mut state);
}
}
if self.is_empty(&state) || depth >= MAX_BACKTRACK {
if state.is_empty() || depth >= MAX_BACKTRACK {
return;
}
@@ -280,13 +305,13 @@ fn find_opportunity(
self.process_switch_int(discr, targets, bb, &mut state);
self.find_opportunity(pred, state, cost, depth + 1);
}
_ => self.recurse_through_terminator(pred, || state, &cost, depth),
_ => self.recurse_through_terminator(pred, state, &cost, depth),
}
} else if let &[ref predecessors @ .., last_pred] = &predecessors[..] {
for &pred in predecessors {
self.recurse_through_terminator(pred, || state.clone(), &cost, depth);
self.recurse_through_terminator(pred, state, &cost, depth);
}
self.recurse_through_terminator(last_pred, || state, &cost, depth);
self.recurse_through_terminator(last_pred, state, &cost, depth);
}
let new_tos = &mut self.opportunities[last_non_rec..];
@@ -313,6 +338,23 @@ fn find_opportunity(
}
}
/// Remove all conditions in the state that alias given place.
fn flood_state(
&self,
place: Place<'tcx>,
extra_elem: Option<TrackElem>,
state: &mut ConditionSet<'a>,
) {
let mut places_to_exclude = FxHashSet::default();
self.map.for_each_aliasing_place(place.as_ref(), extra_elem, &mut |vi| {
places_to_exclude.insert(vi);
});
if places_to_exclude.is_empty() {
return;
}
*state = state.filter(self.arena, |c| !places_to_exclude.contains(&c.place));
}
/// Extract the mutated place from a statement.
///
/// This method returns the `Place` so we can flood the state in case of a partial assignment.
@@ -359,17 +401,12 @@ fn process_immediate(
bb: BasicBlock,
lhs: PlaceIndex,
rhs: ImmTy<'tcx>,
state: &mut State<ConditionSet<'a>>,
state: &mut ConditionSet<'a>,
) {
let register_opportunity = |c: Condition| {
debug!(?bb, ?c.target, "register");
self.opportunities.push(ThreadingOpportunity { chain: vec![bb], target: c.target })
};
if let Some(conditions) = state.try_get_idx(lhs, &self.map)
if let Some(lhs) = self.map.value(lhs)
&& let Immediate::Scalar(Scalar::Int(int)) = *rhs
{
conditions.iter_matches(int).for_each(register_opportunity);
state.register_matches(lhs, int, Some(bb), &mut self.opportunities);
}
}
@@ -380,7 +417,7 @@ fn process_constant(
bb: BasicBlock,
lhs: PlaceIndex,
constant: OpTy<'tcx>,
state: &mut State<ConditionSet<'a>>,
state: &mut ConditionSet<'a>,
) {
self.map.for_each_projection_value(
lhs,
@@ -402,27 +439,38 @@ fn process_constant(
}
},
&mut |place, op| {
if let Some(conditions) = state.try_get_idx(place, &self.map)
if let Some(place) = self.map.value(place)
&& let Some(imm) = self.ecx.read_immediate_raw(op).discard_err()
&& let Some(imm) = imm.right()
&& let Immediate::Scalar(Scalar::Int(int)) = *imm
{
conditions.iter_matches(int).for_each(|c: Condition| {
self.opportunities
.push(ThreadingOpportunity { chain: vec![bb], target: c.target })
})
state.register_matches(place, int, Some(bb), &mut self.opportunities);
}
},
);
}
#[instrument(level = "trace", skip(self))]
fn process_copy(&mut self, lhs: PlaceIndex, rhs: PlaceIndex, state: &mut ConditionSet<'a>) {
let mut renames = FxHashMap::default();
self.map.for_each_value_pair(rhs, lhs, &mut |rhs, lhs| {
renames.insert(lhs, rhs);
});
*state = state.map(self.arena, |mut c| {
if let Some(rhs) = renames.get(&c.place) {
c.place = *rhs
}
c
});
}
#[instrument(level = "trace", skip(self))]
fn process_operand(
&mut self,
bb: BasicBlock,
lhs: PlaceIndex,
rhs: &Operand<'tcx>,
state: &mut State<ConditionSet<'a>>,
state: &mut ConditionSet<'a>,
) {
match rhs {
// If we expect `lhs ?= A`, we have an opportunity if we assume `constant == A`.
@@ -437,7 +485,7 @@ fn process_operand(
// Transfer the conditions on the copied rhs.
Operand::Move(rhs) | Operand::Copy(rhs) => {
let Some(rhs) = self.map.find(rhs.as_ref()) else { return };
state.insert_place_idx(rhs, lhs, &self.map);
self.process_copy(lhs, rhs, state)
}
}
}
@@ -447,16 +495,16 @@ fn process_assign(
&mut self,
bb: BasicBlock,
lhs_place: &Place<'tcx>,
rhs: &Rvalue<'tcx>,
state: &mut State<ConditionSet<'a>>,
rvalue: &Rvalue<'tcx>,
state: &mut ConditionSet<'a>,
) {
let Some(lhs) = self.map.find(lhs_place.as_ref()) else { return };
match rhs {
match rvalue {
Rvalue::Use(operand) => self.process_operand(bb, lhs, operand, state),
// Transfer the conditions on the copy rhs.
Rvalue::Discriminant(rhs) => {
let Some(rhs) = self.map.find_discr(rhs.as_ref()) else { return };
state.insert_place_idx(rhs, lhs, &self.map);
self.process_copy(lhs, rhs, state)
}
// If we expect `lhs ?= A`, we have an opportunity if we assume `constant == A`.
Rvalue::Aggregate(box kind, operands) => {
@@ -488,32 +536,30 @@ fn process_assign(
}
}
// Transfer the conditions on the copy rhs, after inverting the value of the condition.
Rvalue::UnaryOp(UnOp::Not, Operand::Move(place) | Operand::Copy(place)) => {
let layout = self.ecx.layout_of(place.ty(self.body, self.tcx).ty).unwrap();
let Some(conditions) = state.try_get_idx(lhs, &self.map) else { return };
let Some(place) = self.map.find(place.as_ref()) else { return };
let Some(conds) = conditions.map(self.arena, |mut cond| {
cond.value = self
.ecx
.unary_op(UnOp::Not, &ImmTy::from_scalar_int(cond.value, layout))
.discard_err()?
.to_scalar_int()
.discard_err()?;
Rvalue::UnaryOp(UnOp::Not, Operand::Move(operand) | Operand::Copy(operand)) => {
let layout = self.ecx.layout_of(operand.ty(self.body, self.tcx).ty).unwrap();
let Some(lhs) = self.map.value(lhs) else { return };
let Some(operand) = self.map.find_value(operand.as_ref()) else { return };
*state = state.filter_map(self.arena, |mut cond| {
if cond.place == lhs {
cond.place = operand;
cond.value = self
.ecx
.unary_op(UnOp::Not, &ImmTy::from_scalar_int(cond.value, layout))
.discard_err()?
.to_scalar_int()
.discard_err()?;
}
Some(cond)
}) else {
return;
};
state.insert_value_idx(place, conds, &self.map);
});
}
// We expect `lhs ?= A`. We found `lhs = Eq(rhs, B)`.
// Create a condition on `rhs ?= B`.
Rvalue::BinaryOp(
op,
box (Operand::Move(place) | Operand::Copy(place), Operand::Constant(value))
| box (Operand::Constant(value), Operand::Move(place) | Operand::Copy(place)),
box (Operand::Move(operand) | Operand::Copy(operand), Operand::Constant(value))
| box (Operand::Constant(value), Operand::Move(operand) | Operand::Copy(operand)),
) => {
let Some(conditions) = state.try_get_idx(lhs, &self.map) else { return };
let Some(place) = self.map.find(place.as_ref()) else { return };
let equals = match op {
BinOp::Eq => ScalarInt::TRUE,
BinOp::Ne => ScalarInt::FALSE,
@@ -526,20 +572,28 @@ fn process_assign(
// Avoid handling them, though this could be extended in the future.
return;
}
let Some(lhs) = self.map.value(lhs) else { return };
let Some(operand) = self.map.find_value(operand.as_ref()) else { return };
let Some(value) = value.const_.try_eval_scalar_int(self.tcx, self.typing_env)
else {
return;
};
let Some(conds) = conditions.map(self.arena, |c| {
Some(Condition {
value,
polarity: if c.matches(equals) { Polarity::Eq } else { Polarity::Ne },
..c
})
}) else {
return;
};
state.insert_value_idx(place, conds, &self.map);
*state = state.map(self.arena, |c| {
if c.place == lhs {
Condition {
place: operand,
value,
polarity: if c.matches(lhs, equals) {
Polarity::Eq
} else {
Polarity::Ne
},
..c
}
} else {
c
}
});
}
_ => {}
@@ -551,13 +605,8 @@ fn process_statement(
&mut self,
bb: BasicBlock,
stmt: &Statement<'tcx>,
state: &mut State<ConditionSet<'a>>,
state: &mut ConditionSet<'a>,
) {
let register_opportunity = |c: Condition| {
debug!(?bb, ?c.target, "register");
self.opportunities.push(ThreadingOpportunity { chain: vec![bb], target: c.target })
};
// Below, `lhs` is the return value of `mutated_statement`,
// the place to which `conditions` apply.
@@ -581,8 +630,8 @@ fn process_statement(
StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(
Operand::Copy(place) | Operand::Move(place),
)) => {
let Some(conditions) = state.try_get(place.as_ref(), &self.map) else { return };
conditions.iter_matches(ScalarInt::TRUE).for_each(register_opportunity)
let Some(place) = self.map.find_value(place.as_ref()) else { return };
state.register_matches(place, ScalarInt::TRUE, Some(bb), &mut self.opportunities)
}
StatementKind::Assign(box (lhs_place, rhs)) => {
self.process_assign(bb, lhs_place, rhs, state)
@@ -595,8 +644,7 @@ fn process_statement(
fn recurse_through_terminator(
&mut self,
bb: BasicBlock,
// Pass a closure that may clone the state, as we don't want to do it each time.
state: impl FnOnce() -> State<ConditionSet<'a>>,
mut state: ConditionSet<'a>,
cost: &CostChecker<'_, 'tcx>,
depth: usize,
) {
@@ -627,9 +675,8 @@ fn recurse_through_terminator(
};
// We can recurse through this terminator.
let mut state = state();
if let Some(place_to_flood) = place_to_flood {
state.flood_with(place_to_flood.as_ref(), &self.map, ConditionSet::BOTTOM);
self.flood_state(place_to_flood, None, &mut state);
}
self.find_opportunity(bb, state, cost.clone(), depth + 1)
}
@@ -640,7 +687,7 @@ fn process_switch_int(
discr: &Operand<'tcx>,
targets: &SwitchTargets,
target_bb: BasicBlock,
state: &mut State<ConditionSet<'a>>,
state: &mut ConditionSet<'a>,
) {
debug_assert_ne!(target_bb, START_BLOCK);
debug_assert_eq!(self.body.basic_blocks.predecessors()[target_bb].len(), 1);
@@ -650,7 +697,7 @@ fn process_switch_int(
let Ok(discr_layout) = self.ecx.layout_of(discr_ty) else {
return;
};
let Some(conditions) = state.try_get(discr.as_ref(), &self.map) else { return };
let Some(discr) = self.map.find_value(discr.as_ref()) else { return };
if let Some((value, _)) = targets.iter().find(|&(_, target)| target == target_bb) {
let Some(value) = ScalarInt::try_from_uint(value, discr_layout.size) else { return };
@@ -660,10 +707,10 @@ fn process_switch_int(
// through the `SwitchInt` before arriving here. Therefore, we know that
// `discr == value`. If one condition can be fulfilled by `discr == value`,
// that's an opportunity.
for c in conditions.iter_matches(value) {
debug!(?target_bb, ?c.target, "register");
self.opportunities.push(ThreadingOpportunity { chain: vec![], target: c.target });
}
//
// The TO starts with `target_bb`, which will be added by `find_opportunity`, so we
// start with an empty bb chain.
state.register_matches(discr, value, None, &mut self.opportunities);
} else if let Some((value, _, else_bb)) = targets.as_static_if()
&& target_bb == else_bb
{
@@ -672,11 +719,11 @@ fn process_switch_int(
// We only know that `discr != value`. That's much weaker information than
// the equality we had in the previous arm. All we can conclude is that
// the replacement condition `discr != value` can be threaded, and nothing else.
for c in conditions.iter() {
if c.value == value && c.polarity == Polarity::Ne {
debug!(?target_bb, ?c.target, "register");
self.opportunities
.push(ThreadingOpportunity { chain: vec![], target: c.target });
for c in state.iter() {
if c.place == discr && c.value == value && c.polarity == Polarity::Ne {
// The TO starts with `target_bb`, which will be added by `find_opportunity`,
// so we start with an empty bb chain.
self.opportunities.push(c.into_opportunity(None));
}
}
}
tests/coverage/conditions.cov-map
+109 -137
View File
@@ -1,92 +1,72 @@
Function name: conditions::main
Raw bytes (642): 0x[01, 01, 54, 05, 09, 01, 05, 09, 5d, 09, 27, 5d, 61, 27, 65, 5d, 61, 09, 23, 27, 65, 5d, 61, 01, 03, 03, 0d, 11, 51, 11, 4f, 51, 55, 4f, 59, 51, 55, 11, 4b, 4f, 59, 51, 55, 03, 9f, 01, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 9f, 01, 15, 0d, 11, 19, 45, 19, 97, 01, 45, 49, 97, 01, 4d, 45, 49, 19, 93, 01, 97, 01, 4d, 45, 49, 9f, 01, 8f, 02, 0d, 11, 15, 19, 15, 19, 15, 19, 15, 19, 15, 19, 1d, 21, 15, 19, 8f, 02, 1d, 15, 19, 21, 39, 21, e3, 01, 39, 3d, e3, 01, 41, 39, 3d, 21, df, 01, e3, 01, 41, 39, 3d, 8f, 02, cb, 02, 15, 19, 1d, 21, 8f, 02, cb, 02, 15, 19, 1d, 21, 8f, 02, cb, 02, 15, 19, 1d, 21, 8f, 02, cb, 02, 15, 19, 1d, 21, 25, 29, 1d, 21, cb, 02, 25, 1d, 21, 29, 2d, 29, c3, 02, 2d, 31, c3, 02, 35, 2d, 31, 29, bf, 02, c3, 02, 35, 2d, 31, cb, 02, cf, 02, 1d, 21, 25, 29, 52, 01, 03, 01, 00, 0a, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1a, 01, 01, 08, 00, 0c, 01, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 03, 09, 00, 0a, 01, 00, 10, 00, 1d, 05, 01, 09, 00, 17, 05, 01, 09, 00, 0a, 06, 01, 0f, 00, 1c, 09, 01, 0c, 00, 19, 0a, 00, 1d, 00, 2a, 0e, 00, 2e, 00, 3c, 23, 00, 3d, 02, 0a, 1e, 02, 09, 00, 0a, 09, 01, 09, 00, 17, 09, 01, 09, 00, 12, 2a, 02, 09, 00, 0f, 03, 03, 09, 00, 16, 03, 00, 19, 00, 1a, 03, 01, 08, 00, 0c, 03, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 02, 08, 00, 15, 0d, 00, 16, 02, 06, 2e, 02, 0f, 00, 1c, 11, 01, 0c, 00, 19, 32, 00, 1d, 00, 2a, 36, 00, 2e, 00, 3c, 4b, 00, 3d, 02, 0a, 46, 02, 09, 00, 0a, 11, 01, 09, 00, 17, 52, 02, 09, 00, 0f, 9f, 01, 03, 08, 00, 0c, 9f, 01, 01, 0d, 00, 1a, 9f, 01, 00, 1d, 00, 1e, 9f, 01, 01, 0c, 00, 10, 9f, 01, 00, 11, 02, 0a, 00, 02, 09, 00, 0a, 9f, 01, 02, 0c, 00, 19, 15, 00, 1a, 02, 0a, 72, 04, 11, 00, 1e, 19, 01, 10, 00, 1d, 7a, 00, 21, 00, 2e, 7e, 00, 32, 00, 40, 93, 01, 00, 41, 02, 0e, 8e, 01, 02, 0d, 00, 0e, 19, 01, 0d, 00, 1b, 9a, 01, 02, 0d, 00, 13, 00, 02, 05, 00, 06, 8f, 02, 02, 09, 00, 16, 8f, 02, 00, 19, 00, 1a, 8f, 02, 01, 08, 00, 0c, 8f, 02, 00, 0d, 02, 06, 00, 02, 05, 00, 06, cb, 02, 02, 09, 00, 0a, 8f, 02, 00, 10, 00, 1d, 1d, 00, 1e, 02, 06, be, 01, 02, 0f, 00, 1c, 21, 01, 0c, 00, 19, c6, 01, 00, 1d, 00, 2a, ca, 01, 00, 2e, 00, 3c, df, 01, 00, 3d, 02, 0a, da, 01, 02, 09, 00, 0a, 21, 01, 09, 00, 17, 8a, 02, 02, 0d, 00, 20, 8a, 02, 00, 23, 00, 2c, 8a, 02, 01, 09, 00, 11, 8a, 02, 01, 09, 00, 0f, cf, 02, 03, 09, 00, 0a, cb, 02, 00, 10, 00, 1d, 25, 00, 1e, 02, 06, 9e, 02, 02, 0f, 00, 1c, 29, 01, 0c, 00, 19, a6, 02, 00, 1d, 00, 2a, aa, 02, 00, 2e, 00, 3c, bf, 02, 00, 3d, 02, 0a, ba, 02, 02, 09, 00, 0a, 29, 01, 09, 00, 17, c6, 02, 02, 09, 00, 0f, 01, 02, 01, 00, 02]
Raw bytes (581): 0x[01, 01, 40, 05, 09, 01, 05, 09, 51, 09, 13, 51, 55, 01, 03, 03, 0d, 11, 49, 11, 27, 49, 4d, 03, 63, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 63, 15, 0d, 11, 19, 41, 19, 5b, 41, 45, 63, bf, 01, 0d, 11, 15, 19, 15, 19, 15, 19, 15, 19, 15, 19, 1d, 21, 15, 19, bf, 01, 1d, 15, 19, 21, 39, 21, 93, 01, 39, 3d, bf, 01, fb, 01, 15, 19, 1d, 21, bf, 01, fb, 01, 15, 19, 1d, 21, bf, 01, fb, 01, 15, 19, 1d, 21, bf, 01, fb, 01, 15, 19, 1d, 21, 25, 29, 1d, 21, fb, 01, 25, 1d, 21, 29, 2d, 29, f3, 01, 2d, 31, f3, 01, 35, 2d, 31, 29, ef, 01, f3, 01, 35, 2d, 31, fb, 01, ff, 01, 1d, 21, 25, 29, 52, 01, 03, 01, 00, 0a, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1a, 01, 01, 08, 00, 0c, 01, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 03, 09, 00, 0a, 01, 00, 10, 00, 1d, 05, 01, 09, 00, 17, 05, 01, 09, 00, 0a, 06, 01, 0f, 00, 1c, 09, 01, 0c, 00, 19, 0a, 00, 1d, 00, 2a, 0e, 00, 2e, 00, 3c, 09, 00, 3d, 02, 0a, 00, 02, 09, 00, 0a, 09, 01, 09, 00, 17, 09, 01, 09, 00, 12, 16, 02, 09, 00, 0f, 03, 03, 09, 00, 16, 03, 00, 19, 00, 1a, 03, 01, 08, 00, 0c, 03, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 02, 08, 00, 15, 0d, 00, 16, 02, 06, 1a, 02, 0f, 00, 1c, 11, 01, 0c, 00, 19, 1e, 00, 1d, 00, 2a, 22, 00, 2e, 00, 3c, 11, 00, 3d, 02, 0a, 00, 02, 09, 00, 0a, 11, 01, 09, 00, 17, 2a, 02, 09, 00, 0f, 63, 03, 08, 00, 0c, 63, 01, 0d, 00, 1a, 63, 00, 1d, 00, 1e, 63, 01, 0c, 00, 10, 63, 00, 11, 02, 0a, 00, 02, 09, 00, 0a, 63, 02, 0c, 00, 19, 15, 00, 1a, 02, 0a, 4a, 04, 11, 00, 1e, 19, 01, 10, 00, 1d, 52, 00, 21, 00, 2e, 56, 00, 32, 00, 40, 19, 00, 41, 02, 0e, 00, 02, 0d, 00, 0e, 19, 01, 0d, 00, 1b, 5e, 02, 0d, 00, 13, 00, 02, 05, 00, 06, bf, 01, 02, 09, 00, 16, bf, 01, 00, 19, 00, 1a, bf, 01, 01, 08, 00, 0c, bf, 01, 00, 0d, 02, 06, 00, 02, 05, 00, 06, fb, 01, 02, 09, 00, 0a, bf, 01, 00, 10, 00, 1d, 1d, 00, 1e, 02, 06, 82, 01, 02, 0f, 00, 1c, 21, 01, 0c, 00, 19, 8a, 01, 00, 1d, 00, 2a, 8e, 01, 00, 2e, 00, 3c, 21, 00, 3d, 02, 0a, 00, 02, 09, 00, 0a, 21, 01, 09, 00, 17, ba, 01, 02, 0d, 00, 20, ba, 01, 00, 23, 00, 2c, ba, 01, 01, 09, 00, 11, ba, 01, 01, 09, 00, 0f, ff, 01, 03, 09, 00, 0a, fb, 01, 00, 10, 00, 1d, 25, 00, 1e, 02, 06, ce, 01, 02, 0f, 00, 1c, 29, 01, 0c, 00, 19, d6, 01, 00, 1d, 00, 2a, da, 01, 00, 2e, 00, 3c, ef, 01, 00, 3d, 02, 0a, ea, 01, 02, 09, 00, 0a, 29, 01, 09, 00, 17, f6, 01, 02, 09, 00, 0f, 01, 02, 01, 00, 02]
Number of files: 1
- file 0 => $DIR/conditions.rs
Number of expressions: 84
Number of expressions: 64
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(2), rhs = Counter(23)
- expression 3 operands: lhs = Counter(2), rhs = Expression(9, Add)
- expression 4 operands: lhs = Counter(23), rhs = Counter(24)
- expression 5 operands: lhs = Expression(9, Add), rhs = Counter(25)
- expression 6 operands: lhs = Counter(23), rhs = Counter(24)
- expression 7 operands: lhs = Counter(2), rhs = Expression(8, Add)
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(25)
- expression 9 operands: lhs = Counter(23), rhs = Counter(24)
- expression 10 operands: lhs = Counter(0), rhs = Expression(0, Add)
- expression 11 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 12 operands: lhs = Counter(4), rhs = Counter(20)
- expression 13 operands: lhs = Counter(4), rhs = Expression(19, Add)
- expression 14 operands: lhs = Counter(20), rhs = Counter(21)
- expression 15 operands: lhs = Expression(19, Add), rhs = Counter(22)
- expression 16 operands: lhs = Counter(20), rhs = Counter(21)
- expression 17 operands: lhs = Counter(4), rhs = Expression(18, Add)
- expression 18 operands: lhs = Expression(19, Add), rhs = Counter(22)
- expression 19 operands: lhs = Counter(20), rhs = Counter(21)
- expression 20 operands: lhs = Expression(0, Add), rhs = Expression(39, Add)
- expression 21 operands: lhs = Counter(3), rhs = Counter(4)
- expression 22 operands: lhs = Counter(3), rhs = Counter(4)
- expression 23 operands: lhs = Counter(3), rhs = Counter(4)
- expression 2 operands: lhs = Counter(2), rhs = Counter(20)
- expression 3 operands: lhs = Counter(2), rhs = Expression(4, Add)
- expression 4 operands: lhs = Counter(20), rhs = Counter(21)
- expression 5 operands: lhs = Counter(0), rhs = Expression(0, Add)
- expression 6 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 7 operands: lhs = Counter(4), rhs = Counter(18)
- expression 8 operands: lhs = Counter(4), rhs = Expression(9, Add)
- expression 9 operands: lhs = Counter(18), rhs = Counter(19)
- expression 10 operands: lhs = Expression(0, Add), rhs = Expression(24, Add)
- expression 11 operands: lhs = Counter(3), rhs = Counter(4)
- expression 12 operands: lhs = Counter(3), rhs = Counter(4)
- expression 13 operands: lhs = Counter(3), rhs = Counter(4)
- expression 14 operands: lhs = Counter(3), rhs = Counter(4)
- expression 15 operands: lhs = Counter(3), rhs = Counter(4)
- expression 16 operands: lhs = Counter(3), rhs = Counter(4)
- expression 17 operands: lhs = Counter(3), rhs = Counter(4)
- expression 18 operands: lhs = Expression(24, Add), rhs = Counter(5)
- expression 19 operands: lhs = Counter(3), rhs = Counter(4)
- expression 20 operands: lhs = Counter(6), rhs = Counter(16)
- expression 21 operands: lhs = Counter(6), rhs = Expression(22, Add)
- expression 22 operands: lhs = Counter(16), rhs = Counter(17)
- expression 23 operands: lhs = Expression(24, Add), rhs = Expression(47, Add)
- expression 24 operands: lhs = Counter(3), rhs = Counter(4)
- expression 25 operands: lhs = Counter(3), rhs = Counter(4)
- expression 26 operands: lhs = Counter(3), rhs = Counter(4)
- expression 27 operands: lhs = Counter(3), rhs = Counter(4)
- expression 28 operands: lhs = Expression(39, Add), rhs = Counter(5)
- expression 29 operands: lhs = Counter(3), rhs = Counter(4)
- expression 30 operands: lhs = Counter(6), rhs = Counter(17)
- expression 31 operands: lhs = Counter(6), rhs = Expression(37, Add)
- expression 32 operands: lhs = Counter(17), rhs = Counter(18)
- expression 33 operands: lhs = Expression(37, Add), rhs = Counter(19)
- expression 34 operands: lhs = Counter(17), rhs = Counter(18)
- expression 35 operands: lhs = Counter(6), rhs = Expression(36, Add)
- expression 36 operands: lhs = Expression(37, Add), rhs = Counter(19)
- expression 37 operands: lhs = Counter(17), rhs = Counter(18)
- expression 38 operands: lhs = Expression(39, Add), rhs = Expression(67, Add)
- expression 39 operands: lhs = Counter(3), rhs = Counter(4)
- expression 40 operands: lhs = Counter(5), rhs = Counter(6)
- expression 25 operands: lhs = Counter(5), rhs = Counter(6)
- expression 26 operands: lhs = Counter(5), rhs = Counter(6)
- expression 27 operands: lhs = Counter(5), rhs = Counter(6)
- expression 28 operands: lhs = Counter(5), rhs = Counter(6)
- expression 29 operands: lhs = Counter(5), rhs = Counter(6)
- expression 30 operands: lhs = Counter(7), rhs = Counter(8)
- expression 31 operands: lhs = Counter(5), rhs = Counter(6)
- expression 32 operands: lhs = Expression(47, Add), rhs = Counter(7)
- expression 33 operands: lhs = Counter(5), rhs = Counter(6)
- expression 34 operands: lhs = Counter(8), rhs = Counter(14)
- expression 35 operands: lhs = Counter(8), rhs = Expression(36, Add)
- expression 36 operands: lhs = Counter(14), rhs = Counter(15)
- expression 37 operands: lhs = Expression(47, Add), rhs = Expression(62, Add)
- expression 38 operands: lhs = Counter(5), rhs = Counter(6)
- expression 39 operands: lhs = Counter(7), rhs = Counter(8)
- expression 40 operands: lhs = Expression(47, Add), rhs = Expression(62, Add)
- expression 41 operands: lhs = Counter(5), rhs = Counter(6)
- expression 42 operands: lhs = Counter(5), rhs = Counter(6)
- expression 43 operands: lhs = Counter(5), rhs = Counter(6)
- expression 42 operands: lhs = Counter(7), rhs = Counter(8)
- expression 43 operands: lhs = Expression(47, Add), rhs = Expression(62, Add)
- expression 44 operands: lhs = Counter(5), rhs = Counter(6)
- expression 45 operands: lhs = Counter(7), rhs = Counter(8)
- expression 46 operands: lhs = Counter(5), rhs = Counter(6)
- expression 47 operands: lhs = Expression(67, Add), rhs = Counter(7)
- expression 48 operands: lhs = Counter(5), rhs = Counter(6)
- expression 49 operands: lhs = Counter(8), rhs = Counter(14)
- expression 50 operands: lhs = Counter(8), rhs = Expression(56, Add)
- expression 51 operands: lhs = Counter(14), rhs = Counter(15)
- expression 52 operands: lhs = Expression(56, Add), rhs = Counter(16)
- expression 53 operands: lhs = Counter(14), rhs = Counter(15)
- expression 54 operands: lhs = Counter(8), rhs = Expression(55, Add)
- expression 55 operands: lhs = Expression(56, Add), rhs = Counter(16)
- expression 56 operands: lhs = Counter(14), rhs = Counter(15)
- expression 57 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
- expression 58 operands: lhs = Counter(5), rhs = Counter(6)
- expression 59 operands: lhs = Counter(7), rhs = Counter(8)
- expression 60 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
- expression 61 operands: lhs = Counter(5), rhs = Counter(6)
- expression 46 operands: lhs = Expression(47, Add), rhs = Expression(62, Add)
- expression 47 operands: lhs = Counter(5), rhs = Counter(6)
- expression 48 operands: lhs = Counter(7), rhs = Counter(8)
- expression 49 operands: lhs = Counter(9), rhs = Counter(10)
- expression 50 operands: lhs = Counter(7), rhs = Counter(8)
- expression 51 operands: lhs = Expression(62, Add), rhs = Counter(9)
- expression 52 operands: lhs = Counter(7), rhs = Counter(8)
- expression 53 operands: lhs = Counter(10), rhs = Counter(11)
- expression 54 operands: lhs = Counter(10), rhs = Expression(60, Add)
- expression 55 operands: lhs = Counter(11), rhs = Counter(12)
- expression 56 operands: lhs = Expression(60, Add), rhs = Counter(13)
- expression 57 operands: lhs = Counter(11), rhs = Counter(12)
- expression 58 operands: lhs = Counter(10), rhs = Expression(59, Add)
- expression 59 operands: lhs = Expression(60, Add), rhs = Counter(13)
- expression 60 operands: lhs = Counter(11), rhs = Counter(12)
- expression 61 operands: lhs = Expression(62, Add), rhs = Expression(63, Add)
- expression 62 operands: lhs = Counter(7), rhs = Counter(8)
- expression 63 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
- expression 64 operands: lhs = Counter(5), rhs = Counter(6)
- expression 65 operands: lhs = Counter(7), rhs = Counter(8)
- expression 66 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
- expression 67 operands: lhs = Counter(5), rhs = Counter(6)
- expression 68 operands: lhs = Counter(7), rhs = Counter(8)
- expression 69 operands: lhs = Counter(9), rhs = Counter(10)
- expression 70 operands: lhs = Counter(7), rhs = Counter(8)
- expression 71 operands: lhs = Expression(82, Add), rhs = Counter(9)
- expression 72 operands: lhs = Counter(7), rhs = Counter(8)
- expression 73 operands: lhs = Counter(10), rhs = Counter(11)
- expression 74 operands: lhs = Counter(10), rhs = Expression(80, Add)
- expression 75 operands: lhs = Counter(11), rhs = Counter(12)
- expression 76 operands: lhs = Expression(80, Add), rhs = Counter(13)
- expression 77 operands: lhs = Counter(11), rhs = Counter(12)
- expression 78 operands: lhs = Counter(10), rhs = Expression(79, Add)
- expression 79 operands: lhs = Expression(80, Add), rhs = Counter(13)
- expression 80 operands: lhs = Counter(11), rhs = Counter(12)
- expression 81 operands: lhs = Expression(82, Add), rhs = Expression(83, Add)
- expression 82 operands: lhs = Counter(7), rhs = Counter(8)
- expression 83 operands: lhs = Counter(9), rhs = Counter(10)
- expression 63 operands: lhs = Counter(9), rhs = Counter(10)
Number of file 0 mappings: 82
- Code(Counter(0)) at (prev + 3, 1) to (start + 0, 10)
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 22)
@@ -103,16 +83,14 @@ Number of file 0 mappings: 82
= (c0 - c1)
- Code(Counter(2)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(2, Sub)) at (prev + 0, 29) to (start + 0, 42)
= (c2 - c23)
= (c2 - c20)
- Code(Expression(3, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (c2 - (c23 + c24))
- Code(Expression(8, Add)) at (prev + 0, 61) to (start + 2, 10)
= ((c23 + c24) + c25)
- Code(Expression(7, Sub)) at (prev + 2, 9) to (start + 0, 10)
= (c2 - ((c23 + c24) + c25))
= (c2 - (c20 + c21))
- Code(Counter(2)) at (prev + 0, 61) to (start + 2, 10)
- Code(Zero) at (prev + 2, 9) to (start + 0, 10)
- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 23)
- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 18)
- Code(Expression(10, Sub)) at (prev + 2, 9) to (start + 0, 15)
- Code(Expression(5, Sub)) at (prev + 2, 9) to (start + 0, 15)
= (c0 - (c1 + c2))
- Code(Expression(0, Add)) at (prev + 3, 9) to (start + 0, 22)
= (c1 + c2)
@@ -126,101 +104,95 @@ Number of file 0 mappings: 82
- Code(Expression(0, Add)) at (prev + 2, 8) to (start + 0, 21)
= (c1 + c2)
- Code(Counter(3)) at (prev + 0, 22) to (start + 2, 6)
- Code(Expression(11, Sub)) at (prev + 2, 15) to (start + 0, 28)
- Code(Expression(6, Sub)) at (prev + 2, 15) to (start + 0, 28)
= ((c1 + c2) - c3)
- Code(Counter(4)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(12, Sub)) at (prev + 0, 29) to (start + 0, 42)
= (c4 - c20)
- Code(Expression(13, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (c4 - (c20 + c21))
- Code(Expression(18, Add)) at (prev + 0, 61) to (start + 2, 10)
= ((c20 + c21) + c22)
- Code(Expression(17, Sub)) at (prev + 2, 9) to (start + 0, 10)
= (c4 - ((c20 + c21) + c22))
- Code(Expression(7, Sub)) at (prev + 0, 29) to (start + 0, 42)
= (c4 - c18)
- Code(Expression(8, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (c4 - (c18 + c19))
- Code(Counter(4)) at (prev + 0, 61) to (start + 2, 10)
- Code(Zero) at (prev + 2, 9) to (start + 0, 10)
- Code(Counter(4)) at (prev + 1, 9) to (start + 0, 23)
- Code(Expression(20, Sub)) at (prev + 2, 9) to (start + 0, 15)
- Code(Expression(10, Sub)) at (prev + 2, 9) to (start + 0, 15)
= ((c1 + c2) - (c3 + c4))
- Code(Expression(39, Add)) at (prev + 3, 8) to (start + 0, 12)
- Code(Expression(24, Add)) at (prev + 3, 8) to (start + 0, 12)
= (c3 + c4)
- Code(Expression(39, Add)) at (prev + 1, 13) to (start + 0, 26)
- Code(Expression(24, Add)) at (prev + 1, 13) to (start + 0, 26)
= (c3 + c4)
- Code(Expression(39, Add)) at (prev + 0, 29) to (start + 0, 30)
- Code(Expression(24, Add)) at (prev + 0, 29) to (start + 0, 30)
= (c3 + c4)
- Code(Expression(39, Add)) at (prev + 1, 12) to (start + 0, 16)
- Code(Expression(24, Add)) at (prev + 1, 12) to (start + 0, 16)
= (c3 + c4)
- Code(Expression(39, Add)) at (prev + 0, 17) to (start + 2, 10)
- Code(Expression(24, Add)) at (prev + 0, 17) to (start + 2, 10)
= (c3 + c4)
- Code(Zero) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(39, Add)) at (prev + 2, 12) to (start + 0, 25)
- Code(Expression(24, Add)) at (prev + 2, 12) to (start + 0, 25)
= (c3 + c4)
- Code(Counter(5)) at (prev + 0, 26) to (start + 2, 10)
- Code(Expression(28, Sub)) at (prev + 4, 17) to (start + 0, 30)
- Code(Expression(18, Sub)) at (prev + 4, 17) to (start + 0, 30)
= ((c3 + c4) - c5)
- Code(Counter(6)) at (prev + 1, 16) to (start + 0, 29)
- Code(Expression(30, Sub)) at (prev + 0, 33) to (start + 0, 46)
= (c6 - c17)
- Code(Expression(31, Sub)) at (prev + 0, 50) to (start + 0, 64)
= (c6 - (c17 + c18))
- Code(Expression(36, Add)) at (prev + 0, 65) to (start + 2, 14)
= ((c17 + c18) + c19)
- Code(Expression(35, Sub)) at (prev + 2, 13) to (start + 0, 14)
= (c6 - ((c17 + c18) + c19))
- Code(Expression(20, Sub)) at (prev + 0, 33) to (start + 0, 46)
= (c6 - c16)
- Code(Expression(21, Sub)) at (prev + 0, 50) to (start + 0, 64)
= (c6 - (c16 + c17))
- Code(Counter(6)) at (prev + 0, 65) to (start + 2, 14)
- Code(Zero) at (prev + 2, 13) to (start + 0, 14)
- Code(Counter(6)) at (prev + 1, 13) to (start + 0, 27)
- Code(Expression(38, Sub)) at (prev + 2, 13) to (start + 0, 19)
- Code(Expression(23, Sub)) at (prev + 2, 13) to (start + 0, 19)
= ((c3 + c4) - (c5 + c6))
- Code(Zero) at (prev + 2, 5) to (start + 0, 6)
- Code(Expression(67, Add)) at (prev + 2, 9) to (start + 0, 22)
- Code(Expression(47, Add)) at (prev + 2, 9) to (start + 0, 22)
= (c5 + c6)
- Code(Expression(67, Add)) at (prev + 0, 25) to (start + 0, 26)
- Code(Expression(47, Add)) at (prev + 0, 25) to (start + 0, 26)
= (c5 + c6)
- Code(Expression(67, Add)) at (prev + 1, 8) to (start + 0, 12)
- Code(Expression(47, Add)) at (prev + 1, 8) to (start + 0, 12)
= (c5 + c6)
- Code(Expression(67, Add)) at (prev + 0, 13) to (start + 2, 6)
- Code(Expression(47, Add)) at (prev + 0, 13) to (start + 2, 6)
= (c5 + c6)
- Code(Zero) at (prev + 2, 5) to (start + 0, 6)
- Code(Expression(82, Add)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(62, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c7 + c8)
- Code(Expression(67, Add)) at (prev + 0, 16) to (start + 0, 29)
- Code(Expression(47, Add)) at (prev + 0, 16) to (start + 0, 29)
= (c5 + c6)
- Code(Counter(7)) at (prev + 0, 30) to (start + 2, 6)
- Code(Expression(47, Sub)) at (prev + 2, 15) to (start + 0, 28)
- Code(Expression(32, Sub)) at (prev + 2, 15) to (start + 0, 28)
= ((c5 + c6) - c7)
- Code(Counter(8)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(49, Sub)) at (prev + 0, 29) to (start + 0, 42)
- Code(Expression(34, Sub)) at (prev + 0, 29) to (start + 0, 42)
= (c8 - c14)
- Code(Expression(50, Sub)) at (prev + 0, 46) to (start + 0, 60)
- Code(Expression(35, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (c8 - (c14 + c15))
- Code(Expression(55, Add)) at (prev + 0, 61) to (start + 2, 10)
= ((c14 + c15) + c16)
- Code(Expression(54, Sub)) at (prev + 2, 9) to (start + 0, 10)
= (c8 - ((c14 + c15) + c16))
- Code(Counter(8)) at (prev + 0, 61) to (start + 2, 10)
- Code(Zero) at (prev + 2, 9) to (start + 0, 10)
- Code(Counter(8)) at (prev + 1, 9) to (start + 0, 23)
- Code(Expression(66, Sub)) at (prev + 2, 13) to (start + 0, 32)
- Code(Expression(46, Sub)) at (prev + 2, 13) to (start + 0, 32)
= ((c5 + c6) - (c7 + c8))
- Code(Expression(66, Sub)) at (prev + 0, 35) to (start + 0, 44)
- Code(Expression(46, Sub)) at (prev + 0, 35) to (start + 0, 44)
= ((c5 + c6) - (c7 + c8))
- Code(Expression(66, Sub)) at (prev + 1, 9) to (start + 0, 17)
- Code(Expression(46, Sub)) at (prev + 1, 9) to (start + 0, 17)
= ((c5 + c6) - (c7 + c8))
- Code(Expression(66, Sub)) at (prev + 1, 9) to (start + 0, 15)
- Code(Expression(46, Sub)) at (prev + 1, 9) to (start + 0, 15)
= ((c5 + c6) - (c7 + c8))
- Code(Expression(83, Add)) at (prev + 3, 9) to (start + 0, 10)
- Code(Expression(63, Add)) at (prev + 3, 9) to (start + 0, 10)
= (c9 + c10)
- Code(Expression(82, Add)) at (prev + 0, 16) to (start + 0, 29)
- Code(Expression(62, Add)) at (prev + 0, 16) to (start + 0, 29)
= (c7 + c8)
- Code(Counter(9)) at (prev + 0, 30) to (start + 2, 6)
- Code(Expression(71, Sub)) at (prev + 2, 15) to (start + 0, 28)
- Code(Expression(51, Sub)) at (prev + 2, 15) to (start + 0, 28)
= ((c7 + c8) - c9)
- Code(Counter(10)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(73, Sub)) at (prev + 0, 29) to (start + 0, 42)
- Code(Expression(53, Sub)) at (prev + 0, 29) to (start + 0, 42)
= (c10 - c11)
- Code(Expression(74, Sub)) at (prev + 0, 46) to (start + 0, 60)
- Code(Expression(54, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (c10 - (c11 + c12))
- Code(Expression(79, Add)) at (prev + 0, 61) to (start + 2, 10)
- Code(Expression(59, Add)) at (prev + 0, 61) to (start + 2, 10)
= ((c11 + c12) + c13)
- Code(Expression(78, Sub)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(58, Sub)) at (prev + 2, 9) to (start + 0, 10)
= (c10 - ((c11 + c12) + c13))
- Code(Counter(10)) at (prev + 1, 9) to (start + 0, 23)
- Code(Expression(81, Sub)) at (prev + 2, 9) to (start + 0, 15)
- Code(Expression(61, Sub)) at (prev + 2, 9) to (start + 0, 15)
= ((c7 + c8) - (c9 + c10))
- Code(Counter(0)) at (prev + 2, 1) to (start + 0, 2)
Highest counter ID seen: c10
tests/mir-opt/jump_threading.rs
+1 -1
View File
@@ -88,7 +88,7 @@ fn two_reads() -> i32 {
// CHECK: [[c]] = copy [[a]];
// CHECK: [[tmp:_.*]] = copy [[c]];
// CHECK: [[eq:_.*]] = Eq(move [[tmp]], const 2_i32);
// CHECK: switchInt(move [[eq]]) -> [0: bb2, otherwise: bb1];
// CHECK: goto -> bb1;
// CHECK: bb1: {
// CHECK: _0 = const 0_i32;
// CHECK: goto -> bb3;
tests/mir-opt/jump_threading.two_reads.JumpThreading.panic-abort.diff
+2 -1
View File
@@ -29,7 +29,8 @@
StorageLive(_5);
_5 = copy _3;
_4 = Eq(move _5, const 2_i32);
switchInt(move _4) -> [0: bb2, otherwise: bb1];
- switchInt(move _4) -> [0: bb2, otherwise: bb1];
+ goto -> bb1;
}
bb1: {
tests/mir-opt/jump_threading.two_reads.JumpThreading.panic-unwind.diff
+2 -1
View File
@@ -29,7 +29,8 @@
StorageLive(_5);
_5 = copy _3;
_4 = Eq(move _5, const 2_i32);
switchInt(move _4) -> [0: bb2, otherwise: bb1];
- switchInt(move _4) -> [0: bb2, otherwise: bb1];
+ goto -> bb1;
}
bb1: {