perf: Test impact of never removing noop landing pads

[clubby789]

#160015 (comment)

r? ghost

[clubby789]

@bors try @rust-timer queue

[rust-log-analyzer]

The job aarch64-gnu-llvm-21-1 failed! Check out the build log: (web) (plain enhanced) (plain)

Click to see the possible cause of the failure (guessed by this bot)

---- [mir-opt] tests/mir-opt/array_index_is_temporary.rs stdout ----
33         StorageLive(_5);
34         StorageLive(_6);
35         _6 = copy _3;
-         _5 = foo(move _6) -> [return: bb1, unwind continue];
+         _5 = foo(move _6) -> [return: bb1, unwind: bb3];
37     }
38 
39     bb1: {

41         StorageLive(_7);
42         _7 = copy _2;
43         _8 = Lt(copy _7, const 3_usize);
-         assert(move _8, "index out of bounds: the length is {} but the index is {}", const 3_usize, copy _7) -> [success: bb2, unwind continue];
+         assert(move _8, "index out of bounds: the length is {} but the index is {}", const 3_usize, copy _7) -> [success: bb2, unwind: bb3];
45     }
46 
47     bb2: {

53         StorageDead(_2);
---
57 }
58 


thread '[mir-opt] tests/mir-opt/array_index_is_temporary.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/array_index_is_temporary.rs stdout end ----
---- [mir-opt] tests/mir-opt/basic_assignment.rs stdout ----
59   
60       bb4: {
61           StorageDead(_5);
- -         drop(_4) -> [return: bb5, unwind continue];
+ -         drop(_4) -> [return: bb5, unwind: bb8];
63 +         goto -> bb5;
64       }
65   


thread '[mir-opt] tests/mir-opt/basic_assignment.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/basic_assignment.rs stdout end ----
---- [mir-opt] tests/mir-opt/box_partial_move.rs stdout ----
43   
44       bb4: {
45           StorageDead(_3);
- -         drop(_2) -> [return: bb5, unwind continue];
+ -         drop(_2) -> [return: bb5, unwind: bb7];
47 +         goto -> bb14;
48       }
49   


thread '[mir-opt] tests/mir-opt/box_partial_move.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/box_partial_move.maybe_move.ElaborateDrops.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/box_partial_move.rs stdout end ----
---- [mir-opt] tests/mir-opt/box_conditional_drop_allocator.rs stdout ----
74   
75       bb6: {
76           StorageDead(_4);
- -         drop(_1) -> [return: bb7, unwind continue];
+ -         drop(_1) -> [return: bb7, unwind: bb13];
78 +         goto -> bb23;
79       }
80   


thread '[mir-opt] tests/mir-opt/box_conditional_drop_allocator.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/box_conditional_drop_allocator.main.ElaborateDrops.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/box_conditional_drop_allocator.rs stdout end ----
---- [mir-opt] tests/mir-opt/building/fallible_struct_drop.rs stdout ----
124           _7 = copy _1;
125           _6 = BitXor(move _7, const 0_u64);
126           StorageDead(_7);
-           _5 = make_one(move _6) -> [return: bb1, unwind continue];
+           _5 = make_one(move _6) -> [return: bb1, unwind: bb92];
128       }
129   
130       bb1: {

430       bb41: {
431 +         _55 = const false;
432           StorageDead(_14);
- -         drop(_4) -> [return: bb42, unwind continue];
+ -         drop(_4) -> [return: bb42, unwind: bb92];
434 +         goto -> bb97;
435       }
436   

534       }
535   
536       bb60: {
- -         drop(_4) -> [return: bb61, unwind continue];
+ -         drop(_4) -> [return: bb61, unwind: bb92];
538 +         goto -> bb102;
539       }
540   


thread '[mir-opt] tests/mir-opt/building/fallible_struct_drop.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/building/fallible_struct_drop.build.ElaborateDrops.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/building/fallible_struct_drop.rs stdout end ----
---- [mir-opt] tests/mir-opt/building/while_storage.rs stdout ----
21         StorageLive(_3);
22         StorageLive(_2);
23         _2 = copy _1;
-         _3 = get_bool(move _2) -> [return: bb2, unwind continue];
+         _3 = get_bool(move _2) -> [return: bb2, unwind: bb9];
25     }
26 
27     bb2: {

41         StorageLive(_5);
42         StorageLive(_4);
43         _4 = copy _1;
-         _5 = get_bool(move _4) -> [return: bb5, unwind continue];
+         _5 = get_bool(move _4) -> [return: bb5, unwind: bb9];
45     }
46 
47     bb5: {

66     bb8: {
---
70 }
71 


thread '[mir-opt] tests/mir-opt/building/while_storage.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/building/while_storage.while_loop.runtime-optimized.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/building/while_storage.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/aggregate.rs stdout ----
26           StorageLive(_4);
27           StorageLive(_5);
28 -         _5 = copy _1;
- -         _4 = foo(move _5) -> [return: bb1, unwind continue];
+ -         _4 = foo(move _5) -> [return: bb1, unwind: bb2];
30 +         _5 = const 1_u8;
- +         _4 = foo(const 1_u8) -> [return: bb1, unwind continue];
+ +         _4 = foo(const 1_u8) -> [return: bb1, unwind: bb2];
32       }
33   
34       bb1: {

37           _0 = const ();
---
41   }
42   


thread '[mir-opt] tests/mir-opt/const_prop/aggregate.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/aggregate.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/array_index.rs stdout ----
18           StorageLive(_3);
19           _3 = const 2_usize;
20 -         _4 = Lt(copy _3, const 4_usize);
- -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _3) -> [success: bb1, unwind continue];
+ -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _3) -> [success: bb1, unwind: bb2];
22 +         _4 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind: bb2];
24       }
25   
26       bb1: {

31           _0 = const ();
---
35   }
36   


thread '[mir-opt] tests/mir-opt/const_prop/array_index.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/array_index.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs stdout ----
34           _6 = const 3_usize;
35 -         _7 = PtrMetadata(copy _1);
36 -         _8 = Lt(copy _6, copy _7);
- -         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
+ -         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind: bb2];
38 +         _7 = const 3_usize;
39 +         _8 = const false;
- +         assert(const false, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 3_usize) -> [success: bb1, unwind continue];
+ +         assert(const false, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 3_usize) -> [success: bb1, unwind: bb2];
41       }
42   
43       bb1: {

48           StorageDead(_5);
---
52   }
53   


thread '[mir-opt] tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/bad_op_div_by_zero.rs stdout ----
24           StorageLive(_3);
25 -         _3 = copy _1;
26 -         _4 = Eq(copy _3, const 0_i32);
- -         assert(!move _4, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind continue];
+ -         assert(!move _4, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind: bb3];
28 +         _3 = const 0_i32;
29 +         _4 = const true;
- +         assert(!const true, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind continue];
+ +         assert(!const true, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind: bb3];
31       }
32   
33       bb1: {

34 -         _5 = Eq(copy _3, const -1_i32);
35 -         _6 = Eq(const 1_i32, const i32::MIN);
36 -         _7 = BitAnd(move _5, move _6);
- -         assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind continue];
+ -         assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind: bb3];
38 +         _5 = const false;
39 +         _6 = const false;
40 +         _7 = const false;

- +         assert(!const false, "attempt to compute `{} / {}`, which would overflow", const 1_i32, const 0_i32) -> [success: bb2, unwind continue];
+ +         assert(!const false, "attempt to compute `{} / {}`, which would overflow", const 1_i32, const 0_i32) -> [success: bb2, unwind: bb3];
42       }
43   
44       bb2: {

49           StorageDead(_2);
---
53   }
54   


thread '[mir-opt] tests/mir-opt/const_prop/bad_op_div_by_zero.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/bad_op_div_by_zero.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/bad_op_mod_by_zero.rs stdout ----
24           StorageLive(_3);
25 -         _3 = copy _1;
26 -         _4 = Eq(copy _3, const 0_i32);
- -         assert(!move _4, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind continue];
+ -         assert(!move _4, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind: bb3];
28 +         _3 = const 0_i32;
29 +         _4 = const true;
- +         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind continue];
+ +         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind: bb3];
31       }
32   
33       bb1: {

34 -         _5 = Eq(copy _3, const -1_i32);
35 -         _6 = Eq(const 1_i32, const i32::MIN);
36 -         _7 = BitAnd(move _5, move _6);
- -         assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind continue];
+ -         assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind: bb3];
38 +         _5 = const false;
39 +         _6 = const false;
40 +         _7 = const false;

- +         assert(!const false, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, const 0_i32) -> [success: bb2, unwind continue];
+ +         assert(!const false, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, const 0_i32) -> [success: bb2, unwind: bb3];
42       }
43   
44       bb2: {

49           StorageDead(_2);
---
53   }
54   


thread '[mir-opt] tests/mir-opt/const_prop/bad_op_mod_by_zero.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/bad_op_mod_by_zero.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/checked_add.rs stdout ----
12       bb0: {
13           StorageLive(_1);
14 -         _2 = AddWithOverflow(const 1_u32, const 1_u32);
- -         assert(!move (_2.1: bool), "attempt to compute `{} + {}`, which would overflow", const 1_u32, const 1_u32) -> [success: bb1, unwind continue];
+ -         assert(!move (_2.1: bool), "attempt to compute `{} + {}`, which would overflow", const 1_u32, const 1_u32) -> [success: bb1, unwind: bb2];
16 +         _2 = const (2_u32, false);
- +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 1_u32, const 1_u32) -> [success: bb1, unwind continue];
+ +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 1_u32, const 1_u32) -> [success: bb1, unwind: bb2];
18       }
19   
20       bb1: {

23           _0 = const ();
---
27   }
28 + 


thread '[mir-opt] tests/mir-opt/const_prop/checked_add.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/checked_add.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/checked_add.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/control_flow_simplification.rs stdout ----
10       }
11   
12       bb1: {
-           _1 = std::rt::begin_panic::<&str>(const "explicit panic") -> unwind continue;
+           _1 = std::rt::begin_panic::<&str>(const "explicit panic") -> bb3;
14       }
15   
16       bb2: {

17           return;
---
19   }
20   


thread '[mir-opt] tests/mir-opt/const_prop/control_flow_simplification.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/control_flow_simplification.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/indirect.rs stdout ----
15           StorageLive(_2);
16 -         _2 = const 2_u32 as u8 (IntToInt);
17 -         _3 = AddWithOverflow(copy _2, const 1_u8);
- -         assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, const 1_u8) -> [success: bb1, unwind continue];
+ -         assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, const 1_u8) -> [success: bb1, unwind: bb2];
19 +         _2 = const 2_u8;
20 +         _3 = const (3_u8, false);
- +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 2_u8, const 1_u8) -> [success: bb1, unwind continue];
+ +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 2_u8, const 1_u8) -> [success: bb1, unwind: bb2];
22       }
23   
24       bb1: {

28           _0 = const ();
---
32 + }
33 + 


thread '[mir-opt] tests/mir-opt/const_prop/indirect.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/indirect.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/inherit_overflow.rs stdout ----
20           _3 = const 1_u8;
21           StorageLive(_4);
22 -         _4 = AddWithOverflow(copy _2, copy _3);
- -         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind continue];
+ -         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb2, unwind: bb1];
24 +         _4 = const (0_u8, true);
- +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind continue];
+ +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb2, unwind: bb1];
26       }
27   
-       bb1: {
+       bb1 (cleanup): {
+           resume;
+       }
+   
+       bb2: {
29 -         _1 = move (_4.0: u8);
30 +         _1 = const 0_u8;
31           StorageDead(_4);


thread '[mir-opt] tests/mir-opt/const_prop/inherit_overflow.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/inherit_overflow.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/issue_66971.rs stdout ----
16 +         _3 = const ();
17 +         _2 = const ((), 0_u8, 0_u8);
18           StorageDead(_3);
- -         _1 = encode(move _2) -> [return: bb1, unwind continue];
- +         _1 = encode(const ((), 0_u8, 0_u8)) -> [return: bb1, unwind continue];
+ -         _1 = encode(move _2) -> [return: bb1, unwind: bb2];
+ +         _1 = encode(const ((), 0_u8, 0_u8)) -> [return: bb1, unwind: bb2];
21       }
22   
23       bb1: {

25           StorageDead(_1);
---
29 + }
30 + 


thread '[mir-opt] tests/mir-opt/const_prop/issue_66971.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/issue_66971.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/issue_66971.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/large_array_index.rs stdout ----
18           StorageLive(_3);
19           _3 = const 2_usize;
20 -         _4 = Lt(copy _3, const 5000_usize);
- -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 5000_usize, copy _3) -> [success: bb1, unwind continue];
+ -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 5000_usize, copy _3) -> [success: bb1, unwind: bb2];
22 +         _4 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind: bb2];
24       }
25   
26       bb1: {

31           _0 = const ();
---
35   }
36   


thread '[mir-opt] tests/mir-opt/const_prop/large_array_index.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/large_array_index.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/issue_67019.rs stdout ----
16 +         _3 = const (1_u8, 2_u8);
17 +         _2 = const ((1_u8, 2_u8),);
18           StorageDead(_3);
- -         _1 = test(move _2) -> [return: bb1, unwind continue];
- +         _1 = test(const ((1_u8, 2_u8),)) -> [return: bb1, unwind continue];
+ -         _1 = test(move _2) -> [return: bb1, unwind: bb2];
+ +         _1 = test(const ((1_u8, 2_u8),)) -> [return: bb1, unwind: bb2];
21       }
22   
23       bb1: {

25           StorageDead(_1);
---
29 + }
30 + 


thread '[mir-opt] tests/mir-opt/const_prop/issue_67019.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/issue_67019.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/issue_67019.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs stdout ----
14   
15       bb0: {
16           StorageLive(_1);
-           _1 = foo() -> [return: bb1, unwind continue];
+           _1 = foo() -> [return: bb1, unwind: bb2];
18       }
19   
20       bb1: {

26           StorageDead(_2);
---
30   }
31   


thread '[mir-opt] tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs stdout ----
23   
24       bb0: {
25           StorageLive(_1);
-           _1 = foo() -> [return: bb1, unwind continue];
+           _1 = foo() -> [return: bb1, unwind: bb2];
27       }
28   
29       bb1: {

45           StorageDead(_2);
---
49   }
50 + 


thread '[mir-opt] tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/pointer_expose_provenance.rs stdout ----
24           StorageLive(_4);
25           StorageLive(_5);
26           _5 = copy _1;
- -         _4 = read(move _5) -> [return: bb1, unwind continue];
- +         _4 = read(copy _1) -> [return: bb1, unwind continue];
+ -         _4 = read(move _5) -> [return: bb1, unwind: bb2];
+ +         _4 = read(copy _1) -> [return: bb1, unwind: bb2];
29       }
30   
31       bb1: {

34           _0 = const ();
---
38   }
39   


thread '[mir-opt] tests/mir-opt/const_prop/pointer_expose_provenance.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/pointer_expose_provenance.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/repeat.rs stdout ----
20           StorageLive(_4);
21           _4 = const 2_usize;
22 -         _5 = Lt(copy _4, const 8_usize);
- -         assert(move _5, "index out of bounds: the length is {} but the index is {}", const 8_usize, copy _4) -> [success: bb1, unwind continue];
+ -         assert(move _5, "index out of bounds: the length is {} but the index is {}", const 8_usize, copy _4) -> [success: bb1, unwind: bb2];
24 +         _5 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind: bb2];
26       }
27   
28       bb1: {

36           _0 = const ();
---
40   }
41   


thread '[mir-opt] tests/mir-opt/const_prop/repeat.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/repeat.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/scalar_literal_propagation.rs stdout ----
16           StorageLive(_2);
17           StorageLive(_3);
18 -         _3 = copy _1;
- -         _2 = consume(move _3) -> [return: bb1, unwind continue];
+ -         _2 = consume(move _3) -> [return: bb1, unwind: bb2];
20 +         _3 = const 1_u32;
- +         _2 = consume(const 1_u32) -> [return: bb1, unwind continue];
+ +         _2 = consume(const 1_u32) -> [return: bb1, unwind: bb2];
22       }
23   
24       bb1: {

27           _0 = const ();
---
31   }
32   


thread '[mir-opt] tests/mir-opt/const_prop/scalar_literal_propagation.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/scalar_literal_propagation.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/return_place.rs stdout ----
7   
8       bb0: {
9 -         _1 = AddWithOverflow(const 2_u32, const 2_u32);
- -         assert(!move (_1.1: bool), "attempt to compute `{} + {}`, which would overflow", const 2_u32, const 2_u32) -> [success: bb1, unwind continue];
+ -         assert(!move (_1.1: bool), "attempt to compute `{} + {}`, which would overflow", const 2_u32, const 2_u32) -> [success: bb1, unwind: bb2];
11 +         _1 = const (4_u32, false);
- +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 2_u32, const 2_u32) -> [success: bb1, unwind continue];
+ +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 2_u32, const 2_u32) -> [success: bb1, unwind: bb2];
13       }
14   
15       bb1: {

16 -         _0 = move (_1.0: u32);
17 +         _0 = const 4_u32;
18           return;
+       }
+   
+       bb2 (cleanup): {
+           resume;
19       }
20   }
21 + 


thread '[mir-opt] tests/mir-opt/const_prop/return_place.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/return_place.add.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/return_place.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/switch_int.rs stdout ----
13       }
14   
15       bb1: {
-           _0 = foo(const -1_i32) -> [return: bb3, unwind continue];
+           _0 = foo(const -1_i32) -> [return: bb3, unwind: bb4];
17       }
18   
19       bb2: {

-           _0 = foo(const 0_i32) -> [return: bb3, unwind continue];
+           _0 = foo(const 0_i32) -> [return: bb3, unwind: bb4];
21       }
22   
23       bb3: {

24           StorageDead(_1);
---
27   }
28   


thread '[mir-opt] tests/mir-opt/const_prop/switch_int.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/switch_int.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/slice_len.rs stdout ----
32           _6 = const 1_usize;
33 -         _7 = PtrMetadata(copy _2);
34 -         _8 = Lt(copy _6, copy _7);
- -         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
+ -         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind: bb2];
36 +         _7 = const 3_usize;
37 +         _8 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind: bb2];
39       }
40   
41       bb1: {

47           _0 = const ();
---
51   }
52   


thread '[mir-opt] tests/mir-opt/const_prop/slice_len.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/slice_len.rs stdout end ----
---- [mir-opt] tests/mir-opt/const_prop/tuple_literal_propagation.rs stdout ----
17           StorageLive(_2);
18           StorageLive(_3);
19 -         _3 = copy _1;
- -         _2 = consume(move _3) -> [return: bb1, unwind continue];
+ -         _2 = consume(move _3) -> [return: bb1, unwind: bb2];
21 +         _3 = const (1_u32, 2_u32);
- +         _2 = consume(const (1_u32, 2_u32)) -> [return: bb1, unwind continue];
+ +         _2 = consume(const (1_u32, 2_u32)) -> [return: bb1, unwind: bb2];
23       }
24   
25       bb1: {

28           _0 = const ();
---
32   }
33 + 


thread '[mir-opt] tests/mir-opt/const_prop/tuple_literal_propagation.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/const_prop/tuple_literal_propagation.rs stdout end ----
---- [mir-opt] tests/mir-opt/copy-prop/branch.rs stdout ----
16   
17       bb0: {
18           StorageLive(_1);
-           _1 = val() -> [return: bb1, unwind continue];
+           _1 = val() -> [return: bb1, unwind: bb7];
20       }
21   
22       bb1: {

23           StorageLive(_2);
24           StorageLive(_3);
-           _3 = cond() -> [return: bb2, unwind continue];
+           _3 = cond() -> [return: bb2, unwind: bb7];
26       }
27   
28       bb2: {

36   
37       bb4: {
38           StorageLive(_4);
-           _4 = val() -> [return: bb5, unwind continue];
+           _4 = val() -> [return: bb5, unwind: bb7];
40       }
41   
42       bb5: {

51           StorageDead(_2);
---
55   }
56   


thread '[mir-opt] tests/mir-opt/copy-prop/branch.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/copy-prop/branch.rs stdout end ----
---- [mir-opt] tests/mir-opt/copy-prop/calls.rs stdout ----
11   
12       bb0: {
13 -         StorageLive(_1);
- -         _1 = dummy(const 5_u8) -> [return: bb1, unwind continue];
- +         _0 = dummy(const 5_u8) -> [return: bb1, unwind continue];
+ -         _1 = dummy(const 5_u8) -> [return: bb1, unwind: bb2];
+ +         _0 = dummy(const 5_u8) -> [return: bb1, unwind: bb2];
16       }
17   
18       bb1: {

19 -         _0 = copy _1;
---
23   }
24   


thread '[mir-opt] tests/mir-opt/copy-prop/calls.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/copy-prop/calls.rs stdout end ----
---- [mir-opt] tests/mir-opt/copy-prop/copy_propagation_arg.rs stdout ----
11           StorageLive(_2);
12           StorageLive(_3);
13           _3 = copy _1;
-           _2 = dummy(move _3) -> [return: bb1, unwind continue];
+           _2 = dummy(move _3) -> [return: bb1, unwind: bb2];
15       }
16   
17       bb1: {

20           StorageDead(_2);
---
24   }
25   


thread '[mir-opt] tests/mir-opt/copy-prop/copy_propagation_arg.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/copy-prop/copy_propagation_arg.rs stdout end ----
---- [mir-opt] tests/mir-opt/copy-prop/cycle.rs stdout ----
22   
23       bb0: {
24           StorageLive(_1);
-           _1 = val() -> [return: bb1, unwind continue];
+           _1 = val() -> [return: bb1, unwind: bb3];
26       }
27   
28       bb1: {

38           StorageLive(_5);
39           StorageLive(_6);
40           _6 = copy _1;
-           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind continue];
+           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind: bb3];
42       }
43   
44       bb2: {

49           StorageDead(_2);
---
---- [mir-opt] tests/mir-opt/copy-prop/dead_stores_79191.rs stdout ----
17         _1 = copy _2;
18         StorageLive(_4);
19         _4 = copy _1;
-         _0 = id::<usize>(move _4) -> [return: bb1, unwind continue];
+         _0 = id::<usize>(move _4) -> [return: bb1, unwind: bb2];
21     }
22 
23     bb1: {

24         StorageDead(_4);
---
28 }
29 


thread '[mir-opt] tests/mir-opt/copy-prop/dead_stores_79191.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/copy-prop/dead_stores_79191.rs stdout end ----
---- [mir-opt] tests/mir-opt/copy-prop/issue_107511.rs stdout ----
48           _7 = &_2;
49           _6 = move _7 as &[i32] (PointerCoercion(Unsize, Implicit));
50           StorageDead(_7);
-           _5 = core::slice::<impl [i32]>::len(move _6) -> [return: bb1, unwind continue];
+           _5 = core::slice::<impl [i32]>::len(move _6) -> [return: bb1, unwind: bb9];
52       }
53   
54       bb1: {

55           StorageDead(_6);
56           _4 = std::ops::Range::<usize> { start: const 0_usize, end: move _5 };
57           StorageDead(_5);
-           _3 = <std::ops::Range<usize> as IntoIterator>::into_iter(move _4) -> [return: bb2, unwind continue];
+           _3 = <std::ops::Range<usize> as IntoIterator>::into_iter(move _4) -> [return: bb2, unwind: bb9];
59       }
60   
61       bb2: {

72           StorageLive(_13);
73           _13 = &mut _8;
74           _12 = &mut (*_13);
-           _11 = <std::ops::Range<usize> as Iterator>::next(move _12) -> [return: bb4, unwind continue];
+           _11 = <std::ops::Range<usize> as Iterator>::next(move _12) -> [return: bb4, unwind: bb9];
76       }
77   
78       bb4: {

92 -         StorageLive(_18);
93 -         _18 = copy _16;
94 -         _19 = Lt(copy _18, const 4_usize);
- -         assert(move _19, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _18) -> [success: bb8, unwind continue];
+ -         assert(move _19, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _18) -> [success: bb8, unwind: bb9];
96 +         _19 = Lt(copy _16, const 4_usize);
- +         assert(move _19, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _16) -> [success: bb8, unwind continue];
+ +         assert(move _19, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _16) -> [success: bb8, unwind: bb9];
98       }
99   
100       bb7: {

122 -         StorageDead(_10);
---
126   }
127   


thread '[mir-opt] tests/mir-opt/copy-prop/issue_107511.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/copy-prop/issue_107511.rs stdout end ----
---- [mir-opt] tests/mir-opt/copy-prop/reborrow.rs stdout ----
30           StorageLive(_5);
31 -         StorageLive(_6);
32 -         _6 = move _4;
- -         _5 = opaque::<&mut u8>(move _6) -> [return: bb1, unwind continue];
- +         _5 = opaque::<&mut u8>(copy _2) -> [return: bb1, unwind continue];
+ -         _5 = opaque::<&mut u8>(move _6) -> [return: bb1, unwind: bb2];
+ +         _5 = opaque::<&mut u8>(copy _2) -> [return: bb1, unwind: bb2];
35       }
36   
37       bb1: {

42           StorageDead(_3);
---
46   }
47   


thread '[mir-opt] tests/mir-opt/copy-prop/reborrow.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/copy-prop/reborrow.rs stdout end ----
---- [mir-opt] tests/mir-opt/coroutine/async_drop.rs stdout ----
49   
50       bb2: {
51           StorageDead(_3);
- -         drop(_1) -> [return: bb3, drop: bb6, unwind continue];
+ -         drop(_1) -> [return: bb3, unwind: bb9, drop: bb6];
53 +         drop(_1) -> [return: bb3, unwind: bb9];
54       }
55   

65   
66       bb5: {
67           StorageDead(_3);
- -         drop(_1) -> [return: bb6, unwind continue];
+ -         drop(_1) -> [return: bb6, unwind: bb9];
69 +         goto -> bb6;
70       }
71   


thread '[mir-opt] tests/mir-opt/coroutine/async_drop.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/coroutine/async_drop.simple-{closure#0}.ElaborateDrops.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/coroutine/async_drop.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/array_index.rs stdout ----
18           StorageLive(_3);
19           _3 = const 2_usize;
20 -         _4 = Lt(copy _3, const 4_usize);
- -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _3) -> [success: bb1, unwind continue];
+ -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 4_usize, copy _3) -> [success: bb1, unwind: bb2];
22 +         _4 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind: bb2];
24       }
25   
26       bb1: {

31           _0 = const ();
---
35   }
36   


thread '[mir-opt] tests/mir-opt/dataflow-const-prop/array_index.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dataflow-const-prop/array_index.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/checked.rs stdout ----
41           StorageLive(_5);
42 -         _5 = copy _2;
43 -         _6 = AddWithOverflow(copy _4, copy _5);
- -         assert(!move (_6.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, move _5) -> [success: bb1, unwind continue];
+ -         assert(!move (_6.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, move _5) -> [success: bb1, unwind: bb3];
45 +         _5 = const 2_i32;
46 +         _6 = const (3_i32, false);
- +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 1_i32, const 2_i32) -> [success: bb1, unwind continue];
+ +         assert(!const false, "attempt to compute `{} + {}`, which would overflow", const 1_i32, const 2_i32) -> [success: bb1, unwind: bb3];
48       }
49   
50       bb1: {

58           StorageLive(_9);
59 -         _9 = copy _7;
60 -         _10 = AddWithOverflow(copy _9, const 1_i32);
- -         assert(!move (_10.1: bool), "attempt to compute `{} + {}`, which would overflow", move _9, const 1_i32) -> [success: bb2, unwind continue];
+ -         assert(!move (_10.1: bool), "attempt to compute `{} + {}`, which would overflow", move _9, const 1_i32) -> [success: bb2, unwind: bb3];
62 +         _9 = const i32::MAX;
63 +         _10 = const (i32::MIN, true);
- +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const i32::MAX, const 1_i32) -> [success: bb2, unwind continue];
+ +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const i32::MAX, const 1_i32) -> [success: bb2, unwind: bb3];
65       }
66   
67       bb2: {

75           StorageDead(_2);
---
---- [mir-opt] tests/mir-opt/dataflow-const-prop/checked.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/inherit_overflow.rs stdout ----
20           _3 = const 1_u8;
21           StorageLive(_4);
22 -         _4 = AddWithOverflow(copy _2, copy _3);
- -         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind continue];
+ -         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb2, unwind: bb1];
24 +         _4 = const (0_u8, true);
- +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind continue];
+ +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb2, unwind: bb1];
26       }
27   
-       bb1: {
+       bb1 (cleanup): {
+           resume;
+       }
+   
+       bb2: {
29 -         _1 = move (_4.0: u8);
30 +         _1 = const 0_u8;
31           StorageDead(_4);


thread '[mir-opt] tests/mir-opt/dataflow-const-prop/inherit_overflow.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dataflow-const-prop/inherit_overflow.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/large_array_index.rs stdout ----
18           StorageLive(_3);
19           _3 = const 2_usize;
20 -         _4 = Lt(copy _3, const 5000_usize);
- -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 5000_usize, copy _3) -> [success: bb1, unwind continue];
+ -         assert(move _4, "index out of bounds: the length is {} but the index is {}", const 5000_usize, copy _3) -> [success: bb1, unwind: bb2];
22 +         _4 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind: bb2];
24       }
25   
26       bb1: {

31           _0 = const ();
---
35   }
36   


thread '[mir-opt] tests/mir-opt/dataflow-const-prop/large_array_index.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dataflow-const-prop/large_array_index.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/ref_without_sb.rs stdout ----
24           StorageLive(_4);
25           _4 = &_1;
26           _3 = &(*_4);
-           _2 = escape::<i32>(move _3) -> [return: bb1, unwind continue];
+           _2 = escape::<i32>(move _3) -> [return: bb1, unwind: bb3];
28       }
29   
30       bb1: {

33           StorageDead(_2);
34           _1 = const 1_i32;
35           StorageLive(_5);
-           _5 = some_function() -> [return: bb2, unwind continue];
+           _5 = some_function() -> [return: bb2, unwind: bb3];
37       }
38   
39       bb2: {

44           StorageDead(_6);
---
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dataflow-const-prop/ref_without_sb.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/repeat.rs stdout ----
20           StorageLive(_4);
21           _4 = const 2_usize;
22 -         _5 = Lt(copy _4, const 8_usize);
- -         assert(move _5, "index out of bounds: the length is {} but the index is {}", const 8_usize, copy _4) -> [success: bb1, unwind continue];
+ -         assert(move _5, "index out of bounds: the length is {} but the index is {}", const 8_usize, copy _4) -> [success: bb1, unwind: bb2];
24 +         _5 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind: bb2];
26       }
27   
28       bb1: {

35           _0 = const ();
---

thread '[mir-opt] tests/mir-opt/dataflow-const-prop/repeat.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dataflow-const-prop/repeat.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/slice_len.rs stdout ----
38           _6 = const 1_usize;
39 -         _7 = PtrMetadata(copy _2);
40 -         _8 = Lt(copy _6, copy _7);
- -         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
+ -         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind: bb3];
42 +         _7 = const 3_usize;
43 +         _8 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind: bb3];
45       }
46   
47       bb1: {

57           _11 = const 1_usize;
58 -         _12 = PtrMetadata(copy _10);
59 -         _13 = Lt(copy _11, copy _12);
- -         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind continue];
+ -         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind: bb3];
61 +         _12 = const 3_usize;
62 +         _13 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind: bb3];
64       }
65   
66       bb2: {

72           StorageDead(_9);
---
76   }
77   


thread '[mir-opt] tests/mir-opt/dataflow-const-prop/slice_len.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dataflow-const-prop/slice_len.rs stdout end ----
---- [mir-opt] tests/mir-opt/dataflow-const-prop/sibling_ptr.rs stdout ----
28           StorageLive(_4);
29           StorageLive(_5);
30           _5 = copy _3;
-           _4 = std::ptr::mut_ptr::<impl *mut u8>::add(move _5, const 1_usize) -> [return: bb1, unwind continue];
+           _4 = std::ptr::mut_ptr::<impl *mut u8>::add(move _5, const 1_usize) -> [return: bb1, unwind: bb2];
32       }
33   
34       bb1: {

44           StorageDead(_6);
---
---- [mir-opt] tests/mir-opt/dataflow-const-prop/terminator.rs stdout ----
22 +         _4 = const 1_i32;
23 +         _3 = const 2_i32;
24           StorageDead(_4);
- -         _2 = foo(move _3) -> [return: bb1, unwind continue];
- +         _2 = foo(const 2_i32) -> [return: bb1, unwind continue];
+ -         _2 = foo(move _3) -> [return: bb1, unwind: bb2];
+ +         _2 = foo(const 2_i32) -> [return: bb1, unwind: bb2];
27       }
28   
29       bb1: {

32           _0 = const ();
---
---- [mir-opt] tests/mir-opt/dead-store-elimination/call_arg_copy.rs stdout ----
10   
11       bb0: {
12           StorageLive(_2);
- -         _2 = use_both(copy _1, copy _1) -> [return: bb1, unwind continue];
- +         _2 = use_both(copy _1, move _1) -> [return: bb1, unwind continue];
+ -         _2 = use_both(copy _1, copy _1) -> [return: bb1, unwind: bb2];
+ +         _2 = use_both(copy _1, move _1) -> [return: bb1, unwind: bb2];
15       }
16   
17       bb1: {

18           StorageDead(_2);
---
---- [mir-opt] tests/mir-opt/derefer_inline_test.rs stdout ----
9       bb0: {
10           StorageLive(_1);
11           StorageLive(_2);
-           _2 = f() -> [return: bb1, unwind continue];
+           _2 = f() -> [return: bb1, unwind: bb5];
13       }
14   
15       bb1: {

18   
19       bb2: {
20           StorageDead(_2);
-           drop(_1) -> [return: bb3, unwind continue];
+           drop(_1) -> [return: bb3, unwind: bb5];
22       }
23   
24       bb3: {


thread '[mir-opt] tests/mir-opt/derefer_inline_test.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/derefer_inline_test.main.Derefer.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/derefer_inline_test.rs stdout end ----
---- [mir-opt] tests/mir-opt/derefer_complex_case.rs stdout ----
30           StorageLive(_2);
31           _14 = const main::promoted[0];
32           _2 = &(*_14);
-           _1 = <&[i32; 2] as IntoIterator>::into_iter(move _2) -> [return: bb1, unwind continue];
+           _1 = <&[i32; 2] as IntoIterator>::into_iter(move _2) -> [return: bb1, unwind: bb8];
34       }
35   
36       bb1: {

48           StorageLive(_9);
49           _9 = &mut _4;
50           _8 = &mut (*_9);
-           _7 = <std::slice::Iter<'_, i32> as Iterator>::next(move _8) -> [return: bb3, unwind continue];
+           _7 = <std::slice::Iter<'_, i32> as Iterator>::next(move _8) -> [return: bb3, unwind: bb8];
52       }
53   
54       bb3: {

69 +         _12 = copy (*_15);
70           StorageLive(_13);
71           _13 = copy _12;
-           _6 = std::mem::drop::<i32>(move _13) -> [return: bb7, unwind continue];
+           _6 = std::mem::drop::<i32>(move _13) -> [return: bb7, unwind: bb8];
73       }
74   
75       bb6: {

90           StorageDead(_6);
---
---- [mir-opt] tests/mir-opt/derefer_terminator_test.rs stdout ----
33   
34       bb0: {
35           StorageLive(_1);
-           _1 = foo() -> [return: bb1, unwind continue];
+           _1 = foo() -> [return: bb1, unwind: bb6];
37       }
38   
39       bb1: {

40           StorageLive(_2);
-           _2 = foo() -> [return: bb2, unwind continue];
+           _2 = foo() -> [return: bb2, unwind: bb6];
42       }
43   
44       bb2: {

89           StorageDead(_2);
---
---- [mir-opt] tests/mir-opt/dest-prop/branch.rs stdout ----
18   
19       bb0: {
20 -         StorageLive(_1);
- -         _1 = val() -> [return: bb1, unwind continue];
+ -         _1 = val() -> [return: bb1, unwind: bb7];
22 +         nop;
- +         _0 = val() -> [return: bb1, unwind continue];
+ +         _0 = val() -> [return: bb1, unwind: bb7];
24       }
25   
26       bb1: {

27 -         StorageLive(_2);
28 +         nop;
29           StorageLive(_3);
-           _3 = cond() -> [return: bb2, unwind continue];
+           _3 = cond() -> [return: bb2, unwind: bb7];
31       }
32   
33       bb2: {

42   
43       bb4: {
44           StorageLive(_4);
-           _4 = val() -> [return: bb5, unwind continue];
+           _4 = val() -> [return: bb5, unwind: bb7];
46       }
47   
48       bb5: {

61 +         nop;
---
65   }
66   


thread '[mir-opt] tests/mir-opt/dest-prop/branch.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dest-prop/branch.rs stdout end ----
---- [mir-opt] tests/mir-opt/dest-prop/copy_propagation_arg.rs stdout ----
11           StorageLive(_2);
12 -         StorageLive(_3);
13 -         _3 = copy _1;
- -         _2 = dummy(move _3) -> [return: bb1, unwind continue];
+ -         _2 = dummy(move _3) -> [return: bb1, unwind: bb2];
15 +         nop;
16 +         nop;
- +         _2 = dummy(move _1) -> [return: bb1, unwind continue];
+ +         _2 = dummy(move _1) -> [return: bb1, unwind: bb2];
18       }
19   
20       bb1: {

24           StorageDead(_2);
---
28   }
29   


thread '[mir-opt] tests/mir-opt/dest-prop/copy_propagation_arg.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dest-prop/copy_propagation_arg.rs stdout end ----
---- [mir-opt] tests/mir-opt/dest-prop/cycle.rs stdout ----
24       bb0: {
25 -         StorageLive(_1);
26 +         nop;
-           _1 = val() -> [return: bb1, unwind continue];
+           _1 = val() -> [return: bb1, unwind: bb3];
28       }
29   
30       bb1: {

47           StorageLive(_5);
48 -         StorageLive(_6);
49 -         _6 = copy _1;
- -         _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind continue];
+ -         _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind: bb3];
51 +         nop;
52 +         nop;
- +         _5 = std::mem::drop::<i32>(move _1) -> [return: bb2, unwind continue];
+ +         _5 = std::mem::drop::<i32>(move _1) -> [return: bb2, unwind: bb3];
54       }
55   
56       bb2: {

65 +         nop;
---

thread '[mir-opt] tests/mir-opt/dest-prop/cycle.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dest-prop/cycle.rs stdout end ----
---- [mir-opt] tests/mir-opt/dest-prop/dead_stores_79191.rs stdout ----
20         nop;
21         nop;
22         nop;
-         _0 = id::<usize>(move _1) -> [return: bb1, unwind continue];
+         _0 = id::<usize>(move _1) -> [return: bb1, unwind: bb2];
24     }
25 
26     bb1: {

27         nop;
---
31 }
32 


thread '[mir-opt] tests/mir-opt/dest-prop/dead_stores_79191.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dest-prop/dead_stores_79191.rs stdout end ----
---- [mir-opt] tests/mir-opt/dest-prop/dead_stores_better.rs stdout ----
20         nop;
21         nop;
22         nop;
-         _0 = id::<usize>(move _1) -> [return: bb1, unwind continue];
+         _0 = id::<usize>(move _1) -> [return: bb1, unwind: bb2];
24     }
25 
26     bb1: {

27         nop;
---
31 }
32 


thread '[mir-opt] tests/mir-opt/dest-prop/dead_stores_better.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dest-prop/dead_stores_better.rs stdout end ----
---- [mir-opt] tests/mir-opt/dest-prop/nrvo_borrowed.rs stdout ----
25           StorageLive(_6);
26           _6 = &mut _2;
27           _5 = &mut (*_6);
- -         _3 = move _4(move _5) -> [return: bb1, unwind continue];
- +         _3 = move _1(move _5) -> [return: bb1, unwind continue];
+ -         _3 = move _4(move _5) -> [return: bb1, unwind: bb2];
+ +         _3 = move _1(move _5) -> [return: bb1, unwind: bb2];
30       }
31   
32       bb1: {

38           _0 = copy _2;
---
42   }
43   


thread '[mir-opt] tests/mir-opt/dest-prop/nrvo_borrowed.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dest-prop/nrvo_borrowed.rs stdout end ----
---- [mir-opt] tests/mir-opt/dest-prop/simple.rs stdout ----
25           StorageLive(_6);
26           _6 = &mut _2;
27           _5 = &mut (*_6);
- -         _3 = move _4(move _5) -> [return: bb1, unwind continue];
- +         _3 = move _1(move _5) -> [return: bb1, unwind continue];
+ -         _3 = move _4(move _5) -> [return: bb1, unwind: bb2];
+ +         _3 = move _1(move _5) -> [return: bb1, unwind: bb2];
30       }
31   
32       bb1: {

38           _0 = copy _2;
---
42   }
43   


thread '[mir-opt] tests/mir-opt/dest-prop/simple.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dest-prop/simple.rs stdout end ----
---- [mir-opt] tests/mir-opt/dont_reset_cast_kind_without_updating_operand.rs stdout ----
41           StorageLive(_3);
42           StorageLive(_4);
43 -         _4 = ();
- -         _3 = Box::<()>::new(move _4) -> [return: bb1, unwind continue];
+ -         _3 = Box::<()>::new(move _4) -> [return: bb1, unwind: bb3];
45 +         _4 = const ();
- +         _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue];
+ +         _3 = Box::<()>::new(const ()) -> [return: bb1, unwind: bb3];
47       }
48   
49       bb1: {


thread '[mir-opt] tests/mir-opt/dont_reset_cast_kind_without_updating_operand.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/dont_reset_cast_kind_without_updating_operand.rs stdout end ----
---- [mir-opt] tests/mir-opt/funky_arms.rs stdout ----
74           _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
75           _22 = BitAnd(move _23, const 268435456_u32);
76           StorageDead(_23);
-           switchInt(copy _22) -> [0: bb10, otherwise: bb11];
+           switchInt(copy _22) -> [0: bb11, otherwise: bb12];
78       }
79   
80       bb4: {

97           StorageDead(_13);
98           StorageLive(_15);
99           _15 = copy _3;
- -         _0 = float_to_exponential_common_exact::<T>(move _9, move _10, move _11, move _12, move _15) -> [return: bb5, unwind continue];
- +         _0 = float_to_exponential_common_exact::<T>(copy _1, copy _2, move _11, move _12, copy _3) -> [return: bb5, unwind continue];
+ -         _0 = float_to_exponential_common_exact::<T>(move _9, move _10, move _11, move _12, move _15) -> [return: bb5, unwind: bb9];
+ +         _0 = float_to_exponential_common_exact::<T>(copy _1, copy _2, move _11, move _12, copy _3) -> [return: bb5, unwind: bb9];
102       }
103   
104       bb5: {

120           _18 = copy _5;
121           StorageLive(_19);
122           _19 = copy _3;
- -         _0 = float_to_exponential_common_shortest::<T>(move _16, move _17, move _18, move _19) -> [return: bb7, unwind continue];
- +         _0 = float_to_exponential_common_shortest::<T>(copy _1, copy _2, move _18, copy _3) -> [return: bb7, unwind continue];
+ -         _0 = float_to_exponential_common_shortest::<T>(move _16, move _17, move _18, move _19) -> [return: bb7, unwind: bb9];
+ +         _0 = float_to_exponential_common_shortest::<T>(copy _1, copy _2, move _18, copy _3) -> [return: bb7, unwind: bb9];
125       }
126   
127       bb7: {

139           return;
140       }
141   
-       bb9: {
-           _7 = discriminant(_6);
-           switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
+       bb9 (cleanup): {
+           resume;
145       }
146   
147       bb10: {

+           _7 = discriminant(_6);
+           switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb13];
+       }
+   
+       bb11: {
148           StorageDead(_22);
149           _6 = const Option::<usize>::None;
---
155           StorageLive(_24);
156           StorageLive(_25);

159           StorageDead(_25);
160           _6 = Option::<usize>::Some(move _24);
161           StorageDead(_24);
-           goto -> bb9;
+           goto -> bb10;
163       }
164   
-       bb12: {
+       bb13: {
166           unreachable;
167       }
168   }


thread '[mir-opt] tests/mir-opt/funky_arms.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/funky_arms.rs stdout end ----
---- [mir-opt] tests/mir-opt/gvn_clone.rs stdout ----
61           StorageDead(_2);
62           return;
---
65   
66 


thread '[mir-opt] tests/mir-opt/gvn_clone.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/gvn_clone.{impl#0}-clone.GVN.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/gvn_clone.rs stdout end ----
---- [mir-opt] tests/mir-opt/gvn_copy_constant_projection.rs stdout ----
20           StorageLive(_4);
21           _4 = const 0_usize;
22 -         _5 = Lt(copy _4, const 1_usize);
- -         assert(move _5, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _4) -> [success: bb1, unwind continue];
+ -         assert(move _5, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _4) -> [success: bb1, unwind: bb3];
24 +         _5 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 1_usize, const 0_usize) -> [success: bb1, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 1_usize, const 0_usize) -> [success: bb1, unwind: bb3];
26       }
27   
28       bb1: {

31           StorageLive(_7);
32           _7 = const 0_usize;
33 -         _8 = Lt(copy _7, const 1_usize);
- -         assert(move _8, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _7) -> [success: bb2, unwind continue];
+ -         assert(move _8, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _7) -> [success: bb2, unwind: bb3];
35 +         _8 = const true;
- +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 1_usize, const 0_usize) -> [success: bb2, unwind continue];
+ +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 1_usize, const 0_usize) -> [success: bb2, unwind: bb3];
37       }
38   
39       bb2: {

51           StorageDead(_7);
---
55   }
56   


thread '[mir-opt] tests/mir-opt/gvn_copy_constant_projection.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/gvn_copy_constant_projection.rs stdout end ----
---- [mir-opt] tests/mir-opt/gvn.rs stdout ----
202 +         _5 = Add(copy _1, copy _2);
203           StorageDead(_7);
204           StorageDead(_6);
- -         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind continue];
- +         _4 = opaque::<u64>(copy _5) -> [return: bb1, unwind continue];
+ -         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind: bb45];
+ +         _4 = opaque::<u64>(copy _5) -> [return: bb1, unwind: bb45];
207       }
208   
209       bb1: {

221 +         _9 = Mul(copy _1, copy _2);
222           StorageDead(_11);
223           StorageDead(_10);
- -         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind continue];
- +         _8 = opaque::<u64>(copy _9) -> [return: bb2, unwind continue];
+ -         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind: bb45];
+ +         _8 = opaque::<u64>(copy _9) -> [return: bb2, unwind: bb45];
226       }
227   
228       bb2: {

240 +         _13 = Sub(copy _1, copy _2);
241           StorageDead(_15);
242           StorageDead(_14);
- -         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind continue];
- +         _12 = opaque::<u64>(copy _13) -> [return: bb3, unwind continue];
+ -         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind: bb45];
+ +         _12 = opaque::<u64>(copy _13) -> [return: bb3, unwind: bb45];
245       }
246   
247       bb3: {

256           StorageLive(_19);
257           _19 = copy _2;
258 -         _20 = Eq(copy _19, const 0_u64);
- -         assert(!move _20, "attempt to divide `{}` by zero", copy _18) -> [success: bb4, unwind continue];
+ -         assert(!move _20, "attempt to divide `{}` by zero", copy _18) -> [success: bb4, unwind: bb45];
260 +         _20 = Eq(copy _2, const 0_u64);
- +         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb4, unwind continue];
+ +         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb4, unwind: bb45];
262       }
263   
264       bb4: {

266 +         _17 = Div(copy _1, copy _2);
267           StorageDead(_19);
268           StorageDead(_18);
- -         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind continue];
- +         _16 = opaque::<u64>(copy _17) -> [return: bb5, unwind continue];
+ -         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind: bb45];
+ +         _16 = opaque::<u64>(copy _17) -> [return: bb5, unwind: bb45];
271       }
272   
273       bb5: {

282           StorageLive(_24);
283           _24 = copy _2;
284 -         _25 = Eq(copy _24, const 0_u64);
- -         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _23) -> [success: bb6, unwind continue];
+ -         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _23) -> [success: bb6, unwind: bb45];
286 +         _25 = copy _20;
- +         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb6, unwind continue];
+ +         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb6, unwind: bb45];
288       }
289   
290       bb6: {

292 +         _22 = Rem(copy _1, copy _2);
293           StorageDead(_24);
294           StorageDead(_23);
- -         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind continue];
- +         _21 = opaque::<u64>(copy _22) -> [return: bb7, unwind continue];
+ -         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind: bb45];
+ +         _21 = opaque::<u64>(copy _22) -> [return: bb7, unwind: bb45];
297       }
298   
299       bb7: {

311 +         _27 = BitAnd(copy _1, copy _2);
312           StorageDead(_29);
313           StorageDead(_28);
- -         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind continue];
- +         _26 = opaque::<u64>(copy _27) -> [return: bb8, unwind continue];
+ -         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind: bb45];
+ +         _26 = opaque::<u64>(copy _27) -> [return: bb8, unwind: bb45];
316       }
317   
318       bb8: {

330 +         _31 = BitOr(copy _1, copy _2);
331           StorageDead(_33);
332           StorageDead(_32);
- -         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind continue];
- +         _30 = opaque::<u64>(copy _31) -> [return: bb9, unwind continue];
+ -         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind: bb45];
+ +         _30 = opaque::<u64>(copy _31) -> [return: bb9, unwind: bb45];
335       }
336   
337       bb9: {

349 +         _35 = BitXor(copy _1, copy _2);
350           StorageDead(_37);
351           StorageDead(_36);
- -         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind continue];
- +         _34 = opaque::<u64>(copy _35) -> [return: bb10, unwind continue];
+ -         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind: bb45];
+ +         _34 = opaque::<u64>(copy _35) -> [return: bb10, unwind: bb45];
354       }
355   
356       bb10: {

368 +         _39 = Shl(copy _1, copy _2);
369           StorageDead(_41);
370           StorageDead(_40);
- -         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind continue];
- +         _38 = opaque::<u64>(copy _39) -> [return: bb11, unwind continue];
+ -         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind: bb45];
+ +         _38 = opaque::<u64>(copy _39) -> [return: bb11, unwind: bb45];
373       }
374   
375       bb11: {

387 +         _43 = Shr(copy _1, copy _2);
388           StorageDead(_45);
389           StorageDead(_44);
- -         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind continue];
- +         _42 = opaque::<u64>(copy _43) -> [return: bb12, unwind continue];
+ -         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind: bb45];
+ +         _42 = opaque::<u64>(copy _43) -> [return: bb12, unwind: bb45];
392       }
393   
394       bb12: {

403 -         _47 = move _48 as u32 (IntToInt);
404 +         _47 = copy _1 as u32 (IntToInt);
405           StorageDead(_48);
- -         _46 = opaque::<u32>(move _47) -> [return: bb13, unwind continue];
- +         _46 = opaque::<u32>(copy _47) -> [return: bb13, unwind continue];
+ -         _46 = opaque::<u32>(move _47) -> [return: bb13, unwind: bb45];
+ +         _46 = opaque::<u32>(copy _47) -> [return: bb13, unwind: bb45];
408       }
409   
410       bb13: {

419 -         _50 = move _51 as f32 (IntToFloat);
420 +         _50 = copy _1 as f32 (IntToFloat);
421           StorageDead(_51);
- -         _49 = opaque::<f32>(move _50) -> [return: bb14, unwind continue];
- +         _49 = opaque::<f32>(copy _50) -> [return: bb14, unwind continue];
+ -         _49 = opaque::<f32>(move _50) -> [return: bb14, unwind: bb45];
+ +         _49 = opaque::<f32>(copy _50) -> [return: bb14, unwind: bb45];
424       }
425   
426       bb14: {

435 -         _53 = S::<u64>(move _54);
436 +         _53 = S::<u64>(copy _1);
437           StorageDead(_54);
- -         _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind continue];
- +         _52 = opaque::<S<u64>>(copy _53) -> [return: bb15, unwind continue];
+ -         _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind: bb45];
+ +         _52 = opaque::<S<u64>>(copy _53) -> [return: bb15, unwind: bb45];
440       }
441   
442       bb15: {

452 +         _57 = copy _53;
453           StorageDead(_58);
454 -         _56 = copy (_57.0: u64);
- -         _55 = opaque::<u64>(move _56) -> [return: bb16, unwind continue];
+ -         _55 = opaque::<u64>(move _56) -> [return: bb16, unwind: bb45];
456 +         _56 = copy _1;
- +         _55 = opaque::<u64>(copy _1) -> [return: bb16, unwind continue];
+ +         _55 = opaque::<u64>(copy _1) -> [return: bb16, unwind: bb45];
458       }
459   
460       bb16: {

471 +         _60 = copy _5;
472           StorageDead(_62);
473           StorageDead(_61);
- -         _59 = opaque::<u64>(move _60) -> [return: bb17, unwind continue];
- +         _59 = opaque::<u64>(copy _5) -> [return: bb17, unwind continue];
+ -         _59 = opaque::<u64>(move _60) -> [return: bb17, unwind: bb45];
+ +         _59 = opaque::<u64>(copy _5) -> [return: bb17, unwind: bb45];
476       }
477   
478       bb17: {

488 +         _64 = copy _9;
489           StorageDead(_66);
490           StorageDead(_65);
- -         _63 = opaque::<u64>(move _64) -> [return: bb18, unwind continue];
- +         _63 = opaque::<u64>(copy _9) -> [return: bb18, unwind continue];
+ -         _63 = opaque::<u64>(move _64) -> [return: bb18, unwind: bb45];
+ +         _63 = opaque::<u64>(copy _9) -> [return: bb18, unwind: bb45];
493       }
494   
495       bb18: {

505 +         _68 = copy _13;
506           StorageDead(_70);
507           StorageDead(_69);
- -         _67 = opaque::<u64>(move _68) -> [return: bb19, unwind continue];
- +         _67 = opaque::<u64>(copy _13) -> [return: bb19, unwind continue];
+ -         _67 = opaque::<u64>(move _68) -> [return: bb19, unwind: bb45];
+ +         _67 = opaque::<u64>(copy _13) -> [return: bb19, unwind: bb45];
510       }
511   
512       bb19: {

519           StorageLive(_74);
520           _74 = copy _2;
521 -         _75 = Eq(copy _74, const 0_u64);
- -         assert(!move _75, "attempt to divide `{}` by zero", copy _73) -> [success: bb20, unwind continue];
+ -         assert(!move _75, "attempt to divide `{}` by zero", copy _73) -> [success: bb20, unwind: bb45];
523 +         _75 = copy _20;
- +         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb20, unwind continue];
+ +         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb20, unwind: bb45];
525       }
526   
527       bb20: {

529 +         _72 = copy _17;
530           StorageDead(_74);
531           StorageDead(_73);
- -         _71 = opaque::<u64>(move _72) -> [return: bb21, unwind continue];
- +         _71 = opaque::<u64>(copy _17) -> [return: bb21, unwind continue];
+ -         _71 = opaque::<u64>(move _72) -> [return: bb21, unwind: bb45];
+ +         _71 = opaque::<u64>(copy _17) -> [return: bb21, unwind: bb45];
534       }
535   
536       bb21: {

543           StorageLive(_79);
544           _79 = copy _2;
545 -         _80 = Eq(copy _79, const 0_u64);
- -         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _78) -> [success: bb22, unwind continue];
+ -         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _78) -> [success: bb22, unwind: bb45];
547 +         _80 = copy _20;
- +         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb22, unwind continue];
+ +         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb22, unwind: bb45];
549       }
550   
551       bb22: {

553 +         _77 = copy _22;
554           StorageDead(_79);
555           StorageDead(_78);
- -         _76 = opaque::<u64>(move _77) -> [return: bb23, unwind continue];
- +         _76 = opaque::<u64>(copy _22) -> [return: bb23, unwind continue];
+ -         _76 = opaque::<u64>(move _77) -> [return: bb23, unwind: bb45];
+ +         _76 = opaque::<u64>(copy _22) -> [return: bb23, unwind: bb45];
558       }
559   
560       bb23: {

570 +         _82 = copy _27;
571           StorageDead(_84);
572           StorageDead(_83);
- -         _81 = opaque::<u64>(move _82) -> [return: bb24, unwind continue];
- +         _81 = opaque::<u64>(copy _27) -> [return: bb24, unwind continue];
+ -         _81 = opaque::<u64>(move _82) -> [return: bb24, unwind: bb45];
+ +         _81 = opaque::<u64>(copy _27) -> [return: bb24, unwind: bb45];
575       }
576   
577       bb24: {

587 +         _86 = copy _31;
588           StorageDead(_88);
589           StorageDead(_87);
- -         _85 = opaque::<u64>(move _86) -> [return: bb25, unwind continue];
- +         _85 = opaque::<u64>(copy _31) -> [return: bb25, unwind continue];
+ -         _85 = opaque::<u64>(move _86) -> [return: bb25, unwind: bb45];
+ +         _85 = opaque::<u64>(copy _31) -> [return: bb25, unwind: bb45];
592       }
593   
594       bb25: {

604 +         _90 = copy _35;
605           StorageDead(_92);
606           StorageDead(_91);
- -         _89 = opaque::<u64>(move _90) -> [return: bb26, unwind continue];
- +         _89 = opaque::<u64>(copy _35) -> [return: bb26, unwind continue];
+ -         _89 = opaque::<u64>(move _90) -> [return: bb26, unwind: bb45];
+ +         _89 = opaque::<u64>(copy _35) -> [return: bb26, unwind: bb45];
609       }
610   
611       bb26: {

621 +         _94 = copy _39;
622           StorageDead(_96);
623           StorageDead(_95);
- -         _93 = opaque::<u64>(move _94) -> [return: bb27, unwind continue];
- +         _93 = opaque::<u64>(copy _39) -> [return: bb27, unwind continue];
+ -         _93 = opaque::<u64>(move _94) -> [return: bb27, unwind: bb45];
+ +         _93 = opaque::<u64>(copy _39) -> [return: bb27, unwind: bb45];
626       }
627   
628       bb27: {

638 +         _98 = copy _43;
639           StorageDead(_100);
640           StorageDead(_99);
- -         _97 = opaque::<u64>(move _98) -> [return: bb28, unwind continue];
- +         _97 = opaque::<u64>(copy _43) -> [return: bb28, unwind continue];
+ -         _97 = opaque::<u64>(move _98) -> [return: bb28, unwind: bb45];
+ +         _97 = opaque::<u64>(copy _43) -> [return: bb28, unwind: bb45];
643       }
644   
645       bb28: {

652 -         _102 = move _103 as u32 (IntToInt);
653 +         _102 = copy _47;
654           StorageDead(_103);
- -         _101 = opaque::<u32>(move _102) -> [return: bb29, unwind continue];
- +         _101 = opaque::<u32>(copy _47) -> [return: bb29, unwind continue];
+ -         _101 = opaque::<u32>(move _102) -> [return: bb29, unwind: bb45];
+ +         _101 = opaque::<u32>(copy _47) -> [return: bb29, unwind: bb45];
657       }
658   
659       bb29: {

666 -         _105 = move _106 as f32 (IntToFloat);
667 +         _105 = copy _50;
668           StorageDead(_106);
- -         _104 = opaque::<f32>(move _105) -> [return: bb30, unwind continue];
- +         _104 = opaque::<f32>(copy _50) -> [return: bb30, unwind continue];
+ -         _104 = opaque::<f32>(move _105) -> [return: bb30, unwind: bb45];
+ +         _104 = opaque::<f32>(copy _50) -> [return: bb30, unwind: bb45];
671       }
672   
673       bb30: {

680 -         _108 = S::<u64>(move _109);
681 +         _108 = copy _53;
682           StorageDead(_109);
- -         _107 = opaque::<S<u64>>(move _108) -> [return: bb31, unwind continue];
- +         _107 = opaque::<S<u64>>(copy _53) -> [return: bb31, unwind continue];
+ -         _107 = opaque::<S<u64>>(move _108) -> [return: bb31, unwind: bb45];
+ +         _107 = opaque::<S<u64>>(copy _53) -> [return: bb31, unwind: bb45];
685       }
686   
687       bb31: {

696 +         _112 = copy _53;
697           StorageDead(_113);
698 -         _111 = copy (_112.0: u64);
- -         _110 = opaque::<u64>(move _111) -> [return: bb32, unwind continue];
+ -         _110 = opaque::<u64>(move _111) -> [return: bb32, unwind: bb45];
700 +         _111 = copy _1;
- +         _110 = opaque::<u64>(copy _1) -> [return: bb32, unwind continue];
+ +         _110 = opaque::<u64>(copy _1) -> [return: bb32, unwind: bb45];
702       }
703   
704       bb32: {

723 +         _115 = Sub(copy _9, copy _2);
724           StorageDead(_119);
725           StorageDead(_116);
- -         _114 = opaque::<u64>(move _115) -> [return: bb33, unwind continue];
- +         _114 = opaque::<u64>(copy _115) -> [return: bb33, unwind continue];
+ -         _114 = opaque::<u64>(move _115) -> [return: bb33, unwind: bb45];
+ +         _114 = opaque::<u64>(copy _115) -> [return: bb33, unwind: bb45];
728       }
729   
730       bb33: {

748 +         _121 = copy _115;
749           StorageDead(_125);
750           StorageDead(_122);
- -         _120 = opaque::<u64>(move _121) -> [return: bb34, unwind continue];
- +         _120 = opaque::<u64>(copy _115) -> [return: bb34, unwind continue];
+ -         _120 = opaque::<u64>(move _121) -> [return: bb34, unwind: bb45];
+ +         _120 = opaque::<u64>(copy _115) -> [return: bb34, unwind: bb45];
753       }
754   
755       bb34: {

769 +         _128 = Add(copy _129, copy _1);
770           StorageDead(_130);
771 -         StorageDead(_129);
- -         _127 = opaque::<u64>(move _128) -> [return: bb35, unwind continue];
+ -         _127 = opaque::<u64>(move _128) -> [return: bb35, unwind: bb45];
773 +         nop;
- +         _127 = opaque::<u64>(copy _128) -> [return: bb35, unwind continue];
+ +         _127 = opaque::<u64>(copy _128) -> [return: bb35, unwind: bb45];
775       }
776   
777       bb35: {

789 +         _132 = copy _128;
790           StorageDead(_134);
791           StorageDead(_133);
- -         _131 = opaque::<u64>(move _132) -> [return: bb36, unwind continue];
- +         _131 = opaque::<u64>(copy _128) -> [return: bb36, unwind continue];
+ -         _131 = opaque::<u64>(move _132) -> [return: bb36, unwind: bb45];
+ +         _131 = opaque::<u64>(copy _128) -> [return: bb36, unwind: bb45];
794       }
795   
796       bb36: {

808 +         _137 = Add(move _138, copy _1);
809           StorageDead(_139);
810           StorageDead(_138);
-           _136 = opaque::<u64>(move _137) -> [return: bb37, unwind continue];
+           _136 = opaque::<u64>(move _137) -> [return: bb37, unwind: bb45];
812       }
813   
814       bb37: {

824 +         _141 = Add(move _142, copy _1);
825           StorageDead(_143);
826           StorageDead(_142);
-           _140 = opaque::<u64>(move _141) -> [return: bb38, unwind continue];
+           _140 = opaque::<u64>(move _141) -> [return: bb38, unwind: bb45];
828       }
829   
830       bb38: {

843 +         _147 = Add(move _148, copy _1);
844           StorageDead(_149);
845           StorageDead(_148);
-           _146 = opaque::<u64>(move _147) -> [return: bb39, unwind continue];
+           _146 = opaque::<u64>(move _147) -> [return: bb39, unwind: bb45];
847       }
848   
849       bb39: {

859 +         _151 = Add(move _152, copy _1);
860           StorageDead(_153);
861           StorageDead(_152);
-           _150 = opaque::<u64>(move _151) -> [return: bb40, unwind continue];
+           _150 = opaque::<u64>(move _151) -> [return: bb40, unwind: bb45];
863       }
864   
865       bb40: {

877 +         _156 = Add(move _157, copy _1);
878           StorageDead(_158);
879           StorageDead(_157);
-           _155 = opaque::<u64>(move _156) -> [return: bb41, unwind continue];
+           _155 = opaque::<u64>(move _156) -> [return: bb41, unwind: bb45];
881       }
882   
883       bb41: {

893 +         _160 = Add(move _161, copy _1);
894           StorageDead(_162);
895           StorageDead(_161);
-           _159 = opaque::<u64>(move _160) -> [return: bb42, unwind continue];
+           _159 = opaque::<u64>(move _160) -> [return: bb42, unwind: bb45];
897       }
898   
899       bb42: {

917 +         _165 = Add(copy _166, copy _1);
918           StorageDead(_167);
919 -         StorageDead(_166);
- -         _164 = opaque::<u64>(move _165) -> [return: bb43, unwind continue];
+ -         _164 = opaque::<u64>(move _165) -> [return: bb43, unwind: bb45];
921 +         nop;
- +         _164 = opaque::<u64>(copy _165) -> [return: bb43, unwind continue];
+ +         _164 = opaque::<u64>(copy _165) -> [return: bb43, unwind: bb45];
923       }
924   
925       bb43: {

937 +         _169 = copy _165;
938           StorageDead(_171);
939           StorageDead(_170);
- -         _168 = opaque::<u64>(move _169) -> [return: bb44, unwind continue];
- +         _168 = opaque::<u64>(copy _165) -> [return: bb44, unwind continue];
+ -         _168 = opaque::<u64>(move _169) -> [return: bb44, unwind: bb45];
+ +         _168 = opaque::<u64>(copy _165) -> [return: bb44, unwind: bb45];
942       }
943   
944       bb44: {

949           StorageDead(_135);
---
953   }
954   


thread '[mir-opt] tests/mir-opt/gvn.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/gvn.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/caller_with_trivial_bound.rs stdout ----
10   
11       bb0: {
12           StorageLive(_1);
-           _1 = bar::<T>() -> [return: bb1, unwind continue];
+           _1 = bar::<T>() -> [return: bb1, unwind: bb3];
14       }
15   
16       bb1: {


thread '[mir-opt] tests/mir-opt/inline/caller_with_trivial_bound.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/caller_with_trivial_bound.foo.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/caller_with_trivial_bound.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/cycle.rs stdout ----
7   
8       bb0: {
9           StorageLive(_1);
-           _1 = f::<fn() {main}>(main) -> [return: bb1, unwind continue];
+           _1 = f::<fn() {main}>(main) -> [return: bb1, unwind: bb2];
11       }
12   
13       bb1: {

14           StorageDead(_1);
---
18   }
19   


thread '[mir-opt] tests/mir-opt/inline/cycle.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/cycle.g.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/cycle.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/asm_unwind.rs stdout ----
13   
14       bb0: {
15           StorageLive(_1);
- -         _1 = foo() -> [return: bb1, unwind continue];
+ -         _1 = foo() -> [return: bb1, unwind: bb2];
17 +         StorageLive(_2);
- +         asm!("", options(MAY_UNWIND)) -> [return: bb2, unwind: bb3];
+ +         asm!("", options(MAY_UNWIND)) -> [return: bb3, unwind: bb4];
19       }
20   
-       bb1: {
+ -     bb1: {
+ +     bb1 (cleanup): {
+ +         resume;
+ +     }
+ + 
+ +     bb2: {
22 +         StorageDead(_2);
23           StorageDead(_1);
24           _0 = const ();

25           return;
+       }
+   
+ -     bb2 (cleanup): {
+ -         resume;
+ +     bb3: {
+ +         drop(_2) -> [return: bb2, unwind: bb1];
26 +     }
27 + 
- +     bb2: {
- +         drop(_2) -> [return: bb1, unwind continue];
- +     }
- + 
- +     bb3 (cleanup): {
- +         drop(_2) -> [return: bb4, unwind terminate(cleanup)];
- +     }
- + 
36 +     bb4 (cleanup): {
- +         resume;
+ +         drop(_2) -> [return: bb1, unwind terminate(cleanup)];
38       }
39   }
40   


---
---- [mir-opt] tests/mir-opt/inline/forced.rs stdout ----
9   
10       bb0: {
11           StorageLive(_1);
- -         _1 = callee_forced() -> [return: bb1, unwind continue];
+ -         _1 = callee_forced() -> [return: bb1, unwind: bb2];
13 -     }
14 - 
15 -     bb1: {

16           StorageDead(_1);
17           _0 = const ();
18           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
19       }
20   }
21   


---
---- [mir-opt] tests/mir-opt/inline/dyn_trait.rs stdout ----
9       bb0: {
10           StorageLive(_2);
11           _2 = copy _1;
-           _0 = <dyn Cache<V = V> as Cache>::store_nocache(move _2) -> [return: bb1, unwind continue];
+           _0 = <dyn Cache<V = V> as Cache>::store_nocache(move _2) -> [return: bb1, unwind: bb2];
13       }
14   
15       bb1: {

16           StorageDead(_2);
---
19   }
20   


thread '[mir-opt] tests/mir-opt/inline/dyn_trait.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/dyn_trait.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/exponential_runtime.rs stdout ----
37   
38       bb0: {
39           StorageLive(_1);
- -         _1 = <() as G>::call() -> [return: bb1, unwind continue];
+ -         _1 = <() as G>::call() -> [return: bb1, unwind: bb2];
41 +         StorageLive(_2);
42 +         StorageLive(_3);
43 +         StorageLive(_4);

56 +         StorageLive(_17);
57 +         StorageLive(_18);
58 +         StorageLive(_19);
- +         _17 = <() as A>::call() -> [return: bb12, unwind continue];
+ +         _17 = <() as A>::call() -> [return: bb13, unwind: bb1];
60       }
61   
-       bb1: {
+ -     bb1: {
+ +     bb1 (cleanup): {
+ +         resume;
+ +     }
+ + 
+ +     bb2: {
63 +         StorageDead(_4);
64 +         StorageDead(_3);
65 +         StorageDead(_2);

66           StorageDead(_1);
67           _0 = const ();
68           return;
+       }
+   
+ -     bb2 (cleanup): {
+ -         resume;
+ +     bb3: {
+ +         _4 = <() as F>::call() -> [return: bb2, unwind: bb1];
69 +     }
70 + 
- +     bb2: {
- +         _4 = <() as F>::call() -> [return: bb1, unwind continue];
- +     }
- + 
- +     bb3: {
+ +     bb4: {
76 +         StorageDead(_7);
77 +         StorageDead(_6);
78 +         StorageDead(_5);

- +         _3 = <() as F>::call() -> [return: bb2, unwind continue];
+ +         _3 = <() as F>::call() -> [return: bb3, unwind: bb1];
80 +     }
81 + 
- +     bb4: {
- +         _7 = <() as E>::call() -> [return: bb3, unwind continue];
+ +     bb5: {
+ +         _7 = <() as E>::call() -> [return: bb4, unwind: bb1];
84 +     }
85 + 
- +     bb5: {
+ +     bb6: {
87 +         StorageDead(_10);
88 +         StorageDead(_9);
89 +         StorageDead(_8);

- +         _6 = <() as E>::call() -> [return: bb4, unwind continue];
+ +         _6 = <() as E>::call() -> [return: bb5, unwind: bb1];
91 +     }
92 + 
- +     bb6: {
- +         _10 = <() as D>::call() -> [return: bb5, unwind continue];
+ +     bb7: {
+ +         _10 = <() as D>::call() -> [return: bb6, unwind: bb1];
95 +     }
96 + 
- +     bb7: {
+ +     bb8: {
98 +         StorageDead(_13);
99 +         StorageDead(_12);
100 +         StorageDead(_11);

- +         _9 = <() as D>::call() -> [return: bb6, unwind continue];
+ +         _9 = <() as D>::call() -> [return: bb7, unwind: bb1];
102 +     }
103 + 
- +     bb8: {
- +         _13 = <() as C>::call() -> [return: bb7, unwind continue];
+ +     bb9: {
+ +         _13 = <() as C>::call() -> [return: bb8, unwind: bb1];
106 +     }
107 + 
- +     bb9: {
+ +     bb10: {
109 +         StorageDead(_16);
110 +         StorageDead(_15);
111 +         StorageDead(_14);

- +         _12 = <() as C>::call() -> [return: bb8, unwind continue];
+ +         _12 = <() as C>::call() -> [return: bb9, unwind: bb1];
113 +     }
114 + 
- +     bb10: {
- +         _16 = <() as B>::call() -> [return: bb9, unwind continue];
+ +     bb11: {
+ +         _16 = <() as B>::call() -> [return: bb10, unwind: bb1];
117 +     }
118 + 
- +     bb11: {
+ +     bb12: {
120 +         StorageDead(_19);
121 +         StorageDead(_18);
122 +         StorageDead(_17);

- +         _15 = <() as B>::call() -> [return: bb10, unwind continue];
+ +         _15 = <() as B>::call() -> [return: bb11, unwind: bb1];
124 +     }
125 + 
- +     bb12: {
- +         _18 = <() as A>::call() -> [return: bb13, unwind continue];
+ +     bb13: {
+ +         _18 = <() as A>::call() -> [return: bb14, unwind: bb1];
128 +     }
129 + 
- +     bb13: {
- +         _19 = <() as A>::call() -> [return: bb11, unwind continue];
+ +     bb14: {
+ +         _19 = <() as A>::call() -> [return: bb12, unwind: bb1];
132       }
133   }
134   


---
---- [mir-opt] tests/mir-opt/inline/forced_closure_inherent.rs stdout ----
9   
10       bb0: {
11           StorageLive(_2);
- -         _2 = Foo::callee_forced() -> [return: bb1, unwind continue];
+ -         _2 = Foo::callee_forced() -> [return: bb1, unwind: bb2];
13 -     }
14 - 
15 -     bb1: {

16           StorageDead(_2);
17           _0 = const ();
18           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
19       }
20   }
21   


thread '[mir-opt] tests/mir-opt/inline/forced_closure_inherent.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/forced_closure_inherent.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/forced_inherent.rs stdout ----
9   
10       bb0: {
11           StorageLive(_1);
- -         _1 = Foo::bar() -> [return: bb1, unwind continue];
+ -         _1 = Foo::bar() -> [return: bb1, unwind: bb2];
13 -     }
14 - 
15 -     bb1: {

16           StorageDead(_1);
17           _0 = const ();
18           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
19       }
20   }
21   


---
---- [mir-opt] tests/mir-opt/inline/forced_closure.rs stdout ----
9   
10       bb0: {
11           StorageLive(_2);
- -         _2 = callee_forced() -> [return: bb1, unwind continue];
+ -         _2 = callee_forced() -> [return: bb1, unwind: bb2];
13 -     }
14 - 
15 -     bb1: {

16           StorageDead(_2);
17           _0 = const ();
18           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
19       }
20   }
21   


thread '[mir-opt] tests/mir-opt/inline/forced_closure.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/forced_closure.caller-{closure#0}.ForceInline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/forced_closure.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/forced_dead_code.rs stdout ----
9   
10       bb0: {
11           StorageLive(_1);
- -         _1 = callee_forced() -> [return: bb1, unwind continue];
+ -         _1 = callee_forced() -> [return: bb1, unwind: bb2];
13 -     }
14 - 
15 -     bb1: {

16           StorageDead(_1);
17           _0 = const ();
18           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
19       }
20   }
21   


---
---- [mir-opt] tests/mir-opt/inline/forced_inherent_ambiguous.rs stdout ----
9   
10       bb0: {
11           StorageLive(_1);
- -         _1 = Foo::bar() -> [return: bb1, unwind continue];
+ -         _1 = Foo::bar() -> [return: bb1, unwind: bb2];
13 -     }
14 - 
15 -     bb1: {

16           StorageDead(_1);
17           _0 = const ();
18           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
19       }
20   }
21   


---
---- [mir-opt] tests/mir-opt/inline/forced_inherent_dead_code.rs stdout ----
9   
10       bb0: {
11           StorageLive(_1);
- -         _1 = Foo::callee_forced() -> [return: bb1, unwind continue];
+ -         _1 = Foo::callee_forced() -> [return: bb1, unwind: bb2];
13 -     }
14 - 
15 -     bb1: {

16           StorageDead(_1);
17           _0 = const ();
18           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
19       }
20   }
21   


---
---- [mir-opt] tests/mir-opt/inline/inline_coroutine.rs stdout ----
30           StorageLive(_2);
31           StorageLive(_3);
32           StorageLive(_4);
- -         _4 = g() -> [return: bb1, unwind continue];
+ -         _4 = g() -> [return: bb1, unwind: bb6];
34 +         _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)};
35 +         _3 = &mut _4;
36 +         _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { pointer: copy _3 };


thread '[mir-opt] tests/mir-opt/inline/inline_coroutine.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/inline_coroutine.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/inline_cycle_generic.rs stdout ----
13   
14       bb0: {
15           StorageLive(_1);
- -         _1 = <C as Call>::call() -> [return: bb1, unwind continue];
- +         _1 = <B<C> as Call>::call() -> [return: bb1, unwind continue];
+ -         _1 = <C as Call>::call() -> [return: bb1, unwind: bb2];
+ +         _1 = <B<C> as Call>::call() -> [return: bb2, unwind: bb1];
18       }
19   
-       bb1: {
+ -     bb1: {
+ +     bb1 (cleanup): {
+ +         resume;
+ +     }
+ + 
+ +     bb2: {
21           StorageDead(_1);
22           _0 = const ();
23           return;

+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
24       }
25   }
26   


---
---- [mir-opt] tests/mir-opt/inline/inline_cycle.rs stdout ----
13   
14       bb0: {
15           StorageLive(_1);
-           _1 = <C as Call>::call() -> [return: bb1, unwind continue];
+ -         _1 = <C as Call>::call() -> [return: bb1, unwind: bb2];
+ +         _1 = <C as Call>::call() -> [return: bb2, unwind: bb1];
17       }
18   
-       bb1: {
+ -     bb1: {
+ +     bb1 (cleanup): {
+ +         resume;
+ +     }
+ + 
+ +     bb2: {
20           StorageDead(_1);
21           _0 = const ();
22           return;

+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
23       }
24   }
25   


---
- +     }
- + 
+       }
+   
+ -     bb1 (cleanup): {
+ -         resume;
17 +     bb1: {
18 +         goto -> bb1;
19       }


---
---- [mir-opt] tests/mir-opt/inline/inline_empty_drop_glue.rs stdout ----
14       bb0: {
15           StorageLive(_2);
16           _2 = copy _1;
- -         _0 = drop_in_place::<[char]>(move _2) -> [return: bb1, unwind continue];
+ -         _0 = drop_in_place::<[char]>(move _2) -> [return: bb1, unwind: bb2];
18 -     }
19 - 
20 -     bb1: {

23 +         StorageDead(_3);
24           StorageDead(_2);
25           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
26       }
27   }
28   


---
---- [mir-opt] tests/mir-opt/inline/inline_options.rs stdout ----
12 
13     bb0: {
14         StorageLive(_1);
-         _1 = not_inlined() -> [return: bb1, unwind continue];
+         _1 = not_inlined() -> [return: bb1, unwind: bb2];
16     }
17 
18     bb1: {

21         StorageLive(_3);
22         StorageLive(_4);
23         StorageLive(_5);
-         _3 = g() -> [return: bb3, unwind continue];
+         _3 = g() -> [return: bb4, unwind: bb2];
25     }
26 
-     bb2: {
+     bb2 (cleanup): {
+         resume;
---
33         return;
34     }
35 
-     bb3: {
-         _4 = g() -> [return: bb4, unwind continue];
+     bb4: {
+         _4 = g() -> [return: bb5, unwind: bb2];
38     }
39 
-     bb4: {
-         _5 = g() -> [return: bb2, unwind continue];
+     bb5: {
+         _5 = g() -> [return: bb3, unwind: bb2];
42     }
43 }
44 


thread '[mir-opt] tests/mir-opt/inline/inline_options.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/inline_options.main.Inline.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/inline_options.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/inline_more_in_non_inline.rs stdout ----
16         _3 = copy _1;
17         StorageLive(_4);
18         StorageLive(_5);
-         _4 = other_thing(copy _3) -> [return: bb2, unwind continue];
+         _4 = other_thing(copy _3) -> [return: bb3, unwind: bb1];
20     }
21 
-     bb1: {
+     bb1 (cleanup): {
+         resume;
---
28         return;
29     }
30 
-     bb2: {
-         _5 = other_thing(move _3) -> [return: bb1, unwind continue];
+     bb3: {
+         _5 = other_thing(move _3) -> [return: bb2, unwind: bb1];
33     }
34 }
35 


thread '[mir-opt] tests/mir-opt/inline/inline_more_in_non_inline.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/inline_more_in_non_inline.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/inline_specialization.rs stdout ----
12   
13       bb0: {
14           StorageLive(_1);
- -         _1 = <Vec<()> as Foo>::bar() -> [return: bb1, unwind continue];
+ -         _1 = <Vec<()> as Foo>::bar() -> [return: bb1, unwind: bb2];
16 -     }
17 - 
18 -     bb1: {

20           _0 = const ();
21           StorageDead(_1);
22           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
23       }
24   }
25   


thread '[mir-opt] tests/mir-opt/inline/inline_specialization.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/inline_specialization.main.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/inline_specialization.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/inline_shims.rs stdout ----
11       bb0: {
12           StorageLive(_2);
13           _2 = &_1;
- -         _0 = <fn(A, B) as Clone>::clone(move _2) -> [return: bb1, unwind continue];
+ -         _0 = <fn(A, B) as Clone>::clone(move _2) -> [return: bb1, unwind: bb2];
15 -     }
16 - 
17 -     bb1: {

18 +         _0 = copy (*_2);
19           StorageDead(_2);
20           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
21       }
22   }
23   


---
---- [mir-opt] tests/mir-opt/inline/inline_trait_method.rs stdout ----
8     bb0: {
9         StorageLive(_2);
10         _2 = copy _1;
-         _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind continue];
+         _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind: bb2];
12     }
13 
14     bb1: {

15         StorageDead(_2);
---
18 }
19 


thread '[mir-opt] tests/mir-opt/inline/inline_trait_method.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/inline_trait_method.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/inline_trait_method_2.rs stdout ----
15         _3 = copy _1;
16         _2 = move _3;
17         StorageDead(_3);
-         _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind continue];
+         _0 = <dyn X as X>::y(move _2) -> [return: bb2, unwind: bb1];
19     }
20 
-     bb1: {
+     bb1 (cleanup): {
+         resume;
---
23         return;
24     }


thread '[mir-opt] tests/mir-opt/inline/inline_trait_method_2.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/inline_trait_method_2.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/issue_106141.rs stdout ----
16 +     }
17   
18       bb0: {
- -         _0 = inner() -> [return: bb1, unwind continue];
+ -         _0 = inner() -> [return: bb1, unwind: bb2];
20 +         StorageLive(_1);
21 +         StorageLive(_2);
22 +         _1 = const inner::promoted[0];

- +         _0 = index() -> [return: bb1, unwind continue];
+ +         _0 = index() -> [return: bb2, unwind: bb1];
24       }
25   
-       bb1: {
+ -     bb1: {
+ -         return;
+ +     bb1 (cleanup): {
+ +         resume;
+       }
+   
+ -     bb2 (cleanup): {
+ -         resume;
+ +     bb2: {
27 +         StorageLive(_3);
28 +         _2 = Lt(copy _0, const 1_usize);
- +         assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _0) -> [success: bb2, unwind continue];
+ +         assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _0) -> [success: bb3, unwind: bb1];
30 +     }
31 + 
- +     bb2: {
+ +     bb3: {
33 +         _3 = copy (*_1)[_0];
- +         switchInt(move _3) -> [0: bb3, otherwise: bb4];
+ +         switchInt(move _3) -> [0: bb4, otherwise: bb5];
35 +     }
36 + 
- +     bb3: {
+ +     bb4: {
38 +         _0 = const 0_usize;
---
48   }
49   


thread '[mir-opt] tests/mir-opt/inline/issue_106141.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/issue_106141.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/issue_78442.rs stdout ----
36           StorageDead(_4);
37           StorageDead(_2);
38           _0 = const ();
-           drop(_1) -> [return: bb4, unwind continue];
+           drop(_1) -> [return: bb4, unwind: bb7];
40       }
41   
42       bb4: {


thread '[mir-opt] tests/mir-opt/inline/issue_78442.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/issue_78442.bar.PostAnalysisNormalize.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/issue_78442.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline/rustc_no_mir_inline.rs stdout ----
7   
8       bb0: {
9           StorageLive(_1);
-           _1 = callee() -> [return: bb1, unwind continue];
+           _1 = callee() -> [return: bb1, unwind: bb2];
11       }
12   
13       bb1: {

14           StorageDead(_1);
---
---- [mir-opt] tests/mir-opt/inline/unchecked_shifts.rs stdout ----
20           _3 = copy _1;
21           StorageLive(_4);
22           _4 = copy _2;
- -         _0 = core::num::<impl u16>::unchecked_shl(move _3, move _4) -> [return: bb1, unwind continue];
+ -         _0 = core::num::<impl u16>::unchecked_shl(move _3, move _4) -> [return: bb1, unwind: bb2];
24 +         StorageLive(_5);
25 +         switchInt(UbChecks) -> [0: bb2, otherwise: bb1];
26       }

35           StorageDead(_4);
36           StorageDead(_3);
37           return;
+ -     }
+ - 
+ -     bb2 (cleanup): {
+ -         resume;
38       }
39   }
40   


thread '[mir-opt] tests/mir-opt/inline/unchecked_shifts.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline/unchecked_shifts.rs stdout end ----
---- [mir-opt] tests/mir-opt/inline_default_trait_body.rs stdout ----
14           StorageLive(_3);
15           _5 = const <Self as Trait>::a::promoted[0];
16           _3 = &(*_5);
-           _2 = <() as Trait>::b(move _3) -> [return: bb1, unwind continue];
+           _2 = <() as Trait>::b(move _3) -> [return: bb1, unwind: bb2];
18       }
19   
20       bb1: {

22           StorageDead(_2);
---
---- [mir-opt] tests/mir-opt/inline_double_cycle.rs stdout ----
18           StorageLive(_1);
19           StorageLive(_2);
20           _2 = ();
- -         _1 = <fn() {a} as FnOnce<()>>::call_once(a, move _2) -> [return: bb1, unwind continue];
+ -         _1 = <fn() {a} as FnOnce<()>>::call_once(a, move _2) -> [return: bb1, unwind: bb3];
22 +         StorageLive(_5);
23 +         _5 = a;
- +         _1 = move _5() -> [return: bb1, unwind continue];
+ +         _1 = move _5() -> [return: bb2, unwind: bb1];
25       }
26   
-       bb1: {
+ -     bb1: {
+ +     bb1 (cleanup): {
+ +         resume;
+ +     }
+ + 
+ +     bb2: {
28 +         StorageDead(_5);
29           StorageDead(_2);
30           StorageDead(_1);

31           StorageLive(_3);
32           StorageLive(_4);
33           _4 = ();
- -         _3 = <fn() {b} as FnOnce<()>>::call_once(b, move _4) -> [return: bb2, unwind continue];
+ -         _3 = <fn() {b} as FnOnce<()>>::call_once(b, move _4) -> [return: bb2, unwind: bb3];
35 +         StorageLive(_6);
36 +         _6 = b;
- +         _3 = move _6() -> [return: bb2, unwind continue];
+ +         _3 = move _6() -> [return: bb3, unwind: bb1];
38       }
39   
-       bb2: {
+ -     bb2: {
+ +     bb3: {
---
44           _0 = const ();
45           return;
+ -     }
+ - 
+ -     bb3 (cleanup): {
+ -         resume;
46       }
47   }
48   


thread '[mir-opt] tests/mir-opt/inline_double_cycle.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/inline_double_cycle.a.Inline.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/inline_double_cycle.rs stdout end ----
---- [mir-opt] tests/mir-opt/instsimplify/combine_array_len.rs stdout ----
28           StorageLive(_3);
29           _3 = const 0_usize;
30           _4 = Lt(copy _3, const 2_usize);
-           assert(move _4, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _3) -> [success: bb1, unwind continue];
+           assert(move _4, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _3) -> [success: bb1, unwind: bb3];
32       }
33   
34       bb1: {

38           StorageLive(_6);
39           _6 = const 1_usize;
40           _7 = Lt(copy _6, const 2_usize);
-           assert(move _7, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _6) -> [success: bb2, unwind continue];
+           assert(move _7, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _6) -> [success: bb2, unwind: bb3];
42       }
43   
44       bb2: {

66           StorageDead(_5);
---
70   }
71   


thread '[mir-opt] tests/mir-opt/instsimplify/combine_array_len.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/instsimplify/combine_array_len.rs stdout end ----
---- [mir-opt] tests/mir-opt/instsimplify/combine_clone_of_primitives.rs stdout ----
21           _4 = &((*_1).0: T);
22 -         _3 = &(*_4);
23 +         _3 = copy _4;
-           _2 = <T as Clone>::clone(move _3) -> [return: bb1, unwind continue];
+           _2 = <T as Clone>::clone(move _3) -> [return: bb1, unwind: bb5];
25       }
26   
27       bb1: {


thread '[mir-opt] tests/mir-opt/instsimplify/combine_clone_of_primitives.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/instsimplify/combine_clone_of_primitives.rs stdout end ----
---- [mir-opt] tests/mir-opt/issue_104451_unwindable_intrinsics.rs stdout ----
9         StorageLive(_1);
10         StorageLive(_2);
11         _2 = ();
-         _1 = const_eval_select::<(), fn() -> ! {ow_ct}, fn() -> ! {ow_ct}, !>(move _2, ow_ct, ow_ct) -> unwind continue;
+         _1 = const_eval_select::<(), fn() -> ! {ow_ct}, fn() -> ! {ow_ct}, !>(move _2, ow_ct, ow_ct) -> bb1;
+     }
+ 
+     bb1 (cleanup): {
+         resume;
13     }
14 }
15 


thread '[mir-opt] tests/mir-opt/issue_104451_unwindable_intrinsics.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/issue_104451_unwindable_intrinsics.main.AbortUnwindingCalls.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/issue_104451_unwindable_intrinsics.rs stdout end ----
---- [mir-opt] tests/mir-opt/issue_101973.rs stdout ----
46           _9 = copy _1;
47 -         _10 = const 8_i32 as u32 (IntToInt);
48 -         _11 = Lt(move _10, const 32_u32);
- -         assert(move _11, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind continue];
+ -         assert(move _11, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind: bb3];
50 +         _10 = const 8_u32;
51 +         _11 = const true;
- +         assert(const true, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind continue];
+ +         assert(const true, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind: bb3];
53       }
54   
55       bb1: {

60           StorageDead(_8);
61 -         _12 = const 1_i32 as u32 (IntToInt);
62 -         _13 = Lt(move _12, const 32_u32);
- -         assert(move _13, "attempt to shift left by `{}`, which would overflow", const 1_i32) -> [success: bb2, unwind continue];
+ -         assert(move _13, "attempt to shift left by `{}`, which would overflow", const 1_i32) -> [success: bb2, unwind: bb3];
64 +         _12 = const 1_u32;
65 +         _13 = const true;
- +         assert(const true, "attempt to shift left by `{}`, which would overflow", const 1_i32) -> [success: bb2, unwind continue];
+ +         assert(const true, "attempt to shift left by `{}`, which would overflow", const 1_i32) -> [success: bb2, unwind: bb3];
67       }
68   
69       bb2: {

70           _6 = Shl(move _7, const 1_i32);
71           StorageDead(_7);
- -         _3 = rotate_right::<u32>(move _4, move _6) -> [return: bb3, unwind unreachable];
- +         _3 = rotate_right::<u32>(copy _14, move _6) -> [return: bb3, unwind unreachable];
+ -         _3 = rotate_right::<u32>(move _4, move _6) -> [return: bb4, unwind unreachable];
+ +         _3 = rotate_right::<u32>(copy _14, move _6) -> [return: bb4, unwind unreachable];
74       }
75   
-       bb3: {
+       bb3 (cleanup): {
+           resume;
+       }
+   
+       bb4: {
77           StorageDead(_6);
78           StorageDead(_4);
79           _2 = move _3 as i32 (IntToInt);


thread '[mir-opt] tests/mir-opt/issue_101973.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/issue_101973.rs stdout end ----
---- [mir-opt] tests/mir-opt/issue_41110.rs stdout ----
59   
60       bb5: {
61           StorageDead(_2);
- -         drop(_1) -> [return: bb6, unwind continue];
+ -         drop(_1) -> [return: bb6, unwind: bb10];
63 +         goto -> bb6;
64       }
65   


thread '[mir-opt] tests/mir-opt/issue_41110.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/issue_41110.rs stdout end ----
---- [mir-opt] tests/mir-opt/issue_41888.rs stdout ----
85   
86       bb9: {
87           StorageDead(_2);
- -         drop(_1) -> [return: bb10, unwind continue];
+ -         drop(_1) -> [return: bb10, unwind: bb12];
89 +         goto -> bb17;
90       }
91   


thread '[mir-opt] tests/mir-opt/issue_41888.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/issue_41888.rs stdout end ----
---- [mir-opt] tests/mir-opt/issue_62289.rs stdout ----
28         StorageLive(_1);
29         StorageLive(_2);
30         StorageLive(_3);
-         _3 = Box::<[u32; 1]>::new_uninit() -> [return: bb1, unwind continue];
+         _3 = Box::<[u32; 1]>::new_uninit() -> [return: bb1, unwind: bb14];
32     }
33 
34     bb1: {


thread '[mir-opt] tests/mir-opt/issue_62289.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/issue_62289.test.ElaborateDrops.after.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/issue_62289.rs stdout end ----
---- [mir-opt] tests/mir-opt/issue_76432.rs stdout ----
31       }
32   
33       bb1: {
-           _8 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind continue;
+           _8 = core::panicking::panic(const "internal error: entered unreachable code") -> bb3;
35       }
36   
37       bb2: {

40           // DBG: _7 = &(*_2)[2 of 3];
41           StorageDead(_4);
42           return;
+       }
+   
+       bb3 (cleanup): {
---
199           StorageLive(_1);
200           StorageLive(_2);
-           _22 = const true;
-           _23 = const true;
-           _2 = env_var() -> [return: bb1, unwind continue];
+           _2 = env_var() -> [return: bb1, unwind: bb15];
204       }
205   
206       bb1: {

+           _22 = const true;
+           _23 = const true;
207           _4 = discriminant(_2);
208           switchInt(move _4) -> [0: bb3, 1: bb4, otherwise: bb2];
209       }


thread '[mir-opt] tests/mir-opt/jump_threading.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/jump_threading.chained_conditions.JumpThreading.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/jump_threading.rs stdout end ----
---- [mir-opt] tests/mir-opt/lower_slice_len.rs stdout ----
20           StorageLive(_5);
21           StorageLive(_6);
22           _6 = &(*_2);
- -         _5 = core::slice::<impl [u8]>::len(move _6) -> [return: bb1, unwind continue];
+ -         _5 = core::slice::<impl [u8]>::len(move _6) -> [return: bb1, unwind: bb6];
24 +         _5 = PtrMetadata(move _6);
25 +         goto -> bb1;
26       }

38           _7 = copy _1;
39           _8 = PtrMetadata(copy _2);
40           _9 = Lt(copy _7, copy _8);
-           assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb3, unwind continue];
+           assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb3, unwind: bb6];
42       }
43   
44       bb3: {

57       bb5: {
---
61   }
62   


thread '[mir-opt] tests/mir-opt/lower_slice_len.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/lower_slice_len.rs stdout end ----
---- [mir-opt] tests/mir-opt/lower_array_len.rs stdout ----
42           StorageLive(_8);
43           _8 = copy _1;
44 -         _9 = Lt(copy _8, const N);
- -         assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, copy _8) -> [success: bb3, unwind continue];
+ -         assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, copy _8) -> [success: bb3, unwind: bb6];
46 +         _9 = copy _3;
- +         assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind continue];
+ +         assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind: bb6];
48       }
49   
50       bb3: {

64       bb5: {
---
68   }
69   


thread '[mir-opt] tests/mir-opt/lower_array_len.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/lower_array_len.rs stdout end ----
---- [mir-opt] tests/mir-opt/no_spurious_drop_after_call.rs stdout ----
14         StorageLive(_4);
15         _4 = const "";
16         _3 = &(*_4);
-         _2 = <str as ToString>::to_string(move _3) -> [return: bb1, unwind continue];
+         _2 = <str as ToString>::to_string(move _3) -> [return: bb1, unwind: bb4];
18     }
19 
20     bb1: {


thread '[mir-opt] tests/mir-opt/no_spurious_drop_after_call.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/no_spurious_drop_after_call.rs stdout end ----
---- [mir-opt] tests/mir-opt/pre-codegen/deref_nested_borrows.rs stdout ----
18           StorageLive(_2);
19           _6 = no_retag copy (*_1);
20           _2 = copy (*_6);
-           _3 = unknown() -> [return: bb1, unwind continue];
+           _3 = unknown() -> [return: bb1, unwind: bb2];
22       }
23   
24       bb1: {

33           StorageDead(_4);
---
37   }
38   


thread '[mir-opt] tests/mir-opt/pre-codegen/deref_nested_borrows.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/pre-codegen/deref_nested_borrows.rs stdout end ----
---- [mir-opt] tests/mir-opt/pre-codegen/drop_boxed_slice.rs stdout ----
4     debug ptr => _1;
5     let mut _0: ();
6     scope 1 (inlined drop_in_place::<Box<[T]>>) {
-         scope 2 (inlined std::ptr::drop_glue::<Box<[T]>> - shim(Some(Box<[T]>))) {
-             scope 3 (inlined <Box<[T]> as Drop>::drop) {
-                 let _2: std::ptr::NonNull<[T]>;
-                 let mut _3: *mut [T];
-                 let mut _4: *const [T];
-                 let _9: ();
-                 scope 4 {
-                     scope 5 {
-                         scope 18 (inlined Layout::size) {
-                         }
-                         scope 19 (inlined std::ptr::Unique::<[T]>::cast::<u8>) {
-                             let mut _8: std::ptr::NonNull<u8>;
-                             scope 20 (inlined NonNull::<[T]>::cast::<u8>) {
-                                 let mut _7: *mut u8;
-                                 scope 21 (inlined NonNull::<[T]>::as_ptr) {
-                                 }
-                             }
-                         }
-                         scope 22 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {
-                             scope 23 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {
-                             }
-                         }
-                         scope 24 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                             scope 25 (inlined std::alloc::Global::deallocate_impl) {
-                                 scope 26 (inlined std::alloc::Global::deallocate_impl_runtime) {
-                                     scope 27 (inlined Layout::size) {
-                                     }
-                                     scope 28 (inlined alloc::alloc::dealloc_nonnull) {
-                                         scope 29 (inlined Layout::size) {
-                                         }
-                                         scope 30 (inlined Layout::alignment) {
---
-                     scope 6 (inlined std::ptr::Unique::<[T]>::as_ptr) {
-                         scope 7 (inlined NonNull::<[T]>::as_ptr) {
-                         }
-                     }
-                     scope 8 (inlined Layout::for_value_raw::<[T]>) {
-                         let mut _5: usize;
-                         let mut _6: std::mem::Alignment;
-                         scope 9 {
-                             scope 17 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
-                             }
-                         }
-                         scope 10 (inlined size_of_val_raw::<[T]>) {
-                         }
-                         scope 11 (inlined std::mem::Alignment::of_val_raw::<[T]>) {
-                             scope 12 {
-                                 scope 14 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
-                                     scope 15 (inlined core::ub_checks::check_language_ub) {
-                                         scope 16 (inlined core::ub_checks::check_language_ub::runtime) {
-                                         }
-                                     }
-                                 }
-                             }
-                             scope 13 (inlined align_of_val_raw::<[T]>) {
-                             }
-                         }
-                     }
-                 }
-             }
---
-         StorageLive(_3);
-         StorageLive(_5);
-         StorageLive(_8);
79         StorageLive(_2);
-         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
-         StorageLive(_4);
-         _3 = copy _2 as *mut [T] (Transmute);
-         _4 = copy _2 as *const [T] (Transmute);
-         _5 = std::intrinsics::size_of_val::<[T]>(move _4) -> [return: bb1, unwind unreachable];
+         _2 = &mut (*_1);
+         _0 = std::ptr::drop_glue::<Box<[T]>>(move _2) -> [return: bb1, unwind continue];
85     }
86 
87     bb1: {

-         _6 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
-         StorageDead(_4);
-         switchInt(copy _5) -> [0: bb3, otherwise: bb2];
-     }
- 
-     bb2: {
-         StorageLive(_7);
-         _7 = copy _3 as *mut u8 (PtrToPtr);
-         _8 = copy _7 as std::ptr::NonNull<u8> (Transmute);
-         StorageDead(_7);
-         _9 = alloc::alloc::__rust_dealloc(move _8, move _5, move _6) -> [return: bb3, unwind unreachable];
-     }
- 
-     bb3: {
102         StorageDead(_2);
-         StorageDead(_8);
-         StorageDead(_5);
-         StorageDead(_3);
106         return;
107     }
108 }


thread '[mir-opt] tests/mir-opt/pre-codegen/drop_boxed_slice.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.runtime-optimized.after.64bit.panic-unwind.mir
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/pre-codegen/drop_boxed_slice.rs stdout end ----
---- [mir-opt] tests/mir-opt/pre-codegen/drop_box_of_sized.rs stdout ----
4     debug x => _1;
5     let mut _0: ();
6     scope 1 (inlined drop_in_place::<Box<T>>) {
-         scope 2 (inlined std::ptr::drop_glue::<Box<T>> - shim(Some(Box<T>))) {
-             scope 3 (inlined <Box<T> as Drop>::drop) {
-                 let _2: std::ptr::NonNull<T>;
-                 let _5: ();
-                 scope 4 {
-                     scope 5 {
-                         scope 18 (inlined Layout::size) {
-                         }
-                         scope 19 (inlined std::ptr::Unique::<T>::cast::<u8>) {
-                             let mut _4: std::ptr::NonNull<u8>;
-                             scope 20 (inlined NonNull::<T>::cast::<u8>) {
-                                 scope 21 (inlined NonNull::<T>::as_ptr) {
-                                 }
-                             }
-                         }
-                         scope 22 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {
-                             scope 23 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {
-                             }
-                         }
-                         scope 24 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                             scope 25 (inlined std::alloc::Global::deallocate_impl) {
-                                 scope 26 (inlined std::alloc::Global::deallocate_impl_runtime) {
-                                     scope 27 (inlined Layout::size) {
-                                     }
-                                     scope 28 (inlined alloc::alloc::dealloc_nonnull) {
-                                         scope 29 (inlined Layout::size) {
-                                         }
-                                         scope 30 (inlined Layout::alignment) {
---
-                     scope 6 (inlined std::ptr::Unique::<T>::as_ptr) {
-                         scope 7 (inlined NonNull::<T>::as_ptr) {
-                         }
-                     }
-                     scope 8 (inlined Layout::for_value_raw::<T>) {
-                         let mut _3: std::mem::Alignment;
-                         scope 9 {
-                             scope 17 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
-                             }
-                         }
-                         scope 10 (inlined size_of_val_raw::<T>) {
-                         }
-                         scope 11 (inlined std::mem::Alignment::of_val_raw::<T>) {
-                             scope 12 {
-                                 scope 14 (inlined #[track_caller] std::mem::Alignment::new_unchecked) {
-                                     scope 15 (inlined core::ub_checks::check_language_ub) {
-                                         scope 16 (inlined core::ub_checks::check_language_ub::runtime) {
-                                         }
-                                     }
-                                 }
-                             }
-                             scope 13 (inlined align_of_val_raw::<T>) {
-                             }
-                         }
-                     }
-                 }
-             }
---
71     bb0: {

-         StorageLive(_4);
73         StorageLive(_2);
-         _2 = copy (((*_1).0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>);
-         _3 = const <T as std::mem::SizedTypeProperties>::ALIGN as std::mem::Alignment (Transmute);
-         switchInt(const <T as std::mem::SizedTypeProperties>::SIZE) -> [0: bb3, otherwise: bb1];
+         _2 = &mut (*_1);
+         _0 = std::ptr::drop_glue::<Box<T>>(move _2) -> [return: bb1, unwind continue];
77     }
78 
79     bb1: {

-         _4 = copy _2 as std::ptr::NonNull<u8> (Transmute);
-         switchInt(const <T as std::mem::SizedTypeProperties>::SIZE) -> [0: bb3, otherwise: bb2];
-     }
- 
-     bb2: {
-         _5 = alloc::alloc::__rust_dealloc(move _4, const <T as std::mem::SizedTypeProperties>::SIZE, move _3) -> [return: bb3, unwind unreachable];
-     }
- 
-     bb3: {
89         StorageDead(_2);
-         StorageDead(_4);
---
---- [mir-opt] tests/mir-opt/pre-codegen/drop_box_of_sized.rs stdout end ----
---- [mir-opt] tests/mir-opt/pre-codegen/optimizes_into_variable.rs stdout ----
26       bb0: {
27           StorageLive(_1);
28           _2 = AddWithOverflow(const 2_i32, const 2_i32);
-           assert(!move (_2.1: bool), "attempt to compute `{} + {}`, which would overflow", const 2_i32, const 2_i32) -> [success: bb1, unwind continue];
+           assert(!move (_2.1: bool), "attempt to compute `{} + {}`, which would overflow", const 2_i32, const 2_i32) -> [success: bb1, unwind: bb3];
30       }
31   
32       bb1: {

37           StorageLive(_5);
38           _5 = const 3_usize;
39           _6 = Lt(copy _5, const 6_usize);
-           assert(move _6, "index out of bounds: the length is {} but the index is {}", const 6_usize, copy _5) -> [success: bb2, unwind continue];
+           assert(move _6, "index out of bounds: the length is {} but the index is {}", const 6_usize, copy _5) -> [success: bb2, unwind: bb3];
41       }
42   
43       bb2: {

63           StorageDead(_3);
---
67   }
68   


thread '[mir-opt] tests/mir-opt/pre-codegen/optimizes_into_variable.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/pre-codegen/optimizes_into_variable.rs stdout end ----
---- [mir-opt] tests/mir-opt/remove_storage_markers.rs stdout ----
32 -         StorageLive(_2);
33 -         StorageLive(_3);
34           _3 = std::ops::Range::<i32> { start: const 0_i32, end: const 10_i32 };
-           _2 = <std::ops::Range<i32> as IntoIterator>::into_iter(move _3) -> [return: bb1, unwind continue];
+           _2 = <std::ops::Range<i32> as IntoIterator>::into_iter(move _3) -> [return: bb1, unwind: bb7];
36       }
37   
38       bb1: {

49 -         StorageLive(_9);
50           _9 = &mut _4;
51           _8 = &mut (*_9);
-           _7 = <std::ops::Range<i32> as Iterator>::next(move _8) -> [return: bb3, unwind continue];
+           _7 = <std::ops::Range<i32> as Iterator>::next(move _8) -> [return: bb3, unwind: bb7];
53       }
54   
55       bb3: {

87 -         StorageDead(_2);
---
---- [mir-opt] tests/mir-opt/reference_prop.rs stdout ----
196           StorageLive(_7);
197           StorageLive(_8);
198           _8 = ();
-           _7 = opaque::<()>(move _8) -> [return: bb1, unwind continue];
+           _7 = opaque::<()>(move _8) -> [return: bb1, unwind: bb11];
200       }
201   
202       bb1: {

228           StorageLive(_16);
229           StorageLive(_17);
230           _17 = ();
-           _16 = opaque::<()>(move _17) -> [return: bb2, unwind continue];
+           _16 = opaque::<()>(move _17) -> [return: bb2, unwind: bb11];
232       }
233   
234       bb2: {

253           StorageLive(_23);
254           StorageLive(_24);
255           _24 = copy _21;
- -         _23 = opaque::<&&usize>(move _24) -> [return: bb3, unwind continue];
- +         _23 = opaque::<&&usize>(copy _24) -> [return: bb3, unwind continue];
+ -         _23 = opaque::<&&usize>(move _24) -> [return: bb3, unwind: bb11];
+ +         _23 = opaque::<&&usize>(copy _24) -> [return: bb3, unwind: bb11];
258       }
259   
260       bb3: {

278           StorageLive(_30);
279           StorageLive(_31);
280           _31 = copy _28;
- -         _30 = opaque::<*mut &usize>(move _31) -> [return: bb4, unwind continue];
- +         _30 = opaque::<*mut &usize>(copy _31) -> [return: bb4, unwind continue];
+ -         _30 = opaque::<*mut &usize>(move _31) -> [return: bb4, unwind: bb11];
+ +         _30 = opaque::<*mut &usize>(copy _31) -> [return: bb4, unwind: bb11];
283       }
284   
285       bb4: {

302           StorageLive(_36);
303           StorageLive(_37);
304           _37 = copy _34;
- -         _36 = opaque::<&usize>(move _37) -> [return: bb5, unwind continue];
- +         _36 = opaque::<&usize>(copy _37) -> [return: bb5, unwind continue];
+ -         _36 = opaque::<&usize>(move _37) -> [return: bb5, unwind: bb11];
+ +         _36 = opaque::<&usize>(copy _37) -> [return: bb5, unwind: bb11];
307       }
308   
309       bb5: {

332           StorageLive(_45);
333           StorageLive(_46);
334           _46 = copy _44;
- -         _45 = opaque::<&usize>(move _46) -> [return: bb6, unwind continue];
- +         _45 = opaque::<&usize>(copy _46) -> [return: bb6, unwind continue];
+ -         _45 = opaque::<&usize>(move _46) -> [return: bb6, unwind: bb11];
+ +         _45 = opaque::<&usize>(copy _46) -> [return: bb6, unwind: bb11];
337       }
338   
339       bb6: {

356           StorageLive(_50);
357           StorageLive(_51);
358           _51 = ();
-           _50 = opaque::<()>(move _51) -> [return: bb7, unwind continue];
+           _50 = opaque::<()>(move _51) -> [return: bb7, unwind: bb11];
360       }
361   
362       bb7: {

383           StorageLive(_57);
384           StorageLive(_58);
385           _58 = ();
-           _57 = opaque::<()>(move _58) -> [return: bb8, unwind continue];
+           _57 = opaque::<()>(move _58) -> [return: bb8, unwind: bb11];
387       }
388   
389       bb8: {

406           StorageLive(_64);
407           StorageLive(_65);
408           _65 = ();
-           _64 = opaque::<()>(move _65) -> [return: bb9, unwind continue];
+           _64 = opaque::<()>(move _65) -> [return: bb9, unwind: bb11];
410       }
411   
412       bb9: {

429           StorageLive(_70);
430           StorageLive(_71);
431           _71 = ();
-           _70 = opaque::<()>(move _71) -> [return: bb10, unwind continue];
+           _70 = opaque::<()>(move _71) -> [return: bb10, unwind: bb11];
433       }
434   
435       bb10: {

441           StorageDead(_67);
---
---- [mir-opt] tests/mir-opt/simplify_if.rs stdout ----
14       }
15   
16       bb1: {
-           _2 = noop() -> [return: bb2, unwind continue];
+           _2 = noop() -> [return: bb2, unwind: bb3];
18       }
19   
20       bb2: {

21           StorageDead(_1);
---
24   }
25   


thread '[mir-opt] tests/mir-opt/simplify_if.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/simplify_if.main.SimplifyConstCondition-after-inst-simplify.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/simplify_if.rs stdout end ----
---- [mir-opt] tests/mir-opt/simplify_locals_removes_unused_consts.rs stdout ----
36 +         _2 = (move _3, move _4);
37 +         StorageDead(_4);
38           StorageDead(_3);
- +         _1 = use_zst(move _2) -> [return: bb1, unwind continue];
+ +         _1 = use_zst(move _2) -> [return: bb1, unwind: bb3];
40 +     }
41 + 
42 +     bb1: {

55 +         _6 = Add(move _7, const 2_u8);
56           StorageDead(_7);
57 -         StorageDead(_6);
- -         _4 = use_zst(move _5) -> [return: bb1, unwind continue];
- +         _5 = use_u8(move _6) -> [return: bb2, unwind continue];
+ -         _4 = use_zst(move _5) -> [return: bb1, unwind: bb3];
+ +         _5 = use_u8(move _6) -> [return: bb2, unwind: bb3];
60       }
61   
62 -     bb1: {

70 -         _10 = copy (_11.0: u8);
71 -         _9 = Add(move _10, const 2_u8);
72 -         StorageDead(_10);
- -         _8 = use_u8(move _9) -> [return: bb2, unwind continue];
+ -         _8 = use_u8(move _9) -> [return: bb2, unwind: bb3];
74 -     }
75 - 
76       bb2: {

81 +         StorageDead(_5);
---
---- [mir-opt] tests/mir-opt/simplify_match.rs stdout ----
21       }
22   
23       bb1: {
-           _0 = noop() -> [return: bb2, unwind continue];
+           _0 = noop() -> [return: bb2, unwind: bb3];
25       }
26   
27       bb2: {

28           StorageDead(_1);
---
31   }
32   


thread '[mir-opt] tests/mir-opt/simplify_match.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/simplify_match.rs stdout end ----
---- [mir-opt] tests/mir-opt/single_use_consts.rs stdout ----
16 -         _1 = const <T as MyTrait>::ASSOC_BOOL;
17 +         nop;
18           StorageLive(_2);
-           _2 = do_whatever() -> [return: bb1, unwind continue];
+           _2 = do_whatever() -> [return: bb1, unwind: bb5];
20       }
21   
22       bb1: {

41           StorageDead(_3);
---
45   }
46   


thread '[mir-opt] tests/mir-opt/single_use_consts.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/single_use_consts.rs stdout end ----
---- [mir-opt] tests/mir-opt/sroa/simd_sroa.rs stdout ----
19           _4 = const 0_usize;
20           _5 = PtrMetadata(copy _1);
21           _6 = Lt(copy _4, copy _5);
-           assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue];
+           assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind: bb2];
23       }
24   
25       bb1: {

27           StorageDead(_4);
---
31   }
32   


thread '[mir-opt] tests/mir-opt/sroa/simd_sroa.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/sroa/simd_sroa.foo.ScalarReplacementOfAggregates.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/sroa/simd_sroa.rs stdout end ----
---- [mir-opt] tests/mir-opt/tail_call_drops.rs stdout ----
27       bb0: {
28 +         _8 = const false;
29           StorageLive(_2);
-           _2 = String::new() -> [return: bb1, unwind continue];
+           _2 = String::new() -> [return: bb1, unwind: bb12];
31       }
32   
33       bb1: {

66       bb6: {
67 +         _8 = const false;
68           StorageDead(_4);
- -         drop(_2) -> [return: bb7, unwind continue];
- +         drop(_2) -> [return: bb7, unwind: bb12];
+           drop(_2) -> [return: bb7, unwind: bb12];
71       }
72   
73       bb7: {


thread '[mir-opt] tests/mir-opt/tail_call_drops.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/tail_call_drops.rs stdout end ----
---- [mir-opt] tests/mir-opt/unreachable.rs stdout ----
20   
21       bb0: {
22           StorageLive(_1);
-           _1 = empty() -> [return: bb1, unwind continue];
+           _1 = empty() -> [return: bb1, unwind: bb7];
24       }
25   
26       bb1: {

67           _0 = const ();
---
71   }
72   


thread '[mir-opt] tests/mir-opt/unreachable.rs' panicked at src/tools/compiletest/src/runtest/mir_opt.rs:73:21:
Actual MIR output differs from expected MIR output /checkout/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- [mir-opt] tests/mir-opt/unreachable.rs stdout end ----
---- [mir-opt] tests/mir-opt/unreachable_diverging.rs stdout ----
22           StorageLive(_1);
23           _1 = const true;
24           StorageLive(_2);
-           _2 = empty() -> [return: bb1, unwind continue];
+           _2 = empty() -> [return: bb1, unwind: bb7];
26       }
27   
28       bb1: {

43       }
44   
45       bb3: {
-           _5 = loop_forever() -> [return: bb5, unwind continue];
+           _5 = loop_forever() -> [return: bb5, unwind: bb7];
47       }
48   
49       bb4: {

64           StorageDead(_1);

[hanna-kruppe]

I believe this (disabling the MIR pass) doesn’t disable the post-mono version of the pass added in #143208

[hanna-kruppe]

Ah, in the context of the linked PR it might be okay and expected to only disable the MIR pass. But more generally it seems interesting whether the post-mono version matters because that too should be only an optimization that arguably should be affected by optimize(none).

[rust-bors]

☀️ Try build successful (CI)
Build commit: 8920a79 (8920a79b4deb1bcc5fe577aff7a58658be537bca)
Base parent: e19d321 (e19d321c06479c6fd77533582b0d5a86651f1be3)

[rust-timer]

Finished benchmarking commit (8920a79): comparison URL.

Overall result: ❌✅ regressions and improvements - please read:

Benchmarking means the PR may be perf-sensitive. It's automatically marked not fit for rolling up. Overriding is possible but disadvised: it risks changing compiler perf.

Next, please: If you can, justify the regressions found in this try perf run in writing along with @rustbot label: +perf-regression-triaged. If not, fix the regressions and do another perf run. Neutral or positive results will clear the label automatically.

@bors rollup=never rustc-perf
@rustbot label: -S-waiting-on-perf +perf-regression

Instruction count

Our most reliable metric. Used to determine the overall result above. However, even this metric can be noisy.

	mean	range	count
Regressions ❌ (primary)	0.4%	[0.3%, 0.7%]	8
Regressions ❌ (secondary)	1.0%	[0.1%, 2.0%]	17
Improvements ✅ (primary)	-0.6%	[-1.2%, -0.2%]	6
Improvements ✅ (secondary)	-0.6%	[-1.1%, -0.2%]	7
All ❌✅ (primary)	-0.0%	[-1.2%, 0.7%]	14

Max RSS (memory usage)

Results (primary -0.6%, secondary -2.5%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	1.6%	[1.0%, 2.7%]	3
Regressions ❌ (secondary)	-	-	0
Improvements ✅ (primary)	-4.0%	[-5.1%, -3.0%]	2
Improvements ✅ (secondary)	-2.5%	[-3.2%, -1.9%]	2
All ❌✅ (primary)	-0.6%	[-5.1%, 2.7%]	5

Cycles

Results (primary -1.8%, secondary 0.5%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	-	-	0
Regressions ❌ (secondary)	1.8%	[1.7%, 2.0%]	2
Improvements ✅ (primary)	-1.8%	[-1.8%, -1.8%]	1
Improvements ✅ (secondary)	-2.2%	[-2.2%, -2.2%]	1
All ❌✅ (primary)	-1.8%	[-1.8%, -1.8%]	1

Binary size

Results (primary 0.1%, secondary 0.4%)

A less reliable metric. May be of interest, but not used to determine the overall result above.

	mean	range	count
Regressions ❌ (primary)	0.3%	[0.0%, 2.3%]	16
Regressions ❌ (secondary)	1.7%	[0.0%, 3.9%]	15
Improvements ✅ (primary)	-0.2%	[-1.0%, -0.0%]	17
Improvements ✅ (secondary)	-0.1%	[-0.2%, -0.0%]	43
All ❌✅ (primary)	0.1%	[-1.0%, 2.3%]	33

Bootstrap: 490.165s -> 489.361s (-0.16%)
Artifact size: 388.34 MiB -> 388.13 MiB (-0.05%)