mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #119670 - cjgillot:gvn-arithmetic, r=oli-obk

Browse source 
Fold arithmetic identities in GVN

Extracted from https://github.com/rust-lang/rust/pull/111344

This PR implements a few arithmetic folds for unary and binary operations.
This should take care of the missed optimizations introduced by https://github.com/rust-lang/rust/pull/116012.
This commit is contained in:
bors 2024-01-17 11:46:49 +00:00
commit 52790a98e5
37 changed files with 2092 additions and 511 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

181
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::*;
@ -767,10 +776,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
}
// Operations.
Rvalue::Len(ref mut place) => {
let place = self.simplify_place_value(place, location)?;
Value::Len(place)
}
Rvalue::Len(ref mut place) => return self.simplify_len(place, location),
Rvalue::Cast(kind, ref mut value, to) => {
let from = value.ty(self.local_decls, self.tcx);
let value = self.simplify_operand(value, location)?;
@ -785,17 +791,36 @@ 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?)
// Only short-circuit options after we called `simplify_operand`
// on both operands for side effect.
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?)
// Only short-circuit options after we called `simplify_operand`
// on both operands for side effect.
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)?;
if let Some(value) = self.simplify_unary(op, arg) {
return Some(value);
}
Value::UnaryOp(op, arg)
}
Rvalue::Discriminant(ref mut place) => {
@ -894,6 +919,150 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
Some(self.insert(Value::Aggregate(ty, variant_index, fields)))
}
#[instrument(level = "trace", skip(self), ret)]
fn simplify_unary(&mut self, op: UnOp, value: VnIndex) -> Option<VnIndex> {
let value = match (op, self.get(value)) {
(UnOp::Not, Value::UnaryOp(UnOp::Not, inner)) => return Some(*inner),
(UnOp::Neg, Value::UnaryOp(UnOp::Neg, inner)) => return Some(*inner),
(UnOp::Not, Value::BinaryOp(BinOp::Eq, lhs, rhs)) => {
Value::BinaryOp(BinOp::Ne, *lhs, *rhs)
}
(UnOp::Not, Value::BinaryOp(BinOp::Ne, lhs, rhs)) => {
Value::BinaryOp(BinOp::Eq, *lhs, *rhs)
}
_ => return None,
};
Some(self.insert(value))
}
#[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()?;
if layout.abi.is_scalar() {
let scalar = self.ecx.read_scalar(constant).ok()?;
scalar.to_bits(constant.layout.size).ok()
} else {
// `constant` is a wide pointer. Do not evaluate to bits.
None
}
};
// Represent the values as `Left(bits)` or `Right(VnIndex)`.
use Either::{Left, Right};
let a = as_bits(lhs).map_or(Right(lhs), Left);
let b = as_bits(rhs).map_or(Right(rhs), Left);
let result = match (op, a, b) {
// Neutral elements.
(BinOp::Add | BinOp::BitOr | BinOp::BitXor, Left(0), Right(p))
| (
BinOp::Add
| BinOp::BitOr
| BinOp::BitXor
| BinOp::Sub
| BinOp::Offset
| BinOp::Shl
| BinOp::Shr,
Right(p),
Left(0),
)
| (BinOp::Mul, Left(1), Right(p))
| (BinOp::Mul | BinOp::Div, Right(p), Left(1)) => p,
// Attempt to simplify `x & ALL_ONES` to `x`, with `ALL_ONES` depending on type size.
(BinOp::BitAnd, Right(p), Left(ones)) | (BinOp::BitAnd, Left(ones), Right(p))
if ones == layout.size.truncate(u128::MAX)
|| (layout.ty.is_bool() && ones == 1) =>
{
p
}
// Absorbing elements.
(BinOp::Mul | BinOp::BitAnd, _, Left(0))
| (BinOp::Rem, _, Left(1))
| (
BinOp::Mul | BinOp::Div | BinOp::Rem | BinOp::BitAnd | BinOp::Shl | BinOp::Shr,
Left(0),
_,
) => self.insert_scalar(Scalar::from_uint(0u128, layout.size), lhs_ty),
// Attempt to simplify `x | ALL_ONES` to `ALL_ONES`.
(BinOp::BitOr, _, Left(ones)) | (BinOp::BitOr, Left(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, Left(a), Left(b)) => self.insert_bool(a == b),
(BinOp::Eq, a, b) if a == b => self.insert_bool(true),
(BinOp::Ne, Left(a), Left(b)) => self.insert_bool(a != b),
(BinOp::Ne, a, b) if a == b => self.insert_bool(false),
_ => return None,
};
if checked {
let false_val = self.insert_bool(false);
Some(self.insert_tuple(vec![result, false_val]))
} else {
Some(result)
}
}
fn simplify_len(&mut self, place: &mut Place<'tcx>, location: Location) -> Option<VnIndex> {
// Trivial case: we are fetching a statically known length.
let place_ty = place.ty(self.local_decls, self.tcx).ty;
if let ty::Array(_, len) = place_ty.kind() {
return self.insert_constant(Const::from_ty_const(*len, self.tcx));
}
let mut inner = self.simplify_place_value(place, location)?;
// The length information is stored in the fat pointer.
// Reborrowing copies length information from one pointer to the other.
while let Value::Address { place: borrowed, .. } = self.get(inner)
&& let [PlaceElem::Deref] = borrowed.projection[..]
&& let Some(borrowed) = self.locals[borrowed.local]
{
inner = borrowed;
}
// We have an unsizing cast, which assigns the length to fat pointer metadata.
if let Value::Cast { kind, from, to, .. } = self.get(inner)
&& let CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize) = kind
&& let Some(from) = from.builtin_deref(true)
&& let ty::Array(_, len) = from.ty.kind()
&& let Some(to) = to.builtin_deref(true)
&& let ty::Slice(..) = to.ty.kind()
{
return self.insert_constant(Const::from_ty_const(*len, self.tcx));
}
// Fallback: a symbolic `Len`.
Some(self.insert(Value::Len(inner)))
}
}
fn op_to_prop_const<'tcx>(

7
tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u32, const 1_u32, const 2_u32, const 3_u32];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind unreachable];
+ _4 = const 4_usize;
+ _5 = 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 unreachable];
}
bb1: {

7
tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u32, const 1_u32, const 2_u32, const 3_u32];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind continue];
+ _4 = const 4_usize;
+ _5 = 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];
}
bb1: {

7
tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u32, const 1_u32, const 2_u32, const 3_u32];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind unreachable];
+ _4 = const 4_usize;
+ _5 = 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 unreachable];
}
bb1: {

7
tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u32, const 1_u32, const 2_u32, const 3_u32];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind continue];
+ _4 = const 4_usize;
+ _5 = 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];
}
bb1: {

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;

7
tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u8; 5000];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind unreachable];
+ _4 = const 5000_usize;
+ _5 = 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 unreachable];
}
bb1: {

7
tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u8; 5000];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind continue];
+ _4 = const 5000_usize;
+ _5 = 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];
}
bb1: {

7
tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u8; 5000];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind unreachable];
+ _4 = const 5000_usize;
+ _5 = 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 unreachable];
}
bb1: {

7
tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff
View file

@ -18,11 +18,12 @@
_2 = [const 0_u8; 5000];
StorageLive(_3);
_3 = const 2_usize;
_4 = Len(_2);
- _4 = Len(_2);
- _5 = Lt(_3, _4);
- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+ _5 = Lt(const 2_usize, _4);
+ assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, const 2_usize) -> [success: bb1, unwind continue];
+ _4 = const 5000_usize;
+ _5 = 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];
}
bb1: {

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;
}

7
tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff
View file

@ -20,11 +20,12 @@
_3 = [const 42_u32; 8];
StorageLive(_4);
_4 = const 2_usize;
_5 = Len(_3);
- _5 = Len(_3);
- _6 = Lt(_4, _5);
- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable];
+ _6 = Lt(const 2_usize, _5);
+ assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, const 2_usize) -> [success: bb1, unwind unreachable];
+ _5 = const 8_usize;
+ _6 = 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 unreachable];
}
bb1: {

7
tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff
View file

@ -20,11 +20,12 @@
_3 = [const 42_u32; 8];
StorageLive(_4);
_4 = const 2_usize;
_5 = Len(_3);
- _5 = Len(_3);
- _6 = Lt(_4, _5);
- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue];
+ _6 = Lt(const 2_usize, _5);
+ assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, const 2_usize) -> [success: bb1, unwind continue];
+ _5 = const 8_usize;
+ _6 = 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];
}
bb1: {

7
tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff
View file

@ -20,11 +20,12 @@
_3 = [const 42_u32; 8];
StorageLive(_4);
_4 = const 2_usize;
_5 = Len(_3);
- _5 = Len(_3);
- _6 = Lt(_4, _5);
- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable];
+ _6 = Lt(const 2_usize, _5);
+ assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, const 2_usize) -> [success: bb1, unwind unreachable];
+ _5 = const 8_usize;
+ _6 = 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 unreachable];
}
bb1: {

7
tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff
View file

@ -20,11 +20,12 @@
_3 = [const 42_u32; 8];
StorageLive(_4);
_4 = const 2_usize;
_5 = Len(_3);
- _5 = Len(_3);
- _6 = Lt(_4, _5);
- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue];
+ _6 = Lt(const 2_usize, _5);
+ assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, const 2_usize) -> [success: bb1, unwind continue];
+ _5 = const 8_usize;
+ _6 = 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];
}
bb1: {

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:610:19: 610: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:610:19: 610: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:610:19: 610: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:610:19: 610:21};
- StorageLive(_8);
+ nop;
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:610:19: 610: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:610:19: 610:21};
+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:610:19: 610: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:610:19: 610:21};
+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:610:19: 610: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:610:19: 610: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:610:19: 610: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:610:19: 610: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:610:19: 610:21};
- StorageLive(_8);
+ nop;
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:610:19: 610: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:610:19: 610:21};
+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:610:19: 610: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:610:19: 610:21};
+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:610:19: 610:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
StorageDead(_13);
StorageLive(_14);
StorageLive(_15);

13
tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff
View file

@ -32,11 +32,12 @@
StorageLive(_6);
StorageLive(_7);
_7 = const 0_usize;
_8 = Len(_3);
- _8 = Len(_3);
- _9 = Lt(_7, _8);
- assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb1, unwind unreachable];
+ _9 = Lt(const 0_usize, _8);
+ assert(move _9, "index out of bounds: the length is {} but the index is {}", _8, const 0_usize) -> [success: bb1, unwind unreachable];
+ _8 = const N;
+ _9 = Lt(const 0_usize, const N);
+ assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb1, unwind unreachable];
}
bb1: {
@ -57,9 +58,9 @@
- _13 = Len(_3);
- _14 = Lt(_12, _13);
- assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, _12) -> [success: bb3, unwind unreachable];
+ _13 = _8;
+ _14 = Lt(_2, _8);
+ assert(move _14, "index out of bounds: the length is {} but the index is {}", _8, _2) -> [success: bb3, unwind unreachable];
+ _13 = const N;
+ _14 = Lt(_2, const N);
+ assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, _2) -> [success: bb3, unwind unreachable];
}
bb3: {

13
tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff
View file

@ -32,11 +32,12 @@
StorageLive(_6);
StorageLive(_7);
_7 = const 0_usize;
_8 = Len(_3);
- _8 = Len(_3);
- _9 = Lt(_7, _8);
- assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb1, unwind continue];
+ _9 = Lt(const 0_usize, _8);
+ assert(move _9, "index out of bounds: the length is {} but the index is {}", _8, const 0_usize) -> [success: bb1, unwind continue];
+ _8 = const N;
+ _9 = Lt(const 0_usize, const N);
+ assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb1, unwind continue];
}
bb1: {
@ -57,9 +58,9 @@
- _13 = Len(_3);
- _14 = Lt(_12, _13);
- assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, _12) -> [success: bb3, unwind continue];
+ _13 = _8;
+ _14 = Lt(_2, _8);
+ assert(move _14, "index out of bounds: the length is {} but the index is {}", _8, _2) -> [success: bb3, unwind continue];
+ _13 = const N;
+ _14 = Lt(_2, const N);
+ assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, _2) -> [success: bb3, unwind continue];
}
bb3: {

128
tests/mir-opt/gvn.rs
View file

@ -166,69 +166,89 @@ fn repeated_index<T: Copy, const N: usize>(x: T, idx: usize) {
opaque(a[idx]);
}
fn unary(x: i64) {
// CHECK-LABEL: fn unary(
// CHECK: opaque::<i64>(_1)
opaque(--x); // This is `x`.
// CHECK: [[b:_.*]] = Lt(_1, const 13_i64);
// CHECK: opaque::<bool>([[b]])
let b = x < 13;
opaque(!!b); // This is `b`.
// Both lines should test the same thing.
// CHECK: [[c:_.*]] = Ne(_1, const 15_i64);
// CHECK: opaque::<bool>([[c]])
// CHECK: opaque::<bool>([[c]])
opaque(x != 15);
opaque(!(x == 15));
// Both lines should test the same thing.
// CHECK: [[d:_.*]] = Eq(_1, const 35_i64);
// CHECK: opaque::<bool>([[d]])
// CHECK: opaque::<bool>([[d]])
opaque(x == 35);
opaque(!(x != 35));
}
/// 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 +262,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);
}
@ -625,10 +644,32 @@ fn constant_index_overflow<T: Copy>(x: &[T]) {
opaque(b)
}
fn wide_ptr_ops() {
let a: *const dyn Send = &1 as &dyn Send;
let b: *const dyn Send = &1 as &dyn Send;
let _val = a == b;
let _val = a != b;
let _val = a < b;
let _val = a <= b;
let _val = a > b;
let _val = a >= b;
let a: *const [u8] = unsafe { transmute((1usize, 1usize)) };
let b: *const [u8] = unsafe { transmute((1usize, 2usize)) };
opaque(!(a == b));
opaque(a != b);
opaque(a <= b);
opaque(a < b);
opaque(!(a >= b));
opaque(!(a > b));
}
fn main() {
subexpression_elimination(2, 4, 5);
wrap_unwrap(5);
repeated_index::<u32, 7>(5, 3);
unary(i64::MIN);
arithmetic(5);
comparison(5, 6);
arithmetic_checked(5);
@ -644,6 +685,7 @@ fn main() {
fn_pointers();
indirect_static();
constant_index_overflow(&[5, 3]);
wide_ptr_ops();
}
#[inline(never)]
@ -657,6 +699,7 @@ fn identity<T>(x: T) -> T {
// EMIT_MIR gvn.subexpression_elimination.GVN.diff
// EMIT_MIR gvn.wrap_unwrap.GVN.diff
// EMIT_MIR gvn.repeated_index.GVN.diff
// EMIT_MIR gvn.unary.GVN.diff
// EMIT_MIR gvn.arithmetic.GVN.diff
// EMIT_MIR gvn.comparison.GVN.diff
// EMIT_MIR gvn.arithmetic_checked.GVN.diff
@ -671,3 +714,4 @@ fn identity<T>(x: T) -> T {
// EMIT_MIR gvn.fn_pointers.GVN.diff
// EMIT_MIR gvn.indirect_static.GVN.diff
// EMIT_MIR gvn.constant_index_overflow.GVN.diff
// EMIT_MIR gvn.wide_ptr_ops.GVN.diff

153
tests/mir-opt/gvn.unary.GVN.panic-abort.diff Normal file
View file

@ -0,0 +1,153 @@
- // MIR for `unary` before GVN
+ // MIR for `unary` after GVN
fn unary(_1: i64) -> () {
debug x => _1;
let mut _0: ();
let _2: ();
let mut _3: i64;
let mut _4: i64;
let mut _5: i64;
let _6: bool;
let mut _7: i64;
let _8: ();
let mut _9: bool;
let mut _10: bool;
let mut _11: bool;
let _12: ();
let mut _13: bool;
let mut _14: i64;
let _15: ();
let mut _16: bool;
let mut _17: bool;
let mut _18: i64;
let _19: ();
let mut _20: bool;
let mut _21: i64;
let _22: ();
let mut _23: bool;
let mut _24: bool;
let mut _25: i64;
scope 1 {
debug b => _6;
}
bb0: {
StorageLive(_2);
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_5 = _1;
- _4 = Neg(move _5);
+ _4 = Neg(_1);
StorageDead(_5);
- _3 = Neg(move _4);
+ _3 = _1;
StorageDead(_4);
- _2 = opaque::<i64>(move _3) -> [return: bb1, unwind unreachable];
+ _2 = opaque::<i64>(_1) -> [return: bb1, unwind unreachable];
}
bb1: {
StorageDead(_3);
StorageDead(_2);
- StorageLive(_6);
+ nop;
StorageLive(_7);
_7 = _1;
- _6 = Lt(move _7, const 13_i64);
+ _6 = Lt(_1, const 13_i64);
StorageDead(_7);
StorageLive(_8);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_11 = _6;
- _10 = Not(move _11);
+ _10 = Not(_6);
StorageDead(_11);
- _9 = Not(move _10);
+ _9 = _6;
StorageDead(_10);
- _8 = opaque::<bool>(move _9) -> [return: bb2, unwind unreachable];
+ _8 = opaque::<bool>(_6) -> [return: bb2, unwind unreachable];
}
bb2: {
StorageDead(_9);
StorageDead(_8);
StorageLive(_12);
- StorageLive(_13);
+ nop;
StorageLive(_14);
_14 = _1;
- _13 = Ne(move _14, const 15_i64);
+ _13 = Ne(_1, const 15_i64);
StorageDead(_14);
- _12 = opaque::<bool>(move _13) -> [return: bb3, unwind unreachable];
+ _12 = opaque::<bool>(_13) -> [return: bb3, unwind unreachable];
}
bb3: {
- StorageDead(_13);
+ nop;
StorageDead(_12);
StorageLive(_15);
StorageLive(_16);
StorageLive(_17);
StorageLive(_18);
_18 = _1;
- _17 = Eq(move _18, const 15_i64);
+ _17 = Eq(_1, const 15_i64);
StorageDead(_18);
- _16 = Not(move _17);
+ _16 = _13;
StorageDead(_17);
- _15 = opaque::<bool>(move _16) -> [return: bb4, unwind unreachable];
+ _15 = opaque::<bool>(_13) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_16);
StorageDead(_15);
StorageLive(_19);
- StorageLive(_20);
+ nop;
StorageLive(_21);
_21 = _1;
- _20 = Eq(move _21, const 35_i64);
+ _20 = Eq(_1, const 35_i64);
StorageDead(_21);
- _19 = opaque::<bool>(move _20) -> [return: bb5, unwind unreachable];
+ _19 = opaque::<bool>(_20) -> [return: bb5, unwind unreachable];
}
bb5: {
- StorageDead(_20);
+ nop;
StorageDead(_19);
StorageLive(_22);
StorageLive(_23);
StorageLive(_24);
StorageLive(_25);
_25 = _1;
- _24 = Ne(move _25, const 35_i64);
+ _24 = Ne(_1, const 35_i64);
StorageDead(_25);
- _23 = Not(move _24);
+ _23 = _20;
StorageDead(_24);
- _22 = opaque::<bool>(move _23) -> [return: bb6, unwind unreachable];
+ _22 = opaque::<bool>(_20) -> [return: bb6, unwind unreachable];
}
bb6: {
StorageDead(_23);
StorageDead(_22);
_0 = const ();
- StorageDead(_6);
+ nop;
return;
}
}

153
tests/mir-opt/gvn.unary.GVN.panic-unwind.diff Normal file
View file

@ -0,0 +1,153 @@
- // MIR for `unary` before GVN
+ // MIR for `unary` after GVN
fn unary(_1: i64) -> () {
debug x => _1;
let mut _0: ();
let _2: ();
let mut _3: i64;
let mut _4: i64;
let mut _5: i64;
let _6: bool;
let mut _7: i64;
let _8: ();
let mut _9: bool;
let mut _10: bool;
let mut _11: bool;
let _12: ();
let mut _13: bool;
let mut _14: i64;
let _15: ();
let mut _16: bool;
let mut _17: bool;
let mut _18: i64;
let _19: ();
let mut _20: bool;
let mut _21: i64;
let _22: ();
let mut _23: bool;
let mut _24: bool;
let mut _25: i64;
scope 1 {
debug b => _6;
}
bb0: {
StorageLive(_2);
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_5 = _1;
- _4 = Neg(move _5);
+ _4 = Neg(_1);
StorageDead(_5);
- _3 = Neg(move _4);
+ _3 = _1;
StorageDead(_4);
- _2 = opaque::<i64>(move _3) -> [return: bb1, unwind continue];
+ _2 = opaque::<i64>(_1) -> [return: bb1, unwind continue];
}
bb1: {
StorageDead(_3);
StorageDead(_2);
- StorageLive(_6);
+ nop;
StorageLive(_7);
_7 = _1;
- _6 = Lt(move _7, const 13_i64);
+ _6 = Lt(_1, const 13_i64);
StorageDead(_7);
StorageLive(_8);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_11 = _6;
- _10 = Not(move _11);
+ _10 = Not(_6);
StorageDead(_11);
- _9 = Not(move _10);
+ _9 = _6;
StorageDead(_10);
- _8 = opaque::<bool>(move _9) -> [return: bb2, unwind continue];
+ _8 = opaque::<bool>(_6) -> [return: bb2, unwind continue];
}
bb2: {
StorageDead(_9);
StorageDead(_8);
StorageLive(_12);
- StorageLive(_13);
+ nop;
StorageLive(_14);
_14 = _1;
- _13 = Ne(move _14, const 15_i64);
+ _13 = Ne(_1, const 15_i64);
StorageDead(_14);
- _12 = opaque::<bool>(move _13) -> [return: bb3, unwind continue];
+ _12 = opaque::<bool>(_13) -> [return: bb3, unwind continue];
}
bb3: {
- StorageDead(_13);
+ nop;
StorageDead(_12);
StorageLive(_15);
StorageLive(_16);
StorageLive(_17);
StorageLive(_18);
_18 = _1;
- _17 = Eq(move _18, const 15_i64);
+ _17 = Eq(_1, const 15_i64);
StorageDead(_18);
- _16 = Not(move _17);
+ _16 = _13;
StorageDead(_17);
- _15 = opaque::<bool>(move _16) -> [return: bb4, unwind continue];
+ _15 = opaque::<bool>(_13) -> [return: bb4, unwind continue];
}
bb4: {
StorageDead(_16);
StorageDead(_15);
StorageLive(_19);
- StorageLive(_20);
+ nop;
StorageLive(_21);
_21 = _1;
- _20 = Eq(move _21, const 35_i64);
+ _20 = Eq(_1, const 35_i64);
StorageDead(_21);
- _19 = opaque::<bool>(move _20) -> [return: bb5, unwind continue];
+ _19 = opaque::<bool>(_20) -> [return: bb5, unwind continue];
}
bb5: {
- StorageDead(_20);
+ nop;
StorageDead(_19);
StorageLive(_22);
StorageLive(_23);
StorageLive(_24);
StorageLive(_25);
_25 = _1;
- _24 = Ne(move _25, const 35_i64);
+ _24 = Ne(_1, const 35_i64);
StorageDead(_25);
- _23 = Not(move _24);
+ _23 = _20;
StorageDead(_24);
- _22 = opaque::<bool>(move _23) -> [return: bb6, unwind continue];
+ _22 = opaque::<bool>(_20) -> [return: bb6, unwind continue];
}
bb6: {
StorageDead(_23);
StorageDead(_22);
_0 = const ();
- StorageDead(_6);
+ nop;
return;
}
}

386
tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-abort.diff Normal file
View file

@ -0,0 +1,386 @@
- // MIR for `wide_ptr_ops` before GVN
+ // MIR for `wide_ptr_ops` after GVN
fn wide_ptr_ops() -> () {
let mut _0: ();
let _1: *const dyn std::marker::Send;
let mut _2: *const dyn std::marker::Send;
let _3: &dyn std::marker::Send;
let mut _4: &i32;
let _5: &i32;
let _6: i32;
let mut _8: *const dyn std::marker::Send;
let _9: &dyn std::marker::Send;
let mut _10: &i32;
let _11: &i32;
let _12: i32;
let mut _14: *const dyn std::marker::Send;
let mut _15: *const dyn std::marker::Send;
let mut _16: *const dyn std::marker::Send;
let mut _18: *const dyn std::marker::Send;
let mut _19: *const dyn std::marker::Send;
let mut _20: *const dyn std::marker::Send;
let mut _22: *const dyn std::marker::Send;
let mut _23: *const dyn std::marker::Send;
let mut _24: *const dyn std::marker::Send;
let mut _26: *const dyn std::marker::Send;
let mut _27: *const dyn std::marker::Send;
let mut _28: *const dyn std::marker::Send;
let mut _30: *const dyn std::marker::Send;
let mut _31: *const dyn std::marker::Send;
let mut _32: *const dyn std::marker::Send;
let mut _34: *const dyn std::marker::Send;
let mut _35: *const dyn std::marker::Send;
let mut _36: *const dyn std::marker::Send;
let mut _38: (usize, usize);
let mut _40: (usize, usize);
let _41: ();
let mut _42: bool;
let mut _43: bool;
let mut _44: *const [u8];
let mut _45: *const [u8];
let _46: ();
let mut _47: bool;
let mut _48: *const [u8];
let mut _49: *const [u8];
let _50: ();
let mut _51: bool;
let mut _52: *const [u8];
let mut _53: *const [u8];
let _54: ();
let mut _55: bool;
let mut _56: *const [u8];
let mut _57: *const [u8];
let _58: ();
let mut _59: bool;
let mut _60: bool;
let mut _61: *const [u8];
let mut _62: *const [u8];
let _63: ();
let mut _64: bool;
let mut _65: bool;
let mut _66: *const [u8];
let mut _67: *const [u8];
let mut _69: &i32;
scope 1 {
debug a => _1;
let _7: *const dyn std::marker::Send;
let mut _68: &i32;
scope 2 {
debug b => _7;
let _13: bool;
scope 3 {
debug _val => _13;
let _17: bool;
scope 4 {
debug _val => _17;
let _21: bool;
scope 5 {
debug _val => _21;
let _25: bool;
scope 6 {
debug _val => _25;
let _29: bool;
scope 7 {
debug _val => _29;
let _33: bool;
scope 8 {
debug _val => _33;
let _37: *const [u8];
scope 9 {
debug a => _37;
let _39: *const [u8];
scope 11 {
debug b => _39;
}
scope 12 {
}
}
scope 10 {
}
}
}
}
}
}
}
}
}
bb0: {
- StorageLive(_1);
+ nop;
StorageLive(_2);
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_69 = const _;
_5 = &(*_69);
_4 = &(*_5);
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_4);
_2 = &raw const (*_3);
_1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_2);
StorageDead(_5);
StorageDead(_3);
- StorageLive(_7);
+ nop;
StorageLive(_8);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_68 = const _;
_11 = &(*_68);
_10 = &(*_11);
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_10);
_8 = &raw const (*_9);
_7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_8);
StorageDead(_11);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
_14 = _1;
- StorageLive(_15);
+ nop;
StorageLive(_16);
_16 = _7;
- _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_16);
- _13 = Eq(move _14, move _15);
- StorageDead(_15);
+ _13 = Eq(_1, _15);
+ nop;
StorageDead(_14);
StorageLive(_17);
StorageLive(_18);
_18 = _1;
StorageLive(_19);
StorageLive(_20);
_20 = _7;
- _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _19 = _15;
StorageDead(_20);
- _17 = Ne(move _18, move _19);
+ _17 = Ne(_1, _15);
StorageDead(_19);
StorageDead(_18);
StorageLive(_21);
StorageLive(_22);
_22 = _1;
StorageLive(_23);
StorageLive(_24);
_24 = _7;
- _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _23 = _15;
StorageDead(_24);
- _21 = Lt(move _22, move _23);
+ _21 = Lt(_1, _15);
StorageDead(_23);
StorageDead(_22);
StorageLive(_25);
StorageLive(_26);
_26 = _1;
StorageLive(_27);
StorageLive(_28);
_28 = _7;
- _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _27 = _15;
StorageDead(_28);
- _25 = Le(move _26, move _27);
+ _25 = Le(_1, _15);
StorageDead(_27);
StorageDead(_26);
StorageLive(_29);
StorageLive(_30);
_30 = _1;
StorageLive(_31);
StorageLive(_32);
_32 = _7;
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _31 = _15;
StorageDead(_32);
- _29 = Gt(move _30, move _31);
+ _29 = Gt(_1, _15);
StorageDead(_31);
StorageDead(_30);
StorageLive(_33);
StorageLive(_34);
_34 = _1;
StorageLive(_35);
StorageLive(_36);
_36 = _7;
- _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _35 = _15;
StorageDead(_36);
- _33 = Ge(move _34, move _35);
+ _33 = Ge(_1, _15);
StorageDead(_35);
StorageDead(_34);
- StorageLive(_37);
+ nop;
StorageLive(_38);
- _38 = (const 1_usize, const 1_usize);
- _37 = move _38 as *const [u8] (Transmute);
+ _38 = const (1_usize, 1_usize);
+ _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageDead(_38);
- StorageLive(_39);
+ nop;
StorageLive(_40);
- _40 = (const 1_usize, const 2_usize);
- _39 = move _40 as *const [u8] (Transmute);
+ _40 = const (1_usize, 2_usize);
+ _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
StorageDead(_40);
StorageLive(_41);
- StorageLive(_42);
+ nop;
StorageLive(_43);
StorageLive(_44);
- _44 = _37;
+ _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_45);
- _45 = _39;
- _43 = Eq(move _44, move _45);
+ _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _43 = Eq(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_45);
StorageDead(_44);
_42 = Not(move _43);
StorageDead(_43);
- _41 = opaque::<bool>(move _42) -> [return: bb1, unwind unreachable];
+ _41 = opaque::<bool>(_42) -> [return: bb1, unwind unreachable];
}
bb1: {
- StorageDead(_42);
+ nop;
StorageDead(_41);
StorageLive(_46);
StorageLive(_47);
StorageLive(_48);
- _48 = _37;
+ _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_49);
- _49 = _39;
- _47 = Ne(move _48, move _49);
+ _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _47 = _42;
StorageDead(_49);
StorageDead(_48);
- _46 = opaque::<bool>(move _47) -> [return: bb2, unwind unreachable];
+ _46 = opaque::<bool>(_42) -> [return: bb2, unwind unreachable];
}
bb2: {
StorageDead(_47);
StorageDead(_46);
StorageLive(_50);
StorageLive(_51);
StorageLive(_52);
- _52 = _37;
+ _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_53);
- _53 = _39;
- _51 = Le(move _52, move _53);
+ _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _51 = Le(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_53);
StorageDead(_52);
_50 = opaque::<bool>(move _51) -> [return: bb3, unwind unreachable];
}
bb3: {
StorageDead(_51);
StorageDead(_50);
StorageLive(_54);
StorageLive(_55);
StorageLive(_56);
- _56 = _37;
+ _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_57);
- _57 = _39;
- _55 = Lt(move _56, move _57);
+ _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _55 = Lt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_57);
StorageDead(_56);
_54 = opaque::<bool>(move _55) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_55);
StorageDead(_54);
StorageLive(_58);
StorageLive(_59);
StorageLive(_60);
StorageLive(_61);
- _61 = _37;
+ _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_62);
- _62 = _39;
- _60 = Ge(move _61, move _62);
+ _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _60 = Ge(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_62);
StorageDead(_61);
_59 = Not(move _60);
StorageDead(_60);
_58 = opaque::<bool>(move _59) -> [return: bb5, unwind unreachable];
}
bb5: {
StorageDead(_59);
StorageDead(_58);
StorageLive(_63);
StorageLive(_64);
StorageLive(_65);
StorageLive(_66);
- _66 = _37;
+ _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_67);
- _67 = _39;
- _65 = Gt(move _66, move _67);
+ _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _65 = Gt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_67);
StorageDead(_66);
_64 = Not(move _65);
StorageDead(_65);
_63 = opaque::<bool>(move _64) -> [return: bb6, unwind unreachable];
}
bb6: {
StorageDead(_64);
StorageDead(_63);
_0 = const ();
- StorageDead(_39);
- StorageDead(_37);
+ nop;
+ nop;
StorageDead(_33);
StorageDead(_29);
StorageDead(_25);
StorageDead(_21);
StorageDead(_17);
StorageDead(_13);
- StorageDead(_7);
- StorageDead(_1);
+ nop;
+ nop;
return;
}
+ }
+
+ ALLOC1 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
}

386
tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-unwind.diff Normal file
View file

@ -0,0 +1,386 @@
- // MIR for `wide_ptr_ops` before GVN
+ // MIR for `wide_ptr_ops` after GVN
fn wide_ptr_ops() -> () {
let mut _0: ();
let _1: *const dyn std::marker::Send;
let mut _2: *const dyn std::marker::Send;
let _3: &dyn std::marker::Send;
let mut _4: &i32;
let _5: &i32;
let _6: i32;
let mut _8: *const dyn std::marker::Send;
let _9: &dyn std::marker::Send;
let mut _10: &i32;
let _11: &i32;
let _12: i32;
let mut _14: *const dyn std::marker::Send;
let mut _15: *const dyn std::marker::Send;
let mut _16: *const dyn std::marker::Send;
let mut _18: *const dyn std::marker::Send;
let mut _19: *const dyn std::marker::Send;
let mut _20: *const dyn std::marker::Send;
let mut _22: *const dyn std::marker::Send;
let mut _23: *const dyn std::marker::Send;
let mut _24: *const dyn std::marker::Send;
let mut _26: *const dyn std::marker::Send;
let mut _27: *const dyn std::marker::Send;
let mut _28: *const dyn std::marker::Send;
let mut _30: *const dyn std::marker::Send;
let mut _31: *const dyn std::marker::Send;
let mut _32: *const dyn std::marker::Send;
let mut _34: *const dyn std::marker::Send;
let mut _35: *const dyn std::marker::Send;
let mut _36: *const dyn std::marker::Send;
let mut _38: (usize, usize);
let mut _40: (usize, usize);
let _41: ();
let mut _42: bool;
let mut _43: bool;
let mut _44: *const [u8];
let mut _45: *const [u8];
let _46: ();
let mut _47: bool;
let mut _48: *const [u8];
let mut _49: *const [u8];
let _50: ();
let mut _51: bool;
let mut _52: *const [u8];
let mut _53: *const [u8];
let _54: ();
let mut _55: bool;
let mut _56: *const [u8];
let mut _57: *const [u8];
let _58: ();
let mut _59: bool;
let mut _60: bool;
let mut _61: *const [u8];
let mut _62: *const [u8];
let _63: ();
let mut _64: bool;
let mut _65: bool;
let mut _66: *const [u8];
let mut _67: *const [u8];
let mut _69: &i32;
scope 1 {
debug a => _1;
let _7: *const dyn std::marker::Send;
let mut _68: &i32;
scope 2 {
debug b => _7;
let _13: bool;
scope 3 {
debug _val => _13;
let _17: bool;
scope 4 {
debug _val => _17;
let _21: bool;
scope 5 {
debug _val => _21;
let _25: bool;
scope 6 {
debug _val => _25;
let _29: bool;
scope 7 {
debug _val => _29;
let _33: bool;
scope 8 {
debug _val => _33;
let _37: *const [u8];
scope 9 {
debug a => _37;
let _39: *const [u8];
scope 11 {
debug b => _39;
}
scope 12 {
}
}
scope 10 {
}
}
}
}
}
}
}
}
}
bb0: {
- StorageLive(_1);
+ nop;
StorageLive(_2);
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_69 = const _;
_5 = &(*_69);
_4 = &(*_5);
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_4);
_2 = &raw const (*_3);
_1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_2);
StorageDead(_5);
StorageDead(_3);
- StorageLive(_7);
+ nop;
StorageLive(_8);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_68 = const _;
_11 = &(*_68);
_10 = &(*_11);
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_10);
_8 = &raw const (*_9);
_7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_8);
StorageDead(_11);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
_14 = _1;
- StorageLive(_15);
+ nop;
StorageLive(_16);
_16 = _7;
- _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_16);
- _13 = Eq(move _14, move _15);
- StorageDead(_15);
+ _13 = Eq(_1, _15);
+ nop;
StorageDead(_14);
StorageLive(_17);
StorageLive(_18);
_18 = _1;
StorageLive(_19);
StorageLive(_20);
_20 = _7;
- _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _19 = _15;
StorageDead(_20);
- _17 = Ne(move _18, move _19);
+ _17 = Ne(_1, _15);
StorageDead(_19);
StorageDead(_18);
StorageLive(_21);
StorageLive(_22);
_22 = _1;
StorageLive(_23);
StorageLive(_24);
_24 = _7;
- _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _23 = _15;
StorageDead(_24);
- _21 = Lt(move _22, move _23);
+ _21 = Lt(_1, _15);
StorageDead(_23);
StorageDead(_22);
StorageLive(_25);
StorageLive(_26);
_26 = _1;
StorageLive(_27);
StorageLive(_28);
_28 = _7;
- _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _27 = _15;
StorageDead(_28);
- _25 = Le(move _26, move _27);
+ _25 = Le(_1, _15);
StorageDead(_27);
StorageDead(_26);
StorageLive(_29);
StorageLive(_30);
_30 = _1;
StorageLive(_31);
StorageLive(_32);
_32 = _7;
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _31 = _15;
StorageDead(_32);
- _29 = Gt(move _30, move _31);
+ _29 = Gt(_1, _15);
StorageDead(_31);
StorageDead(_30);
StorageLive(_33);
StorageLive(_34);
_34 = _1;
StorageLive(_35);
StorageLive(_36);
_36 = _7;
- _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _35 = _15;
StorageDead(_36);
- _33 = Ge(move _34, move _35);
+ _33 = Ge(_1, _15);
StorageDead(_35);
StorageDead(_34);
- StorageLive(_37);
+ nop;
StorageLive(_38);
- _38 = (const 1_usize, const 1_usize);
- _37 = move _38 as *const [u8] (Transmute);
+ _38 = const (1_usize, 1_usize);
+ _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageDead(_38);
- StorageLive(_39);
+ nop;
StorageLive(_40);
- _40 = (const 1_usize, const 2_usize);
- _39 = move _40 as *const [u8] (Transmute);
+ _40 = const (1_usize, 2_usize);
+ _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
StorageDead(_40);
StorageLive(_41);
- StorageLive(_42);
+ nop;
StorageLive(_43);
StorageLive(_44);
- _44 = _37;
+ _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_45);
- _45 = _39;
- _43 = Eq(move _44, move _45);
+ _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _43 = Eq(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_45);
StorageDead(_44);
_42 = Not(move _43);
StorageDead(_43);
- _41 = opaque::<bool>(move _42) -> [return: bb1, unwind continue];
+ _41 = opaque::<bool>(_42) -> [return: bb1, unwind continue];
}
bb1: {
- StorageDead(_42);
+ nop;
StorageDead(_41);
StorageLive(_46);
StorageLive(_47);
StorageLive(_48);
- _48 = _37;
+ _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_49);
- _49 = _39;
- _47 = Ne(move _48, move _49);
+ _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _47 = _42;
StorageDead(_49);
StorageDead(_48);
- _46 = opaque::<bool>(move _47) -> [return: bb2, unwind continue];
+ _46 = opaque::<bool>(_42) -> [return: bb2, unwind continue];
}
bb2: {
StorageDead(_47);
StorageDead(_46);
StorageLive(_50);
StorageLive(_51);
StorageLive(_52);
- _52 = _37;
+ _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_53);
- _53 = _39;
- _51 = Le(move _52, move _53);
+ _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _51 = Le(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_53);
StorageDead(_52);
_50 = opaque::<bool>(move _51) -> [return: bb3, unwind continue];
}
bb3: {
StorageDead(_51);
StorageDead(_50);
StorageLive(_54);
StorageLive(_55);
StorageLive(_56);
- _56 = _37;
+ _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_57);
- _57 = _39;
- _55 = Lt(move _56, move _57);
+ _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _55 = Lt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_57);
StorageDead(_56);
_54 = opaque::<bool>(move _55) -> [return: bb4, unwind continue];
}
bb4: {
StorageDead(_55);
StorageDead(_54);
StorageLive(_58);
StorageLive(_59);
StorageLive(_60);
StorageLive(_61);
- _61 = _37;
+ _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_62);
- _62 = _39;
- _60 = Ge(move _61, move _62);
+ _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _60 = Ge(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_62);
StorageDead(_61);
_59 = Not(move _60);
StorageDead(_60);
_58 = opaque::<bool>(move _59) -> [return: bb5, unwind continue];
}
bb5: {
StorageDead(_59);
StorageDead(_58);
StorageLive(_63);
StorageLive(_64);
StorageLive(_65);
StorageLive(_66);
- _66 = _37;
+ _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_67);
- _67 = _39;
- _65 = Gt(move _66, move _67);
+ _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _65 = Gt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
StorageDead(_67);
StorageDead(_66);
_64 = Not(move _65);
StorageDead(_65);
_63 = opaque::<bool>(move _64) -> [return: bb6, unwind continue];
}
bb6: {
StorageDead(_64);
StorageDead(_63);
_0 = const ();
- StorageDead(_39);
- StorageDead(_37);
+ nop;
+ nop;
StorageDead(_33);
StorageDead(_29);
StorageDead(_25);
StorageDead(_21);
StorageDead(_17);
StorageDead(_13);
- StorageDead(_7);
- StorageDead(_1);
+ nop;
+ nop;
return;
}
+ }
+
+ ALLOC1 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
}

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);