dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Simplify binary ops.

This commit is contained in:
Camille GILLOT 2023-03-20 21:37:36 +00:00
parent 92f2e0aa62
commit 666030c51b
19 changed files with 836 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
compiler/rustc_mir_transform/src/gvn.rs
View File

@ -345,11 +345,20 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
Some(self.insert(Value::Constant { value, disambiguator }))
}
fn insert_bool(&mut self, flag: bool) -> VnIndex {
// Booleans are deterministic.
self.insert(Value::Constant { value: Const::from_bool(self.tcx, flag), disambiguator: 0 })
}
fn insert_scalar(&mut self, scalar: Scalar, ty: Ty<'tcx>) -> VnIndex {
self.insert_constant(Const::from_scalar(self.tcx, scalar, ty))
.expect("scalars are deterministic")
}
fn insert_tuple(&mut self, values: Vec<VnIndex>) -> VnIndex {
self.insert(Value::Aggregate(AggregateTy::Tuple, VariantIdx::from_u32(0), values))
}
#[instrument(level = "trace", skip(self), ret)]
fn eval_to_const(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
use Value::*;
@ -785,14 +794,26 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
Value::Cast { kind, value, from, to }
}
Rvalue::BinaryOp(op, box (ref mut lhs, ref mut rhs)) => {
let ty = lhs.ty(self.local_decls, self.tcx);
let lhs = self.simplify_operand(lhs, location);
let rhs = self.simplify_operand(rhs, location);
Value::BinaryOp(op, lhs?, rhs?)
let lhs = lhs?;
let rhs = rhs?;
if let Some(value) = self.simplify_binary(op, false, ty, lhs, rhs) {
return Some(value);
}
Value::BinaryOp(op, lhs, rhs)
}
Rvalue::CheckedBinaryOp(op, box (ref mut lhs, ref mut rhs)) => {
let ty = lhs.ty(self.local_decls, self.tcx);
let lhs = self.simplify_operand(lhs, location);
let rhs = self.simplify_operand(rhs, location);
Value::CheckedBinaryOp(op, lhs?, rhs?)
let lhs = lhs?;
let rhs = rhs?;
if let Some(value) = self.simplify_binary(op, true, ty, lhs, rhs) {
return Some(value);
}
Value::CheckedBinaryOp(op, lhs, rhs)
}
Rvalue::UnaryOp(op, ref mut arg) => {
let arg = self.simplify_operand(arg, location)?;
@ -894,6 +915,92 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
Some(self.insert(Value::Aggregate(ty, variant_index, fields)))
}
#[instrument(level = "trace", skip(self), ret)]
fn simplify_binary(
&mut self,
op: BinOp,
checked: bool,
lhs_ty: Ty<'tcx>,
lhs: VnIndex,
rhs: VnIndex,
) -> Option<VnIndex> {
// Floats are weird enough that none of the logic below applies.
let reasonable_ty =
lhs_ty.is_integral() || lhs_ty.is_bool() || lhs_ty.is_char() || lhs_ty.is_any_ptr();
if !reasonable_ty {
return None;
}
let layout = self.ecx.layout_of(lhs_ty).ok()?;
let as_bits = |value| {
let constant = self.evaluated[value].as_ref()?;
let scalar = self.ecx.read_scalar(constant).ok()?;
scalar.to_bits(constant.layout.size).ok()
};
// Represent the values as `Ok(bits)` or `Err(VnIndex)`.
let a = as_bits(lhs).ok_or(lhs);
let b = as_bits(rhs).ok_or(rhs);
let result = match (op, a, b) {
// Neutral elements.
(BinOp::Add | BinOp::BitOr | BinOp::BitXor, Ok(0), Err(p))
| (
BinOp::Add
| BinOp::BitOr
| BinOp::BitXor
| BinOp::Sub
| BinOp::Offset
| BinOp::Shl
| BinOp::Shr,
Err(p),
Ok(0),
)
| (BinOp::Mul, Ok(1), Err(p))
| (BinOp::Mul | BinOp::Div, Err(p), Ok(1)) => p,
// Attempt to simplify `x & ALL_ONES` to `x`, with `ALL_ONES` depending on type size.
(BinOp::BitAnd, Err(p), Ok(ones)) | (BinOp::BitAnd, Ok(ones), Err(p))
if ones == layout.size.truncate(u128::MAX)
|| (layout.ty.is_bool() && ones == 1) =>
{
p
}
// Absorbing elements.
(BinOp::Mul | BinOp::BitAnd, _, Ok(0))
| (BinOp::Rem, _, Ok(1))
| (
BinOp::Mul | BinOp::Div | BinOp::Rem | BinOp::BitAnd | BinOp::Shl | BinOp::Shr,
Ok(0),
_,
) => self.insert_scalar(Scalar::from_uint(0u128, layout.size), lhs_ty),
// Attempt to simplify `x | ALL_ONES` to `ALL_ONES`.
(BinOp::BitOr, _, Ok(ones)) | (BinOp::BitOr, Ok(ones), _)
if ones == layout.size.truncate(u128::MAX)
|| (layout.ty.is_bool() && ones == 1) =>
{
self.insert_scalar(Scalar::from_uint(ones, layout.size), lhs_ty)
}
// Sub/Xor with itself.
(BinOp::Sub | BinOp::BitXor, a, b) if a == b => {
self.insert_scalar(Scalar::from_uint(0u128, layout.size), lhs_ty)
}
// Comparison:
// - if both operands can be computed as bits, just compare the bits;
// - if we proved that both operands have the same value, we can insert true/false;
// - otherwise, do nothing, as we do not try to prove inequality.
(BinOp::Eq, a, b) if (a.is_ok() && b.is_ok()) || a == b => self.insert_bool(a == b),
(BinOp::Ne, a, b) if (a.is_ok() && b.is_ok()) || a == b => self.insert_bool(a != b),
_ => return None,
};
if checked {
let false_val = self.insert_bool(false);
Some(self.insert_tuple(vec![result, false_val]))
} else {
Some(result)
}
}
}
fn op_to_prop_const<'tcx>(

7
tests/mir-opt/const_prop/boolean_identities.rs
View File

@ -5,10 +5,9 @@ pub fn test(x: bool, y: bool) -> bool {
// CHECK-LABEL: fn test(
// CHECK: debug a => [[a:_.*]];
// CHECK: debug b => [[b:_.*]];
// FIXME(cjgillot) simplify algebraic identity
// CHECK-NOT: [[a]] = const true;
// CHECK-NOT: [[b]] = const false;
// CHECK-NOT: _0 = const false;
// CHECK: [[a]] = const true;
// CHECK: [[b]] = const false;
// CHECK: _0 = const false;
let a = (y | true);
let b = (x & false);
a & b

12
tests/mir-opt/const_prop/boolean_identities.test.GVN.diff
View File

@ -24,21 +24,23 @@
StorageLive(_4);
_4 = _2;
- _3 = BitOr(move _4, const true);
+ _3 = BitOr(_2, const true);
+ _3 = const true;
StorageDead(_4);
- StorageLive(_5);
+ nop;
StorageLive(_6);
_6 = _1;
- _5 = BitAnd(move _6, const false);
+ _5 = BitAnd(_1, const false);
+ _5 = const false;
StorageDead(_6);
StorageLive(_7);
_7 = _3;
- _7 = _3;
+ _7 = const true;
StorageLive(_8);
_8 = _5;
- _8 = _5;
- _0 = BitAnd(move _7, move _8);
+ _0 = BitAnd(_3, _5);
+ _8 = const false;
+ _0 = const false;
StorageDead(_8);
StorageDead(_7);
- StorageDead(_5);

9
tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff
View File

@ -20,7 +20,8 @@
bb0: {
StorageLive(_1);
StorageLive(_2);
- StorageLive(_2);
+ nop;
StorageLive(_3);
- _4 = SizeOf(i32);
- _5 = AlignOf(i32);
@ -39,8 +40,10 @@
StorageDead(_7);
_9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
_2 = (*_9);
_1 = Add(move _2, const 0_i32);
StorageDead(_2);
- _1 = Add(move _2, const 0_i32);
- StorageDead(_2);
+ _1 = _2;
+ nop;
drop(_3) -> [return: bb2, unwind unreachable];
}

9
tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff
View File

@ -20,7 +20,8 @@
bb0: {
StorageLive(_1);
StorageLive(_2);
- StorageLive(_2);
+ nop;
StorageLive(_3);
- _4 = SizeOf(i32);
- _5 = AlignOf(i32);
@ -39,8 +40,10 @@
StorageDead(_7);
_9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
_2 = (*_9);
_1 = Add(move _2, const 0_i32);
StorageDead(_2);
- _1 = Add(move _2, const 0_i32);
- StorageDead(_2);
+ _1 = _2;
+ nop;
drop(_3) -> [return: bb2, unwind: bb3];
}

2
tests/mir-opt/const_prop/boxes.rs
View File

@ -12,7 +12,7 @@ fn main() {
// CHECK: debug x => [[x:_.*]];
// CHECK: (*{{_.*}}) = const 42_i32;
// CHECK: [[tmp:_.*]] = (*{{_.*}});
// CHECK: [[x]] = Add(move [[tmp]], const 0_i32);
// CHECK: [[x]] = [[tmp]];
let x = *(#[rustc_box]
Box::new(42))
+ 0;

3
tests/mir-opt/const_prop/mult_by_zero.rs
View File

@ -3,8 +3,7 @@
// EMIT_MIR mult_by_zero.test.GVN.diff
fn test(x: i32) -> i32 {
// CHECK: fn test(
// FIXME(cjgillot) simplify algebraic identity
// CHECK-NOT: _0 = const 0_i32;
// CHECK: _0 = const 0_i32;
x * 0
}

2
tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff
View File

@ -10,7 +10,7 @@
StorageLive(_2);
_2 = _1;
- _0 = Mul(move _2, const 0_i32);
+ _0 = Mul(_1, const 0_i32);
+ _0 = const 0_i32;
StorageDead(_2);
return;
}

385
tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff
View File

@ -13,13 +13,13 @@
let _8: ();
let mut _9: u64;
let mut _10: u64;
let _11: ();
let mut _12: u64;
let mut _11: u64;
let _12: ();
let mut _13: u64;
let _14: ();
let mut _15: u64;
let mut _14: u64;
let _15: ();
let mut _16: u64;
let mut _17: bool;
let mut _17: u64;
let _18: ();
let mut _19: u64;
let mut _20: u64;
@ -51,18 +51,32 @@
let _46: ();
let mut _47: u64;
let mut _48: u64;
let _49: ();
let mut _50: u64;
let mut _49: bool;
let _50: ();
let mut _51: u64;
let _52: ();
let mut _53: u64;
let mut _52: u64;
let _53: ();
let mut _54: u64;
let _55: ();
let mut _56: u64;
let mut _55: u64;
let _56: ();
let mut _57: u64;
let _58: ();
let mut _59: u64;
let mut _58: u64;
let _59: ();
let mut _60: u64;
let mut _61: u64;
let _62: ();
let mut _63: u64;
let mut _64: u64;
let _65: ();
let mut _66: u64;
let mut _67: u64;
let mut _68: u64;
let _69: ();
let mut _70: u64;
let mut _71: u64;
let _72: ();
let mut _73: u64;
let mut _74: u64;
bb0: {
StorageLive(_2);
@ -70,9 +84,10 @@
StorageLive(_4);
_4 = _1;
- _3 = Add(move _4, const 0_u64);
+ _3 = Add(_1, const 0_u64);
+ _3 = _1;
StorageDead(_4);
_2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable];
- _2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable];
+ _2 = opaque::<u64>(_1) -> [return: bb1, unwind unreachable];
}
bb1: {
@ -83,98 +98,101 @@
StorageLive(_7);
_7 = _1;
- _6 = Sub(move _7, const 0_u64);
+ _6 = Sub(_1, const 0_u64);
+ _6 = _1;
StorageDead(_7);
_5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable];
- _5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable];
+ _5 = opaque::<u64>(_1) -> [return: bb2, unwind unreachable];
}
bb2: {
StorageDead(_6);
StorageDead(_5);
StorageLive(_8);
StorageLive(_9);
- StorageLive(_9);
+ nop;
StorageLive(_10);
_10 = _1;
- _9 = Mul(move _10, const 0_u64);
+ _9 = Mul(_1, const 0_u64);
StorageLive(_11);
_11 = _1;
- _9 = Sub(move _10, move _11);
+ _9 = const 0_u64;
StorageDead(_11);
StorageDead(_10);
_8 = opaque::<u64>(move _9) -> [return: bb3, unwind unreachable];
- _8 = opaque::<u64>(move _9) -> [return: bb3, unwind unreachable];
+ _8 = opaque::<u64>(const 0_u64) -> [return: bb3, unwind unreachable];
}
bb3: {
StorageDead(_9);
- StorageDead(_9);
+ nop;
StorageDead(_8);
StorageLive(_11);
StorageLive(_12);
StorageLive(_13);
_13 = _1;
- _12 = Mul(move _13, const 1_u64);
+ _12 = Mul(_1, const 1_u64);
StorageDead(_13);
_11 = opaque::<u64>(move _12) -> [return: bb4, unwind unreachable];
StorageLive(_14);
_14 = _1;
- _13 = Mul(move _14, const 0_u64);
+ _13 = const 0_u64;
StorageDead(_14);
- _12 = opaque::<u64>(move _13) -> [return: bb4, unwind unreachable];
+ _12 = opaque::<u64>(const 0_u64) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_13);
StorageDead(_12);
StorageDead(_11);
StorageLive(_14);
StorageLive(_15);
StorageLive(_16);
_16 = _1;
- _17 = Eq(const 0_u64, const 0_u64);
- assert(!move _17, "attempt to divide `{}` by zero", _16) -> [success: bb5, unwind unreachable];
+ _17 = const true;
+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb5, unwind unreachable];
StorageLive(_17);
_17 = _1;
- _16 = Mul(move _17, const 1_u64);
+ _16 = _1;
StorageDead(_17);
- _15 = opaque::<u64>(move _16) -> [return: bb5, unwind unreachable];
+ _15 = opaque::<u64>(_1) -> [return: bb5, unwind unreachable];
}
bb5: {
- _15 = Div(move _16, const 0_u64);
+ _15 = Div(_1, const 0_u64);
StorageDead(_16);
_14 = opaque::<u64>(move _15) -> [return: bb6, unwind unreachable];
}
bb6: {
StorageDead(_15);
StorageDead(_14);
StorageLive(_18);
StorageLive(_19);
StorageLive(_20);
_20 = _1;
- _21 = Eq(const 1_u64, const 0_u64);
- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb7, unwind unreachable];
+ _21 = const false;
+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb7, unwind unreachable];
- _21 = Eq(const 0_u64, const 0_u64);
- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind unreachable];
+ _21 = const true;
+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind unreachable];
}
bb6: {
- _19 = Div(move _20, const 0_u64);
+ _19 = Div(_1, const 0_u64);
StorageDead(_20);
_18 = opaque::<u64>(move _19) -> [return: bb7, unwind unreachable];
}
bb7: {
- _19 = Div(move _20, const 1_u64);
+ _19 = Div(_1, const 1_u64);
StorageDead(_20);
_18 = opaque::<u64>(move _19) -> [return: bb8, unwind unreachable];
}
bb8: {
StorageDead(_19);
StorageDead(_18);
StorageLive(_22);
StorageLive(_23);
StorageLive(_24);
_24 = _1;
- _25 = Eq(_24, const 0_u64);
- assert(!move _25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind unreachable];
+ _25 = Eq(_1, const 0_u64);
+ assert(!_25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind unreachable];
- _25 = Eq(const 1_u64, const 0_u64);
- assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind unreachable];
+ _25 = const false;
+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind unreachable];
}
bb8: {
- _23 = Div(move _24, const 1_u64);
+ _23 = _1;
StorageDead(_24);
- _22 = opaque::<u64>(move _23) -> [return: bb9, unwind unreachable];
+ _22 = opaque::<u64>(_1) -> [return: bb9, unwind unreachable];
}
bb9: {
- _23 = Div(const 0_u64, move _24);
+ _23 = Div(const 0_u64, _1);
StorageDead(_24);
_22 = opaque::<u64>(move _23) -> [return: bb10, unwind unreachable];
}
bb10: {
StorageDead(_23);
StorageDead(_22);
StorageLive(_26);
@ -182,79 +200,81 @@
StorageLive(_28);
_28 = _1;
- _29 = Eq(_28, const 0_u64);
- assert(!move _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind unreachable];
+ _29 = _25;
+ assert(!_25, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind unreachable];
- assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
+ _29 = Eq(_1, const 0_u64);
+ assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
}
bb10: {
- _27 = Div(const 0_u64, move _28);
+ _27 = const 0_u64;
StorageDead(_28);
- _26 = opaque::<u64>(move _27) -> [return: bb11, unwind unreachable];
+ _26 = opaque::<u64>(const 0_u64) -> [return: bb11, unwind unreachable];
}
bb11: {
- _27 = Div(const 1_u64, move _28);
+ _27 = Div(const 1_u64, _1);
StorageDead(_28);
_26 = opaque::<u64>(move _27) -> [return: bb12, unwind unreachable];
}
bb12: {
StorageDead(_27);
StorageDead(_26);
StorageLive(_30);
StorageLive(_31);
StorageLive(_32);
_32 = _1;
- _33 = Eq(const 0_u64, const 0_u64);
- assert(!move _33, "attempt to calculate the remainder of `{}` with a divisor of zero", _32) -> [success: bb13, unwind unreachable];
+ _33 = const true;
+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb13, unwind unreachable];
- _33 = Eq(_32, const 0_u64);
- assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
+ _33 = _29;
+ assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
}
bb12: {
- _31 = Div(const 1_u64, move _32);
+ _31 = Div(const 1_u64, _1);
StorageDead(_32);
_30 = opaque::<u64>(move _31) -> [return: bb13, unwind unreachable];
}
bb13: {
- _31 = Rem(move _32, const 0_u64);
+ _31 = Rem(_1, const 0_u64);
StorageDead(_32);
_30 = opaque::<u64>(move _31) -> [return: bb14, unwind unreachable];
}
bb14: {
StorageDead(_31);
StorageDead(_30);
StorageLive(_34);
StorageLive(_35);
StorageLive(_36);
_36 = _1;
- _37 = Eq(const 1_u64, const 0_u64);
- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb15, unwind unreachable];
+ _37 = const false;
+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb15, unwind unreachable];
- _37 = Eq(const 0_u64, const 0_u64);
- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind unreachable];
+ _37 = const true;
+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind unreachable];
}
bb14: {
- _35 = Rem(move _36, const 0_u64);
+ _35 = Rem(_1, const 0_u64);
StorageDead(_36);
_34 = opaque::<u64>(move _35) -> [return: bb15, unwind unreachable];
}
bb15: {
- _35 = Rem(move _36, const 1_u64);
+ _35 = Rem(_1, const 1_u64);
StorageDead(_36);
_34 = opaque::<u64>(move _35) -> [return: bb16, unwind unreachable];
}
bb16: {
StorageDead(_35);
StorageDead(_34);
StorageLive(_38);
StorageLive(_39);
StorageLive(_40);
_40 = _1;
- _41 = Eq(_40, const 0_u64);
- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind unreachable];
+ _41 = _25;
+ assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind unreachable];
- _41 = Eq(const 1_u64, const 0_u64);
- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind unreachable];
+ _41 = const false;
+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind unreachable];
}
bb16: {
- _39 = Rem(move _40, const 1_u64);
+ _39 = const 0_u64;
StorageDead(_40);
- _38 = opaque::<u64>(move _39) -> [return: bb17, unwind unreachable];
+ _38 = opaque::<u64>(const 0_u64) -> [return: bb17, unwind unreachable];
}
bb17: {
- _39 = Rem(const 0_u64, move _40);
+ _39 = Rem(const 0_u64, _1);
StorageDead(_40);
_38 = opaque::<u64>(move _39) -> [return: bb18, unwind unreachable];
}
bb18: {
StorageDead(_39);
StorageDead(_38);
StorageLive(_42);
@ -262,27 +282,35 @@
StorageLive(_44);
_44 = _1;
- _45 = Eq(_44, const 0_u64);
- assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind unreachable];
+ _45 = _25;
+ assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind unreachable];
- assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
+ _45 = _29;
+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
}
bb18: {
- _43 = Rem(const 0_u64, move _44);
+ _43 = const 0_u64;
StorageDead(_44);
- _42 = opaque::<u64>(move _43) -> [return: bb19, unwind unreachable];
+ _42 = opaque::<u64>(const 0_u64) -> [return: bb19, unwind unreachable];
}
bb19: {
- _43 = Rem(const 1_u64, move _44);
+ _43 = Rem(const 1_u64, _1);
StorageDead(_44);
_42 = opaque::<u64>(move _43) -> [return: bb20, unwind unreachable];
}
bb20: {
StorageDead(_43);
StorageDead(_42);
StorageLive(_46);
StorageLive(_47);
StorageLive(_48);
_48 = _1;
- _47 = BitAnd(move _48, const 0_u64);
+ _47 = BitAnd(_1, const 0_u64);
- _49 = Eq(_48, const 0_u64);
- assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
+ _49 = _29;
+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
}
bb20: {
- _47 = Rem(const 1_u64, move _48);
+ _47 = Rem(const 1_u64, _1);
StorageDead(_48);
_46 = opaque::<u64>(move _47) -> [return: bb21, unwind unreachable];
}
@ -290,58 +318,121 @@
bb21: {
StorageDead(_47);
StorageDead(_46);
StorageLive(_49);
StorageLive(_50);
StorageLive(_51);
_51 = _1;
- _50 = BitOr(move _51, const 0_u64);
+ _50 = BitOr(_1, const 0_u64);
StorageDead(_51);
_49 = opaque::<u64>(move _50) -> [return: bb22, unwind unreachable];
StorageLive(_52);
_52 = _1;
- _51 = BitAnd(move _52, const 0_u64);
+ _51 = const 0_u64;
StorageDead(_52);
- _50 = opaque::<u64>(move _51) -> [return: bb22, unwind unreachable];
+ _50 = opaque::<u64>(const 0_u64) -> [return: bb22, unwind unreachable];
}
bb22: {
StorageDead(_51);
StorageDead(_50);
StorageDead(_49);
StorageLive(_52);
StorageLive(_53);
StorageLive(_54);
_54 = _1;
- _53 = BitXor(move _54, const 0_u64);
+ _53 = BitXor(_1, const 0_u64);
StorageDead(_54);
_52 = opaque::<u64>(move _53) -> [return: bb23, unwind unreachable];
StorageLive(_55);
_55 = _1;
- _54 = BitAnd(move _55, const _);
+ _54 = _1;
StorageDead(_55);
- _53 = opaque::<u64>(move _54) -> [return: bb23, unwind unreachable];
+ _53 = opaque::<u64>(_1) -> [return: bb23, unwind unreachable];
}
bb23: {
StorageDead(_54);
StorageDead(_53);
StorageDead(_52);
StorageLive(_55);
StorageLive(_56);
StorageLive(_57);
_57 = _1;
- _56 = Shr(move _57, const 0_i32);
+ _56 = Shr(_1, const 0_i32);
StorageDead(_57);
_55 = opaque::<u64>(move _56) -> [return: bb24, unwind unreachable];
StorageLive(_58);
_58 = _1;
- _57 = BitOr(move _58, const 0_u64);
+ _57 = _1;
StorageDead(_58);
- _56 = opaque::<u64>(move _57) -> [return: bb24, unwind unreachable];
+ _56 = opaque::<u64>(_1) -> [return: bb24, unwind unreachable];
}
bb24: {
StorageDead(_57);
StorageDead(_56);
StorageDead(_55);
StorageLive(_58);
StorageLive(_59);
StorageLive(_60);
_60 = _1;
- _59 = Shl(move _60, const 0_i32);
+ _59 = Shl(_1, const 0_i32);
StorageDead(_60);
_58 = opaque::<u64>(move _59) -> [return: bb25, unwind unreachable];
StorageLive(_61);
_61 = _1;
- _60 = BitOr(move _61, const _);
+ _60 = const u64::MAX;
StorageDead(_61);
- _59 = opaque::<u64>(move _60) -> [return: bb25, unwind unreachable];
+ _59 = opaque::<u64>(const u64::MAX) -> [return: bb25, unwind unreachable];
}
bb25: {
StorageDead(_60);
StorageDead(_59);
StorageDead(_58);
StorageLive(_62);
StorageLive(_63);
StorageLive(_64);
_64 = _1;
- _63 = BitXor(move _64, const 0_u64);
+ _63 = _1;
StorageDead(_64);
- _62 = opaque::<u64>(move _63) -> [return: bb26, unwind unreachable];
+ _62 = opaque::<u64>(_1) -> [return: bb26, unwind unreachable];
}
bb26: {
StorageDead(_63);
StorageDead(_62);
StorageLive(_65);
StorageLive(_66);
StorageLive(_67);
_67 = _1;
StorageLive(_68);
_68 = _1;
- _66 = BitXor(move _67, move _68);
+ _66 = const 0_u64;
StorageDead(_68);
StorageDead(_67);
- _65 = opaque::<u64>(move _66) -> [return: bb27, unwind unreachable];
+ _65 = opaque::<u64>(const 0_u64) -> [return: bb27, unwind unreachable];
}
bb27: {
StorageDead(_66);
StorageDead(_65);
StorageLive(_69);
StorageLive(_70);
StorageLive(_71);
_71 = _1;
- _70 = Shr(move _71, const 0_i32);
+ _70 = _1;
StorageDead(_71);
- _69 = opaque::<u64>(move _70) -> [return: bb28, unwind unreachable];
+ _69 = opaque::<u64>(_1) -> [return: bb28, unwind unreachable];
}
bb28: {
StorageDead(_70);
StorageDead(_69);
StorageLive(_72);
StorageLive(_73);
StorageLive(_74);
_74 = _1;
- _73 = Shl(move _74, const 0_i32);
+ _73 = _1;
StorageDead(_74);
- _72 = opaque::<u64>(move _73) -> [return: bb29, unwind unreachable];
+ _72 = opaque::<u64>(_1) -> [return: bb29, unwind unreachable];
}
bb29: {
StorageDead(_73);
StorageDead(_72);
_0 = const ();
return;
}

385
tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff
View File

@ -13,13 +13,13 @@
let _8: ();
let mut _9: u64;
let mut _10: u64;
let _11: ();
let mut _12: u64;
let mut _11: u64;
let _12: ();
let mut _13: u64;
let _14: ();
let mut _15: u64;
let mut _14: u64;
let _15: ();
let mut _16: u64;
let mut _17: bool;
let mut _17: u64;
let _18: ();
let mut _19: u64;
let mut _20: u64;
@ -51,18 +51,32 @@
let _46: ();
let mut _47: u64;
let mut _48: u64;
let _49: ();
let mut _50: u64;
let mut _49: bool;
let _50: ();
let mut _51: u64;
let _52: ();
let mut _53: u64;
let mut _52: u64;
let _53: ();
let mut _54: u64;
let _55: ();
let mut _56: u64;
let mut _55: u64;
let _56: ();
let mut _57: u64;
let _58: ();
let mut _59: u64;
let mut _58: u64;
let _59: ();
let mut _60: u64;
let mut _61: u64;
let _62: ();
let mut _63: u64;
let mut _64: u64;
let _65: ();
let mut _66: u64;
let mut _67: u64;
let mut _68: u64;
let _69: ();
let mut _70: u64;
let mut _71: u64;
let _72: ();
let mut _73: u64;
let mut _74: u64;
bb0: {
StorageLive(_2);
@ -70,9 +84,10 @@
StorageLive(_4);
_4 = _1;
- _3 = Add(move _4, const 0_u64);
+ _3 = Add(_1, const 0_u64);
+ _3 = _1;
StorageDead(_4);
_2 = opaque::<u64>(move _3) -> [return: bb1, unwind continue];
- _2 = opaque::<u64>(move _3) -> [return: bb1, unwind continue];
+ _2 = opaque::<u64>(_1) -> [return: bb1, unwind continue];
}
bb1: {
@ -83,98 +98,101 @@
StorageLive(_7);
_7 = _1;
- _6 = Sub(move _7, const 0_u64);
+ _6 = Sub(_1, const 0_u64);
+ _6 = _1;
StorageDead(_7);
_5 = opaque::<u64>(move _6) -> [return: bb2, unwind continue];
- _5 = opaque::<u64>(move _6) -> [return: bb2, unwind continue];
+ _5 = opaque::<u64>(_1) -> [return: bb2, unwind continue];
}
bb2: {
StorageDead(_6);
StorageDead(_5);
StorageLive(_8);
StorageLive(_9);
- StorageLive(_9);
+ nop;
StorageLive(_10);
_10 = _1;
- _9 = Mul(move _10, const 0_u64);
+ _9 = Mul(_1, const 0_u64);
StorageLive(_11);
_11 = _1;
- _9 = Sub(move _10, move _11);
+ _9 = const 0_u64;
StorageDead(_11);
StorageDead(_10);
_8 = opaque::<u64>(move _9) -> [return: bb3, unwind continue];
- _8 = opaque::<u64>(move _9) -> [return: bb3, unwind continue];
+ _8 = opaque::<u64>(const 0_u64) -> [return: bb3, unwind continue];
}
bb3: {
StorageDead(_9);
- StorageDead(_9);
+ nop;
StorageDead(_8);
StorageLive(_11);
StorageLive(_12);
StorageLive(_13);
_13 = _1;
- _12 = Mul(move _13, const 1_u64);
+ _12 = Mul(_1, const 1_u64);
StorageDead(_13);
_11 = opaque::<u64>(move _12) -> [return: bb4, unwind continue];
StorageLive(_14);
_14 = _1;
- _13 = Mul(move _14, const 0_u64);
+ _13 = const 0_u64;
StorageDead(_14);
- _12 = opaque::<u64>(move _13) -> [return: bb4, unwind continue];
+ _12 = opaque::<u64>(const 0_u64) -> [return: bb4, unwind continue];
}
bb4: {
StorageDead(_13);
StorageDead(_12);
StorageDead(_11);
StorageLive(_14);
StorageLive(_15);
StorageLive(_16);
_16 = _1;
- _17 = Eq(const 0_u64, const 0_u64);
- assert(!move _17, "attempt to divide `{}` by zero", _16) -> [success: bb5, unwind continue];
+ _17 = const true;
+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb5, unwind continue];
StorageLive(_17);
_17 = _1;
- _16 = Mul(move _17, const 1_u64);
+ _16 = _1;
StorageDead(_17);
- _15 = opaque::<u64>(move _16) -> [return: bb5, unwind continue];
+ _15 = opaque::<u64>(_1) -> [return: bb5, unwind continue];
}
bb5: {
- _15 = Div(move _16, const 0_u64);
+ _15 = Div(_1, const 0_u64);
StorageDead(_16);
_14 = opaque::<u64>(move _15) -> [return: bb6, unwind continue];
}
bb6: {
StorageDead(_15);
StorageDead(_14);
StorageLive(_18);
StorageLive(_19);
StorageLive(_20);
_20 = _1;
- _21 = Eq(const 1_u64, const 0_u64);
- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb7, unwind continue];
+ _21 = const false;
+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb7, unwind continue];
- _21 = Eq(const 0_u64, const 0_u64);
- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind continue];
+ _21 = const true;
+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind continue];
}
bb6: {
- _19 = Div(move _20, const 0_u64);
+ _19 = Div(_1, const 0_u64);
StorageDead(_20);
_18 = opaque::<u64>(move _19) -> [return: bb7, unwind continue];
}
bb7: {
- _19 = Div(move _20, const 1_u64);
+ _19 = Div(_1, const 1_u64);
StorageDead(_20);
_18 = opaque::<u64>(move _19) -> [return: bb8, unwind continue];
}
bb8: {
StorageDead(_19);
StorageDead(_18);
StorageLive(_22);
StorageLive(_23);
StorageLive(_24);
_24 = _1;
- _25 = Eq(_24, const 0_u64);
- assert(!move _25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind continue];
+ _25 = Eq(_1, const 0_u64);
+ assert(!_25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind continue];
- _25 = Eq(const 1_u64, const 0_u64);
- assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind continue];
+ _25 = const false;
+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind continue];
}
bb8: {
- _23 = Div(move _24, const 1_u64);
+ _23 = _1;
StorageDead(_24);
- _22 = opaque::<u64>(move _23) -> [return: bb9, unwind continue];
+ _22 = opaque::<u64>(_1) -> [return: bb9, unwind continue];
}
bb9: {
- _23 = Div(const 0_u64, move _24);
+ _23 = Div(const 0_u64, _1);
StorageDead(_24);
_22 = opaque::<u64>(move _23) -> [return: bb10, unwind continue];
}
bb10: {
StorageDead(_23);
StorageDead(_22);
StorageLive(_26);
@ -182,79 +200,81 @@
StorageLive(_28);
_28 = _1;
- _29 = Eq(_28, const 0_u64);
- assert(!move _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind continue];
+ _29 = _25;
+ assert(!_25, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind continue];
- assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue];
+ _29 = Eq(_1, const 0_u64);
+ assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue];
}
bb10: {
- _27 = Div(const 0_u64, move _28);
+ _27 = const 0_u64;
StorageDead(_28);
- _26 = opaque::<u64>(move _27) -> [return: bb11, unwind continue];
+ _26 = opaque::<u64>(const 0_u64) -> [return: bb11, unwind continue];
}
bb11: {
- _27 = Div(const 1_u64, move _28);
+ _27 = Div(const 1_u64, _1);
StorageDead(_28);
_26 = opaque::<u64>(move _27) -> [return: bb12, unwind continue];
}
bb12: {
StorageDead(_27);
StorageDead(_26);
StorageLive(_30);
StorageLive(_31);
StorageLive(_32);
_32 = _1;
- _33 = Eq(const 0_u64, const 0_u64);
- assert(!move _33, "attempt to calculate the remainder of `{}` with a divisor of zero", _32) -> [success: bb13, unwind continue];
+ _33 = const true;
+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb13, unwind continue];
- _33 = Eq(_32, const 0_u64);
- assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue];
+ _33 = _29;
+ assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue];
}
bb12: {
- _31 = Div(const 1_u64, move _32);
+ _31 = Div(const 1_u64, _1);
StorageDead(_32);
_30 = opaque::<u64>(move _31) -> [return: bb13, unwind continue];
}
bb13: {
- _31 = Rem(move _32, const 0_u64);
+ _31 = Rem(_1, const 0_u64);
StorageDead(_32);
_30 = opaque::<u64>(move _31) -> [return: bb14, unwind continue];
}
bb14: {
StorageDead(_31);
StorageDead(_30);
StorageLive(_34);
StorageLive(_35);
StorageLive(_36);
_36 = _1;
- _37 = Eq(const 1_u64, const 0_u64);
- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb15, unwind continue];
+ _37 = const false;
+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb15, unwind continue];
- _37 = Eq(const 0_u64, const 0_u64);
- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind continue];
+ _37 = const true;
+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind continue];
}
bb14: {
- _35 = Rem(move _36, const 0_u64);
+ _35 = Rem(_1, const 0_u64);
StorageDead(_36);
_34 = opaque::<u64>(move _35) -> [return: bb15, unwind continue];
}
bb15: {
- _35 = Rem(move _36, const 1_u64);
+ _35 = Rem(_1, const 1_u64);
StorageDead(_36);
_34 = opaque::<u64>(move _35) -> [return: bb16, unwind continue];
}
bb16: {
StorageDead(_35);
StorageDead(_34);
StorageLive(_38);
StorageLive(_39);
StorageLive(_40);
_40 = _1;
- _41 = Eq(_40, const 0_u64);
- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind continue];
+ _41 = _25;
+ assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind continue];
- _41 = Eq(const 1_u64, const 0_u64);
- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind continue];
+ _41 = const false;
+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind continue];
}
bb16: {
- _39 = Rem(move _40, const 1_u64);
+ _39 = const 0_u64;
StorageDead(_40);
- _38 = opaque::<u64>(move _39) -> [return: bb17, unwind continue];
+ _38 = opaque::<u64>(const 0_u64) -> [return: bb17, unwind continue];
}
bb17: {
- _39 = Rem(const 0_u64, move _40);
+ _39 = Rem(const 0_u64, _1);
StorageDead(_40);
_38 = opaque::<u64>(move _39) -> [return: bb18, unwind continue];
}
bb18: {
StorageDead(_39);
StorageDead(_38);
StorageLive(_42);
@ -262,27 +282,35 @@
StorageLive(_44);
_44 = _1;
- _45 = Eq(_44, const 0_u64);
- assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind continue];
+ _45 = _25;
+ assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind continue];
- assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue];
+ _45 = _29;
+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue];
}
bb18: {
- _43 = Rem(const 0_u64, move _44);
+ _43 = const 0_u64;
StorageDead(_44);
- _42 = opaque::<u64>(move _43) -> [return: bb19, unwind continue];
+ _42 = opaque::<u64>(const 0_u64) -> [return: bb19, unwind continue];
}
bb19: {
- _43 = Rem(const 1_u64, move _44);
+ _43 = Rem(const 1_u64, _1);
StorageDead(_44);
_42 = opaque::<u64>(move _43) -> [return: bb20, unwind continue];
}
bb20: {
StorageDead(_43);
StorageDead(_42);
StorageLive(_46);
StorageLive(_47);
StorageLive(_48);
_48 = _1;
- _47 = BitAnd(move _48, const 0_u64);
+ _47 = BitAnd(_1, const 0_u64);
- _49 = Eq(_48, const 0_u64);
- assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue];
+ _49 = _29;
+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue];
}
bb20: {
- _47 = Rem(const 1_u64, move _48);
+ _47 = Rem(const 1_u64, _1);
StorageDead(_48);
_46 = opaque::<u64>(move _47) -> [return: bb21, unwind continue];
}
@ -290,58 +318,121 @@
bb21: {
StorageDead(_47);
StorageDead(_46);
StorageLive(_49);
StorageLive(_50);
StorageLive(_51);
_51 = _1;
- _50 = BitOr(move _51, const 0_u64);
+ _50 = BitOr(_1, const 0_u64);
StorageDead(_51);
_49 = opaque::<u64>(move _50) -> [return: bb22, unwind continue];
StorageLive(_52);
_52 = _1;
- _51 = BitAnd(move _52, const 0_u64);
+ _51 = const 0_u64;
StorageDead(_52);
- _50 = opaque::<u64>(move _51) -> [return: bb22, unwind continue];
+ _50 = opaque::<u64>(const 0_u64) -> [return: bb22, unwind continue];
}
bb22: {
StorageDead(_51);
StorageDead(_50);
StorageDead(_49);
StorageLive(_52);
StorageLive(_53);
StorageLive(_54);
_54 = _1;
- _53 = BitXor(move _54, const 0_u64);
+ _53 = BitXor(_1, const 0_u64);
StorageDead(_54);
_52 = opaque::<u64>(move _53) -> [return: bb23, unwind continue];
StorageLive(_55);
_55 = _1;
- _54 = BitAnd(move _55, const _);
+ _54 = _1;
StorageDead(_55);
- _53 = opaque::<u64>(move _54) -> [return: bb23, unwind continue];
+ _53 = opaque::<u64>(_1) -> [return: bb23, unwind continue];
}
bb23: {
StorageDead(_54);
StorageDead(_53);
StorageDead(_52);
StorageLive(_55);
StorageLive(_56);
StorageLive(_57);
_57 = _1;
- _56 = Shr(move _57, const 0_i32);
+ _56 = Shr(_1, const 0_i32);
StorageDead(_57);
_55 = opaque::<u64>(move _56) -> [return: bb24, unwind continue];
StorageLive(_58);
_58 = _1;
- _57 = BitOr(move _58, const 0_u64);
+ _57 = _1;
StorageDead(_58);
- _56 = opaque::<u64>(move _57) -> [return: bb24, unwind continue];
+ _56 = opaque::<u64>(_1) -> [return: bb24, unwind continue];
}
bb24: {
StorageDead(_57);
StorageDead(_56);
StorageDead(_55);
StorageLive(_58);
StorageLive(_59);
StorageLive(_60);
_60 = _1;
- _59 = Shl(move _60, const 0_i32);
+ _59 = Shl(_1, const 0_i32);
StorageDead(_60);
_58 = opaque::<u64>(move _59) -> [return: bb25, unwind continue];
StorageLive(_61);
_61 = _1;
- _60 = BitOr(move _61, const _);
+ _60 = const u64::MAX;
StorageDead(_61);
- _59 = opaque::<u64>(move _60) -> [return: bb25, unwind continue];
+ _59 = opaque::<u64>(const u64::MAX) -> [return: bb25, unwind continue];
}
bb25: {
StorageDead(_60);
StorageDead(_59);
StorageDead(_58);
StorageLive(_62);
StorageLive(_63);
StorageLive(_64);
_64 = _1;
- _63 = BitXor(move _64, const 0_u64);
+ _63 = _1;
StorageDead(_64);
- _62 = opaque::<u64>(move _63) -> [return: bb26, unwind continue];
+ _62 = opaque::<u64>(_1) -> [return: bb26, unwind continue];
}
bb26: {
StorageDead(_63);
StorageDead(_62);
StorageLive(_65);
StorageLive(_66);
StorageLive(_67);
_67 = _1;
StorageLive(_68);
_68 = _1;
- _66 = BitXor(move _67, move _68);
+ _66 = const 0_u64;
StorageDead(_68);
StorageDead(_67);
- _65 = opaque::<u64>(move _66) -> [return: bb27, unwind continue];
+ _65 = opaque::<u64>(const 0_u64) -> [return: bb27, unwind continue];
}
bb27: {
StorageDead(_66);
StorageDead(_65);
StorageLive(_69);
StorageLive(_70);
StorageLive(_71);
_71 = _1;
- _70 = Shr(move _71, const 0_i32);
+ _70 = _1;
StorageDead(_71);
- _69 = opaque::<u64>(move _70) -> [return: bb28, unwind continue];
+ _69 = opaque::<u64>(_1) -> [return: bb28, unwind continue];
}
bb28: {
StorageDead(_70);
StorageDead(_69);
StorageLive(_72);
StorageLive(_73);
StorageLive(_74);
_74 = _1;
- _73 = Shl(move _74, const 0_i32);
+ _73 = _1;
StorageDead(_74);
- _72 = opaque::<u64>(move _73) -> [return: bb29, unwind continue];
+ _72 = opaque::<u64>(_1) -> [return: bb29, unwind continue];
}
bb29: {
StorageDead(_73);
StorageDead(_72);
_0 = const ();
return;
}

101
tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
View File

@ -15,11 +15,16 @@
let _10: ();
let mut _11: u64;
let mut _12: u64;
let mut _13: (u64, bool);
let _14: ();
let mut _15: u64;
let mut _13: u64;
let mut _14: (u64, bool);
let _15: ();
let mut _16: u64;
let mut _17: (u64, bool);
let mut _17: u64;
let mut _18: (u64, bool);
let _19: ();
let mut _20: u64;
let mut _21: u64;
let mut _22: (u64, bool);
bb0: {
StorageLive(_2);
@ -29,13 +34,15 @@
- _5 = CheckedAdd(_4, const 0_u64);
- assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind unreachable];
+ _5 = CheckedAdd(_1, const 0_u64);
+ assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind unreachable];
+ assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind unreachable];
}
bb1: {
_3 = move (_5.0: u64);
- _3 = move (_5.0: u64);
+ _3 = _1;
StorageDead(_4);
_2 = opaque::<u64>(move _3) -> [return: bb2, unwind unreachable];
- _2 = opaque::<u64>(move _3) -> [return: bb2, unwind unreachable];
+ _2 = opaque::<u64>(_1) -> [return: bb2, unwind unreachable];
}
bb2: {
@ -47,59 +54,95 @@
_8 = _1;
- _9 = CheckedSub(_8, const 0_u64);
- assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind unreachable];
+ _9 = CheckedSub(_1, const 0_u64);
+ assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind unreachable];
+ _9 = _5;
+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind unreachable];
}
bb3: {
_7 = move (_9.0: u64);
- _7 = move (_9.0: u64);
+ _7 = _1;
StorageDead(_8);
_6 = opaque::<u64>(move _7) -> [return: bb4, unwind unreachable];
- _6 = opaque::<u64>(move _7) -> [return: bb4, unwind unreachable];
+ _6 = opaque::<u64>(_1) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_7);
StorageDead(_6);
StorageLive(_10);
StorageLive(_11);
- StorageLive(_11);
+ nop;
StorageLive(_12);
_12 = _1;
- _13 = CheckedMul(_12, const 0_u64);
- assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", move _12, const 0_u64) -> [success: bb5, unwind unreachable];
+ _13 = CheckedMul(_1, const 0_u64);
+ assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb5, unwind unreachable];
StorageLive(_13);
_13 = _1;
- _14 = CheckedSub(_12, _13);
- assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind unreachable];
+ _14 = const (0_u64, false);
+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind unreachable];
}
bb5: {
_11 = move (_13.0: u64);
- _11 = move (_14.0: u64);
+ _11 = const 0_u64;
StorageDead(_13);
StorageDead(_12);
_10 = opaque::<u64>(move _11) -> [return: bb6, unwind unreachable];
- _10 = opaque::<u64>(move _11) -> [return: bb6, unwind unreachable];
+ _10 = opaque::<u64>(const 0_u64) -> [return: bb6, unwind unreachable];
}
bb6: {
StorageDead(_11);
- StorageDead(_11);
+ nop;
StorageDead(_10);
StorageLive(_14);
StorageLive(_15);
StorageLive(_16);
_16 = _1;
- _17 = CheckedMul(_16, const 1_u64);
- assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", move _16, const 1_u64) -> [success: bb7, unwind unreachable];
+ _17 = CheckedMul(_1, const 1_u64);
+ assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb7, unwind unreachable];
StorageLive(_17);
_17 = _1;
- _18 = CheckedMul(_17, const 0_u64);
- assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind unreachable];
+ _18 = const (0_u64, false);
+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind unreachable];
}
bb7: {
_15 = move (_17.0: u64);
StorageDead(_16);
_14 = opaque::<u64>(move _15) -> [return: bb8, unwind unreachable];
- _16 = move (_18.0: u64);
+ _16 = const 0_u64;
StorageDead(_17);
- _15 = opaque::<u64>(move _16) -> [return: bb8, unwind unreachable];
+ _15 = opaque::<u64>(const 0_u64) -> [return: bb8, unwind unreachable];
}
bb8: {
StorageDead(_16);
StorageDead(_15);
StorageDead(_14);
StorageLive(_19);
StorageLive(_20);
StorageLive(_21);
_21 = _1;
- _22 = CheckedMul(_21, const 1_u64);
- assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind unreachable];
+ _22 = _5;
+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind unreachable];
}
bb9: {
- _20 = move (_22.0: u64);
+ _20 = _1;
StorageDead(_21);
- _19 = opaque::<u64>(move _20) -> [return: bb10, unwind unreachable];
+ _19 = opaque::<u64>(_1) -> [return: bb10, unwind unreachable];
}
bb10: {
StorageDead(_20);
StorageDead(_19);
_0 = const ();
return;
}
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
}

101
tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
View File

@ -15,11 +15,16 @@
let _10: ();
let mut _11: u64;
let mut _12: u64;
let mut _13: (u64, bool);
let _14: ();
let mut _15: u64;
let mut _13: u64;
let mut _14: (u64, bool);
let _15: ();
let mut _16: u64;
let mut _17: (u64, bool);
let mut _17: u64;
let mut _18: (u64, bool);
let _19: ();
let mut _20: u64;
let mut _21: u64;
let mut _22: (u64, bool);
bb0: {
StorageLive(_2);
@ -29,13 +34,15 @@
- _5 = CheckedAdd(_4, const 0_u64);
- assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind continue];
+ _5 = CheckedAdd(_1, const 0_u64);
+ assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind continue];
+ assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind continue];
}
bb1: {
_3 = move (_5.0: u64);
- _3 = move (_5.0: u64);
+ _3 = _1;
StorageDead(_4);
_2 = opaque::<u64>(move _3) -> [return: bb2, unwind continue];
- _2 = opaque::<u64>(move _3) -> [return: bb2, unwind continue];
+ _2 = opaque::<u64>(_1) -> [return: bb2, unwind continue];
}
bb2: {
@ -47,59 +54,95 @@
_8 = _1;
- _9 = CheckedSub(_8, const 0_u64);
- assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind continue];
+ _9 = CheckedSub(_1, const 0_u64);
+ assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind continue];
+ _9 = _5;
+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind continue];
}
bb3: {
_7 = move (_9.0: u64);
- _7 = move (_9.0: u64);
+ _7 = _1;
StorageDead(_8);
_6 = opaque::<u64>(move _7) -> [return: bb4, unwind continue];
- _6 = opaque::<u64>(move _7) -> [return: bb4, unwind continue];
+ _6 = opaque::<u64>(_1) -> [return: bb4, unwind continue];
}
bb4: {
StorageDead(_7);
StorageDead(_6);
StorageLive(_10);
StorageLive(_11);
- StorageLive(_11);
+ nop;
StorageLive(_12);
_12 = _1;
- _13 = CheckedMul(_12, const 0_u64);
- assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", move _12, const 0_u64) -> [success: bb5, unwind continue];
+ _13 = CheckedMul(_1, const 0_u64);
+ assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb5, unwind continue];
StorageLive(_13);
_13 = _1;
- _14 = CheckedSub(_12, _13);
- assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind continue];
+ _14 = const (0_u64, false);
+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind continue];
}
bb5: {
_11 = move (_13.0: u64);
- _11 = move (_14.0: u64);
+ _11 = const 0_u64;
StorageDead(_13);
StorageDead(_12);
_10 = opaque::<u64>(move _11) -> [return: bb6, unwind continue];
- _10 = opaque::<u64>(move _11) -> [return: bb6, unwind continue];
+ _10 = opaque::<u64>(const 0_u64) -> [return: bb6, unwind continue];
}
bb6: {
StorageDead(_11);
- StorageDead(_11);
+ nop;
StorageDead(_10);
StorageLive(_14);
StorageLive(_15);
StorageLive(_16);
_16 = _1;
- _17 = CheckedMul(_16, const 1_u64);
- assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", move _16, const 1_u64) -> [success: bb7, unwind continue];
+ _17 = CheckedMul(_1, const 1_u64);
+ assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb7, unwind continue];
StorageLive(_17);
_17 = _1;
- _18 = CheckedMul(_17, const 0_u64);
- assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind continue];
+ _18 = const (0_u64, false);
+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind continue];
}
bb7: {
_15 = move (_17.0: u64);
StorageDead(_16);
_14 = opaque::<u64>(move _15) -> [return: bb8, unwind continue];
- _16 = move (_18.0: u64);
+ _16 = const 0_u64;
StorageDead(_17);
- _15 = opaque::<u64>(move _16) -> [return: bb8, unwind continue];
+ _15 = opaque::<u64>(const 0_u64) -> [return: bb8, unwind continue];
}
bb8: {
StorageDead(_16);
StorageDead(_15);
StorageDead(_14);
StorageLive(_19);
StorageLive(_20);
StorageLive(_21);
_21 = _1;
- _22 = CheckedMul(_21, const 1_u64);
- assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind continue];
+ _22 = _5;
+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind continue];
}
bb9: {
- _20 = move (_22.0: u64);
+ _20 = _1;
StorageDead(_21);
- _19 = opaque::<u64>(move _20) -> [return: bb10, unwind continue];
+ _19 = opaque::<u64>(_1) -> [return: bb10, unwind continue];
}
bb10: {
StorageDead(_20);
StorageDead(_19);
_0 = const ();
return;
}
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
}

10
tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
View File

@ -30,10 +30,11 @@
StorageLive(_6);
_6 = _1;
- _4 = Eq(move _5, move _6);
+ _4 = Eq(_1, _1);
+ _4 = const true;
StorageDead(_6);
StorageDead(_5);
_3 = opaque::<bool>(move _4) -> [return: bb1, unwind unreachable];
- _3 = opaque::<bool>(move _4) -> [return: bb1, unwind unreachable];
+ _3 = opaque::<bool>(const true) -> [return: bb1, unwind unreachable];
}
bb1: {
@ -46,10 +47,11 @@
StorageLive(_10);
_10 = _1;
- _8 = Ne(move _9, move _10);
+ _8 = Ne(_1, _1);
+ _8 = const false;
StorageDead(_10);
StorageDead(_9);
_7 = opaque::<bool>(move _8) -> [return: bb2, unwind unreachable];
- _7 = opaque::<bool>(move _8) -> [return: bb2, unwind unreachable];
+ _7 = opaque::<bool>(const false) -> [return: bb2, unwind unreachable];
}
bb2: {

10
tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
View File

@ -30,10 +30,11 @@
StorageLive(_6);
_6 = _1;
- _4 = Eq(move _5, move _6);
+ _4 = Eq(_1, _1);
+ _4 = const true;
StorageDead(_6);
StorageDead(_5);
_3 = opaque::<bool>(move _4) -> [return: bb1, unwind continue];
- _3 = opaque::<bool>(move _4) -> [return: bb1, unwind continue];
+ _3 = opaque::<bool>(const true) -> [return: bb1, unwind continue];
}
bb1: {
@ -46,10 +47,11 @@
StorageLive(_10);
_10 = _1;
- _8 = Ne(move _9, move _10);
+ _8 = Ne(_1, _1);
+ _8 = const false;
StorageDead(_10);
StorageDead(_9);
_7 = opaque::<bool>(move _8) -> [return: bb2, unwind continue];
- _7 = opaque::<bool>(move _8) -> [return: bb2, unwind continue];
+ _7 = opaque::<bool>(const false) -> [return: bb2, unwind continue];
}
bb2: {

18
tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
View File

@ -8,10 +8,10 @@
let mut _3: fn(u8) -> u8;
let _5: ();
let mut _6: fn(u8) -> u8;
let mut _9: {closure@$DIR/gvn.rs:591:19: 591:21};
let mut _9: {closure@$DIR/gvn.rs:585:19: 585:21};
let _10: ();
let mut _11: fn();
let mut _13: {closure@$DIR/gvn.rs:591:19: 591:21};
let mut _13: {closure@$DIR/gvn.rs:585:19: 585:21};
let _14: ();
let mut _15: fn();
scope 1 {
@ -19,7 +19,7 @@
let _4: fn(u8) -> u8;
scope 2 {
debug g => _4;
let _7: {closure@$DIR/gvn.rs:591:19: 591:21};
let _7: {closure@$DIR/gvn.rs:585:19: 585:21};
scope 3 {
debug closure => _7;
let _8: fn();
@ -62,16 +62,16 @@
StorageDead(_6);
StorageDead(_5);
- StorageLive(_7);
- _7 = {closure@$DIR/gvn.rs:591:19: 591:21};
- _7 = {closure@$DIR/gvn.rs:585:19: 585:21};
- StorageLive(_8);
+ nop;
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
+ nop;
StorageLive(_9);
- _9 = _7;
- _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
StorageDead(_9);
StorageLive(_10);
StorageLive(_11);
@ -88,8 +88,8 @@
StorageLive(_13);
- _13 = _7;
- _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
StorageDead(_13);
StorageLive(_14);
StorageLive(_15);

18
tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
View File

@ -8,10 +8,10 @@
let mut _3: fn(u8) -> u8;
let _5: ();
let mut _6: fn(u8) -> u8;
let mut _9: {closure@$DIR/gvn.rs:591:19: 591:21};
let mut _9: {closure@$DIR/gvn.rs:585:19: 585:21};
let _10: ();
let mut _11: fn();
let mut _13: {closure@$DIR/gvn.rs:591:19: 591:21};
let mut _13: {closure@$DIR/gvn.rs:585:19: 585:21};
let _14: ();
let mut _15: fn();
scope 1 {
@ -19,7 +19,7 @@
let _4: fn(u8) -> u8;
scope 2 {
debug g => _4;
let _7: {closure@$DIR/gvn.rs:591:19: 591:21};
let _7: {closure@$DIR/gvn.rs:585:19: 585:21};
scope 3 {
debug closure => _7;
let _8: fn();
@ -62,16 +62,16 @@
StorageDead(_6);
StorageDead(_5);
- StorageLive(_7);
- _7 = {closure@$DIR/gvn.rs:591:19: 591:21};
- _7 = {closure@$DIR/gvn.rs:585:19: 585:21};
- StorageLive(_8);
+ nop;
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
+ nop;
StorageLive(_9);
- _9 = _7;
- _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
StorageDead(_9);
StorageLive(_10);
StorageLive(_11);
@ -88,8 +88,8 @@
StorageLive(_13);
- _13 = _7;
- _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
StorageDead(_13);
StorageLive(_14);
StorageLive(_15);

78
tests/mir-opt/gvn.rs
View File

@ -169,66 +169,61 @@ fn repeated_index<T: Copy, const N: usize>(x: T, idx: usize) {
/// Verify symbolic integer arithmetic simplifications.
fn arithmetic(x: u64) {
// CHECK-LABEL: fn arithmetic(
// CHECK: [[add:_.*]] = Add(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[add]])
// CHECK: opaque::<u64>(_1)
opaque(x + 0);
// CHECK: [[sub:_.*]] = Sub(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[sub]])
// CHECK: opaque::<u64>(_1)
opaque(x - 0);
// CHECK: [[mul0:_.*]] = Mul(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[mul0]])
// CHECK: opaque::<u64>(const 0_u64)
opaque(x - x);
// CHECK: opaque::<u64>(const 0_u64)
opaque(x * 0);
// CHECK: [[mul1:_.*]] = Mul(_1, const 1_u64);
// CHECK: opaque::<u64>(move [[mul1]])
// CHECK: opaque::<u64>(_1)
opaque(x * 1);
// CHECK: assert(!const true, "attempt to divide `{}` by zero",
// CHECK: [[div0:_.*]] = Div(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[div0]])
opaque(x / 0);
// CHECK: [[div1:_.*]] = Div(_1, const 1_u64);
// CHECK: opaque::<u64>(move [[div1]])
// CHECK: opaque::<u64>(_1)
opaque(x / 1);
// CHECK: [[zdiv:_.*]] = Div(const 0_u64, _1);
// CHECK: opaque::<u64>(move [[zdiv]])
// CHECK: opaque::<u64>(const 0_u64)
opaque(0 / x);
// CHECK: [[odiv:_.*]] = Div(const 1_u64, _1);
// CHECK: opaque::<u64>(move [[odiv]])
opaque(1 / x);
// CHECK: assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero"
// CHECK: [[rem0:_.*]] = Rem(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[rem0]])
opaque(x % 0);
// CHECK: [[rem1:_.*]] = Rem(_1, const 1_u64);
// CHECK: opaque::<u64>(move [[rem1]])
// CHECK: opaque::<u64>(const 0_u64)
opaque(x % 1);
// CHECK: [[zrem:_.*]] = Rem(const 0_u64, _1);
// CHECK: opaque::<u64>(move [[zrem]])
// CHECK: opaque::<u64>(const 0_u64)
opaque(0 % x);
// CHECK: [[orem:_.*]] = Rem(const 1_u64, _1);
// CHECK: opaque::<u64>(move [[orem]])
opaque(1 % x);
// CHECK: [[and:_.*]] = BitAnd(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[and]])
// CHECK: opaque::<u64>(const 0_u64)
opaque(x & 0);
// CHECK: [[or:_.*]] = BitOr(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[or]])
// CHECK: opaque::<u64>(_1)
opaque(x & u64::MAX);
// CHECK: opaque::<u64>(_1)
opaque(x | 0);
// CHECK: [[xor:_.*]] = BitXor(_1, const 0_u64);
// CHECK: opaque::<u64>(move [[xor]])
// CHECK: opaque::<u64>(const u64::MAX)
opaque(x | u64::MAX);
// CHECK: opaque::<u64>(_1)
opaque(x ^ 0);
// CHECK: [[shr:_.*]] = Shr(_1, const 0_i32);
// CHECK: opaque::<u64>(move [[shr]])
// CHECK: opaque::<u64>(const 0_u64)
opaque(x ^ x);
// CHECK: opaque::<u64>(_1)
opaque(x >> 0);
// CHECK: [[shl:_.*]] = Shl(_1, const 0_i32);
// CHECK: opaque::<u64>(move [[shl]])
// CHECK: opaque::<u64>(_1)
opaque(x << 0);
}
fn comparison(x: u64, y: u64) {
// CHECK-LABEL: fn comparison(
// CHECK: [[eqxx:_.*]] = Eq(_1, _1);
// CHECK: opaque::<bool>(move [[eqxx]])
// CHECK: opaque::<bool>(const true)
opaque(x == x);
// CHECK: [[nexx:_.*]] = Ne(_1, _1);
// CHECK: opaque::<bool>(move [[nexx]])
// CHECK: opaque::<bool>(const false)
opaque(x != x);
// CHECK: [[eqxy:_.*]] = Eq(_1, _2);
// CHECK: opaque::<bool>(move [[eqxy]])
@ -242,21 +237,20 @@ fn comparison(x: u64, y: u64) {
#[rustc_inherit_overflow_checks]
fn arithmetic_checked(x: u64) {
// CHECK-LABEL: fn arithmetic_checked(
// CHECK: [[cadd:_.*]] = CheckedAdd(_1, const 0_u64);
// CHECK: [[add:_.*]] = move ([[cadd]].0: u64);
// CHECK: opaque::<u64>(move [[add]])
// CHECK: assert(!const false,
// CHECK: opaque::<u64>(_1)
opaque(x + 0);
// CHECK: [[csub:_.*]] = CheckedSub(_1, const 0_u64);
// CHECK: [[sub:_.*]] = move ([[csub]].0: u64);
// CHECK: opaque::<u64>(move [[sub]])
// CHECK: assert(!const false,
// CHECK: opaque::<u64>(_1)
opaque(x - 0);
// CHECK: [[cmul0:_.*]] = CheckedMul(_1, const 0_u64);
// CHECK: [[mul0:_.*]] = move ([[cmul0]].0: u64);
// CHECK: opaque::<u64>(move [[mul0]])
// CHECK: assert(!const false,
// CHECK: opaque::<u64>(const 0_u64)
opaque(x - x);
// CHECK: assert(!const false,
// CHECK: opaque::<u64>(const 0_u64)
opaque(x * 0);
// CHECK: [[cmul1:_.*]] = CheckedMul(_1, const 1_u64);
// CHECK: [[mul1:_.*]] = move ([[cmul1]].0: u64);
// CHECK: opaque::<u64>(move [[mul1]])
// CHECK: assert(!const false,
// CHECK: opaque::<u64>(_1)
opaque(x * 1);
}

17
tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
View File

@ -19,7 +19,6 @@
scope 1 (inlined imm8) {
debug x => _5;
let mut _14: u32;
let mut _15: u32;
scope 2 {
debug out => _4;
}
@ -36,14 +35,14 @@
StorageLive(_5);
_5 = _1;
_4 = const 0_u32;
StorageLive(_15);
StorageLive(_14);
- _14 = Shr(_5, const 0_i32);
+ _14 = Shr(_1, const 0_i32);
_15 = BitAnd(move _14, const 255_u32);
StorageDead(_14);
_4 = BitOr(const 0_u32, move _15);
StorageDead(_15);
- StorageLive(_14);
- _14 = BitAnd(_5, const 255_u32);
- _4 = BitOr(const 0_u32, move _14);
- StorageDead(_14);
+ nop;
+ _14 = BitAnd(_1, const 255_u32);
+ _4 = _14;
+ nop;
StorageDead(_5);
StorageLive(_6);
StorageLive(_7);

17
tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
View File

@ -19,7 +19,6 @@
scope 1 (inlined imm8) {
debug x => _5;
let mut _14: u32;
let mut _15: u32;
scope 2 {
debug out => _4;
}
@ -36,14 +35,14 @@
StorageLive(_5);
_5 = _1;
_4 = const 0_u32;
StorageLive(_15);
StorageLive(_14);
- _14 = Shr(_5, const 0_i32);
+ _14 = Shr(_1, const 0_i32);
_15 = BitAnd(move _14, const 255_u32);
StorageDead(_14);
_4 = BitOr(const 0_u32, move _15);
StorageDead(_15);
- StorageLive(_14);
- _14 = BitAnd(_5, const 255_u32);
- _4 = BitOr(const 0_u32, move _14);
- StorageDead(_14);
+ nop;
+ _14 = BitAnd(_1, const 255_u32);
+ _4 = _14;
+ nop;
StorageDead(_5);
StorageLive(_6);
StorageLive(_7);