mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add SingleUseConsts mir-opt pass

Browse Source
This commit is contained in:
Scott McMurray 2024-06-02 19:41:00 -07:00
parent d2fb97fcec
commit a4d0fc39ba
31 changed files with 1004 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_mir_transform/src/const_debuginfo.rs
View File

@ -16,7 +16,8 @@
impl<'tcx> MirPass<'tcx> for ConstDebugInfo {
fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
sess.mir_opt_level() > 0
// Disabled in favour of `SingleUseConsts`
sess.mir_opt_level() > 2
}
fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {

2
compiler/rustc_mir_transform/src/lib.rs
View File

@ -106,6 +106,7 @@
pub mod simplify;
mod simplify_branches;
mod simplify_comparison_integral;
mod single_use_consts;
mod sroa;
mod unreachable_enum_branching;
mod unreachable_prop;
@ -593,6 +594,7 @@ fn o1<T>(x: T) -> WithMinOptLevel<T> {
&gvn::GVN,
&simplify::SimplifyLocals::AfterGVN,
&dataflow_const_prop::DataflowConstProp,
&single_use_consts::SingleUseConsts,
&const_debuginfo::ConstDebugInfo,
&o1(simplify_branches::SimplifyConstCondition::AfterConstProp),
&jump_threading::JumpThreading,

195
compiler/rustc_mir_transform/src/single_use_consts.rs Normal file
View File

@ -0,0 +1,195 @@
use rustc_index::{bit_set::BitSet, IndexVec};
use rustc_middle::bug;
use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
use rustc_middle::mir::*;
use rustc_middle::ty::TyCtxt;
/// Various parts of MIR building introduce temporaries that are commonly not needed.
///
/// Notably, `if CONST` and `match CONST` end up being used-once temporaries, which
/// obfuscates the structure for other passes and codegen, which would like to always
/// be able to just see the constant directly.
///
/// At higher optimization levels fancier passes like GVN will take care of this
/// in a more general fashion, but this handles the easy cases so can run in debug.
///
/// This only removes constants with a single-use because re-evaluating constants
/// isn't always an improvement, especially for large ones.
///
/// It also removes *never*-used constants, since it had all the information
/// needed to do that too, including updating the debug info.
pub struct SingleUseConsts;
impl<'tcx> MirPass<'tcx> for SingleUseConsts {
fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
sess.mir_opt_level() > 0
}
fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
let mut finder = SingleUseConstsFinder {
ineligible_locals: BitSet::new_empty(body.local_decls.len()),
locations: IndexVec::new(),
};
finder.ineligible_locals.insert_range(..=Local::from_usize(body.arg_count));
finder.visit_body(body);
for (local, locations) in finder.locations.iter_enumerated() {
if finder.ineligible_locals.contains(local) {
continue;
}
let Some(init_loc) = locations.init_loc else {
continue;
};
// We're only changing an operand, not the terminator kinds or successors
let basic_blocks = body.basic_blocks.as_mut_preserves_cfg();
let init_statement =
basic_blocks[init_loc.block].statements[init_loc.statement_index].replace_nop();
let StatementKind::Assign(place_and_rvalue) = init_statement.kind else {
bug!("No longer an assign?");
};
let (place, rvalue) = *place_and_rvalue;
assert_eq!(place.as_local(), Some(local));
let Rvalue::Use(operand) = rvalue else { bug!("No longer a use?") };
let mut replacer = LocalReplacer { tcx, local, operand: Some(operand) };
for var_debug_info in &mut body.var_debug_info {
replacer.visit_var_debug_info(var_debug_info);
}
let Some(use_loc) = locations.use_loc else { continue };
let use_block = &mut basic_blocks[use_loc.block];
if let Some(use_statement) = use_block.statements.get_mut(use_loc.statement_index) {
replacer.visit_statement(use_statement, use_loc);
} else {
replacer.visit_terminator(use_block.terminator_mut(), use_loc);
}
if replacer.operand.is_some() {
bug!(
"operand wasn't used replacing local {local:?} with locations {locations:?} in body {body:#?}"
);
}
}
}
}
#[derive(Copy, Clone, Debug)]
struct LocationPair {
init_loc: Option<Location>,
use_loc: Option<Location>,
}
impl LocationPair {
fn new() -> Self {
Self { init_loc: None, use_loc: None }
}
}
struct SingleUseConstsFinder {
ineligible_locals: BitSet<Local>,
locations: IndexVec<Local, LocationPair>,
}
impl<'tcx> Visitor<'tcx> for SingleUseConstsFinder {
fn visit_assign(&mut self, place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) {
if let Some(local) = place.as_local()
&& let Rvalue::Use(operand) = rvalue
&& let Operand::Constant(_) = operand
{
let locations = self.locations.ensure_contains_elem(local, LocationPair::new);
if locations.init_loc.is_some() {
self.ineligible_locals.insert(local);
} else {
locations.init_loc = Some(location);
}
} else {
self.super_assign(place, rvalue, location);
}
}
fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location) {
if let Some(place) = operand.place()
&& let Some(local) = place.as_local()
{
let locations = self.locations.ensure_contains_elem(local, LocationPair::new);
if locations.use_loc.is_some() {
self.ineligible_locals.insert(local);
} else {
locations.use_loc = Some(location);
}
} else {
self.super_operand(operand, location);
}
}
fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
match &statement.kind {
// Storage markers are irrelevant to this.
StatementKind::StorageLive(_) | StatementKind::StorageDead(_) => {}
_ => self.super_statement(statement, location),
}
}
fn visit_var_debug_info(&mut self, var_debug_info: &VarDebugInfo<'tcx>) {
if let VarDebugInfoContents::Place(place) = &var_debug_info.value
&& let Some(_local) = place.as_local()
{
// It's a simple one that we can easily update
} else {
self.super_var_debug_info(var_debug_info);
}
}
fn visit_local(&mut self, local: Local, _context: PlaceContext, _location: Location) {
// If there's any path that gets here, rather than being understood elsewhere,
// then we'd better not do anything with this local.
self.ineligible_locals.insert(local);
}
}
struct LocalReplacer<'tcx> {
tcx: TyCtxt<'tcx>,
local: Local,
operand: Option<Operand<'tcx>>,
}
impl<'tcx> MutVisitor<'tcx> for LocalReplacer<'tcx> {
fn tcx(&self) -> TyCtxt<'tcx> {
self.tcx
}
fn visit_operand(&mut self, operand: &mut Operand<'tcx>, _location: Location) {
if let Operand::Copy(place) | Operand::Move(place) = operand
&& let Some(local) = place.as_local()
&& local == self.local
{
*operand = self.operand.take().unwrap_or_else(|| {
bug!("there was a second use of the operand");
});
}
}
fn visit_var_debug_info(&mut self, var_debug_info: &mut VarDebugInfo<'tcx>) {
if let VarDebugInfoContents::Place(place) = &var_debug_info.value
&& let Some(local) = place.as_local()
&& local == self.local
{
let const_op = self
.operand
.as_ref()
.unwrap_or_else(|| {
bug!("the operand was already stolen");
})
.constant()
.unwrap()
.clone();
var_debug_info.value = VarDebugInfoContents::Const(const_op);
}
}
}

6
tests/mir-opt/building/match/sort_candidates.rs
View File

@ -5,9 +5,9 @@ fn constant_eq(s: &str, b: bool) -> u32 {
// Check that we only test "a" once
// CHECK-LABEL: fn constant_eq(
// CHECK: bb0: {
// CHECK: [[a:_.*]] = const "a";
// CHECK-NOT: {{_.*}} = const "a";
// CHECK-NOT: const "a"
// CHECK: {{_[0-9]+}} = const "a" as &[u8] (Transmute);
// CHECK-NOT: const "a"
match (s, b) {
("a", _) if true => 1,
("b", true) => 2,

2
tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff
View File

@ -18,7 +18,7 @@
bb0: {
StorageLive(_1);
StorageLive(_2);
_2 = const 1_u32;
nop;
_1 = Un { us: const 1_u32 };
StorageDead(_2);
StorageLive(_3);

2
tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff
View File

@ -18,7 +18,7 @@
bb0: {
StorageLive(_1);
StorageLive(_2);
_2 = const 1_u32;
nop;
_1 = Un { us: const 1_u32 };
StorageDead(_2);
StorageLive(_3);

4
tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
View File

@ -29,8 +29,8 @@
_3 = &_4;
_2 = move _3 as &[T] (PointerCoercion(Unsize));
StorageDead(_3);
_5 = const 3_usize;
_6 = const true;
nop;
nop;
goto -> bb2;
}

4
tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
View File

@ -29,8 +29,8 @@
_3 = &_4;
_2 = move _3 as &[T] (PointerCoercion(Unsize));
StorageDead(_3);
_5 = const 3_usize;
_6 = const true;
nop;
nop;
goto -> bb2;
}

32
tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
View File

@ -23,16 +23,15 @@
let mut _12: isize;
let _13: std::alloc::AllocError;
let mut _14: !;
let _15: &str;
let mut _16: &dyn std::fmt::Debug;
let mut _17: &std::alloc::AllocError;
let mut _15: &dyn std::fmt::Debug;
let mut _16: &std::alloc::AllocError;
scope 7 {
}
scope 8 {
}
}
scope 9 (inlined NonNull::<[u8]>::as_ptr) {
let mut _18: *const [u8];
let mut _17: *const [u8];
}
}
scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
@ -87,36 +86,33 @@
StorageDead(_8);
StorageDead(_7);
StorageLive(_12);
StorageLive(_15);
_12 = discriminant(_6);
switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1];
}
bb5: {
_15 = const "called `Result::unwrap()` on an `Err` value";
StorageLive(_15);
StorageLive(_16);
StorageLive(_17);
_17 = &_13;
_16 = move _17 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
StorageDead(_17);
_14 = result::unwrap_failed(move _15, move _16) -> unwind unreachable;
_16 = &_13;
_15 = move _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
StorageDead(_16);
_14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
}
bb6: {
_5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>);
StorageDead(_15);
StorageDead(_12);
StorageDead(_6);
- StorageLive(_18);
- StorageLive(_17);
+ nop;
_18 = (_5.0: *const [u8]);
- _4 = move _18 as *mut [u8] (PtrToPtr);
- StorageDead(_18);
+ _4 = _18 as *mut [u8] (PtrToPtr);
_17 = (_5.0: *const [u8]);
- _4 = move _17 as *mut [u8] (PtrToPtr);
- StorageDead(_17);
+ _4 = _17 as *mut [u8] (PtrToPtr);
+ nop;
StorageDead(_5);
- _3 = move _4 as *mut u8 (PtrToPtr);
+ _3 = _18 as *mut u8 (PtrToPtr);
+ _3 = _17 as *mut u8 (PtrToPtr);
StorageDead(_4);
StorageDead(_3);
- StorageDead(_1);

32
tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
View File

@ -23,16 +23,15 @@
let mut _12: isize;
let _13: std::alloc::AllocError;
let mut _14: !;
let _15: &str;
let mut _16: &dyn std::fmt::Debug;
let mut _17: &std::alloc::AllocError;
let mut _15: &dyn std::fmt::Debug;
let mut _16: &std::alloc::AllocError;
scope 7 {
}
scope 8 {
}
}
scope 9 (inlined NonNull::<[u8]>::as_ptr) {
let mut _18: *const [u8];
let mut _17: *const [u8];
}
}
scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
@ -87,36 +86,33 @@
StorageDead(_8);
StorageDead(_7);
StorageLive(_12);
StorageLive(_15);
_12 = discriminant(_6);
switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1];
}
bb5: {
_15 = const "called `Result::unwrap()` on an `Err` value";
StorageLive(_15);
StorageLive(_16);
StorageLive(_17);
_17 = &_13;
_16 = move _17 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
StorageDead(_17);
_14 = result::unwrap_failed(move _15, move _16) -> unwind unreachable;
_16 = &_13;
_15 = move _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
StorageDead(_16);
_14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
}
bb6: {
_5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>);
StorageDead(_15);
StorageDead(_12);
StorageDead(_6);
- StorageLive(_18);
- StorageLive(_17);
+ nop;
_18 = (_5.0: *const [u8]);
- _4 = move _18 as *mut [u8] (PtrToPtr);
- StorageDead(_18);
+ _4 = _18 as *mut [u8] (PtrToPtr);
_17 = (_5.0: *const [u8]);
- _4 = move _17 as *mut [u8] (PtrToPtr);
- StorageDead(_17);
+ _4 = _17 as *mut [u8] (PtrToPtr);
+ nop;
StorageDead(_5);
- _3 = move _4 as *mut u8 (PtrToPtr);
+ _3 = _18 as *mut u8 (PtrToPtr);
+ _3 = _17 as *mut u8 (PtrToPtr);
StorageDead(_4);
StorageDead(_3);
- StorageDead(_1);

102
tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir
View File

@ -4,35 +4,34 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
debug slice => _1;
debug f => _2;
let mut _0: ();
let mut _12: std::slice::Iter<'_, T>;
let mut _11: std::slice::Iter<'_, T>;
let mut _12: std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _13: std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _14: std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _15: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _16: std::option::Option<(usize, &T)>;
let mut _17: isize;
let mut _20: &impl Fn(usize, &T);
let mut _21: (usize, &T);
let _22: ();
let mut _14: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _15: std::option::Option<(usize, &T)>;
let mut _16: isize;
let mut _19: &impl Fn(usize, &T);
let mut _20: (usize, &T);
let _21: ();
scope 1 {
debug iter => _14;
let _18: usize;
let _19: &T;
debug iter => _13;
let _17: usize;
let _18: &T;
scope 2 {
debug i => _18;
debug x => _19;
debug i => _17;
debug x => _18;
}
}
scope 3 (inlined core::slice::<impl [T]>::iter) {
scope 4 (inlined std::slice::Iter::<'_, T>::new) {
let _3: usize;
let mut _7: bool;
let mut _7: *mut T;
let mut _8: *mut T;
let mut _9: *mut T;
let mut _11: *const T;
let mut _10: *const T;
scope 5 {
let _6: std::ptr::NonNull<T>;
scope 6 {
let _10: *const T;
let _9: *const T;
scope 7 {
}
scope 11 (inlined without_provenance::<T>) {
@ -61,7 +60,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
}
bb0: {
StorageLive(_12);
StorageLive(_11);
StorageLive(_3);
StorageLive(_6);
StorageLive(_4);
@ -70,62 +69,59 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
_4 = &raw const (*_1);
_5 = _4 as *const T (PtrToPtr);
_6 = NonNull::<T> { pointer: _5 };
StorageLive(_10);
StorageLive(_7);
_7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
switchInt(move _7) -> [0: bb1, otherwise: bb2];
StorageLive(_9);
switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_9);
StorageLive(_8);
_8 = _4 as *mut T (PtrToPtr);
_9 = Offset(_8, _3);
StorageLive(_7);
_7 = _4 as *mut T (PtrToPtr);
_8 = Offset(_7, _3);
StorageDead(_7);
_9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_8);
_10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_9);
goto -> bb3;
}
bb2: {
_10 = _3 as *const T (Transmute);
_9 = _3 as *const T (Transmute);
goto -> bb3;
}
bb3: {
StorageDead(_7);
StorageLive(_11);
_11 = _10;
_12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_11);
StorageLive(_10);
_10 = _9;
_11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_10);
StorageDead(_9);
StorageDead(_5);
StorageDead(_4);
StorageDead(_6);
StorageDead(_3);
_13 = Enumerate::<std::slice::Iter<'_, T>> { iter: _12, count: const 0_usize };
StorageDead(_12);
StorageLive(_14);
_14 = _13;
_12 = Enumerate::<std::slice::Iter<'_, T>> { iter: _11, count: const 0_usize };
StorageDead(_11);
StorageLive(_13);
_13 = _12;
goto -> bb4;
}
bb4: {
StorageLive(_16);
StorageLive(_15);
_15 = &mut _14;
_16 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _15) -> [return: bb5, unwind unreachable];
StorageLive(_14);
_14 = &mut _13;
_15 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _14) -> [return: bb5, unwind unreachable];
}
bb5: {
StorageDead(_15);
_17 = discriminant(_16);
switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
StorageDead(_14);
_16 = discriminant(_15);
switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
}
bb6: {
StorageDead(_16);
StorageDead(_14);
StorageDead(_15);
StorageDead(_13);
drop(_2) -> [return: bb7, unwind unreachable];
}
@ -134,19 +130,19 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
}
bb8: {
_18 = (((_16 as Some).0: (usize, &T)).0: usize);
_19 = (((_16 as Some).0: (usize, &T)).1: &T);
_17 = (((_15 as Some).0: (usize, &T)).0: usize);
_18 = (((_15 as Some).0: (usize, &T)).1: &T);
StorageLive(_19);
_19 = &_2;
StorageLive(_20);
_20 = &_2;
StorageLive(_21);
_21 = (_18, _19);
_22 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _20, move _21) -> [return: bb9, unwind unreachable];
_20 = (_17, _18);
_21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind unreachable];
}
bb9: {
StorageDead(_21);
StorageDead(_20);
StorageDead(_16);
StorageDead(_19);
StorageDead(_15);
goto -> bb4;
}

102
tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
View File

@ -4,35 +4,34 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
debug slice => _1;
debug f => _2;
let mut _0: ();
let mut _12: std::slice::Iter<'_, T>;
let mut _11: std::slice::Iter<'_, T>;
let mut _12: std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _13: std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _14: std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _15: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _16: std::option::Option<(usize, &T)>;
let mut _17: isize;
let mut _20: &impl Fn(usize, &T);
let mut _21: (usize, &T);
let _22: ();
let mut _14: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
let mut _15: std::option::Option<(usize, &T)>;
let mut _16: isize;
let mut _19: &impl Fn(usize, &T);
let mut _20: (usize, &T);
let _21: ();
scope 1 {
debug iter => _14;
let _18: usize;
let _19: &T;
debug iter => _13;
let _17: usize;
let _18: &T;
scope 2 {
debug i => _18;
debug x => _19;
debug i => _17;
debug x => _18;
}
}
scope 3 (inlined core::slice::<impl [T]>::iter) {
scope 4 (inlined std::slice::Iter::<'_, T>::new) {
let _3: usize;
let mut _7: bool;
let mut _7: *mut T;
let mut _8: *mut T;
let mut _9: *mut T;
let mut _11: *const T;
let mut _10: *const T;
scope 5 {
let _6: std::ptr::NonNull<T>;
scope 6 {
let _10: *const T;
let _9: *const T;
scope 7 {
}
scope 11 (inlined without_provenance::<T>) {
@ -61,7 +60,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
}
bb0: {
StorageLive(_12);
StorageLive(_11);
StorageLive(_3);
StorageLive(_6);
StorageLive(_4);
@ -70,62 +69,59 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
_4 = &raw const (*_1);
_5 = _4 as *const T (PtrToPtr);
_6 = NonNull::<T> { pointer: _5 };
StorageLive(_10);
StorageLive(_7);
_7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
switchInt(move _7) -> [0: bb1, otherwise: bb2];
StorageLive(_9);
switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_9);
StorageLive(_8);
_8 = _4 as *mut T (PtrToPtr);
_9 = Offset(_8, _3);
StorageLive(_7);
_7 = _4 as *mut T (PtrToPtr);
_8 = Offset(_7, _3);
StorageDead(_7);
_9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_8);
_10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_9);
goto -> bb3;
}
bb2: {
_10 = _3 as *const T (Transmute);
_9 = _3 as *const T (Transmute);
goto -> bb3;
}
bb3: {
StorageDead(_7);
StorageLive(_11);
_11 = _10;
_12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_11);
StorageLive(_10);
_10 = _9;
_11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_10);
StorageDead(_9);
StorageDead(_5);
StorageDead(_4);
StorageDead(_6);
StorageDead(_3);
_13 = Enumerate::<std::slice::Iter<'_, T>> { iter: _12, count: const 0_usize };
StorageDead(_12);
StorageLive(_14);
_14 = _13;
_12 = Enumerate::<std::slice::Iter<'_, T>> { iter: _11, count: const 0_usize };
StorageDead(_11);
StorageLive(_13);
_13 = _12;
goto -> bb4;
}
bb4: {
StorageLive(_16);
StorageLive(_15);
_15 = &mut _14;
_16 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _15) -> [return: bb5, unwind: bb11];
StorageLive(_14);
_14 = &mut _13;
_15 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _14) -> [return: bb5, unwind: bb11];
}
bb5: {
StorageDead(_15);
_17 = discriminant(_16);
switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
StorageDead(_14);
_16 = discriminant(_15);
switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
}
bb6: {
StorageDead(_16);
StorageDead(_14);
StorageDead(_15);
StorageDead(_13);
drop(_2) -> [return: bb7, unwind continue];
}
@ -134,19 +130,19 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
}
bb8: {
_18 = (((_16 as Some).0: (usize, &T)).0: usize);
_19 = (((_16 as Some).0: (usize, &T)).1: &T);
_17 = (((_15 as Some).0: (usize, &T)).0: usize);
_18 = (((_15 as Some).0: (usize, &T)).1: &T);
StorageLive(_19);
_19 = &_2;
StorageLive(_20);
_20 = &_2;
StorageLive(_21);
_21 = (_18, _19);
_22 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _20, move _21) -> [return: bb9, unwind: bb11];
_20 = (_17, _18);
_21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11];
}
bb9: {
StorageDead(_21);
StorageDead(_20);
StorageDead(_16);
StorageDead(_19);
StorageDead(_15);
goto -> bb4;
}

88
tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir
View File

@ -4,32 +4,31 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
debug slice => _1;
debug f => _2;
let mut _0: ();
let mut _11: std::slice::Iter<'_, T>;
let mut _12: std::slice::Iter<'_, T>;
let mut _13: std::slice::Iter<'_, T>;
let mut _14: &mut std::slice::Iter<'_, T>;
let mut _15: std::option::Option<&T>;
let mut _16: isize;
let mut _18: &impl Fn(&T);
let mut _19: (&T,);
let _20: ();
let mut _13: &mut std::slice::Iter<'_, T>;
let mut _14: std::option::Option<&T>;
let mut _15: isize;
let mut _17: &impl Fn(&T);
let mut _18: (&T,);
let _19: ();
scope 1 {
debug iter => _13;
let _17: &T;
debug iter => _12;
let _16: &T;
scope 2 {
debug x => _17;
debug x => _16;
}
}
scope 3 (inlined core::slice::<impl [T]>::iter) {
scope 4 (inlined std::slice::Iter::<'_, T>::new) {
let _3: usize;
let mut _7: bool;
let mut _7: *mut T;
let mut _8: *mut T;
let mut _9: *mut T;
let mut _11: *const T;
let mut _10: *const T;
scope 5 {
let _6: std::ptr::NonNull<T>;
scope 6 {
let _10: *const T;
let _9: *const T;
scope 7 {
}
scope 11 (inlined without_provenance::<T>) {
@ -62,60 +61,57 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
_4 = &raw const (*_1);
_5 = _4 as *const T (PtrToPtr);
_6 = NonNull::<T> { pointer: _5 };
StorageLive(_10);
StorageLive(_7);
_7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
switchInt(move _7) -> [0: bb1, otherwise: bb2];
StorageLive(_9);
switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_9);
StorageLive(_8);
_8 = _4 as *mut T (PtrToPtr);
_9 = Offset(_8, _3);
StorageLive(_7);
_7 = _4 as *mut T (PtrToPtr);
_8 = Offset(_7, _3);
StorageDead(_7);
_9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_8);
_10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_9);
goto -> bb3;
}
bb2: {
_10 = _3 as *const T (Transmute);
_9 = _3 as *const T (Transmute);
goto -> bb3;
}
bb3: {
StorageDead(_7);
StorageLive(_11);
_11 = _10;
_12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_11);
StorageLive(_10);
_10 = _9;
_11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_10);
StorageDead(_9);
StorageDead(_5);
StorageDead(_4);
StorageDead(_6);
StorageDead(_3);
StorageLive(_13);
_13 = _12;
StorageLive(_12);
_12 = _11;
goto -> bb4;
}
bb4: {
StorageLive(_15);
StorageLive(_14);
_14 = &mut _13;
_15 = <std::slice::Iter<'_, T> as Iterator>::next(move _14) -> [return: bb5, unwind unreachable];
StorageLive(_13);
_13 = &mut _12;
_14 = <std::slice::Iter<'_, T> as Iterator>::next(move _13) -> [return: bb5, unwind unreachable];
}
bb5: {
StorageDead(_14);
_16 = discriminant(_15);
switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
StorageDead(_13);
_15 = discriminant(_14);
switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
}
bb6: {
StorageDead(_15);
StorageDead(_13);
StorageDead(_14);
StorageDead(_12);
drop(_2) -> [return: bb7, unwind unreachable];
}
@ -124,18 +120,18 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
}
bb8: {
_17 = ((_15 as Some).0: &T);
_16 = ((_14 as Some).0: &T);
StorageLive(_17);
_17 = &_2;
StorageLive(_18);
_18 = &_2;
StorageLive(_19);
_19 = (_17,);
_20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind unreachable];
_18 = (_16,);
_19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind unreachable];
}
bb9: {
StorageDead(_19);
StorageDead(_18);
StorageDead(_15);
StorageDead(_17);
StorageDead(_14);
goto -> bb4;
}

88
tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir
View File

@ -4,32 +4,31 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
debug slice => _1;
debug f => _2;
let mut _0: ();
let mut _11: std::slice::Iter<'_, T>;
let mut _12: std::slice::Iter<'_, T>;
let mut _13: std::slice::Iter<'_, T>;
let mut _14: &mut std::slice::Iter<'_, T>;
let mut _15: std::option::Option<&T>;
let mut _16: isize;
let mut _18: &impl Fn(&T);
let mut _19: (&T,);
let _20: ();
let mut _13: &mut std::slice::Iter<'_, T>;
let mut _14: std::option::Option<&T>;
let mut _15: isize;
let mut _17: &impl Fn(&T);
let mut _18: (&T,);
let _19: ();
scope 1 {
debug iter => _13;
let _17: &T;
debug iter => _12;
let _16: &T;
scope 2 {
debug x => _17;
debug x => _16;
}
}
scope 3 (inlined core::slice::<impl [T]>::iter) {
scope 4 (inlined std::slice::Iter::<'_, T>::new) {
let _3: usize;
let mut _7: bool;
let mut _7: *mut T;
let mut _8: *mut T;
let mut _9: *mut T;
let mut _11: *const T;
let mut _10: *const T;
scope 5 {
let _6: std::ptr::NonNull<T>;
scope 6 {
let _10: *const T;
let _9: *const T;
scope 7 {
}
scope 11 (inlined without_provenance::<T>) {
@ -62,60 +61,57 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
_4 = &raw const (*_1);
_5 = _4 as *const T (PtrToPtr);
_6 = NonNull::<T> { pointer: _5 };
StorageLive(_10);
StorageLive(_7);
_7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
switchInt(move _7) -> [0: bb1, otherwise: bb2];
StorageLive(_9);
switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_9);
StorageLive(_8);
_8 = _4 as *mut T (PtrToPtr);
_9 = Offset(_8, _3);
StorageLive(_7);
_7 = _4 as *mut T (PtrToPtr);
_8 = Offset(_7, _3);
StorageDead(_7);
_9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_8);
_10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_9);
goto -> bb3;
}
bb2: {
_10 = _3 as *const T (Transmute);
_9 = _3 as *const T (Transmute);
goto -> bb3;
}
bb3: {
StorageDead(_7);
StorageLive(_11);
_11 = _10;
_12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_11);
StorageLive(_10);
_10 = _9;
_11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_10);
StorageDead(_9);
StorageDead(_5);
StorageDead(_4);
StorageDead(_6);
StorageDead(_3);
StorageLive(_13);
_13 = _12;
StorageLive(_12);
_12 = _11;
goto -> bb4;
}
bb4: {
StorageLive(_15);
StorageLive(_14);
_14 = &mut _13;
_15 = <std::slice::Iter<'_, T> as Iterator>::next(move _14) -> [return: bb5, unwind: bb11];
StorageLive(_13);
_13 = &mut _12;
_14 = <std::slice::Iter<'_, T> as Iterator>::next(move _13) -> [return: bb5, unwind: bb11];
}
bb5: {
StorageDead(_14);
_16 = discriminant(_15);
switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
StorageDead(_13);
_15 = discriminant(_14);
switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
}
bb6: {
StorageDead(_15);
StorageDead(_13);
StorageDead(_14);
StorageDead(_12);
drop(_2) -> [return: bb7, unwind continue];
}
@ -124,18 +120,18 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
}
bb8: {
_17 = ((_15 as Some).0: &T);
_16 = ((_14 as Some).0: &T);
StorageLive(_17);
_17 = &_2;
StorageLive(_18);
_18 = &_2;
StorageLive(_19);
_19 = (_17,);
_20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind: bb11];
_18 = (_16,);
_19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind: bb11];
}
bb9: {
StorageDead(_19);
StorageDead(_18);
StorageDead(_15);
StorageDead(_17);
StorageDead(_14);
goto -> bb4;
}

96
tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir
View File

@ -4,35 +4,34 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
debug slice => _1;
debug f => _2;
let mut _0: ();
let mut _12: std::slice::Iter<'_, T>;
let mut _11: std::slice::Iter<'_, T>;
let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
let mut _13: std::iter::Rev<std::slice::Iter<'_, T>>;
let mut _14: std::iter::Rev<std::slice::Iter<'_, T>>;
let mut _16: std::option::Option<&T>;
let mut _17: isize;
let mut _19: &impl Fn(&T);
let mut _20: (&T,);
let _21: ();
let mut _15: std::option::Option<&T>;
let mut _16: isize;
let mut _18: &impl Fn(&T);
let mut _19: (&T,);
let _20: ();
scope 1 {
debug iter => _14;
let _18: &T;
debug iter => _13;
let _17: &T;
scope 2 {
debug x => _18;
debug x => _17;
}
scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
let mut _15: &mut std::slice::Iter<'_, T>;
let mut _14: &mut std::slice::Iter<'_, T>;
}
}
scope 3 (inlined core::slice::<impl [T]>::iter) {
scope 4 (inlined std::slice::Iter::<'_, T>::new) {
let _3: usize;
let mut _7: bool;
let mut _7: *mut T;
let mut _8: *mut T;
let mut _9: *mut T;
let mut _11: *const T;
let mut _10: *const T;
scope 5 {
let _6: std::ptr::NonNull<T>;
scope 6 {
let _10: *const T;
let _9: *const T;
scope 7 {
}
scope 11 (inlined without_provenance::<T>) {
@ -61,7 +60,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
}
bb0: {
StorageLive(_12);
StorageLive(_11);
StorageLive(_3);
StorageLive(_6);
StorageLive(_4);
@ -70,62 +69,59 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
_4 = &raw const (*_1);
_5 = _4 as *const T (PtrToPtr);
_6 = NonNull::<T> { pointer: _5 };
StorageLive(_10);
StorageLive(_7);
_7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
switchInt(move _7) -> [0: bb1, otherwise: bb2];
StorageLive(_9);
switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_9);
StorageLive(_8);
_8 = _4 as *mut T (PtrToPtr);
_9 = Offset(_8, _3);
StorageLive(_7);
_7 = _4 as *mut T (PtrToPtr);
_8 = Offset(_7, _3);
StorageDead(_7);
_9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_8);
_10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_9);
goto -> bb3;
}
bb2: {
_10 = _3 as *const T (Transmute);
_9 = _3 as *const T (Transmute);
goto -> bb3;
}
bb3: {
StorageDead(_7);
StorageLive(_11);
_11 = _10;
_12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_11);
StorageLive(_10);
_10 = _9;
_11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_10);
StorageDead(_9);
StorageDead(_5);
StorageDead(_4);
StorageDead(_6);
StorageDead(_3);
_13 = Rev::<std::slice::Iter<'_, T>> { iter: _12 };
StorageDead(_12);
StorageLive(_14);
_14 = _13;
_12 = Rev::<std::slice::Iter<'_, T>> { iter: _11 };
StorageDead(_11);
StorageLive(_13);
_13 = _12;
goto -> bb4;
}
bb4: {
StorageLive(_16);
StorageLive(_15);
_15 = &mut (_14.0: std::slice::Iter<'_, T>);
_16 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _15) -> [return: bb5, unwind unreachable];
StorageLive(_14);
_14 = &mut (_13.0: std::slice::Iter<'_, T>);
_15 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _14) -> [return: bb5, unwind unreachable];
}
bb5: {
StorageDead(_15);
_17 = discriminant(_16);
switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
StorageDead(_14);
_16 = discriminant(_15);
switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
}
bb6: {
StorageDead(_16);
StorageDead(_14);
StorageDead(_15);
StorageDead(_13);
drop(_2) -> [return: bb7, unwind unreachable];
}
@ -134,18 +130,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
}
bb8: {
_18 = ((_16 as Some).0: &T);
_17 = ((_15 as Some).0: &T);
StorageLive(_18);
_18 = &_2;
StorageLive(_19);
_19 = &_2;
StorageLive(_20);
_20 = (_18,);
_21 = <impl Fn(&T) as Fn<(&T,)>>::call(move _19, move _20) -> [return: bb9, unwind unreachable];
_19 = (_17,);
_20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind unreachable];
}
bb9: {
StorageDead(_20);
StorageDead(_19);
StorageDead(_16);
StorageDead(_18);
StorageDead(_15);
goto -> bb4;
}

96
tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir
View File

@ -4,35 +4,34 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
debug slice => _1;
debug f => _2;
let mut _0: ();
let mut _12: std::slice::Iter<'_, T>;
let mut _11: std::slice::Iter<'_, T>;
let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
let mut _13: std::iter::Rev<std::slice::Iter<'_, T>>;
let mut _14: std::iter::Rev<std::slice::Iter<'_, T>>;
let mut _16: std::option::Option<&T>;
let mut _17: isize;
let mut _19: &impl Fn(&T);
let mut _20: (&T,);
let _21: ();
let mut _15: std::option::Option<&T>;
let mut _16: isize;
let mut _18: &impl Fn(&T);
let mut _19: (&T,);
let _20: ();
scope 1 {
debug iter => _14;
let _18: &T;
debug iter => _13;
let _17: &T;
scope 2 {
debug x => _18;
debug x => _17;
}
scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
let mut _15: &mut std::slice::Iter<'_, T>;
let mut _14: &mut std::slice::Iter<'_, T>;
}
}
scope 3 (inlined core::slice::<impl [T]>::iter) {
scope 4 (inlined std::slice::Iter::<'_, T>::new) {
let _3: usize;
let mut _7: bool;
let mut _7: *mut T;
let mut _8: *mut T;
let mut _9: *mut T;
let mut _11: *const T;
let mut _10: *const T;
scope 5 {
let _6: std::ptr::NonNull<T>;
scope 6 {
let _10: *const T;
let _9: *const T;
scope 7 {
}
scope 11 (inlined without_provenance::<T>) {
@ -61,7 +60,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
}
bb0: {
StorageLive(_12);
StorageLive(_11);
StorageLive(_3);
StorageLive(_6);
StorageLive(_4);
@ -70,62 +69,59 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
_4 = &raw const (*_1);
_5 = _4 as *const T (PtrToPtr);
_6 = NonNull::<T> { pointer: _5 };
StorageLive(_10);
StorageLive(_7);
_7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
switchInt(move _7) -> [0: bb1, otherwise: bb2];
StorageLive(_9);
switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
}
bb1: {
StorageLive(_9);
StorageLive(_8);
_8 = _4 as *mut T (PtrToPtr);
_9 = Offset(_8, _3);
StorageLive(_7);
_7 = _4 as *mut T (PtrToPtr);
_8 = Offset(_7, _3);
StorageDead(_7);
_9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_8);
_10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
StorageDead(_9);
goto -> bb3;
}
bb2: {
_10 = _3 as *const T (Transmute);
_9 = _3 as *const T (Transmute);
goto -> bb3;
}
bb3: {
StorageDead(_7);
StorageLive(_11);
_11 = _10;
_12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_11);
StorageLive(_10);
_10 = _9;
_11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
StorageDead(_10);
StorageDead(_9);
StorageDead(_5);
StorageDead(_4);
StorageDead(_6);
StorageDead(_3);
_13 = Rev::<std::slice::Iter<'_, T>> { iter: _12 };
StorageDead(_12);
StorageLive(_14);
_14 = _13;
_12 = Rev::<std::slice::Iter<'_, T>> { iter: _11 };
StorageDead(_11);
StorageLive(_13);
_13 = _12;
goto -> bb4;
}
bb4: {
StorageLive(_16);
StorageLive(_15);
_15 = &mut (_14.0: std::slice::Iter<'_, T>);
_16 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _15) -> [return: bb5, unwind: bb11];
StorageLive(_14);
_14 = &mut (_13.0: std::slice::Iter<'_, T>);
_15 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _14) -> [return: bb5, unwind: bb11];
}
bb5: {
StorageDead(_15);
_17 = discriminant(_16);
switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
StorageDead(_14);
_16 = discriminant(_15);
switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
}
bb6: {
StorageDead(_16);
StorageDead(_14);
StorageDead(_15);
StorageDead(_13);
drop(_2) -> [return: bb7, unwind continue];
}
@ -134,18 +130,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
}
bb8: {
_18 = ((_16 as Some).0: &T);
_17 = ((_15 as Some).0: &T);
StorageLive(_18);
_18 = &_2;
StorageLive(_19);
_19 = &_2;
StorageLive(_20);
_20 = (_18,);
_21 = <impl Fn(&T) as Fn<(&T,)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11];
_19 = (_17,);
_20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind: bb11];
}
bb9: {
StorageDead(_20);
StorageDead(_19);
StorageDead(_16);
StorageDead(_18);
StorageDead(_15);
goto -> bb4;
}

12
tests/mir-opt/single_use_consts.assign_const_to_return.SingleUseConsts.panic-abort.diff Normal file
View File

@ -0,0 +1,12 @@
- // MIR for `assign_const_to_return` before SingleUseConsts
+ // MIR for `assign_const_to_return` after SingleUseConsts
fn assign_const_to_return() -> bool {
let mut _0: bool;
bb0: {
_0 = const <T as MyTrait>::ASSOC_BOOL;
return;
}
}

12
tests/mir-opt/single_use_consts.assign_const_to_return.SingleUseConsts.panic-unwind.diff Normal file
View File

@ -0,0 +1,12 @@
- // MIR for `assign_const_to_return` before SingleUseConsts
+ // MIR for `assign_const_to_return` after SingleUseConsts
fn assign_const_to_return() -> bool {
let mut _0: bool;
bb0: {
_0 = const <T as MyTrait>::ASSOC_BOOL;
return;
}
}

31
tests/mir-opt/single_use_consts.if_const.SingleUseConsts.panic-abort.diff Normal file
View File

@ -0,0 +1,31 @@
- // MIR for `if_const` before SingleUseConsts
+ // MIR for `if_const` after SingleUseConsts
fn if_const() -> i32 {
let mut _0: i32;
let mut _1: bool;
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_BOOL;
- switchInt(move _1) -> [0: bb2, otherwise: bb1];
+ nop;
+ switchInt(const <T as MyTrait>::ASSOC_BOOL) -> [0: bb2, otherwise: bb1];
}
bb1: {
_0 = const 7_i32;
goto -> bb3;
}
bb2: {
_0 = const 42_i32;
goto -> bb3;
}
bb3: {
StorageDead(_1);
return;
}
}

31
tests/mir-opt/single_use_consts.if_const.SingleUseConsts.panic-unwind.diff Normal file
View File

@ -0,0 +1,31 @@
- // MIR for `if_const` before SingleUseConsts
+ // MIR for `if_const` after SingleUseConsts
fn if_const() -> i32 {
let mut _0: i32;
let mut _1: bool;
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_BOOL;
- switchInt(move _1) -> [0: bb2, otherwise: bb1];
+ nop;
+ switchInt(const <T as MyTrait>::ASSOC_BOOL) -> [0: bb2, otherwise: bb1];
}
bb1: {
_0 = const 7_i32;
goto -> bb3;
}
bb2: {
_0 = const 42_i32;
goto -> bb3;
}
bb3: {
StorageDead(_1);
return;
}
}

46
tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff Normal file
View File

@ -0,0 +1,46 @@
- // MIR for `if_const_debug` before SingleUseConsts
+ // MIR for `if_const_debug` after SingleUseConsts
fn if_const_debug() -> i32 {
let mut _0: i32;
let _1: bool;
let _2: ();
let mut _3: bool;
scope 1 {
- debug my_bool => _1;
+ debug my_bool => const <T as MyTrait>::ASSOC_BOOL;
}
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_BOOL;
+ nop;
StorageLive(_2);
_2 = do_whatever() -> [return: bb1, unwind unreachable];
}
bb1: {
StorageDead(_2);
StorageLive(_3);
- _3 = _1;
+ _3 = const <T as MyTrait>::ASSOC_BOOL;
switchInt(move _3) -> [0: bb3, otherwise: bb2];
}
bb2: {
_0 = const 7_i32;
goto -> bb4;
}
bb3: {
_0 = const 42_i32;
goto -> bb4;
}
bb4: {
StorageDead(_3);
StorageDead(_1);
return;
}
}

46
tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff Normal file
View File

@ -0,0 +1,46 @@
- // MIR for `if_const_debug` before SingleUseConsts
+ // MIR for `if_const_debug` after SingleUseConsts
fn if_const_debug() -> i32 {
let mut _0: i32;
let _1: bool;
let _2: ();
let mut _3: bool;
scope 1 {
- debug my_bool => _1;
+ debug my_bool => const <T as MyTrait>::ASSOC_BOOL;
}
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_BOOL;
+ nop;
StorageLive(_2);
_2 = do_whatever() -> [return: bb1, unwind continue];
}
bb1: {
StorageDead(_2);
StorageLive(_3);
- _3 = _1;
+ _3 = const <T as MyTrait>::ASSOC_BOOL;
switchInt(move _3) -> [0: bb3, otherwise: bb2];
}
bb2: {
_0 = const 7_i32;
goto -> bb4;
}
bb3: {
_0 = const 42_i32;
goto -> bb4;
}
bb4: {
StorageDead(_3);
StorageDead(_1);
return;
}
}

14
tests/mir-opt/single_use_consts.keep_parameter.SingleUseConsts.panic-abort.diff Normal file
View File

@ -0,0 +1,14 @@
- // MIR for `keep_parameter` before SingleUseConsts
+ // MIR for `keep_parameter` after SingleUseConsts
fn keep_parameter(_1: i32) -> () {
debug other => _1;
let mut _0: ();
bb0: {
_1 = const <T as MyTrait>::ASSOC_INT;
_0 = const ();
return;
}
}

14
tests/mir-opt/single_use_consts.keep_parameter.SingleUseConsts.panic-unwind.diff Normal file
View File

@ -0,0 +1,14 @@
- // MIR for `keep_parameter` before SingleUseConsts
+ // MIR for `keep_parameter` after SingleUseConsts
fn keep_parameter(_1: i32) -> () {
debug other => _1;
let mut _0: ();
bb0: {
_1 = const <T as MyTrait>::ASSOC_INT;
_0 = const ();
return;
}
}

36
tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff Normal file
View File

@ -0,0 +1,36 @@
- // MIR for `match_const` before SingleUseConsts
+ // MIR for `match_const` after SingleUseConsts
fn match_const() -> &str {
let mut _0: &str;
let mut _1: i32;
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_INT;
- switchInt(_1) -> [7: bb2, 42: bb3, otherwise: bb1];
+ nop;
+ switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb2, 42: bb3, otherwise: bb1];
}
bb1: {
_0 = const "world";
goto -> bb4;
}
bb2: {
_0 = const "hello";
goto -> bb4;
}
bb3: {
_0 = const "towel";
goto -> bb4;
}
bb4: {
StorageDead(_1);
return;
}
}

36
tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff Normal file
View File

@ -0,0 +1,36 @@
- // MIR for `match_const` before SingleUseConsts
+ // MIR for `match_const` after SingleUseConsts
fn match_const() -> &str {
let mut _0: &str;
let mut _1: i32;
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_INT;
- switchInt(_1) -> [7: bb2, 42: bb3, otherwise: bb1];
+ nop;
+ switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb2, 42: bb3, otherwise: bb1];
}
bb1: {
_0 = const "world";
goto -> bb4;
}
bb2: {
_0 = const "hello";
goto -> bb4;
}
bb3: {
_0 = const "towel";
goto -> bb4;
}
bb4: {
StorageDead(_1);
return;
}
}

47
tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff Normal file
View File

@ -0,0 +1,47 @@
- // MIR for `match_const_debug` before SingleUseConsts
+ // MIR for `match_const_debug` after SingleUseConsts
fn match_const_debug() -> &str {
let mut _0: &str;
let _1: i32;
let _2: ();
scope 1 {
- debug my_int => _1;
+ debug my_int => const <T as MyTrait>::ASSOC_INT;
}
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_INT;
+ nop;
StorageLive(_2);
_2 = do_whatever() -> [return: bb1, unwind unreachable];
}
bb1: {
StorageDead(_2);
- switchInt(_1) -> [7: bb3, 42: bb4, otherwise: bb2];
+ switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb3, 42: bb4, otherwise: bb2];
}
bb2: {
_0 = const "world";
goto -> bb5;
}
bb3: {
_0 = const "hello";
goto -> bb5;
}
bb4: {
_0 = const "towel";
goto -> bb5;
}
bb5: {
StorageDead(_1);
return;
}
}

47
tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff Normal file
View File

@ -0,0 +1,47 @@
- // MIR for `match_const_debug` before SingleUseConsts
+ // MIR for `match_const_debug` after SingleUseConsts
fn match_const_debug() -> &str {
let mut _0: &str;
let _1: i32;
let _2: ();
scope 1 {
- debug my_int => _1;
+ debug my_int => const <T as MyTrait>::ASSOC_INT;
}
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_INT;
+ nop;
StorageLive(_2);
_2 = do_whatever() -> [return: bb1, unwind continue];
}
bb1: {
StorageDead(_2);
- switchInt(_1) -> [7: bb3, 42: bb4, otherwise: bb2];
+ switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb3, 42: bb4, otherwise: bb2];
}
bb2: {
_0 = const "world";
goto -> bb5;
}
bb3: {
_0 = const "hello";
goto -> bb5;
}
bb4: {
_0 = const "towel";
goto -> bb5;
}
bb5: {
StorageDead(_1);
return;
}
}

21
tests/mir-opt/single_use_consts.never_used_debug.SingleUseConsts.panic-abort.diff Normal file
View File

@ -0,0 +1,21 @@
- // MIR for `never_used_debug` before SingleUseConsts
+ // MIR for `never_used_debug` after SingleUseConsts
fn never_used_debug() -> () {
let mut _0: ();
let _1: i32;
scope 1 {
- debug my_int => _1;
+ debug my_int => const <T as MyTrait>::ASSOC_INT;
}
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_INT;
+ nop;
_0 = const ();
StorageDead(_1);
return;
}
}

21
tests/mir-opt/single_use_consts.never_used_debug.SingleUseConsts.panic-unwind.diff Normal file
View File

@ -0,0 +1,21 @@
- // MIR for `never_used_debug` before SingleUseConsts
+ // MIR for `never_used_debug` after SingleUseConsts
fn never_used_debug() -> () {
let mut _0: ();
let _1: i32;
scope 1 {
- debug my_int => _1;
+ debug my_int => const <T as MyTrait>::ASSOC_INT;
}
bb0: {
StorageLive(_1);
- _1 = const <T as MyTrait>::ASSOC_INT;
+ nop;
_0 = const ();
StorageDead(_1);
return;
}
}

80
tests/mir-opt/single_use_consts.rs Normal file
View File

@ -0,0 +1,80 @@
//@ test-mir-pass: SingleUseConsts
//@ compile-flags: -C debuginfo=full
// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
trait MyTrait {
const ASSOC_BOOL: bool;
const ASSOC_INT: i32;
}
// EMIT_MIR single_use_consts.if_const.SingleUseConsts.diff
fn if_const<T: MyTrait>() -> i32 {
// CHECK-LABEL: fn if_const(
// CHECK: switchInt(const <T as MyTrait>::ASSOC_BOOL)
if T::ASSOC_BOOL { 7 } else { 42 }
}
// EMIT_MIR single_use_consts.match_const.SingleUseConsts.diff
fn match_const<T: MyTrait>() -> &'static str {
// CHECK-LABEL: fn match_const(
// CHECK: switchInt(const <T as MyTrait>::ASSOC_INT)
match T::ASSOC_INT {
7 => "hello",
42 => "towel",
_ => "world",
}
}
// EMIT_MIR single_use_consts.if_const_debug.SingleUseConsts.diff
fn if_const_debug<T: MyTrait>() -> i32 {
// CHECK-LABEL: fn if_const_debug(
// CHECK: my_bool => const <T as MyTrait>::ASSOC_BOOL;
// FIXME: `if` forces a temporary (unlike `match`), so the const isn't direct
// CHECK: _3 = const <T as MyTrait>::ASSOC_BOOL;
// CHECK: switchInt(move _3)
let my_bool = T::ASSOC_BOOL;
do_whatever();
if my_bool { 7 } else { 42 }
}
// EMIT_MIR single_use_consts.match_const_debug.SingleUseConsts.diff
fn match_const_debug<T: MyTrait>() -> &'static str {
// CHECK-LABEL: fn match_const_debug(
// CHECK: my_int => const <T as MyTrait>::ASSOC_INT;
// CHECK: switchInt(const <T as MyTrait>::ASSOC_INT)
let my_int = T::ASSOC_INT;
do_whatever();
match my_int {
7 => "hello",
42 => "towel",
_ => "world",
}
}
// EMIT_MIR single_use_consts.never_used_debug.SingleUseConsts.diff
#[allow(unused_variables)]
fn never_used_debug<T: MyTrait>() {
// CHECK-LABEL: fn never_used_debug(
// CHECK: my_int => const <T as MyTrait>::ASSOC_INT;
// CHECK-NOT: ASSOC_INT
// CHECK: nop
// CHECK-NOT: ASSOC_INT
let my_int = T::ASSOC_INT;
}
// EMIT_MIR single_use_consts.assign_const_to_return.SingleUseConsts.diff
fn assign_const_to_return<T: MyTrait>() -> bool {
// CHECK-LABEL: fn assign_const_to_return(
// CHECK: _0 = const <T as MyTrait>::ASSOC_BOOL;
T::ASSOC_BOOL
}
// EMIT_MIR single_use_consts.keep_parameter.SingleUseConsts.diff
fn keep_parameter<T: MyTrait>(mut other: i32) {
// CHECK-LABEL: fn keep_parameter(
// CHECK: _1 = const <T as MyTrait>::ASSOC_INT;
// CHECK: _0 = const ();
other = T::ASSOC_INT;
}
fn do_whatever() {}