Add global value numbering pass.

compiler/rustc_middle/src/mir/syntax.rs

@@ -1333,7 +1333,7 @@ pub enum AggregateKind<'tcx> {
     Generator(DefId, GenericArgsRef<'tcx>, hir::Movability),
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
 pub enum NullOp<'tcx> {
     /// Returns the size of a value of that type
     SizeOf,

compiler/rustc_mir_transform/src/gvn.rs

@@ -0,0 +1,413 @@
+use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
+use rustc_data_structures::graph::dominators::Dominators;
+use rustc_index::bit_set::BitSet;
+use rustc_index::IndexVec;
+use rustc_macros::newtype_index;
+use rustc_middle::mir::visit::*;
+use rustc_middle::mir::*;
+use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_target::abi::{VariantIdx, FIRST_VARIANT};
+
+use crate::ssa::SsaLocals;
+use crate::MirPass;
+
+/// Global value numbering.
+pub struct GVN;
+
+impl<'tcx> MirPass<'tcx> for GVN {
+    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
+        sess.mir_opt_level() >= 4
+    }
+
+    #[instrument(level = "trace", skip(self, tcx, body))]
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        debug!(def_id = ?body.source.def_id());
+        propagate_ssa(tcx, body);
+    }
+}
+
+fn propagate_ssa<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+    let param_env = tcx.param_env_reveal_all_normalized(body.source.def_id());
+    let ssa = SsaLocals::new(body);
+    // Clone dominators as we need them while mutating the body.
+    let dominators = body.basic_blocks.dominators().clone();
+
+    let mut state = VnState::new(tcx, param_env, &body.local_decls);
+    for arg in body.args_iter() {
+        if ssa.is_ssa(arg) {
+            let value = state.new_opaque().unwrap();
+            state.assign(arg, value);
+        }
+    }
+
+    for (local, rvalue, _) in ssa.assignments(body) {
+        let value = state.insert_rvalue(rvalue).or_else(|| state.new_opaque()).unwrap();
+        state.assign(local, value);
+    }
+
+    // Stop creating opaques during replacement as it is useless.
+    state.next_opaque = None;
+
+    let mut any_replacement = false;
+    let mut replacer = Replacer {
+        tcx,
+        param_env,
+        ssa,
+        dominators,
+        state,
+        reused_locals: BitSet::new_empty(body.local_decls.len()),
+        any_replacement: &mut any_replacement,
+    };
+
+    let reverse_postorder = body.basic_blocks.reverse_postorder().to_vec();
+    for bb in reverse_postorder {
+        let data = &mut body.basic_blocks.as_mut_preserves_cfg()[bb];
+        replacer.visit_basic_block_data(bb, data);
+    }
+
+    StorageRemover { tcx, reused_locals: replacer.reused_locals }.visit_body_preserves_cfg(body);
+
+    if any_replacement {
+        crate::simplify::remove_unused_definitions(body);
+    }
+}
+
+newtype_index! {
+    struct VnIndex {}
+}
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+enum Value<'tcx> {
+    // Root values.
+    /// Used to represent values we know nothing about.
+    /// The `usize` is a counter incremented by `new_opaque`.
+    Opaque(usize),
+    /// Evaluated or unevaluated constant value.
+    Constant(Const<'tcx>),
+    /// An aggregate value, either tuple/closure/struct/enum.
+    /// This does not contain unions, as we cannot reason with the value.
+    Aggregate(Ty<'tcx>, VariantIdx, Vec<VnIndex>),
+    /// This corresponds to a `[value; count]` expression.
+    Repeat(VnIndex, ty::Const<'tcx>),
+    /// The address of a place.
+    Address {
+        place: Place<'tcx>,
+        /// Give each borrow and pointer a different provenance, so we don't merge them.
+        provenance: usize,
+    },
+
+    // Extractions.
+    /// This is the *value* obtained by projecting another value.
+    Projection(VnIndex, ProjectionElem<VnIndex, Ty<'tcx>>),
+    /// Discriminant of the given value.
+    Discriminant(VnIndex),
+    /// Length of an array or slice.
+    Len(VnIndex),
+
+    // Operations.
+    NullaryOp(NullOp<'tcx>, Ty<'tcx>),
+    UnaryOp(UnOp, VnIndex),
+    BinaryOp(BinOp, VnIndex, VnIndex),
+    CheckedBinaryOp(BinOp, VnIndex, VnIndex),
+    Cast {
+        kind: CastKind,
+        value: VnIndex,
+        from: Ty<'tcx>,
+        to: Ty<'tcx>,
+    },
+}
+
+struct VnState<'body, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    local_decls: &'body LocalDecls<'tcx>,
+    /// Value stored in each local.
+    locals: IndexVec<Local, Option<VnIndex>>,
+    /// First local to be assigned that value.
+    rev_locals: FxHashMap<VnIndex, Vec<Local>>,
+    values: FxIndexSet<Value<'tcx>>,
+    /// Counter to generate different values.
+    /// This is an option to stop creating opaques during replacement.
+    next_opaque: Option<usize>,
+}
+
+impl<'body, 'tcx> VnState<'body, 'tcx> {
+    fn new(
+        tcx: TyCtxt<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
+        local_decls: &'body LocalDecls<'tcx>,
+    ) -> Self {
+        VnState {
+            tcx,
+            param_env,
+            local_decls,
+            locals: IndexVec::from_elem(None, local_decls),
+            rev_locals: FxHashMap::default(),
+            values: FxIndexSet::default(),
+            next_opaque: Some(0),
+        }
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn insert(&mut self, value: Value<'tcx>) -> VnIndex {
+        let (index, _) = self.values.insert_full(value);
+        VnIndex::from_usize(index)
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn new_opaque(&mut self) -> Option<VnIndex> {
+        let next_opaque = self.next_opaque.as_mut()?;
+        let value = Value::Opaque(*next_opaque);
+        *next_opaque += 1;
+        Some(self.insert(value))
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn new_pointer(&mut self, place: Place<'tcx>) -> Option<VnIndex> {
+        let next_opaque = self.next_opaque.as_mut()?;
+        let value = Value::Address { place, provenance: *next_opaque };
+        *next_opaque += 1;
+        Some(self.insert(value))
+    }
+
+    fn get(&self, index: VnIndex) -> &Value<'tcx> {
+        self.values.get_index(index.as_usize()).unwrap()
+    }
+
+    #[instrument(level = "trace", skip(self))]
+    fn assign(&mut self, local: Local, value: VnIndex) {
+        self.locals[local] = Some(value);
+        self.rev_locals.entry(value).or_default().push(local);
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn insert_place(&mut self, place: Place<'tcx>) -> Option<VnIndex> {
+        let mut value = self.locals[place.local]?;
+
+        for (index, proj) in place.projection.iter().enumerate() {
+            let proj = match proj {
+                ProjectionElem::Deref => {
+                    let ty = Place::ty_from(
+                        place.local,
+                        &place.projection[..index],
+                        self.local_decls,
+                        self.tcx,
+                    )
+                    .ty;
+                    if let Some(Mutability::Not) = ty.ref_mutability()
+                        && let Some(pointee_ty) = ty.builtin_deref(true)
+                        && pointee_ty.ty.is_freeze(self.tcx, self.param_env)
+                    {
+                        // An immutable borrow `_x` always points to the same value for the
+                        // lifetime of the borrow, so we can merge all instances of `*_x`.
+                        ProjectionElem::Deref
+                    } else {
+                        return None;
+                    }
+                }
+                ProjectionElem::Field(f, ty) => ProjectionElem::Field(f, ty),
+                ProjectionElem::Index(idx) => {
+                    let idx = self.locals[idx]?;
+                    ProjectionElem::Index(idx)
+                }
+                ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
+                    ProjectionElem::ConstantIndex { offset, min_length, from_end }
+                }
+                ProjectionElem::Subslice { from, to, from_end } => {
+                    ProjectionElem::Subslice { from, to, from_end }
+                }
+                ProjectionElem::Downcast(name, index) => ProjectionElem::Downcast(name, index),
+                ProjectionElem::OpaqueCast(ty) => ProjectionElem::OpaqueCast(ty),
+            };
+            value = self.insert(Value::Projection(value, proj));
+        }
+
+        Some(value)
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn insert_operand(&mut self, operand: &Operand<'tcx>) -> Option<VnIndex> {
+        match *operand {
+            Operand::Constant(ref constant) => Some(self.insert(Value::Constant(constant.const_))),
+            Operand::Copy(place) | Operand::Move(place) => self.insert_place(place),
+        }
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn insert_rvalue(&mut self, rvalue: &Rvalue<'tcx>) -> Option<VnIndex> {
+        let value = match *rvalue {
+            // Forward values.
+            Rvalue::Use(ref operand) => return self.insert_operand(operand),
+            Rvalue::CopyForDeref(place) => return self.insert_operand(&Operand::Copy(place)),
+
+            // Roots.
+            Rvalue::Repeat(ref op, amount) => {
+                let op = self.insert_operand(op)?;
+                Value::Repeat(op, amount)
+            }
+            Rvalue::NullaryOp(op, ty) => Value::NullaryOp(op, ty),
+            Rvalue::Aggregate(box ref kind, ref fields) => {
+                let variant_index = match *kind {
+                    AggregateKind::Array(..)
+                    | AggregateKind::Tuple
+                    | AggregateKind::Closure(..)
+                    | AggregateKind::Generator(..) => FIRST_VARIANT,
+                    AggregateKind::Adt(_, variant_index, _, _, None) => variant_index,
+                    // Do not track unions.
+                    AggregateKind::Adt(_, _, _, _, Some(_)) => return None,
+                };
+                let fields: Option<Vec<_>> = fields
+                    .iter()
+                    .map(|op| self.insert_operand(op).or_else(|| self.new_opaque()))
+                    .collect();
+                let ty = rvalue.ty(self.local_decls, self.tcx);
+                Value::Aggregate(ty, variant_index, fields?)
+            }
+            Rvalue::Ref(.., place) | Rvalue::AddressOf(_, place) => return self.new_pointer(place),
+
+            // Operations.
+            Rvalue::Len(place) => {
+                let place = self.insert_place(place)?;
+                Value::Len(place)
+            }
+            Rvalue::Cast(kind, ref value, to) => {
+                let from = value.ty(self.local_decls, self.tcx);
+                let value = self.insert_operand(value)?;
+                Value::Cast { kind, value, from, to }
+            }
+            Rvalue::BinaryOp(op, box (ref lhs, ref rhs)) => {
+                let lhs = self.insert_operand(lhs)?;
+                let rhs = self.insert_operand(rhs)?;
+                Value::BinaryOp(op, lhs, rhs)
+            }
+            Rvalue::CheckedBinaryOp(op, box (ref lhs, ref rhs)) => {
+                let lhs = self.insert_operand(lhs)?;
+                let rhs = self.insert_operand(rhs)?;
+                Value::CheckedBinaryOp(op, lhs, rhs)
+            }
+            Rvalue::UnaryOp(op, ref arg) => {
+                let arg = self.insert_operand(arg)?;
+                Value::UnaryOp(op, arg)
+            }
+            Rvalue::Discriminant(place) => {
+                let place = self.insert_place(place)?;
+                Value::Discriminant(place)
+            }
+
+            // Unsupported values.
+            Rvalue::ThreadLocalRef(..) | Rvalue::ShallowInitBox(..) => return None,
+        };
+        debug!(?value);
+        Some(self.insert(value))
+    }
+}
+
+struct Replacer<'a, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    ssa: SsaLocals,
+    dominators: Dominators<BasicBlock>,
+    state: VnState<'a, 'tcx>,
+    reused_locals: BitSet<Local>,
+    any_replacement: &'a mut bool,
+}
+
+impl<'tcx> Replacer<'_, 'tcx> {
+    fn try_as_constant(&mut self, index: VnIndex) -> Option<ConstOperand<'tcx>> {
+        if let Value::Constant(const_) = self.state.get(index) {
+            Some(ConstOperand { span: rustc_span::DUMMY_SP, user_ty: None, const_: const_.clone() })
+        } else {
+            None
+        }
+    }
+
+    fn try_as_local(&mut self, index: VnIndex, loc: Location) -> Option<Local> {
+        let other = self.state.rev_locals.get(&index)?;
+        other
+            .iter()
+            .copied()
+            .find(|&other| self.ssa.assignment_dominates(&self.dominators, other, loc))
+    }
+
+    fn is_local_copiable(&self, local: Local) -> bool {
+        let ty = self.state.local_decls[local].ty;
+        // We only unify copy types as we only emit copies.
+        // We already simplify mutable reborrows as assignments, so we also allow copying those.
+        ty.is_ref() || ty.is_copy_modulo_regions(self.tcx, self.param_env)
+    }
+}
+
+impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn visit_operand(&mut self, operand: &mut Operand<'tcx>, location: Location) {
+        if let Some(place) = operand.place()
+            && let Some(value) = self.state.insert_place(place)
+        {
+            if let Some(const_) = self.try_as_constant(value) {
+                *operand = Operand::Constant(Box::new(const_));
+                *self.any_replacement = true;
+            } else if let Some(local) = self.try_as_local(value, location)
+                && *operand != Operand::Move(local.into())
+                && self.is_local_copiable(local)
+            {
+                *operand = Operand::Copy(local.into());
+                self.reused_locals.insert(local);
+                *self.any_replacement = true;
+            }
+        }
+    }
+
+    fn visit_statement(&mut self, stmt: &mut Statement<'tcx>, location: Location) {
+        self.super_statement(stmt, location);
+        if let StatementKind::Assign(box (_, ref mut rvalue)) = stmt.kind
+            && let Some(value) = self.state.insert_rvalue(rvalue)
+        {
+            if let Some(const_) = self.try_as_constant(value) {
+                *rvalue = Rvalue::Use(Operand::Constant(Box::new(const_)));
+                *self.any_replacement = true;
+            } else if let Some(local) = self.try_as_local(value, location)
+                && *rvalue != Rvalue::Use(Operand::Move(local.into()))
+                && self.is_local_copiable(local)
+            {
+                *rvalue = Rvalue::Use(Operand::Copy(local.into()));
+                self.reused_locals.insert(local);
+                *self.any_replacement = true;
+            }
+        }
+    }
+}
+
+struct StorageRemover<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    reused_locals: BitSet<Local>,
+}
+
+impl<'tcx> MutVisitor<'tcx> for StorageRemover<'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn visit_operand(&mut self, operand: &mut Operand<'tcx>, _: Location) {
+        if let Operand::Move(place) = *operand
+            && let Some(local) = place.as_local()
+            && self.reused_locals.contains(local)
+        {
+            *operand = Operand::Copy(place);
+        }
+    }
+
+    fn visit_statement(&mut self, stmt: &mut Statement<'tcx>, loc: Location) {
+        match stmt.kind {
+            // When removing storage statements, we need to remove both (#107511).
+            StatementKind::StorageLive(l) | StatementKind::StorageDead(l)
+                if self.reused_locals.contains(l) =>
+            {
+                stmt.make_nop()
+            }
+            _ => self.super_statement(stmt, loc),
+        }
+    }
+}

compiler/rustc_mir_transform/src/lib.rs

@@ -76,6 +76,7 @@ mod errors;
 mod ffi_unwind_calls;
 mod function_item_references;
 mod generator;
+mod gvn;
 pub mod inline;
 mod instsimplify;
 mod large_enums;
@@ -549,6 +550,7 @@ fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             // latter pass will leverage the created opportunities.
             &separate_const_switch::SeparateConstSwitch,
             &const_prop::ConstProp,
+            &gvn::GVN,
             &dataflow_const_prop::DataflowConstProp,
             //
             // Const-prop runs unconditionally, but doesn't mutate the MIR at mir-opt-level=0.

compiler/rustc_mir_transform/src/ref_prop.rs

@@ -108,7 +108,7 @@ enum Value<'tcx> {
 }
 
 /// For each local, save the place corresponding to `*local`.
-#[instrument(level = "trace", skip(tcx, body))]
+#[instrument(level = "trace", skip(tcx, body, ssa))]
 fn compute_replacement<'tcx>(
     tcx: TyCtxt<'tcx>,
     body: &Body<'tcx>,

compiler/rustc_mir_transform/src/ssa.rs

@@ -13,7 +13,6 @@ use rustc_middle::middle::resolve_bound_vars::Set1;
 use rustc_middle::mir::visit::*;
 use rustc_middle::mir::*;
 
-#[derive(Debug)]
 pub struct SsaLocals {
     /// Assignments to each local. This defines whether the local is SSA.
     assignments: IndexVec<Local, Set1<LocationExtended>>,
@@ -129,6 +128,25 @@ impl SsaLocals {
         self.direct_uses[local]
     }
 
+    pub fn assignment_dominates(
+        &self,
+        dominators: &Dominators<BasicBlock>,
+        local: Local,
+        location: Location,
+    ) -> bool {
+        match self.assignments[local] {
+            Set1::One(LocationExtended::Arg) => true,
+            Set1::One(LocationExtended::Plain(ass)) => {
+                if ass.block == location.block {
+                    ass.statement_index < location.statement_index
+                } else {
+                    dominators.dominates(ass.block, location.block)
+                }
+            }
+            _ => false,
+        }
+    }
+
     pub fn assignments<'a, 'tcx>(
         &'a self,
         body: &'a Body<'tcx>,

tests/mir-opt/const_debuginfo.main.ConstDebugInfo.diff

@@ -68,10 +68,7 @@
           _2 = const 2_u8;
           _3 = const 3_u8;
           StorageLive(_4);
-          StorageLive(_5);
-          _5 = const 3_u8;
           _4 = const 6_u8;
-          StorageDead(_5);
           StorageLive(_9);
           _9 = const "hello, world!";
           StorageLive(_14);

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

@@ -0,0 +1,342 @@
+- // MIR for `arithmetic` before GVN
++ // MIR for `arithmetic` after GVN
+  
+  fn arithmetic(_1: u64) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: u64;
+      let mut _4: u64;
+      let _5: ();
+      let mut _6: u64;
+      let mut _7: u64;
+      let _8: ();
+      let mut _9: u64;
+      let mut _10: u64;
+      let _11: ();
+      let mut _12: u64;
+      let mut _13: u64;
+      let _14: ();
+      let mut _15: u64;
+      let mut _16: u64;
+      let mut _17: bool;
+      let _18: ();
+      let mut _19: u64;
+      let mut _20: u64;
+      let mut _21: bool;
+      let _22: ();
+      let mut _23: u64;
+      let mut _24: u64;
+      let mut _25: bool;
+      let _26: ();
+      let mut _27: u64;
+      let mut _28: u64;
+      let mut _29: bool;
+      let _30: ();
+      let mut _31: u64;
+      let mut _32: u64;
+      let mut _33: bool;
+      let _34: ();
+      let mut _35: u64;
+      let mut _36: u64;
+      let mut _37: bool;
+      let _38: ();
+      let mut _39: u64;
+      let mut _40: u64;
+      let mut _41: bool;
+      let _42: ();
+      let mut _43: u64;
+      let mut _44: u64;
+      let mut _45: bool;
+      let _46: ();
+      let mut _47: u64;
+      let mut _48: u64;
+      let _49: ();
+      let mut _50: u64;
+      let mut _51: u64;
+      let _52: ();
+      let mut _53: u64;
+      let mut _54: u64;
+      let _55: ();
+      let mut _56: u64;
+      let mut _57: u64;
+      let _58: ();
+      let mut _59: u64;
+      let mut _60: u64;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _3 = Add(move _4, const 0_u64);
+-         StorageDead(_4);
++         _3 = Add(_1, const 0_u64);
+          _2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_5);
+          StorageLive(_6);
+-         StorageLive(_7);
+-         _7 = _1;
+-         _6 = Sub(move _7, const 0_u64);
+-         StorageDead(_7);
++         _6 = Sub(_1, const 0_u64);
+          _5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageLive(_8);
+          StorageLive(_9);
+-         StorageLive(_10);
+-         _10 = _1;
+-         _9 = Mul(move _10, const 0_u64);
+-         StorageDead(_10);
++         _9 = Mul(_1, const 0_u64);
+          _8 = opaque::<u64>(move _9) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_11);
+          StorageLive(_12);
+-         StorageLive(_13);
+-         _13 = _1;
+-         _12 = Mul(move _13, const 1_u64);
+-         StorageDead(_13);
++         _12 = Mul(_1, const 1_u64);
+          _11 = opaque::<u64>(move _12) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          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];
++         assert(!_17, "attempt to divide `{}` by zero", _1) -> [success: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+-         _15 = Div(move _16, const 0_u64);
+-         StorageDead(_16);
++         _15 = Div(_1, const 0_u64);
+          _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];
++         assert(!_21, "attempt to divide `{}` by zero", _1) -> [success: bb7, unwind unreachable];
+      }
+  
+      bb7: {
+-         _19 = Div(move _20, const 1_u64);
+-         StorageDead(_20);
++         _19 = Div(_1, const 1_u64);
+          _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];
+      }
+  
+      bb9: {
+-         _23 = Div(const 0_u64, move _24);
+-         StorageDead(_24);
++         _23 = Div(const 0_u64, _1);
+          _22 = opaque::<u64>(move _23) -> [return: bb10, unwind unreachable];
+      }
+  
+      bb10: {
+          StorageDead(_23);
+          StorageDead(_22);
+          StorageLive(_26);
+          StorageLive(_27);
+-         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];
++         assert(!_25, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind unreachable];
+      }
+  
+      bb11: {
+-         _27 = Div(const 1_u64, move _28);
+-         StorageDead(_28);
++         _27 = Div(const 1_u64, _1);
+          _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];
++         assert(!_17, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb13, unwind unreachable];
+      }
+  
+      bb13: {
+-         _31 = Rem(move _32, const 0_u64);
+-         StorageDead(_32);
++         _31 = Rem(_1, const 0_u64);
+          _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];
++         assert(!_21, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb15, unwind unreachable];
+      }
+  
+      bb15: {
+-         _35 = Rem(move _36, const 1_u64);
+-         StorageDead(_36);
++         _35 = Rem(_1, const 1_u64);
+          _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];
++         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind unreachable];
+      }
+  
+      bb17: {
+-         _39 = Rem(const 0_u64, move _40);
+-         StorageDead(_40);
++         _39 = Rem(const 0_u64, _1);
+          _38 = opaque::<u64>(move _39) -> [return: bb18, unwind unreachable];
+      }
+  
+      bb18: {
+          StorageDead(_39);
+          StorageDead(_38);
+          StorageLive(_42);
+          StorageLive(_43);
+-         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];
++         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind unreachable];
+      }
+  
+      bb19: {
+-         _43 = Rem(const 1_u64, move _44);
+-         StorageDead(_44);
++         _43 = Rem(const 1_u64, _1);
+          _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);
+-         StorageDead(_48);
++         _47 = BitAnd(_1, const 0_u64);
+          _46 = opaque::<u64>(move _47) -> [return: bb21, unwind unreachable];
+      }
+  
+      bb21: {
+          StorageDead(_47);
+          StorageDead(_46);
+          StorageLive(_49);
+          StorageLive(_50);
+-         StorageLive(_51);
+-         _51 = _1;
+-         _50 = BitOr(move _51, const 0_u64);
+-         StorageDead(_51);
++         _50 = BitOr(_1, const 0_u64);
+          _49 = opaque::<u64>(move _50) -> [return: bb22, unwind unreachable];
+      }
+  
+      bb22: {
+          StorageDead(_50);
+          StorageDead(_49);
+          StorageLive(_52);
+          StorageLive(_53);
+-         StorageLive(_54);
+-         _54 = _1;
+-         _53 = BitXor(move _54, const 0_u64);
+-         StorageDead(_54);
++         _53 = BitXor(_1, const 0_u64);
+          _52 = opaque::<u64>(move _53) -> [return: bb23, unwind unreachable];
+      }
+  
+      bb23: {
+          StorageDead(_53);
+          StorageDead(_52);
+          StorageLive(_55);
+          StorageLive(_56);
+-         StorageLive(_57);
+-         _57 = _1;
+-         _56 = Shr(move _57, const 0_i32);
+-         StorageDead(_57);
++         _56 = Shr(_1, const 0_i32);
+          _55 = opaque::<u64>(move _56) -> [return: bb24, unwind unreachable];
+      }
+  
+      bb24: {
+          StorageDead(_56);
+          StorageDead(_55);
+          StorageLive(_58);
+          StorageLive(_59);
+-         StorageLive(_60);
+-         _60 = _1;
+-         _59 = Shl(move _60, const 0_i32);
+-         StorageDead(_60);
++         _59 = Shl(_1, const 0_i32);
+          _58 = opaque::<u64>(move _59) -> [return: bb25, unwind unreachable];
+      }
+  
+      bb25: {
+          StorageDead(_59);
+          StorageDead(_58);
+          _0 = const ();
+          return;
+      }
+  }
+  

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

@@ -0,0 +1,342 @@
+- // MIR for `arithmetic` before GVN
++ // MIR for `arithmetic` after GVN
+  
+  fn arithmetic(_1: u64) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: u64;
+      let mut _4: u64;
+      let _5: ();
+      let mut _6: u64;
+      let mut _7: u64;
+      let _8: ();
+      let mut _9: u64;
+      let mut _10: u64;
+      let _11: ();
+      let mut _12: u64;
+      let mut _13: u64;
+      let _14: ();
+      let mut _15: u64;
+      let mut _16: u64;
+      let mut _17: bool;
+      let _18: ();
+      let mut _19: u64;
+      let mut _20: u64;
+      let mut _21: bool;
+      let _22: ();
+      let mut _23: u64;
+      let mut _24: u64;
+      let mut _25: bool;
+      let _26: ();
+      let mut _27: u64;
+      let mut _28: u64;
+      let mut _29: bool;
+      let _30: ();
+      let mut _31: u64;
+      let mut _32: u64;
+      let mut _33: bool;
+      let _34: ();
+      let mut _35: u64;
+      let mut _36: u64;
+      let mut _37: bool;
+      let _38: ();
+      let mut _39: u64;
+      let mut _40: u64;
+      let mut _41: bool;
+      let _42: ();
+      let mut _43: u64;
+      let mut _44: u64;
+      let mut _45: bool;
+      let _46: ();
+      let mut _47: u64;
+      let mut _48: u64;
+      let _49: ();
+      let mut _50: u64;
+      let mut _51: u64;
+      let _52: ();
+      let mut _53: u64;
+      let mut _54: u64;
+      let _55: ();
+      let mut _56: u64;
+      let mut _57: u64;
+      let _58: ();
+      let mut _59: u64;
+      let mut _60: u64;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _3 = Add(move _4, const 0_u64);
+-         StorageDead(_4);
++         _3 = Add(_1, const 0_u64);
+          _2 = opaque::<u64>(move _3) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_5);
+          StorageLive(_6);
+-         StorageLive(_7);
+-         _7 = _1;
+-         _6 = Sub(move _7, const 0_u64);
+-         StorageDead(_7);
++         _6 = Sub(_1, const 0_u64);
+          _5 = opaque::<u64>(move _6) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageLive(_8);
+          StorageLive(_9);
+-         StorageLive(_10);
+-         _10 = _1;
+-         _9 = Mul(move _10, const 0_u64);
+-         StorageDead(_10);
++         _9 = Mul(_1, const 0_u64);
+          _8 = opaque::<u64>(move _9) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_11);
+          StorageLive(_12);
+-         StorageLive(_13);
+-         _13 = _1;
+-         _12 = Mul(move _13, const 1_u64);
+-         StorageDead(_13);
++         _12 = Mul(_1, const 1_u64);
+          _11 = opaque::<u64>(move _12) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          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];
++         assert(!_17, "attempt to divide `{}` by zero", _1) -> [success: bb5, unwind continue];
+      }
+  
+      bb5: {
+-         _15 = Div(move _16, const 0_u64);
+-         StorageDead(_16);
++         _15 = Div(_1, const 0_u64);
+          _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];
++         assert(!_21, "attempt to divide `{}` by zero", _1) -> [success: bb7, unwind continue];
+      }
+  
+      bb7: {
+-         _19 = Div(move _20, const 1_u64);
+-         StorageDead(_20);
++         _19 = Div(_1, const 1_u64);
+          _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];
+      }
+  
+      bb9: {
+-         _23 = Div(const 0_u64, move _24);
+-         StorageDead(_24);
++         _23 = Div(const 0_u64, _1);
+          _22 = opaque::<u64>(move _23) -> [return: bb10, unwind continue];
+      }
+  
+      bb10: {
+          StorageDead(_23);
+          StorageDead(_22);
+          StorageLive(_26);
+          StorageLive(_27);
+-         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];
++         assert(!_25, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind continue];
+      }
+  
+      bb11: {
+-         _27 = Div(const 1_u64, move _28);
+-         StorageDead(_28);
++         _27 = Div(const 1_u64, _1);
+          _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];
++         assert(!_17, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb13, unwind continue];
+      }
+  
+      bb13: {
+-         _31 = Rem(move _32, const 0_u64);
+-         StorageDead(_32);
++         _31 = Rem(_1, const 0_u64);
+          _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];
++         assert(!_21, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb15, unwind continue];
+      }
+  
+      bb15: {
+-         _35 = Rem(move _36, const 1_u64);
+-         StorageDead(_36);
++         _35 = Rem(_1, const 1_u64);
+          _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];
++         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind continue];
+      }
+  
+      bb17: {
+-         _39 = Rem(const 0_u64, move _40);
+-         StorageDead(_40);
++         _39 = Rem(const 0_u64, _1);
+          _38 = opaque::<u64>(move _39) -> [return: bb18, unwind continue];
+      }
+  
+      bb18: {
+          StorageDead(_39);
+          StorageDead(_38);
+          StorageLive(_42);
+          StorageLive(_43);
+-         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];
++         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind continue];
+      }
+  
+      bb19: {
+-         _43 = Rem(const 1_u64, move _44);
+-         StorageDead(_44);
++         _43 = Rem(const 1_u64, _1);
+          _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);
+-         StorageDead(_48);
++         _47 = BitAnd(_1, const 0_u64);
+          _46 = opaque::<u64>(move _47) -> [return: bb21, unwind continue];
+      }
+  
+      bb21: {
+          StorageDead(_47);
+          StorageDead(_46);
+          StorageLive(_49);
+          StorageLive(_50);
+-         StorageLive(_51);
+-         _51 = _1;
+-         _50 = BitOr(move _51, const 0_u64);
+-         StorageDead(_51);
++         _50 = BitOr(_1, const 0_u64);
+          _49 = opaque::<u64>(move _50) -> [return: bb22, unwind continue];
+      }
+  
+      bb22: {
+          StorageDead(_50);
+          StorageDead(_49);
+          StorageLive(_52);
+          StorageLive(_53);
+-         StorageLive(_54);
+-         _54 = _1;
+-         _53 = BitXor(move _54, const 0_u64);
+-         StorageDead(_54);
++         _53 = BitXor(_1, const 0_u64);
+          _52 = opaque::<u64>(move _53) -> [return: bb23, unwind continue];
+      }
+  
+      bb23: {
+          StorageDead(_53);
+          StorageDead(_52);
+          StorageLive(_55);
+          StorageLive(_56);
+-         StorageLive(_57);
+-         _57 = _1;
+-         _56 = Shr(move _57, const 0_i32);
+-         StorageDead(_57);
++         _56 = Shr(_1, const 0_i32);
+          _55 = opaque::<u64>(move _56) -> [return: bb24, unwind continue];
+      }
+  
+      bb24: {
+          StorageDead(_56);
+          StorageDead(_55);
+          StorageLive(_58);
+          StorageLive(_59);
+-         StorageLive(_60);
+-         _60 = _1;
+-         _59 = Shl(move _60, const 0_i32);
+-         StorageDead(_60);
++         _59 = Shl(_1, const 0_i32);
+          _58 = opaque::<u64>(move _59) -> [return: bb25, unwind continue];
+      }
+  
+      bb25: {
+          StorageDead(_59);
+          StorageDead(_58);
+          _0 = const ();
+          return;
+      }
+  }
+  

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

@@ -0,0 +1,389 @@
+- // MIR for `arithmetic_checked` before GVN
++ // MIR for `arithmetic_checked` after GVN
+  
+  fn arithmetic_checked(_1: u64) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: u64;
+      let mut _4: u64;
+      let mut _5: (u64, bool);
+      let _6: ();
+      let mut _7: u64;
+      let mut _8: u64;
+      let mut _9: (u64, bool);
+      let _10: ();
+      let mut _11: u64;
+      let mut _12: u64;
+      let mut _13: (u64, bool);
+      let _14: ();
+      let mut _15: u64;
+      let mut _16: u64;
+      let mut _17: (u64, bool);
+      let _18: ();
+      let mut _19: u64;
+      let mut _20: u64;
+      let mut _21: bool;
+      let _22: ();
+      let mut _23: u64;
+      let mut _24: u64;
+      let mut _25: bool;
+      let _26: ();
+      let mut _27: u64;
+      let mut _28: u64;
+      let mut _29: bool;
+      let _30: ();
+      let mut _31: u64;
+      let mut _32: u64;
+      let mut _33: bool;
+      let _34: ();
+      let mut _35: u64;
+      let mut _36: u64;
+      let mut _37: bool;
+      let _38: ();
+      let mut _39: u64;
+      let mut _40: u64;
+      let mut _41: bool;
+      let _42: ();
+      let mut _43: u64;
+      let mut _44: u64;
+      let mut _45: bool;
+      let _46: ();
+      let mut _47: u64;
+      let mut _48: u64;
+      let mut _49: bool;
+      let _50: ();
+      let mut _51: u64;
+      let mut _52: u64;
+      let _53: ();
+      let mut _54: u64;
+      let mut _55: u64;
+      let _56: ();
+      let mut _57: u64;
+      let mut _58: u64;
+      let _59: ();
+      let mut _60: u64;
+      let mut _61: u64;
+      let mut _62: u32;
+      let mut _63: bool;
+      let _64: ();
+      let mut _65: u64;
+      let mut _66: u64;
+      let mut _67: u32;
+      let mut _68: bool;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _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];
+      }
+  
+      bb1: {
+          _3 = move (_5.0: u64);
+-         StorageDead(_4);
+          _2 = opaque::<u64>(move _3) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_6);
+          StorageLive(_7);
+-         StorageLive(_8);
+-         _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];
+      }
+  
+      bb3: {
+          _7 = move (_9.0: u64);
+-         StorageDead(_8);
+          _6 = opaque::<u64>(move _7) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_10);
+          StorageLive(_11);
+-         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];
+      }
+  
+      bb5: {
+          _11 = move (_13.0: u64);
+-         StorageDead(_12);
+          _10 = opaque::<u64>(move _11) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+          StorageDead(_11);
+          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];
+      }
+  
+      bb7: {
+          _15 = move (_17.0: u64);
+-         StorageDead(_16);
+          _14 = opaque::<u64>(move _15) -> [return: bb8, unwind unreachable];
+      }
+  
+      bb8: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_18);
+          StorageLive(_19);
+-         StorageLive(_20);
+-         _20 = _1;
+          _21 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb9, unwind unreachable];
++         assert(!_21, "attempt to divide `{}` by zero", _1) -> [success: bb9, unwind unreachable];
+      }
+  
+      bb9: {
+-         _19 = Div(move _20, const 0_u64);
+-         StorageDead(_20);
++         _19 = Div(_1, const 0_u64);
+          _18 = opaque::<u64>(move _19) -> [return: bb10, unwind unreachable];
+      }
+  
+      bb10: {
+          StorageDead(_19);
+          StorageDead(_18);
+          StorageLive(_22);
+          StorageLive(_23);
+-         StorageLive(_24);
+-         _24 = _1;
+          _25 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb11, unwind unreachable];
++         assert(!_25, "attempt to divide `{}` by zero", _1) -> [success: bb11, unwind unreachable];
+      }
+  
+      bb11: {
+-         _23 = Div(move _24, const 1_u64);
+-         StorageDead(_24);
++         _23 = Div(_1, const 1_u64);
+          _22 = opaque::<u64>(move _23) -> [return: bb12, unwind unreachable];
+      }
+  
+      bb12: {
+          StorageDead(_23);
+          StorageDead(_22);
+          StorageLive(_26);
+          StorageLive(_27);
+-         StorageLive(_28);
+-         _28 = _1;
+-         _29 = Eq(_28, const 0_u64);
+-         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind unreachable];
++         _29 = Eq(_1, const 0_u64);
++         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind unreachable];
+      }
+  
+      bb13: {
+-         _27 = Div(const 0_u64, move _28);
+-         StorageDead(_28);
++         _27 = Div(const 0_u64, _1);
+          _26 = opaque::<u64>(move _27) -> [return: bb14, unwind unreachable];
+      }
+  
+      bb14: {
+          StorageDead(_27);
+          StorageDead(_26);
+          StorageLive(_30);
+          StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = _1;
+-         _33 = Eq(_32, const 0_u64);
+-         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind unreachable];
++         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind unreachable];
+      }
+  
+      bb15: {
+-         _31 = Div(const 1_u64, move _32);
+-         StorageDead(_32);
++         _31 = Div(const 1_u64, _1);
+          _30 = opaque::<u64>(move _31) -> [return: bb16, unwind unreachable];
+      }
+  
+      bb16: {
+          StorageDead(_31);
+          StorageDead(_30);
+          StorageLive(_34);
+          StorageLive(_35);
+-         StorageLive(_36);
+-         _36 = _1;
+-         _37 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb17, unwind unreachable];
++         assert(!_21, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb17, unwind unreachable];
+      }
+  
+      bb17: {
+-         _35 = Rem(move _36, const 0_u64);
+-         StorageDead(_36);
++         _35 = Rem(_1, const 0_u64);
+          _34 = opaque::<u64>(move _35) -> [return: bb18, unwind unreachable];
+      }
+  
+      bb18: {
+          StorageDead(_35);
+          StorageDead(_34);
+          StorageLive(_38);
+          StorageLive(_39);
+-         StorageLive(_40);
+-         _40 = _1;
+-         _41 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb19, unwind unreachable];
++         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb19, unwind unreachable];
+      }
+  
+      bb19: {
+-         _39 = Rem(move _40, const 1_u64);
+-         StorageDead(_40);
++         _39 = Rem(_1, const 1_u64);
+          _38 = opaque::<u64>(move _39) -> [return: bb20, unwind unreachable];
+      }
+  
+      bb20: {
+          StorageDead(_39);
+          StorageDead(_38);
+          StorageLive(_42);
+          StorageLive(_43);
+-         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 0_u64) -> [success: bb21, unwind unreachable];
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind unreachable];
+      }
+  
+      bb21: {
+-         _43 = Rem(const 0_u64, move _44);
+-         StorageDead(_44);
++         _43 = Rem(const 0_u64, _1);
+          _42 = opaque::<u64>(move _43) -> [return: bb22, unwind unreachable];
+      }
+  
+      bb22: {
+          StorageDead(_43);
+          StorageDead(_42);
+          StorageLive(_46);
+          StorageLive(_47);
+-         StorageLive(_48);
+-         _48 = _1;
+-         _49 = Eq(_48, const 0_u64);
+-         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind unreachable];
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind unreachable];
+      }
+  
+      bb23: {
+-         _47 = Rem(const 1_u64, move _48);
+-         StorageDead(_48);
++         _47 = Rem(const 1_u64, _1);
+          _46 = opaque::<u64>(move _47) -> [return: bb24, unwind unreachable];
+      }
+  
+      bb24: {
+          StorageDead(_47);
+          StorageDead(_46);
+          StorageLive(_50);
+          StorageLive(_51);
+-         StorageLive(_52);
+-         _52 = _1;
+-         _51 = BitAnd(move _52, const 0_u64);
+-         StorageDead(_52);
++         _51 = BitAnd(_1, const 0_u64);
+          _50 = opaque::<u64>(move _51) -> [return: bb25, unwind unreachable];
+      }
+  
+      bb25: {
+          StorageDead(_51);
+          StorageDead(_50);
+          StorageLive(_53);
+          StorageLive(_54);
+-         StorageLive(_55);
+-         _55 = _1;
+-         _54 = BitOr(move _55, const 0_u64);
+-         StorageDead(_55);
++         _54 = BitOr(_1, const 0_u64);
+          _53 = opaque::<u64>(move _54) -> [return: bb26, unwind unreachable];
+      }
+  
+      bb26: {
+          StorageDead(_54);
+          StorageDead(_53);
+          StorageLive(_56);
+          StorageLive(_57);
+-         StorageLive(_58);
+-         _58 = _1;
+-         _57 = BitXor(move _58, const 0_u64);
+-         StorageDead(_58);
++         _57 = BitXor(_1, const 0_u64);
+          _56 = opaque::<u64>(move _57) -> [return: bb27, unwind unreachable];
+      }
+  
+      bb27: {
+          StorageDead(_57);
+          StorageDead(_56);
+          StorageLive(_59);
+          StorageLive(_60);
+-         StorageLive(_61);
+-         _61 = _1;
+          _62 = const 0_i32 as u32 (IntToInt);
+-         _63 = Lt(move _62, const 64_u32);
+-         assert(move _63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind unreachable];
++         _63 = Lt(_62, const 64_u32);
++         assert(_63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind unreachable];
+      }
+  
+      bb28: {
+-         _60 = Shr(move _61, const 0_i32);
+-         StorageDead(_61);
++         _60 = Shr(_1, const 0_i32);
+          _59 = opaque::<u64>(move _60) -> [return: bb29, unwind unreachable];
+      }
+  
+      bb29: {
+          StorageDead(_60);
+          StorageDead(_59);
+          StorageLive(_64);
+          StorageLive(_65);
+-         StorageLive(_66);
+-         _66 = _1;
+-         _67 = const 0_i32 as u32 (IntToInt);
+-         _68 = Lt(move _67, const 64_u32);
+-         assert(move _68, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind unreachable];
++         assert(_63, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind unreachable];
+      }
+  
+      bb30: {
+-         _65 = Shl(move _66, const 0_i32);
+-         StorageDead(_66);
++         _65 = Shl(_1, const 0_i32);
+          _64 = opaque::<u64>(move _65) -> [return: bb31, unwind unreachable];
+      }
+  
+      bb31: {
+          StorageDead(_65);
+          StorageDead(_64);
+          _0 = const ();
+          return;
+      }
+  }
+  

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

@@ -0,0 +1,389 @@
+- // MIR for `arithmetic_checked` before GVN
++ // MIR for `arithmetic_checked` after GVN
+  
+  fn arithmetic_checked(_1: u64) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: u64;
+      let mut _4: u64;
+      let mut _5: (u64, bool);
+      let _6: ();
+      let mut _7: u64;
+      let mut _8: u64;
+      let mut _9: (u64, bool);
+      let _10: ();
+      let mut _11: u64;
+      let mut _12: u64;
+      let mut _13: (u64, bool);
+      let _14: ();
+      let mut _15: u64;
+      let mut _16: u64;
+      let mut _17: (u64, bool);
+      let _18: ();
+      let mut _19: u64;
+      let mut _20: u64;
+      let mut _21: bool;
+      let _22: ();
+      let mut _23: u64;
+      let mut _24: u64;
+      let mut _25: bool;
+      let _26: ();
+      let mut _27: u64;
+      let mut _28: u64;
+      let mut _29: bool;
+      let _30: ();
+      let mut _31: u64;
+      let mut _32: u64;
+      let mut _33: bool;
+      let _34: ();
+      let mut _35: u64;
+      let mut _36: u64;
+      let mut _37: bool;
+      let _38: ();
+      let mut _39: u64;
+      let mut _40: u64;
+      let mut _41: bool;
+      let _42: ();
+      let mut _43: u64;
+      let mut _44: u64;
+      let mut _45: bool;
+      let _46: ();
+      let mut _47: u64;
+      let mut _48: u64;
+      let mut _49: bool;
+      let _50: ();
+      let mut _51: u64;
+      let mut _52: u64;
+      let _53: ();
+      let mut _54: u64;
+      let mut _55: u64;
+      let _56: ();
+      let mut _57: u64;
+      let mut _58: u64;
+      let _59: ();
+      let mut _60: u64;
+      let mut _61: u64;
+      let mut _62: u32;
+      let mut _63: bool;
+      let _64: ();
+      let mut _65: u64;
+      let mut _66: u64;
+      let mut _67: u32;
+      let mut _68: bool;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _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];
+      }
+  
+      bb1: {
+          _3 = move (_5.0: u64);
+-         StorageDead(_4);
+          _2 = opaque::<u64>(move _3) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_6);
+          StorageLive(_7);
+-         StorageLive(_8);
+-         _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];
+      }
+  
+      bb3: {
+          _7 = move (_9.0: u64);
+-         StorageDead(_8);
+          _6 = opaque::<u64>(move _7) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_10);
+          StorageLive(_11);
+-         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];
+      }
+  
+      bb5: {
+          _11 = move (_13.0: u64);
+-         StorageDead(_12);
+          _10 = opaque::<u64>(move _11) -> [return: bb6, unwind continue];
+      }
+  
+      bb6: {
+          StorageDead(_11);
+          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];
+      }
+  
+      bb7: {
+          _15 = move (_17.0: u64);
+-         StorageDead(_16);
+          _14 = opaque::<u64>(move _15) -> [return: bb8, unwind continue];
+      }
+  
+      bb8: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_18);
+          StorageLive(_19);
+-         StorageLive(_20);
+-         _20 = _1;
+          _21 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb9, unwind continue];
++         assert(!_21, "attempt to divide `{}` by zero", _1) -> [success: bb9, unwind continue];
+      }
+  
+      bb9: {
+-         _19 = Div(move _20, const 0_u64);
+-         StorageDead(_20);
++         _19 = Div(_1, const 0_u64);
+          _18 = opaque::<u64>(move _19) -> [return: bb10, unwind continue];
+      }
+  
+      bb10: {
+          StorageDead(_19);
+          StorageDead(_18);
+          StorageLive(_22);
+          StorageLive(_23);
+-         StorageLive(_24);
+-         _24 = _1;
+          _25 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb11, unwind continue];
++         assert(!_25, "attempt to divide `{}` by zero", _1) -> [success: bb11, unwind continue];
+      }
+  
+      bb11: {
+-         _23 = Div(move _24, const 1_u64);
+-         StorageDead(_24);
++         _23 = Div(_1, const 1_u64);
+          _22 = opaque::<u64>(move _23) -> [return: bb12, unwind continue];
+      }
+  
+      bb12: {
+          StorageDead(_23);
+          StorageDead(_22);
+          StorageLive(_26);
+          StorageLive(_27);
+-         StorageLive(_28);
+-         _28 = _1;
+-         _29 = Eq(_28, const 0_u64);
+-         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind continue];
++         _29 = Eq(_1, const 0_u64);
++         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind continue];
+      }
+  
+      bb13: {
+-         _27 = Div(const 0_u64, move _28);
+-         StorageDead(_28);
++         _27 = Div(const 0_u64, _1);
+          _26 = opaque::<u64>(move _27) -> [return: bb14, unwind continue];
+      }
+  
+      bb14: {
+          StorageDead(_27);
+          StorageDead(_26);
+          StorageLive(_30);
+          StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = _1;
+-         _33 = Eq(_32, const 0_u64);
+-         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind continue];
++         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind continue];
+      }
+  
+      bb15: {
+-         _31 = Div(const 1_u64, move _32);
+-         StorageDead(_32);
++         _31 = Div(const 1_u64, _1);
+          _30 = opaque::<u64>(move _31) -> [return: bb16, unwind continue];
+      }
+  
+      bb16: {
+          StorageDead(_31);
+          StorageDead(_30);
+          StorageLive(_34);
+          StorageLive(_35);
+-         StorageLive(_36);
+-         _36 = _1;
+-         _37 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb17, unwind continue];
++         assert(!_21, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb17, unwind continue];
+      }
+  
+      bb17: {
+-         _35 = Rem(move _36, const 0_u64);
+-         StorageDead(_36);
++         _35 = Rem(_1, const 0_u64);
+          _34 = opaque::<u64>(move _35) -> [return: bb18, unwind continue];
+      }
+  
+      bb18: {
+          StorageDead(_35);
+          StorageDead(_34);
+          StorageLive(_38);
+          StorageLive(_39);
+-         StorageLive(_40);
+-         _40 = _1;
+-         _41 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb19, unwind continue];
++         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb19, unwind continue];
+      }
+  
+      bb19: {
+-         _39 = Rem(move _40, const 1_u64);
+-         StorageDead(_40);
++         _39 = Rem(_1, const 1_u64);
+          _38 = opaque::<u64>(move _39) -> [return: bb20, unwind continue];
+      }
+  
+      bb20: {
+          StorageDead(_39);
+          StorageDead(_38);
+          StorageLive(_42);
+          StorageLive(_43);
+-         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 0_u64) -> [success: bb21, unwind continue];
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind continue];
+      }
+  
+      bb21: {
+-         _43 = Rem(const 0_u64, move _44);
+-         StorageDead(_44);
++         _43 = Rem(const 0_u64, _1);
+          _42 = opaque::<u64>(move _43) -> [return: bb22, unwind continue];
+      }
+  
+      bb22: {
+          StorageDead(_43);
+          StorageDead(_42);
+          StorageLive(_46);
+          StorageLive(_47);
+-         StorageLive(_48);
+-         _48 = _1;
+-         _49 = Eq(_48, const 0_u64);
+-         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind continue];
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind continue];
+      }
+  
+      bb23: {
+-         _47 = Rem(const 1_u64, move _48);
+-         StorageDead(_48);
++         _47 = Rem(const 1_u64, _1);
+          _46 = opaque::<u64>(move _47) -> [return: bb24, unwind continue];
+      }
+  
+      bb24: {
+          StorageDead(_47);
+          StorageDead(_46);
+          StorageLive(_50);
+          StorageLive(_51);
+-         StorageLive(_52);
+-         _52 = _1;
+-         _51 = BitAnd(move _52, const 0_u64);
+-         StorageDead(_52);
++         _51 = BitAnd(_1, const 0_u64);
+          _50 = opaque::<u64>(move _51) -> [return: bb25, unwind continue];
+      }
+  
+      bb25: {
+          StorageDead(_51);
+          StorageDead(_50);
+          StorageLive(_53);
+          StorageLive(_54);
+-         StorageLive(_55);
+-         _55 = _1;
+-         _54 = BitOr(move _55, const 0_u64);
+-         StorageDead(_55);
++         _54 = BitOr(_1, const 0_u64);
+          _53 = opaque::<u64>(move _54) -> [return: bb26, unwind continue];
+      }
+  
+      bb26: {
+          StorageDead(_54);
+          StorageDead(_53);
+          StorageLive(_56);
+          StorageLive(_57);
+-         StorageLive(_58);
+-         _58 = _1;
+-         _57 = BitXor(move _58, const 0_u64);
+-         StorageDead(_58);
++         _57 = BitXor(_1, const 0_u64);
+          _56 = opaque::<u64>(move _57) -> [return: bb27, unwind continue];
+      }
+  
+      bb27: {
+          StorageDead(_57);
+          StorageDead(_56);
+          StorageLive(_59);
+          StorageLive(_60);
+-         StorageLive(_61);
+-         _61 = _1;
+          _62 = const 0_i32 as u32 (IntToInt);
+-         _63 = Lt(move _62, const 64_u32);
+-         assert(move _63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind continue];
++         _63 = Lt(_62, const 64_u32);
++         assert(_63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind continue];
+      }
+  
+      bb28: {
+-         _60 = Shr(move _61, const 0_i32);
+-         StorageDead(_61);
++         _60 = Shr(_1, const 0_i32);
+          _59 = opaque::<u64>(move _60) -> [return: bb29, unwind continue];
+      }
+  
+      bb29: {
+          StorageDead(_60);
+          StorageDead(_59);
+          StorageLive(_64);
+          StorageLive(_65);
+-         StorageLive(_66);
+-         _66 = _1;
+-         _67 = const 0_i32 as u32 (IntToInt);
+-         _68 = Lt(move _67, const 64_u32);
+-         assert(move _68, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind continue];
++         assert(_63, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind continue];
+      }
+  
+      bb30: {
+-         _65 = Shl(move _66, const 0_i32);
+-         StorageDead(_66);
++         _65 = Shl(_1, const 0_i32);
+          _64 = opaque::<u64>(move _65) -> [return: bb31, unwind continue];
+      }
+  
+      bb31: {
+          StorageDead(_65);
+          StorageDead(_64);
+          _0 = const ();
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff

@@ -0,0 +1,165 @@
+- // MIR for `arithmetic_float` before GVN
++ // MIR for `arithmetic_float` after GVN
+  
+  fn arithmetic_float(_1: f64) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: f64;
+      let mut _4: f64;
+      let _5: ();
+      let mut _6: f64;
+      let mut _7: f64;
+      let _8: ();
+      let mut _9: f64;
+      let mut _10: f64;
+      let _11: ();
+      let mut _12: f64;
+      let mut _13: f64;
+      let _14: ();
+      let mut _15: f64;
+      let mut _16: f64;
+      let _17: ();
+      let mut _18: f64;
+      let mut _19: f64;
+      let _20: ();
+      let mut _21: f64;
+      let mut _22: f64;
+      let _23: ();
+      let mut _24: bool;
+      let mut _25: f64;
+      let mut _26: f64;
+      let _27: ();
+      let mut _28: bool;
+      let mut _29: f64;
+      let mut _30: f64;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _3 = Add(move _4, const 0f64);
+-         StorageDead(_4);
++         _3 = Add(_1, const 0f64);
+          _2 = opaque::<f64>(move _3) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_5);
+          StorageLive(_6);
+-         StorageLive(_7);
+-         _7 = _1;
+-         _6 = Sub(move _7, const 0f64);
+-         StorageDead(_7);
++         _6 = Sub(_1, const 0f64);
+          _5 = opaque::<f64>(move _6) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageLive(_8);
+          StorageLive(_9);
+-         StorageLive(_10);
+-         _10 = _1;
+-         _9 = Mul(move _10, const 0f64);
+-         StorageDead(_10);
++         _9 = Mul(_1, const 0f64);
+          _8 = opaque::<f64>(move _9) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_11);
+          StorageLive(_12);
+-         StorageLive(_13);
+-         _13 = _1;
+-         _12 = Div(move _13, const 0f64);
+-         StorageDead(_13);
++         _12 = Div(_1, const 0f64);
+          _11 = opaque::<f64>(move _12) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageLive(_14);
+          StorageLive(_15);
+-         StorageLive(_16);
+-         _16 = _1;
+-         _15 = Div(const 0f64, move _16);
+-         StorageDead(_16);
++         _15 = Div(const 0f64, _1);
+          _14 = opaque::<f64>(move _15) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_17);
+          StorageLive(_18);
+-         StorageLive(_19);
+-         _19 = _1;
+-         _18 = Rem(move _19, const 0f64);
+-         StorageDead(_19);
++         _18 = Rem(_1, const 0f64);
+          _17 = opaque::<f64>(move _18) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+          StorageDead(_18);
+          StorageDead(_17);
+          StorageLive(_20);
+          StorageLive(_21);
+-         StorageLive(_22);
+-         _22 = _1;
+-         _21 = Rem(const 0f64, move _22);
+-         StorageDead(_22);
++         _21 = Rem(const 0f64, _1);
+          _20 = opaque::<f64>(move _21) -> [return: bb7, unwind unreachable];
+      }
+  
+      bb7: {
+          StorageDead(_21);
+          StorageDead(_20);
+          StorageLive(_23);
+          StorageLive(_24);
+-         StorageLive(_25);
+-         _25 = _1;
+-         StorageLive(_26);
+-         _26 = _1;
+-         _24 = Eq(move _25, move _26);
+-         StorageDead(_26);
+-         StorageDead(_25);
++         _24 = Eq(_1, _1);
+          _23 = opaque::<bool>(move _24) -> [return: bb8, unwind unreachable];
+      }
+  
+      bb8: {
+          StorageDead(_24);
+          StorageDead(_23);
+          StorageLive(_27);
+          StorageLive(_28);
+-         StorageLive(_29);
+-         _29 = _1;
+-         StorageLive(_30);
+-         _30 = _1;
+-         _28 = Ne(move _29, move _30);
+-         StorageDead(_30);
+-         StorageDead(_29);
++         _28 = Ne(_1, _1);
+          _27 = opaque::<bool>(move _28) -> [return: bb9, unwind unreachable];
+      }
+  
+      bb9: {
+          StorageDead(_28);
+          StorageDead(_27);
+          _0 = const ();
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff

@@ -0,0 +1,165 @@
+- // MIR for `arithmetic_float` before GVN
++ // MIR for `arithmetic_float` after GVN
+  
+  fn arithmetic_float(_1: f64) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: f64;
+      let mut _4: f64;
+      let _5: ();
+      let mut _6: f64;
+      let mut _7: f64;
+      let _8: ();
+      let mut _9: f64;
+      let mut _10: f64;
+      let _11: ();
+      let mut _12: f64;
+      let mut _13: f64;
+      let _14: ();
+      let mut _15: f64;
+      let mut _16: f64;
+      let _17: ();
+      let mut _18: f64;
+      let mut _19: f64;
+      let _20: ();
+      let mut _21: f64;
+      let mut _22: f64;
+      let _23: ();
+      let mut _24: bool;
+      let mut _25: f64;
+      let mut _26: f64;
+      let _27: ();
+      let mut _28: bool;
+      let mut _29: f64;
+      let mut _30: f64;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _3 = Add(move _4, const 0f64);
+-         StorageDead(_4);
++         _3 = Add(_1, const 0f64);
+          _2 = opaque::<f64>(move _3) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_5);
+          StorageLive(_6);
+-         StorageLive(_7);
+-         _7 = _1;
+-         _6 = Sub(move _7, const 0f64);
+-         StorageDead(_7);
++         _6 = Sub(_1, const 0f64);
+          _5 = opaque::<f64>(move _6) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageLive(_8);
+          StorageLive(_9);
+-         StorageLive(_10);
+-         _10 = _1;
+-         _9 = Mul(move _10, const 0f64);
+-         StorageDead(_10);
++         _9 = Mul(_1, const 0f64);
+          _8 = opaque::<f64>(move _9) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_11);
+          StorageLive(_12);
+-         StorageLive(_13);
+-         _13 = _1;
+-         _12 = Div(move _13, const 0f64);
+-         StorageDead(_13);
++         _12 = Div(_1, const 0f64);
+          _11 = opaque::<f64>(move _12) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageLive(_14);
+          StorageLive(_15);
+-         StorageLive(_16);
+-         _16 = _1;
+-         _15 = Div(const 0f64, move _16);
+-         StorageDead(_16);
++         _15 = Div(const 0f64, _1);
+          _14 = opaque::<f64>(move _15) -> [return: bb5, unwind continue];
+      }
+  
+      bb5: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_17);
+          StorageLive(_18);
+-         StorageLive(_19);
+-         _19 = _1;
+-         _18 = Rem(move _19, const 0f64);
+-         StorageDead(_19);
++         _18 = Rem(_1, const 0f64);
+          _17 = opaque::<f64>(move _18) -> [return: bb6, unwind continue];
+      }
+  
+      bb6: {
+          StorageDead(_18);
+          StorageDead(_17);
+          StorageLive(_20);
+          StorageLive(_21);
+-         StorageLive(_22);
+-         _22 = _1;
+-         _21 = Rem(const 0f64, move _22);
+-         StorageDead(_22);
++         _21 = Rem(const 0f64, _1);
+          _20 = opaque::<f64>(move _21) -> [return: bb7, unwind continue];
+      }
+  
+      bb7: {
+          StorageDead(_21);
+          StorageDead(_20);
+          StorageLive(_23);
+          StorageLive(_24);
+-         StorageLive(_25);
+-         _25 = _1;
+-         StorageLive(_26);
+-         _26 = _1;
+-         _24 = Eq(move _25, move _26);
+-         StorageDead(_26);
+-         StorageDead(_25);
++         _24 = Eq(_1, _1);
+          _23 = opaque::<bool>(move _24) -> [return: bb8, unwind continue];
+      }
+  
+      bb8: {
+          StorageDead(_24);
+          StorageDead(_23);
+          StorageLive(_27);
+          StorageLive(_28);
+-         StorageLive(_29);
+-         _29 = _1;
+-         StorageLive(_30);
+-         _30 = _1;
+-         _28 = Ne(move _29, move _30);
+-         StorageDead(_30);
+-         StorageDead(_29);
++         _28 = Ne(_1, _1);
+          _27 = opaque::<bool>(move _28) -> [return: bb9, unwind continue];
+      }
+  
+      bb9: {
+          StorageDead(_28);
+          StorageDead(_27);
+          _0 = const ();
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.cast.GVN.panic-abort.diff

@@ -0,0 +1,501 @@
+- // MIR for `cast` before GVN
++ // MIR for `cast` after GVN
+  
+  fn cast() -> () {
+      let mut _0: ();
+      let _1: i64;
+      let _4: ();
+      let mut _5: u8;
+      let mut _6: i64;
+      let _7: ();
+      let mut _8: u16;
+      let mut _9: i64;
+      let _10: ();
+      let mut _11: u32;
+      let mut _12: i64;
+      let _13: ();
+      let mut _14: u64;
+      let mut _15: i64;
+      let _16: ();
+      let mut _17: i8;
+      let mut _18: i64;
+      let _19: ();
+      let mut _20: i16;
+      let mut _21: i64;
+      let _22: ();
+      let mut _23: i32;
+      let mut _24: i64;
+      let _25: ();
+      let mut _26: i64;
+      let _27: ();
+      let mut _28: f32;
+      let mut _29: i64;
+      let _30: ();
+      let mut _31: f64;
+      let mut _32: i64;
+      let _33: ();
+      let mut _34: u8;
+      let mut _35: u64;
+      let _36: ();
+      let mut _37: u16;
+      let mut _38: u64;
+      let _39: ();
+      let mut _40: u32;
+      let mut _41: u64;
+      let _42: ();
+      let mut _43: u64;
+      let _44: ();
+      let mut _45: i8;
+      let mut _46: u64;
+      let _47: ();
+      let mut _48: i16;
+      let mut _49: u64;
+      let _50: ();
+      let mut _51: i32;
+      let mut _52: u64;
+      let _53: ();
+      let mut _54: i64;
+      let mut _55: u64;
+      let _56: ();
+      let mut _57: f32;
+      let mut _58: u64;
+      let _59: ();
+      let mut _60: f64;
+      let mut _61: u64;
+      let _62: ();
+      let mut _63: u8;
+      let mut _64: f64;
+      let _65: ();
+      let mut _66: u16;
+      let mut _67: f64;
+      let _68: ();
+      let mut _69: u32;
+      let mut _70: f64;
+      let _71: ();
+      let mut _72: u64;
+      let mut _73: f64;
+      let _74: ();
+      let mut _75: i8;
+      let mut _76: f64;
+      let _77: ();
+      let mut _78: i16;
+      let mut _79: f64;
+      let _80: ();
+      let mut _81: i32;
+      let mut _82: f64;
+      let _83: ();
+      let mut _84: i64;
+      let mut _85: f64;
+      let _86: ();
+      let mut _87: f32;
+      let mut _88: f64;
+      let _89: ();
+      let mut _90: f64;
+      scope 1 {
+          debug i => _1;
+          let _2: u64;
+          scope 2 {
+              debug u => _2;
+              let _3: f64;
+              scope 3 {
+                  debug f => _3;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+          _1 = const 1_i64;
+          StorageLive(_2);
+          _2 = const 1_u64;
+          StorageLive(_3);
+          _3 = const 1f64;
+          StorageLive(_4);
+          StorageLive(_5);
+-         StorageLive(_6);
+-         _6 = _1;
+-         _5 = move _6 as u8 (IntToInt);
+-         StorageDead(_6);
++         _5 = const 1_i64 as u8 (IntToInt);
+          _4 = opaque::<u8>(move _5) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_7);
+          StorageLive(_8);
+-         StorageLive(_9);
+-         _9 = _1;
+-         _8 = move _9 as u16 (IntToInt);
+-         StorageDead(_9);
++         _8 = const 1_i64 as u16 (IntToInt);
+          _7 = opaque::<u16>(move _8) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageLive(_10);
+          StorageLive(_11);
+-         StorageLive(_12);
+-         _12 = _1;
+-         _11 = move _12 as u32 (IntToInt);
+-         StorageDead(_12);
++         _11 = const 1_i64 as u32 (IntToInt);
+          _10 = opaque::<u32>(move _11) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_11);
+          StorageDead(_10);
+          StorageLive(_13);
+          StorageLive(_14);
+-         StorageLive(_15);
+-         _15 = _1;
+-         _14 = move _15 as u64 (IntToInt);
+-         StorageDead(_15);
++         _14 = const 1_i64 as u64 (IntToInt);
+          _13 = opaque::<u64>(move _14) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_14);
+          StorageDead(_13);
+          StorageLive(_16);
+          StorageLive(_17);
+-         StorageLive(_18);
+-         _18 = _1;
+-         _17 = move _18 as i8 (IntToInt);
+-         StorageDead(_18);
++         _17 = const 1_i64 as i8 (IntToInt);
+          _16 = opaque::<i8>(move _17) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+          StorageDead(_17);
+          StorageDead(_16);
+          StorageLive(_19);
+          StorageLive(_20);
+-         StorageLive(_21);
+-         _21 = _1;
+-         _20 = move _21 as i16 (IntToInt);
+-         StorageDead(_21);
++         _20 = const 1_i64 as i16 (IntToInt);
+          _19 = opaque::<i16>(move _20) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+          StorageDead(_20);
+          StorageDead(_19);
+          StorageLive(_22);
+          StorageLive(_23);
+-         StorageLive(_24);
+-         _24 = _1;
+-         _23 = move _24 as i32 (IntToInt);
+-         StorageDead(_24);
++         _23 = const 1_i64 as i32 (IntToInt);
+          _22 = opaque::<i32>(move _23) -> [return: bb7, unwind unreachable];
+      }
+  
+      bb7: {
+          StorageDead(_23);
+          StorageDead(_22);
+          StorageLive(_25);
+-         StorageLive(_26);
+-         _26 = _1;
+-         _25 = opaque::<i64>(move _26) -> [return: bb8, unwind unreachable];
++         _25 = opaque::<i64>(const 1_i64) -> [return: bb8, unwind unreachable];
+      }
+  
+      bb8: {
+-         StorageDead(_26);
+          StorageDead(_25);
+          StorageLive(_27);
+          StorageLive(_28);
+-         StorageLive(_29);
+-         _29 = _1;
+-         _28 = move _29 as f32 (IntToFloat);
+-         StorageDead(_29);
++         _28 = const 1_i64 as f32 (IntToFloat);
+          _27 = opaque::<f32>(move _28) -> [return: bb9, unwind unreachable];
+      }
+  
+      bb9: {
+          StorageDead(_28);
+          StorageDead(_27);
+          StorageLive(_30);
+          StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = _1;
+-         _31 = move _32 as f64 (IntToFloat);
+-         StorageDead(_32);
++         _31 = const 1_i64 as f64 (IntToFloat);
+          _30 = opaque::<f64>(move _31) -> [return: bb10, unwind unreachable];
+      }
+  
+      bb10: {
+          StorageDead(_31);
+          StorageDead(_30);
+          StorageLive(_33);
+          StorageLive(_34);
+-         StorageLive(_35);
+-         _35 = _2;
+-         _34 = move _35 as u8 (IntToInt);
+-         StorageDead(_35);
++         _34 = const 1_u64 as u8 (IntToInt);
+          _33 = opaque::<u8>(move _34) -> [return: bb11, unwind unreachable];
+      }
+  
+      bb11: {
+          StorageDead(_34);
+          StorageDead(_33);
+          StorageLive(_36);
+          StorageLive(_37);
+-         StorageLive(_38);
+-         _38 = _2;
+-         _37 = move _38 as u16 (IntToInt);
+-         StorageDead(_38);
++         _37 = const 1_u64 as u16 (IntToInt);
+          _36 = opaque::<u16>(move _37) -> [return: bb12, unwind unreachable];
+      }
+  
+      bb12: {
+          StorageDead(_37);
+          StorageDead(_36);
+          StorageLive(_39);
+          StorageLive(_40);
+-         StorageLive(_41);
+-         _41 = _2;
+-         _40 = move _41 as u32 (IntToInt);
+-         StorageDead(_41);
++         _40 = const 1_u64 as u32 (IntToInt);
+          _39 = opaque::<u32>(move _40) -> [return: bb13, unwind unreachable];
+      }
+  
+      bb13: {
+          StorageDead(_40);
+          StorageDead(_39);
+          StorageLive(_42);
+-         StorageLive(_43);
+-         _43 = _2;
+-         _42 = opaque::<u64>(move _43) -> [return: bb14, unwind unreachable];
++         _42 = opaque::<u64>(const 1_u64) -> [return: bb14, unwind unreachable];
+      }
+  
+      bb14: {
+-         StorageDead(_43);
+          StorageDead(_42);
+          StorageLive(_44);
+          StorageLive(_45);
+-         StorageLive(_46);
+-         _46 = _2;
+-         _45 = move _46 as i8 (IntToInt);
+-         StorageDead(_46);
++         _45 = const 1_u64 as i8 (IntToInt);
+          _44 = opaque::<i8>(move _45) -> [return: bb15, unwind unreachable];
+      }
+  
+      bb15: {
+          StorageDead(_45);
+          StorageDead(_44);
+          StorageLive(_47);
+          StorageLive(_48);
+-         StorageLive(_49);
+-         _49 = _2;
+-         _48 = move _49 as i16 (IntToInt);
+-         StorageDead(_49);
++         _48 = const 1_u64 as i16 (IntToInt);
+          _47 = opaque::<i16>(move _48) -> [return: bb16, unwind unreachable];
+      }
+  
+      bb16: {
+          StorageDead(_48);
+          StorageDead(_47);
+          StorageLive(_50);
+          StorageLive(_51);
+-         StorageLive(_52);
+-         _52 = _2;
+-         _51 = move _52 as i32 (IntToInt);
+-         StorageDead(_52);
++         _51 = const 1_u64 as i32 (IntToInt);
+          _50 = opaque::<i32>(move _51) -> [return: bb17, unwind unreachable];
+      }
+  
+      bb17: {
+          StorageDead(_51);
+          StorageDead(_50);
+          StorageLive(_53);
+          StorageLive(_54);
+-         StorageLive(_55);
+-         _55 = _2;
+-         _54 = move _55 as i64 (IntToInt);
+-         StorageDead(_55);
++         _54 = const 1_u64 as i64 (IntToInt);
+          _53 = opaque::<i64>(move _54) -> [return: bb18, unwind unreachable];
+      }
+  
+      bb18: {
+          StorageDead(_54);
+          StorageDead(_53);
+          StorageLive(_56);
+          StorageLive(_57);
+-         StorageLive(_58);
+-         _58 = _2;
+-         _57 = move _58 as f32 (IntToFloat);
+-         StorageDead(_58);
++         _57 = const 1_u64 as f32 (IntToFloat);
+          _56 = opaque::<f32>(move _57) -> [return: bb19, unwind unreachable];
+      }
+  
+      bb19: {
+          StorageDead(_57);
+          StorageDead(_56);
+          StorageLive(_59);
+          StorageLive(_60);
+-         StorageLive(_61);
+-         _61 = _2;
+-         _60 = move _61 as f64 (IntToFloat);
+-         StorageDead(_61);
++         _60 = const 1_u64 as f64 (IntToFloat);
+          _59 = opaque::<f64>(move _60) -> [return: bb20, unwind unreachable];
+      }
+  
+      bb20: {
+          StorageDead(_60);
+          StorageDead(_59);
+          StorageLive(_62);
+          StorageLive(_63);
+-         StorageLive(_64);
+-         _64 = _3;
+-         _63 = move _64 as u8 (FloatToInt);
+-         StorageDead(_64);
++         _63 = const 1f64 as u8 (FloatToInt);
+          _62 = opaque::<u8>(move _63) -> [return: bb21, unwind unreachable];
+      }
+  
+      bb21: {
+          StorageDead(_63);
+          StorageDead(_62);
+          StorageLive(_65);
+          StorageLive(_66);
+-         StorageLive(_67);
+-         _67 = _3;
+-         _66 = move _67 as u16 (FloatToInt);
+-         StorageDead(_67);
++         _66 = const 1f64 as u16 (FloatToInt);
+          _65 = opaque::<u16>(move _66) -> [return: bb22, unwind unreachable];
+      }
+  
+      bb22: {
+          StorageDead(_66);
+          StorageDead(_65);
+          StorageLive(_68);
+          StorageLive(_69);
+-         StorageLive(_70);
+-         _70 = _3;
+-         _69 = move _70 as u32 (FloatToInt);
+-         StorageDead(_70);
++         _69 = const 1f64 as u32 (FloatToInt);
+          _68 = opaque::<u32>(move _69) -> [return: bb23, unwind unreachable];
+      }
+  
+      bb23: {
+          StorageDead(_69);
+          StorageDead(_68);
+          StorageLive(_71);
+          StorageLive(_72);
+-         StorageLive(_73);
+-         _73 = _3;
+-         _72 = move _73 as u64 (FloatToInt);
+-         StorageDead(_73);
++         _72 = const 1f64 as u64 (FloatToInt);
+          _71 = opaque::<u64>(move _72) -> [return: bb24, unwind unreachable];
+      }
+  
+      bb24: {
+          StorageDead(_72);
+          StorageDead(_71);
+          StorageLive(_74);
+          StorageLive(_75);
+-         StorageLive(_76);
+-         _76 = _3;
+-         _75 = move _76 as i8 (FloatToInt);
+-         StorageDead(_76);
++         _75 = const 1f64 as i8 (FloatToInt);
+          _74 = opaque::<i8>(move _75) -> [return: bb25, unwind unreachable];
+      }
+  
+      bb25: {
+          StorageDead(_75);
+          StorageDead(_74);
+          StorageLive(_77);
+          StorageLive(_78);
+-         StorageLive(_79);
+-         _79 = _3;
+-         _78 = move _79 as i16 (FloatToInt);
+-         StorageDead(_79);
++         _78 = const 1f64 as i16 (FloatToInt);
+          _77 = opaque::<i16>(move _78) -> [return: bb26, unwind unreachable];
+      }
+  
+      bb26: {
+          StorageDead(_78);
+          StorageDead(_77);
+          StorageLive(_80);
+          StorageLive(_81);
+-         StorageLive(_82);
+-         _82 = _3;
+-         _81 = move _82 as i32 (FloatToInt);
+-         StorageDead(_82);
++         _81 = const 1f64 as i32 (FloatToInt);
+          _80 = opaque::<i32>(move _81) -> [return: bb27, unwind unreachable];
+      }
+  
+      bb27: {
+          StorageDead(_81);
+          StorageDead(_80);
+          StorageLive(_83);
+          StorageLive(_84);
+-         StorageLive(_85);
+-         _85 = _3;
+-         _84 = move _85 as i64 (FloatToInt);
+-         StorageDead(_85);
++         _84 = const 1f64 as i64 (FloatToInt);
+          _83 = opaque::<i64>(move _84) -> [return: bb28, unwind unreachable];
+      }
+  
+      bb28: {
+          StorageDead(_84);
+          StorageDead(_83);
+          StorageLive(_86);
+          StorageLive(_87);
+-         StorageLive(_88);
+-         _88 = _3;
+-         _87 = move _88 as f32 (FloatToFloat);
+-         StorageDead(_88);
++         _87 = const 1f64 as f32 (FloatToFloat);
+          _86 = opaque::<f32>(move _87) -> [return: bb29, unwind unreachable];
+      }
+  
+      bb29: {
+          StorageDead(_87);
+          StorageDead(_86);
+          StorageLive(_89);
+-         StorageLive(_90);
+-         _90 = _3;
+-         _89 = opaque::<f64>(move _90) -> [return: bb30, unwind unreachable];
++         _89 = opaque::<f64>(const 1f64) -> [return: bb30, unwind unreachable];
+      }
+  
+      bb30: {
+-         StorageDead(_90);
+          StorageDead(_89);
+          _0 = const ();
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.cast.GVN.panic-unwind.diff

@@ -0,0 +1,501 @@
+- // MIR for `cast` before GVN
++ // MIR for `cast` after GVN
+  
+  fn cast() -> () {
+      let mut _0: ();
+      let _1: i64;
+      let _4: ();
+      let mut _5: u8;
+      let mut _6: i64;
+      let _7: ();
+      let mut _8: u16;
+      let mut _9: i64;
+      let _10: ();
+      let mut _11: u32;
+      let mut _12: i64;
+      let _13: ();
+      let mut _14: u64;
+      let mut _15: i64;
+      let _16: ();
+      let mut _17: i8;
+      let mut _18: i64;
+      let _19: ();
+      let mut _20: i16;
+      let mut _21: i64;
+      let _22: ();
+      let mut _23: i32;
+      let mut _24: i64;
+      let _25: ();
+      let mut _26: i64;
+      let _27: ();
+      let mut _28: f32;
+      let mut _29: i64;
+      let _30: ();
+      let mut _31: f64;
+      let mut _32: i64;
+      let _33: ();
+      let mut _34: u8;
+      let mut _35: u64;
+      let _36: ();
+      let mut _37: u16;
+      let mut _38: u64;
+      let _39: ();
+      let mut _40: u32;
+      let mut _41: u64;
+      let _42: ();
+      let mut _43: u64;
+      let _44: ();
+      let mut _45: i8;
+      let mut _46: u64;
+      let _47: ();
+      let mut _48: i16;
+      let mut _49: u64;
+      let _50: ();
+      let mut _51: i32;
+      let mut _52: u64;
+      let _53: ();
+      let mut _54: i64;
+      let mut _55: u64;
+      let _56: ();
+      let mut _57: f32;
+      let mut _58: u64;
+      let _59: ();
+      let mut _60: f64;
+      let mut _61: u64;
+      let _62: ();
+      let mut _63: u8;
+      let mut _64: f64;
+      let _65: ();
+      let mut _66: u16;
+      let mut _67: f64;
+      let _68: ();
+      let mut _69: u32;
+      let mut _70: f64;
+      let _71: ();
+      let mut _72: u64;
+      let mut _73: f64;
+      let _74: ();
+      let mut _75: i8;
+      let mut _76: f64;
+      let _77: ();
+      let mut _78: i16;
+      let mut _79: f64;
+      let _80: ();
+      let mut _81: i32;
+      let mut _82: f64;
+      let _83: ();
+      let mut _84: i64;
+      let mut _85: f64;
+      let _86: ();
+      let mut _87: f32;
+      let mut _88: f64;
+      let _89: ();
+      let mut _90: f64;
+      scope 1 {
+          debug i => _1;
+          let _2: u64;
+          scope 2 {
+              debug u => _2;
+              let _3: f64;
+              scope 3 {
+                  debug f => _3;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+          _1 = const 1_i64;
+          StorageLive(_2);
+          _2 = const 1_u64;
+          StorageLive(_3);
+          _3 = const 1f64;
+          StorageLive(_4);
+          StorageLive(_5);
+-         StorageLive(_6);
+-         _6 = _1;
+-         _5 = move _6 as u8 (IntToInt);
+-         StorageDead(_6);
++         _5 = const 1_i64 as u8 (IntToInt);
+          _4 = opaque::<u8>(move _5) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_7);
+          StorageLive(_8);
+-         StorageLive(_9);
+-         _9 = _1;
+-         _8 = move _9 as u16 (IntToInt);
+-         StorageDead(_9);
++         _8 = const 1_i64 as u16 (IntToInt);
+          _7 = opaque::<u16>(move _8) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageLive(_10);
+          StorageLive(_11);
+-         StorageLive(_12);
+-         _12 = _1;
+-         _11 = move _12 as u32 (IntToInt);
+-         StorageDead(_12);
++         _11 = const 1_i64 as u32 (IntToInt);
+          _10 = opaque::<u32>(move _11) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_11);
+          StorageDead(_10);
+          StorageLive(_13);
+          StorageLive(_14);
+-         StorageLive(_15);
+-         _15 = _1;
+-         _14 = move _15 as u64 (IntToInt);
+-         StorageDead(_15);
++         _14 = const 1_i64 as u64 (IntToInt);
+          _13 = opaque::<u64>(move _14) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_14);
+          StorageDead(_13);
+          StorageLive(_16);
+          StorageLive(_17);
+-         StorageLive(_18);
+-         _18 = _1;
+-         _17 = move _18 as i8 (IntToInt);
+-         StorageDead(_18);
++         _17 = const 1_i64 as i8 (IntToInt);
+          _16 = opaque::<i8>(move _17) -> [return: bb5, unwind continue];
+      }
+  
+      bb5: {
+          StorageDead(_17);
+          StorageDead(_16);
+          StorageLive(_19);
+          StorageLive(_20);
+-         StorageLive(_21);
+-         _21 = _1;
+-         _20 = move _21 as i16 (IntToInt);
+-         StorageDead(_21);
++         _20 = const 1_i64 as i16 (IntToInt);
+          _19 = opaque::<i16>(move _20) -> [return: bb6, unwind continue];
+      }
+  
+      bb6: {
+          StorageDead(_20);
+          StorageDead(_19);
+          StorageLive(_22);
+          StorageLive(_23);
+-         StorageLive(_24);
+-         _24 = _1;
+-         _23 = move _24 as i32 (IntToInt);
+-         StorageDead(_24);
++         _23 = const 1_i64 as i32 (IntToInt);
+          _22 = opaque::<i32>(move _23) -> [return: bb7, unwind continue];
+      }
+  
+      bb7: {
+          StorageDead(_23);
+          StorageDead(_22);
+          StorageLive(_25);
+-         StorageLive(_26);
+-         _26 = _1;
+-         _25 = opaque::<i64>(move _26) -> [return: bb8, unwind continue];
++         _25 = opaque::<i64>(const 1_i64) -> [return: bb8, unwind continue];
+      }
+  
+      bb8: {
+-         StorageDead(_26);
+          StorageDead(_25);
+          StorageLive(_27);
+          StorageLive(_28);
+-         StorageLive(_29);
+-         _29 = _1;
+-         _28 = move _29 as f32 (IntToFloat);
+-         StorageDead(_29);
++         _28 = const 1_i64 as f32 (IntToFloat);
+          _27 = opaque::<f32>(move _28) -> [return: bb9, unwind continue];
+      }
+  
+      bb9: {
+          StorageDead(_28);
+          StorageDead(_27);
+          StorageLive(_30);
+          StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = _1;
+-         _31 = move _32 as f64 (IntToFloat);
+-         StorageDead(_32);
++         _31 = const 1_i64 as f64 (IntToFloat);
+          _30 = opaque::<f64>(move _31) -> [return: bb10, unwind continue];
+      }
+  
+      bb10: {
+          StorageDead(_31);
+          StorageDead(_30);
+          StorageLive(_33);
+          StorageLive(_34);
+-         StorageLive(_35);
+-         _35 = _2;
+-         _34 = move _35 as u8 (IntToInt);
+-         StorageDead(_35);
++         _34 = const 1_u64 as u8 (IntToInt);
+          _33 = opaque::<u8>(move _34) -> [return: bb11, unwind continue];
+      }
+  
+      bb11: {
+          StorageDead(_34);
+          StorageDead(_33);
+          StorageLive(_36);
+          StorageLive(_37);
+-         StorageLive(_38);
+-         _38 = _2;
+-         _37 = move _38 as u16 (IntToInt);
+-         StorageDead(_38);
++         _37 = const 1_u64 as u16 (IntToInt);
+          _36 = opaque::<u16>(move _37) -> [return: bb12, unwind continue];
+      }
+  
+      bb12: {
+          StorageDead(_37);
+          StorageDead(_36);
+          StorageLive(_39);
+          StorageLive(_40);
+-         StorageLive(_41);
+-         _41 = _2;
+-         _40 = move _41 as u32 (IntToInt);
+-         StorageDead(_41);
++         _40 = const 1_u64 as u32 (IntToInt);
+          _39 = opaque::<u32>(move _40) -> [return: bb13, unwind continue];
+      }
+  
+      bb13: {
+          StorageDead(_40);
+          StorageDead(_39);
+          StorageLive(_42);
+-         StorageLive(_43);
+-         _43 = _2;
+-         _42 = opaque::<u64>(move _43) -> [return: bb14, unwind continue];
++         _42 = opaque::<u64>(const 1_u64) -> [return: bb14, unwind continue];
+      }
+  
+      bb14: {
+-         StorageDead(_43);
+          StorageDead(_42);
+          StorageLive(_44);
+          StorageLive(_45);
+-         StorageLive(_46);
+-         _46 = _2;
+-         _45 = move _46 as i8 (IntToInt);
+-         StorageDead(_46);
++         _45 = const 1_u64 as i8 (IntToInt);
+          _44 = opaque::<i8>(move _45) -> [return: bb15, unwind continue];
+      }
+  
+      bb15: {
+          StorageDead(_45);
+          StorageDead(_44);
+          StorageLive(_47);
+          StorageLive(_48);
+-         StorageLive(_49);
+-         _49 = _2;
+-         _48 = move _49 as i16 (IntToInt);
+-         StorageDead(_49);
++         _48 = const 1_u64 as i16 (IntToInt);
+          _47 = opaque::<i16>(move _48) -> [return: bb16, unwind continue];
+      }
+  
+      bb16: {
+          StorageDead(_48);
+          StorageDead(_47);
+          StorageLive(_50);
+          StorageLive(_51);
+-         StorageLive(_52);
+-         _52 = _2;
+-         _51 = move _52 as i32 (IntToInt);
+-         StorageDead(_52);
++         _51 = const 1_u64 as i32 (IntToInt);
+          _50 = opaque::<i32>(move _51) -> [return: bb17, unwind continue];
+      }
+  
+      bb17: {
+          StorageDead(_51);
+          StorageDead(_50);
+          StorageLive(_53);
+          StorageLive(_54);
+-         StorageLive(_55);
+-         _55 = _2;
+-         _54 = move _55 as i64 (IntToInt);
+-         StorageDead(_55);
++         _54 = const 1_u64 as i64 (IntToInt);
+          _53 = opaque::<i64>(move _54) -> [return: bb18, unwind continue];
+      }
+  
+      bb18: {
+          StorageDead(_54);
+          StorageDead(_53);
+          StorageLive(_56);
+          StorageLive(_57);
+-         StorageLive(_58);
+-         _58 = _2;
+-         _57 = move _58 as f32 (IntToFloat);
+-         StorageDead(_58);
++         _57 = const 1_u64 as f32 (IntToFloat);
+          _56 = opaque::<f32>(move _57) -> [return: bb19, unwind continue];
+      }
+  
+      bb19: {
+          StorageDead(_57);
+          StorageDead(_56);
+          StorageLive(_59);
+          StorageLive(_60);
+-         StorageLive(_61);
+-         _61 = _2;
+-         _60 = move _61 as f64 (IntToFloat);
+-         StorageDead(_61);
++         _60 = const 1_u64 as f64 (IntToFloat);
+          _59 = opaque::<f64>(move _60) -> [return: bb20, unwind continue];
+      }
+  
+      bb20: {
+          StorageDead(_60);
+          StorageDead(_59);
+          StorageLive(_62);
+          StorageLive(_63);
+-         StorageLive(_64);
+-         _64 = _3;
+-         _63 = move _64 as u8 (FloatToInt);
+-         StorageDead(_64);
++         _63 = const 1f64 as u8 (FloatToInt);
+          _62 = opaque::<u8>(move _63) -> [return: bb21, unwind continue];
+      }
+  
+      bb21: {
+          StorageDead(_63);
+          StorageDead(_62);
+          StorageLive(_65);
+          StorageLive(_66);
+-         StorageLive(_67);
+-         _67 = _3;
+-         _66 = move _67 as u16 (FloatToInt);
+-         StorageDead(_67);
++         _66 = const 1f64 as u16 (FloatToInt);
+          _65 = opaque::<u16>(move _66) -> [return: bb22, unwind continue];
+      }
+  
+      bb22: {
+          StorageDead(_66);
+          StorageDead(_65);
+          StorageLive(_68);
+          StorageLive(_69);
+-         StorageLive(_70);
+-         _70 = _3;
+-         _69 = move _70 as u32 (FloatToInt);
+-         StorageDead(_70);
++         _69 = const 1f64 as u32 (FloatToInt);
+          _68 = opaque::<u32>(move _69) -> [return: bb23, unwind continue];
+      }
+  
+      bb23: {
+          StorageDead(_69);
+          StorageDead(_68);
+          StorageLive(_71);
+          StorageLive(_72);
+-         StorageLive(_73);
+-         _73 = _3;
+-         _72 = move _73 as u64 (FloatToInt);
+-         StorageDead(_73);
++         _72 = const 1f64 as u64 (FloatToInt);
+          _71 = opaque::<u64>(move _72) -> [return: bb24, unwind continue];
+      }
+  
+      bb24: {
+          StorageDead(_72);
+          StorageDead(_71);
+          StorageLive(_74);
+          StorageLive(_75);
+-         StorageLive(_76);
+-         _76 = _3;
+-         _75 = move _76 as i8 (FloatToInt);
+-         StorageDead(_76);
++         _75 = const 1f64 as i8 (FloatToInt);
+          _74 = opaque::<i8>(move _75) -> [return: bb25, unwind continue];
+      }
+  
+      bb25: {
+          StorageDead(_75);
+          StorageDead(_74);
+          StorageLive(_77);
+          StorageLive(_78);
+-         StorageLive(_79);
+-         _79 = _3;
+-         _78 = move _79 as i16 (FloatToInt);
+-         StorageDead(_79);
++         _78 = const 1f64 as i16 (FloatToInt);
+          _77 = opaque::<i16>(move _78) -> [return: bb26, unwind continue];
+      }
+  
+      bb26: {
+          StorageDead(_78);
+          StorageDead(_77);
+          StorageLive(_80);
+          StorageLive(_81);
+-         StorageLive(_82);
+-         _82 = _3;
+-         _81 = move _82 as i32 (FloatToInt);
+-         StorageDead(_82);
++         _81 = const 1f64 as i32 (FloatToInt);
+          _80 = opaque::<i32>(move _81) -> [return: bb27, unwind continue];
+      }
+  
+      bb27: {
+          StorageDead(_81);
+          StorageDead(_80);
+          StorageLive(_83);
+          StorageLive(_84);
+-         StorageLive(_85);
+-         _85 = _3;
+-         _84 = move _85 as i64 (FloatToInt);
+-         StorageDead(_85);
++         _84 = const 1f64 as i64 (FloatToInt);
+          _83 = opaque::<i64>(move _84) -> [return: bb28, unwind continue];
+      }
+  
+      bb28: {
+          StorageDead(_84);
+          StorageDead(_83);
+          StorageLive(_86);
+          StorageLive(_87);
+-         StorageLive(_88);
+-         _88 = _3;
+-         _87 = move _88 as f32 (FloatToFloat);
+-         StorageDead(_88);
++         _87 = const 1f64 as f32 (FloatToFloat);
+          _86 = opaque::<f32>(move _87) -> [return: bb29, unwind continue];
+      }
+  
+      bb29: {
+          StorageDead(_87);
+          StorageDead(_86);
+          StorageLive(_89);
+-         StorageLive(_90);
+-         _90 = _3;
+-         _89 = opaque::<f64>(move _90) -> [return: bb30, unwind continue];
++         _89 = opaque::<f64>(const 1f64) -> [return: bb30, unwind continue];
+      }
+  
+      bb30: {
+-         StorageDead(_90);
+          StorageDead(_89);
+          _0 = const ();
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff

@@ -0,0 +1,191 @@
+- // MIR for `dereferences` before GVN
++ // MIR for `dereferences` after GVN
+  
+  fn dereferences(_1: &mut u32, _2: &impl Copy, _3: &S<u32>) -> () {
+      debug t => _1;
+      debug u => _2;
+      debug s => _3;
+      let mut _0: ();
+      let _4: ();
+      let mut _5: u32;
+      let _6: ();
+      let mut _7: u32;
+      let _8: *const u32;
+      let _9: ();
+      let mut _10: u32;
+      let _11: ();
+      let mut _12: u32;
+      let _14: ();
+      let mut _15: u32;
+      let _16: ();
+      let mut _17: u32;
+      let _19: ();
+      let mut _20: u32;
+      let _21: ();
+      let mut _22: u32;
+      let _23: ();
+      let mut _24: &u32;
+      let _25: ();
+      let mut _26: impl Copy;
+      let _27: ();
+      let mut _28: impl Copy;
+      let _29: ();
+      let mut _30: u32;
+      let _31: ();
+      let mut _32: u32;
+      scope 1 {
+          debug z => _8;
+          let _13: *mut u32;
+          scope 2 {
+          }
+          scope 3 {
+          }
+          scope 4 {
+              debug z => _13;
+              let _18: &u32;
+              scope 5 {
+              }
+              scope 6 {
+              }
+              scope 7 {
+                  debug z => _18;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_4);
+          StorageLive(_5);
+          _5 = (*_1);
+          _4 = opaque::<u32>(move _5) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_6);
+          StorageLive(_7);
+          _7 = (*_1);
+          _6 = opaque::<u32>(move _7) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_8);
+          _8 = &raw const (*_1);
+          StorageLive(_9);
+          StorageLive(_10);
+          _10 = (*_8);
+          _9 = opaque::<u32>(move _10) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = (*_8);
+          _11 = opaque::<u32>(move _12) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageLive(_13);
+          _13 = &raw mut (*_1);
+          StorageLive(_14);
+          StorageLive(_15);
+          _15 = (*_13);
+          _14 = opaque::<u32>(move _15) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_16);
+          StorageLive(_17);
+          _17 = (*_13);
+          _16 = opaque::<u32>(move _17) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+          StorageDead(_17);
+          StorageDead(_16);
+          StorageLive(_18);
+          _18 = &(*_1);
+          StorageLive(_19);
+-         StorageLive(_20);
+          _20 = (*_18);
+-         _19 = opaque::<u32>(move _20) -> [return: bb7, unwind unreachable];
++         _19 = opaque::<u32>(_20) -> [return: bb7, unwind unreachable];
+      }
+  
+      bb7: {
+-         StorageDead(_20);
+          StorageDead(_19);
+          StorageLive(_21);
+-         StorageLive(_22);
+-         _22 = (*_18);
+-         _21 = opaque::<u32>(move _22) -> [return: bb8, unwind unreachable];
++         _21 = opaque::<u32>(_20) -> [return: bb8, unwind unreachable];
+      }
+  
+      bb8: {
+-         StorageDead(_22);
+          StorageDead(_21);
+          StorageLive(_23);
+          StorageLive(_24);
+          _24 = &(*_18);
+          _23 = opaque::<&u32>(move _24) -> [return: bb9, unwind unreachable];
+      }
+  
+      bb9: {
+          StorageDead(_24);
+          StorageDead(_23);
+          StorageLive(_25);
+          StorageLive(_26);
+          _26 = (*_2);
+          _25 = opaque::<impl Copy>(move _26) -> [return: bb10, unwind unreachable];
+      }
+  
+      bb10: {
+          StorageDead(_26);
+          StorageDead(_25);
+          StorageLive(_27);
+          StorageLive(_28);
+          _28 = (*_2);
+          _27 = opaque::<impl Copy>(move _28) -> [return: bb11, unwind unreachable];
+      }
+  
+      bb11: {
+          StorageDead(_28);
+          StorageDead(_27);
+          StorageLive(_29);
+-         StorageLive(_30);
+          _30 = ((*_3).0: u32);
+-         _29 = opaque::<u32>(move _30) -> [return: bb12, unwind unreachable];
++         _29 = opaque::<u32>(_30) -> [return: bb12, unwind unreachable];
+      }
+  
+      bb12: {
+-         StorageDead(_30);
+          StorageDead(_29);
+          StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = ((*_3).0: u32);
+-         _31 = opaque::<u32>(move _32) -> [return: bb13, unwind unreachable];
++         _31 = opaque::<u32>(_30) -> [return: bb13, unwind unreachable];
+      }
+  
+      bb13: {
+-         StorageDead(_32);
+          StorageDead(_31);
+          _0 = const ();
+          StorageDead(_18);
+          StorageDead(_13);
+          StorageDead(_8);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff

@@ -0,0 +1,191 @@
+- // MIR for `dereferences` before GVN
++ // MIR for `dereferences` after GVN
+  
+  fn dereferences(_1: &mut u32, _2: &impl Copy, _3: &S<u32>) -> () {
+      debug t => _1;
+      debug u => _2;
+      debug s => _3;
+      let mut _0: ();
+      let _4: ();
+      let mut _5: u32;
+      let _6: ();
+      let mut _7: u32;
+      let _8: *const u32;
+      let _9: ();
+      let mut _10: u32;
+      let _11: ();
+      let mut _12: u32;
+      let _14: ();
+      let mut _15: u32;
+      let _16: ();
+      let mut _17: u32;
+      let _19: ();
+      let mut _20: u32;
+      let _21: ();
+      let mut _22: u32;
+      let _23: ();
+      let mut _24: &u32;
+      let _25: ();
+      let mut _26: impl Copy;
+      let _27: ();
+      let mut _28: impl Copy;
+      let _29: ();
+      let mut _30: u32;
+      let _31: ();
+      let mut _32: u32;
+      scope 1 {
+          debug z => _8;
+          let _13: *mut u32;
+          scope 2 {
+          }
+          scope 3 {
+          }
+          scope 4 {
+              debug z => _13;
+              let _18: &u32;
+              scope 5 {
+              }
+              scope 6 {
+              }
+              scope 7 {
+                  debug z => _18;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_4);
+          StorageLive(_5);
+          _5 = (*_1);
+          _4 = opaque::<u32>(move _5) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_6);
+          StorageLive(_7);
+          _7 = (*_1);
+          _6 = opaque::<u32>(move _7) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_8);
+          _8 = &raw const (*_1);
+          StorageLive(_9);
+          StorageLive(_10);
+          _10 = (*_8);
+          _9 = opaque::<u32>(move _10) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = (*_8);
+          _11 = opaque::<u32>(move _12) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageLive(_13);
+          _13 = &raw mut (*_1);
+          StorageLive(_14);
+          StorageLive(_15);
+          _15 = (*_13);
+          _14 = opaque::<u32>(move _15) -> [return: bb5, unwind continue];
+      }
+  
+      bb5: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_16);
+          StorageLive(_17);
+          _17 = (*_13);
+          _16 = opaque::<u32>(move _17) -> [return: bb6, unwind continue];
+      }
+  
+      bb6: {
+          StorageDead(_17);
+          StorageDead(_16);
+          StorageLive(_18);
+          _18 = &(*_1);
+          StorageLive(_19);
+-         StorageLive(_20);
+          _20 = (*_18);
+-         _19 = opaque::<u32>(move _20) -> [return: bb7, unwind continue];
++         _19 = opaque::<u32>(_20) -> [return: bb7, unwind continue];
+      }
+  
+      bb7: {
+-         StorageDead(_20);
+          StorageDead(_19);
+          StorageLive(_21);
+-         StorageLive(_22);
+-         _22 = (*_18);
+-         _21 = opaque::<u32>(move _22) -> [return: bb8, unwind continue];
++         _21 = opaque::<u32>(_20) -> [return: bb8, unwind continue];
+      }
+  
+      bb8: {
+-         StorageDead(_22);
+          StorageDead(_21);
+          StorageLive(_23);
+          StorageLive(_24);
+          _24 = &(*_18);
+          _23 = opaque::<&u32>(move _24) -> [return: bb9, unwind continue];
+      }
+  
+      bb9: {
+          StorageDead(_24);
+          StorageDead(_23);
+          StorageLive(_25);
+          StorageLive(_26);
+          _26 = (*_2);
+          _25 = opaque::<impl Copy>(move _26) -> [return: bb10, unwind continue];
+      }
+  
+      bb10: {
+          StorageDead(_26);
+          StorageDead(_25);
+          StorageLive(_27);
+          StorageLive(_28);
+          _28 = (*_2);
+          _27 = opaque::<impl Copy>(move _28) -> [return: bb11, unwind continue];
+      }
+  
+      bb11: {
+          StorageDead(_28);
+          StorageDead(_27);
+          StorageLive(_29);
+-         StorageLive(_30);
+          _30 = ((*_3).0: u32);
+-         _29 = opaque::<u32>(move _30) -> [return: bb12, unwind continue];
++         _29 = opaque::<u32>(_30) -> [return: bb12, unwind continue];
+      }
+  
+      bb12: {
+-         StorageDead(_30);
+          StorageDead(_29);
+          StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = ((*_3).0: u32);
+-         _31 = opaque::<u32>(move _32) -> [return: bb13, unwind continue];
++         _31 = opaque::<u32>(_30) -> [return: bb13, unwind continue];
+      }
+  
+      bb13: {
+-         StorageDead(_32);
+          StorageDead(_31);
+          _0 = const ();
+          StorageDead(_18);
+          StorageDead(_13);
+          StorageDead(_8);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff

@@ -0,0 +1,198 @@
+- // MIR for `multiple_branches` before GVN
++ // MIR for `multiple_branches` after GVN
+  
+  fn multiple_branches(_1: bool, _2: u8, _3: u8) -> () {
+      debug t => _1;
+      debug x => _2;
+      debug y => _3;
+      let mut _0: ();
+      let _4: ();
+      let mut _5: bool;
+      let _6: ();
+      let mut _7: u8;
+      let mut _8: u8;
+      let mut _9: u8;
+      let _10: ();
+      let mut _11: u8;
+      let mut _12: u8;
+      let mut _13: u8;
+      let _14: ();
+      let mut _15: u8;
+      let mut _16: u8;
+      let mut _17: u8;
+      let _18: ();
+      let mut _19: u8;
+      let mut _20: u8;
+      let mut _21: u8;
+      let _22: ();
+      let mut _23: u8;
+      let mut _24: u8;
+      let mut _25: u8;
+      let mut _26: bool;
+      let _27: ();
+      let mut _28: u8;
+      let mut _29: u8;
+      let mut _30: u8;
+      let _31: ();
+      let mut _32: u8;
+      let mut _33: u8;
+      let mut _34: u8;
+  
+      bb0: {
+-         StorageLive(_4);
+-         StorageLive(_5);
+-         _5 = _1;
+-         switchInt(move _5) -> [0: bb4, otherwise: bb1];
++         switchInt(_1) -> [0: bb4, otherwise: bb1];
+      }
+  
+      bb1: {
+          StorageLive(_6);
+-         StorageLive(_7);
+-         StorageLive(_8);
+-         _8 = _2;
+-         StorageLive(_9);
+-         _9 = _3;
+-         _7 = Add(move _8, move _9);
+-         StorageDead(_9);
+-         StorageDead(_8);
+-         _6 = opaque::<u8>(move _7) -> [return: bb2, unwind unreachable];
++         _7 = Add(_2, _3);
++         _6 = opaque::<u8>(_7) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+-         StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_10);
+-         StorageLive(_11);
+-         StorageLive(_12);
+-         _12 = _2;
+-         StorageLive(_13);
+-         _13 = _3;
+-         _11 = Add(move _12, move _13);
+-         StorageDead(_13);
+-         StorageDead(_12);
+-         _10 = opaque::<u8>(move _11) -> [return: bb3, unwind unreachable];
++         _10 = opaque::<u8>(_7) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+-         StorageDead(_11);
+          StorageDead(_10);
+-         _4 = const ();
+          goto -> bb7;
+      }
+  
+      bb4: {
+          StorageLive(_14);
+-         StorageLive(_15);
+-         StorageLive(_16);
+-         _16 = _2;
+-         StorageLive(_17);
+-         _17 = _3;
+-         _15 = Add(move _16, move _17);
+-         StorageDead(_17);
+-         StorageDead(_16);
+-         _14 = opaque::<u8>(move _15) -> [return: bb5, unwind unreachable];
++         _15 = Add(_2, _3);
++         _14 = opaque::<u8>(_15) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+-         StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_18);
+-         StorageLive(_19);
+-         StorageLive(_20);
+-         _20 = _2;
+-         StorageLive(_21);
+-         _21 = _3;
+-         _19 = Add(move _20, move _21);
+-         StorageDead(_21);
+-         StorageDead(_20);
+-         _18 = opaque::<u8>(move _19) -> [return: bb6, unwind unreachable];
++         _18 = opaque::<u8>(_15) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+-         StorageDead(_19);
+          StorageDead(_18);
+-         _4 = const ();
+          goto -> bb7;
+      }
+  
+      bb7: {
+-         StorageDead(_5);
+-         StorageDead(_4);
+          StorageLive(_22);
+-         StorageLive(_23);
+-         StorageLive(_24);
+-         _24 = _2;
+-         StorageLive(_25);
+-         _25 = _3;
+-         _23 = Add(move _24, move _25);
+-         StorageDead(_25);
+-         StorageDead(_24);
+-         _22 = opaque::<u8>(move _23) -> [return: bb8, unwind unreachable];
++         _23 = Add(_2, _3);
++         _22 = opaque::<u8>(_23) -> [return: bb8, unwind unreachable];
+      }
+  
+      bb8: {
+-         StorageDead(_23);
+          StorageDead(_22);
+-         StorageLive(_26);
+-         _26 = _1;
+-         switchInt(move _26) -> [0: bb11, otherwise: bb9];
++         switchInt(_1) -> [0: bb11, otherwise: bb9];
+      }
+  
+      bb9: {
+          StorageLive(_27);
+-         StorageLive(_28);
+-         StorageLive(_29);
+-         _29 = _2;
+-         StorageLive(_30);
+-         _30 = _3;
+-         _28 = Add(move _29, move _30);
+-         StorageDead(_30);
+-         StorageDead(_29);
+-         _27 = opaque::<u8>(move _28) -> [return: bb10, unwind unreachable];
++         _27 = opaque::<u8>(_23) -> [return: bb10, unwind unreachable];
+      }
+  
+      bb10: {
+-         StorageDead(_28);
+          StorageDead(_27);
+          _0 = const ();
+          goto -> bb13;
+      }
+  
+      bb11: {
+          StorageLive(_31);
+-         StorageLive(_32);
+-         StorageLive(_33);
+-         _33 = _2;
+-         StorageLive(_34);
+-         _34 = _3;
+-         _32 = Add(move _33, move _34);
+-         StorageDead(_34);
+-         StorageDead(_33);
+-         _31 = opaque::<u8>(move _32) -> [return: bb12, unwind unreachable];
++         _31 = opaque::<u8>(_23) -> [return: bb12, unwind unreachable];
+      }
+  
+      bb12: {
+-         StorageDead(_32);
+          StorageDead(_31);
+          _0 = const ();
+          goto -> bb13;
+      }
+  
+      bb13: {
+-         StorageDead(_26);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff

@@ -0,0 +1,198 @@
+- // MIR for `multiple_branches` before GVN
++ // MIR for `multiple_branches` after GVN
+  
+  fn multiple_branches(_1: bool, _2: u8, _3: u8) -> () {
+      debug t => _1;
+      debug x => _2;
+      debug y => _3;
+      let mut _0: ();
+      let _4: ();
+      let mut _5: bool;
+      let _6: ();
+      let mut _7: u8;
+      let mut _8: u8;
+      let mut _9: u8;
+      let _10: ();
+      let mut _11: u8;
+      let mut _12: u8;
+      let mut _13: u8;
+      let _14: ();
+      let mut _15: u8;
+      let mut _16: u8;
+      let mut _17: u8;
+      let _18: ();
+      let mut _19: u8;
+      let mut _20: u8;
+      let mut _21: u8;
+      let _22: ();
+      let mut _23: u8;
+      let mut _24: u8;
+      let mut _25: u8;
+      let mut _26: bool;
+      let _27: ();
+      let mut _28: u8;
+      let mut _29: u8;
+      let mut _30: u8;
+      let _31: ();
+      let mut _32: u8;
+      let mut _33: u8;
+      let mut _34: u8;
+  
+      bb0: {
+-         StorageLive(_4);
+-         StorageLive(_5);
+-         _5 = _1;
+-         switchInt(move _5) -> [0: bb4, otherwise: bb1];
++         switchInt(_1) -> [0: bb4, otherwise: bb1];
+      }
+  
+      bb1: {
+          StorageLive(_6);
+-         StorageLive(_7);
+-         StorageLive(_8);
+-         _8 = _2;
+-         StorageLive(_9);
+-         _9 = _3;
+-         _7 = Add(move _8, move _9);
+-         StorageDead(_9);
+-         StorageDead(_8);
+-         _6 = opaque::<u8>(move _7) -> [return: bb2, unwind continue];
++         _7 = Add(_2, _3);
++         _6 = opaque::<u8>(_7) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+-         StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_10);
+-         StorageLive(_11);
+-         StorageLive(_12);
+-         _12 = _2;
+-         StorageLive(_13);
+-         _13 = _3;
+-         _11 = Add(move _12, move _13);
+-         StorageDead(_13);
+-         StorageDead(_12);
+-         _10 = opaque::<u8>(move _11) -> [return: bb3, unwind continue];
++         _10 = opaque::<u8>(_7) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+-         StorageDead(_11);
+          StorageDead(_10);
+-         _4 = const ();
+          goto -> bb7;
+      }
+  
+      bb4: {
+          StorageLive(_14);
+-         StorageLive(_15);
+-         StorageLive(_16);
+-         _16 = _2;
+-         StorageLive(_17);
+-         _17 = _3;
+-         _15 = Add(move _16, move _17);
+-         StorageDead(_17);
+-         StorageDead(_16);
+-         _14 = opaque::<u8>(move _15) -> [return: bb5, unwind continue];
++         _15 = Add(_2, _3);
++         _14 = opaque::<u8>(_15) -> [return: bb5, unwind continue];
+      }
+  
+      bb5: {
+-         StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_18);
+-         StorageLive(_19);
+-         StorageLive(_20);
+-         _20 = _2;
+-         StorageLive(_21);
+-         _21 = _3;
+-         _19 = Add(move _20, move _21);
+-         StorageDead(_21);
+-         StorageDead(_20);
+-         _18 = opaque::<u8>(move _19) -> [return: bb6, unwind continue];
++         _18 = opaque::<u8>(_15) -> [return: bb6, unwind continue];
+      }
+  
+      bb6: {
+-         StorageDead(_19);
+          StorageDead(_18);
+-         _4 = const ();
+          goto -> bb7;
+      }
+  
+      bb7: {
+-         StorageDead(_5);
+-         StorageDead(_4);
+          StorageLive(_22);
+-         StorageLive(_23);
+-         StorageLive(_24);
+-         _24 = _2;
+-         StorageLive(_25);
+-         _25 = _3;
+-         _23 = Add(move _24, move _25);
+-         StorageDead(_25);
+-         StorageDead(_24);
+-         _22 = opaque::<u8>(move _23) -> [return: bb8, unwind continue];
++         _23 = Add(_2, _3);
++         _22 = opaque::<u8>(_23) -> [return: bb8, unwind continue];
+      }
+  
+      bb8: {
+-         StorageDead(_23);
+          StorageDead(_22);
+-         StorageLive(_26);
+-         _26 = _1;
+-         switchInt(move _26) -> [0: bb11, otherwise: bb9];
++         switchInt(_1) -> [0: bb11, otherwise: bb9];
+      }
+  
+      bb9: {
+          StorageLive(_27);
+-         StorageLive(_28);
+-         StorageLive(_29);
+-         _29 = _2;
+-         StorageLive(_30);
+-         _30 = _3;
+-         _28 = Add(move _29, move _30);
+-         StorageDead(_30);
+-         StorageDead(_29);
+-         _27 = opaque::<u8>(move _28) -> [return: bb10, unwind continue];
++         _27 = opaque::<u8>(_23) -> [return: bb10, unwind continue];
+      }
+  
+      bb10: {
+-         StorageDead(_28);
+          StorageDead(_27);
+          _0 = const ();
+          goto -> bb13;
+      }
+  
+      bb11: {
+          StorageLive(_31);
+-         StorageLive(_32);
+-         StorageLive(_33);
+-         _33 = _2;
+-         StorageLive(_34);
+-         _34 = _3;
+-         _32 = Add(move _33, move _34);
+-         StorageDead(_34);
+-         StorageDead(_33);
+-         _31 = opaque::<u8>(move _32) -> [return: bb12, unwind continue];
++         _31 = opaque::<u8>(_23) -> [return: bb12, unwind continue];
+      }
+  
+      bb12: {
+-         StorageDead(_32);
+          StorageDead(_31);
+          _0 = const ();
+          goto -> bb13;
+      }
+  
+      bb13: {
+-         StorageDead(_26);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.references.GVN.panic-abort.diff

@@ -0,0 +1,105 @@
+- // MIR for `references` before GVN
++ // MIR for `references` after GVN
+  
+  fn references(_1: impl Sized) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: &impl Sized;
+      let _4: ();
+      let mut _5: &impl Sized;
+      let _6: ();
+      let mut _7: &mut impl Sized;
+      let _8: ();
+      let mut _9: &mut impl Sized;
+      let _10: ();
+      let mut _11: *const impl Sized;
+      let _12: ();
+      let mut _13: *const impl Sized;
+      let _14: ();
+      let mut _15: *mut impl Sized;
+      let _16: ();
+      let mut _17: *mut impl Sized;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = &_1;
+          _2 = opaque::<&impl Sized>(move _3) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_4);
+          StorageLive(_5);
+          _5 = &_1;
+          _4 = opaque::<&impl Sized>(move _5) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_6);
+          StorageLive(_7);
+          _7 = &mut _1;
+          _6 = opaque::<&mut impl Sized>(move _7) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = &mut _1;
+          _8 = opaque::<&mut impl Sized>(move _9) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_10);
+          StorageLive(_11);
+          _11 = &raw const _1;
+          _10 = opaque::<*const impl Sized>(move _11) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+          StorageDead(_11);
+          StorageDead(_10);
+          StorageLive(_12);
+          StorageLive(_13);
+          _13 = &raw const _1;
+          _12 = opaque::<*const impl Sized>(move _13) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+          StorageDead(_13);
+          StorageDead(_12);
+          StorageLive(_14);
+          StorageLive(_15);
+          _15 = &raw mut _1;
+          _14 = opaque::<*mut impl Sized>(move _15) -> [return: bb7, unwind unreachable];
+      }
+  
+      bb7: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_16);
+          StorageLive(_17);
+          _17 = &raw mut _1;
+          _16 = opaque::<*mut impl Sized>(move _17) -> [return: bb8, unwind unreachable];
+      }
+  
+      bb8: {
+          StorageDead(_17);
+          StorageDead(_16);
+          _0 = const ();
+          drop(_1) -> [return: bb9, unwind unreachable];
+      }
+  
+      bb9: {
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.references.GVN.panic-unwind.diff

@@ -0,0 +1,113 @@
+- // MIR for `references` before GVN
++ // MIR for `references` after GVN
+  
+  fn references(_1: impl Sized) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: &impl Sized;
+      let _4: ();
+      let mut _5: &impl Sized;
+      let _6: ();
+      let mut _7: &mut impl Sized;
+      let _8: ();
+      let mut _9: &mut impl Sized;
+      let _10: ();
+      let mut _11: *const impl Sized;
+      let _12: ();
+      let mut _13: *const impl Sized;
+      let _14: ();
+      let mut _15: *mut impl Sized;
+      let _16: ();
+      let mut _17: *mut impl Sized;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = &_1;
+          _2 = opaque::<&impl Sized>(move _3) -> [return: bb1, unwind: bb10];
+      }
+  
+      bb1: {
+          StorageDead(_3);
+          StorageDead(_2);
+          StorageLive(_4);
+          StorageLive(_5);
+          _5 = &_1;
+          _4 = opaque::<&impl Sized>(move _5) -> [return: bb2, unwind: bb10];
+      }
+  
+      bb2: {
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_6);
+          StorageLive(_7);
+          _7 = &mut _1;
+          _6 = opaque::<&mut impl Sized>(move _7) -> [return: bb3, unwind: bb10];
+      }
+  
+      bb3: {
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = &mut _1;
+          _8 = opaque::<&mut impl Sized>(move _9) -> [return: bb4, unwind: bb10];
+      }
+  
+      bb4: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_10);
+          StorageLive(_11);
+          _11 = &raw const _1;
+          _10 = opaque::<*const impl Sized>(move _11) -> [return: bb5, unwind: bb10];
+      }
+  
+      bb5: {
+          StorageDead(_11);
+          StorageDead(_10);
+          StorageLive(_12);
+          StorageLive(_13);
+          _13 = &raw const _1;
+          _12 = opaque::<*const impl Sized>(move _13) -> [return: bb6, unwind: bb10];
+      }
+  
+      bb6: {
+          StorageDead(_13);
+          StorageDead(_12);
+          StorageLive(_14);
+          StorageLive(_15);
+          _15 = &raw mut _1;
+          _14 = opaque::<*mut impl Sized>(move _15) -> [return: bb7, unwind: bb10];
+      }
+  
+      bb7: {
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageLive(_16);
+          StorageLive(_17);
+          _17 = &raw mut _1;
+          _16 = opaque::<*mut impl Sized>(move _17) -> [return: bb8, unwind: bb10];
+      }
+  
+      bb8: {
+          StorageDead(_17);
+          StorageDead(_16);
+          _0 = const ();
+          drop(_1) -> [return: bb9, unwind: bb11];
+      }
+  
+      bb9: {
+          return;
+      }
+  
+      bb10 (cleanup): {
+          drop(_1) -> [return: bb11, unwind terminate(cleanup)];
+      }
+  
+      bb11 (cleanup): {
+          resume;
+      }
+  }
+  

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

@@ -0,0 +1,76 @@
+- // MIR for `repeated_index` before GVN
++ // MIR for `repeated_index` after GVN
+  
+  fn repeated_index(_1: T, _2: usize) -> () {
+      debug x => _1;
+      debug idx => _2;
+      let mut _0: ();
+      let _3: [T; N];
+      let mut _4: T;
+      let _5: ();
+      let mut _6: T;
+      let _7: usize;
+      let mut _8: usize;
+      let mut _9: bool;
+      let _10: ();
+      let mut _11: T;
+      let _12: usize;
+      let mut _13: usize;
+      let mut _14: bool;
+      scope 1 {
+          debug a => _3;
+      }
+  
+      bb0: {
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _3 = [move _4; N];
+-         StorageDead(_4);
++         _3 = [_1; N];
+          StorageLive(_5);
+          StorageLive(_6);
+          StorageLive(_7);
+          _7 = const 0_usize;
+          _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];
+      }
+  
+      bb1: {
+          _6 = _3[_7];
+          _5 = opaque::<T>(move _6) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_6);
+          StorageDead(_7);
+          StorageDead(_5);
+          StorageLive(_10);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = _2;
+-         _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];
++         _14 = Lt(_2, _8);
++         assert(move _14, "index out of bounds: the length is {} but the index is {}", _8, _2) -> [success: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          _11 = _3[_12];
+          _10 = opaque::<T>(move _11) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_11);
+          StorageDead(_12);
+          StorageDead(_10);
+          _0 = const ();
+          StorageDead(_3);
+          return;
+      }
+  }
+  

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

@@ -0,0 +1,76 @@
+- // MIR for `repeated_index` before GVN
++ // MIR for `repeated_index` after GVN
+  
+  fn repeated_index(_1: T, _2: usize) -> () {
+      debug x => _1;
+      debug idx => _2;
+      let mut _0: ();
+      let _3: [T; N];
+      let mut _4: T;
+      let _5: ();
+      let mut _6: T;
+      let _7: usize;
+      let mut _8: usize;
+      let mut _9: bool;
+      let _10: ();
+      let mut _11: T;
+      let _12: usize;
+      let mut _13: usize;
+      let mut _14: bool;
+      scope 1 {
+          debug a => _3;
+      }
+  
+      bb0: {
+          StorageLive(_3);
+-         StorageLive(_4);
+-         _4 = _1;
+-         _3 = [move _4; N];
+-         StorageDead(_4);
++         _3 = [_1; N];
+          StorageLive(_5);
+          StorageLive(_6);
+          StorageLive(_7);
+          _7 = const 0_usize;
+          _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];
+      }
+  
+      bb1: {
+          _6 = _3[_7];
+          _5 = opaque::<T>(move _6) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_6);
+          StorageDead(_7);
+          StorageDead(_5);
+          StorageLive(_10);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = _2;
+-         _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];
++         _14 = Lt(_2, _8);
++         assert(move _14, "index out of bounds: the length is {} but the index is {}", _8, _2) -> [success: bb3, unwind continue];
+      }
+  
+      bb3: {
+          _11 = _3[_12];
+          _10 = opaque::<T>(move _11) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_11);
+          StorageDead(_12);
+          StorageDead(_10);
+          _0 = const ();
+          StorageDead(_3);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.rs

@@ -0,0 +1,240 @@
+// unit-test: GVN
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+
+#![feature(raw_ref_op)]
+#![feature(rustc_attrs)]
+#![allow(unconditional_panic)]
+
+struct S<T>(T);
+
+fn subexpression_elimination(x: u64, y: u64, mut z: u64) {
+    opaque(x + y);
+    opaque(x * y);
+    opaque(x - y);
+    opaque(x / y);
+    opaque(x % y);
+    opaque(x & y);
+    opaque(x | y);
+    opaque(x ^ y);
+    opaque(x << y);
+    opaque(x >> y);
+    opaque(x as u32);
+    opaque(x as f32);
+    opaque(S(x));
+    opaque(S(x).0);
+
+    // Those are duplicates to substitute somehow.
+    opaque((x + y) + z);
+    opaque((x * y) + z);
+    opaque((x - y) + z);
+    opaque((x / y) + z);
+    opaque((x % y) + z);
+    opaque((x & y) + z);
+    opaque((x | y) + z);
+    opaque((x ^ y) + z);
+    opaque((x << y) + z);
+    opaque((x >> y) + z);
+    opaque(S(x)); //< This is not substituted as `S` is not `Copy`.
+    opaque(S(x).0); //<  But this can be.
+
+    // We can substitute through an immutable reference too.
+    let a = &z;
+    opaque(*a + x);
+    opaque(*a + x);
+
+    // But not through a mutable reference or a pointer.
+    let b = &mut z;
+    opaque(*b + x);
+    opaque(*b + x);
+    unsafe {
+        let c = &raw const z;
+        opaque(*c + x);
+        opaque(*c + x);
+        let d = &raw mut z;
+        opaque(*d + x);
+        opaque(*d + x);
+    }
+
+    // We can substitute again, but not with the earlier computations.
+    // Important: `e` is not `a`!
+    let e = &z;
+    opaque(*e + x);
+    opaque(*e + x);
+
+}
+
+fn wrap_unwrap<T: Copy>(x: T) -> T {
+    match Some(x) {
+        Some(y) => y,
+        None => panic!(),
+    }
+}
+
+fn repeated_index<T: Copy, const N: usize>(x: T, idx: usize) {
+    let a = [x; N];
+    opaque(a[0]);
+    opaque(a[idx]);
+}
+
+fn arithmetic(x: u64) {
+    opaque(x + 0);
+    opaque(x - 0);
+    opaque(x * 0);
+    opaque(x * 1);
+    opaque(x / 0);
+    opaque(x / 1);
+    opaque(0 / x);
+    opaque(1 / x);
+    opaque(x % 0);
+    opaque(x % 1);
+    opaque(0 % x);
+    opaque(1 % x);
+    opaque(x & 0);
+    opaque(x | 0);
+    opaque(x ^ 0);
+    opaque(x >> 0);
+    opaque(x << 0);
+}
+
+#[rustc_inherit_overflow_checks]
+fn arithmetic_checked(x: u64) {
+    opaque(x + 0);
+    opaque(x - 0);
+    opaque(x * 0);
+    opaque(x * 1);
+    opaque(x / 0);
+    opaque(x / 1);
+    opaque(0 / x);
+    opaque(1 / x);
+    opaque(x % 0);
+    opaque(x % 1);
+    opaque(0 % x);
+    opaque(1 % x);
+    opaque(x & 0);
+    opaque(x | 0);
+    opaque(x ^ 0);
+    opaque(x >> 0);
+    opaque(x << 0);
+}
+
+fn arithmetic_float(x: f64) {
+    opaque(x + 0.);
+    opaque(x - 0.);
+    opaque(x * 0.);
+    opaque(x / 0.);
+    opaque(0. / x);
+    opaque(x % 0.);
+    opaque(0. % x);
+    // Those are not simplifiable to `true`/`false`, thanks to NaNs.
+    opaque(x == x);
+    opaque(x != x);
+}
+
+fn cast() {
+    let i = 1_i64;
+    let u = 1_u64;
+    let f = 1_f64;
+    opaque(i as u8);
+    opaque(i as u16);
+    opaque(i as u32);
+    opaque(i as u64);
+    opaque(i as i8);
+    opaque(i as i16);
+    opaque(i as i32);
+    opaque(i as i64);
+    opaque(i as f32);
+    opaque(i as f64);
+    opaque(u as u8);
+    opaque(u as u16);
+    opaque(u as u32);
+    opaque(u as u64);
+    opaque(u as i8);
+    opaque(u as i16);
+    opaque(u as i32);
+    opaque(u as i64);
+    opaque(u as f32);
+    opaque(u as f64);
+    opaque(f as u8);
+    opaque(f as u16);
+    opaque(f as u32);
+    opaque(f as u64);
+    opaque(f as i8);
+    opaque(f as i16);
+    opaque(f as i32);
+    opaque(f as i64);
+    opaque(f as f32);
+    opaque(f as f64);
+}
+
+fn multiple_branches(t: bool, x: u8, y: u8) {
+    if t {
+        opaque(x + y); // a
+        opaque(x + y); // should reuse a
+    } else {
+        opaque(x + y); // b
+        opaque(x + y); // shoud reuse b
+    }
+    opaque(x + y); // c
+    if t {
+        opaque(x + y); // should reuse c
+    } else {
+        opaque(x + y); // should reuse c
+    }
+}
+
+fn references(mut x: impl Sized) {
+    opaque(&x);
+    opaque(&x); // should not reuse a
+    opaque(&mut x);
+    opaque(&mut x); // should not reuse a
+    opaque(&raw const x);
+    opaque(&raw const x); // should not reuse a
+    opaque(&raw mut x);
+    opaque(&raw mut x); // should not reuse a
+}
+
+fn dereferences(t: &mut u32, u: &impl Copy, s: &S<u32>) {
+    opaque(*t);
+    opaque(*t); // this cannot reuse a, as x is &mut.
+    let z = &raw const *t;
+    unsafe { opaque(*z) };
+    unsafe { opaque(*z) }; // this cannot reuse a, as x is *const.
+    let z = &raw mut *t;
+    unsafe { opaque(*z) };
+    unsafe { opaque(*z) }; // this cannot reuse a, as x is *mut.
+    let z = &*t;
+    opaque(*z);
+    opaque(*z); // this can reuse, as `z` is immutable ref, Freeze and Copy.
+    opaque(&*z); // but not for a reborrow.
+    opaque(*u);
+    opaque(*u); // this cannot reuse, as `z` is not Freeze.
+    opaque(s.0);
+    opaque(s.0); // *s is not Copy, by (*s).0 is, so we can reuse.
+}
+
+fn main() {
+    subexpression_elimination(2, 4, 5);
+    wrap_unwrap(5);
+    repeated_index::<u32, 7>(5, 3);
+    arithmetic(5);
+    arithmetic_checked(5);
+    arithmetic_float(5.);
+    cast();
+    multiple_branches(true, 5, 9);
+    references(5);
+    dereferences(&mut 5, &6, &S(7));
+}
+
+#[inline(never)]
+fn opaque(_: impl Sized) {}
+
+// EMIT_MIR gvn.subexpression_elimination.GVN.diff
+// EMIT_MIR gvn.wrap_unwrap.GVN.diff
+// EMIT_MIR gvn.repeated_index.GVN.diff
+// EMIT_MIR gvn.arithmetic.GVN.diff
+// EMIT_MIR gvn.arithmetic_checked.GVN.diff
+// EMIT_MIR gvn.arithmetic_float.GVN.diff
+// EMIT_MIR gvn.cast.GVN.diff
+// EMIT_MIR gvn.multiple_branches.GVN.diff
+// EMIT_MIR gvn.references.GVN.diff
+// EMIT_MIR gvn.dereferences.GVN.diff

tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff

@@ -0,0 +1,882 @@
+- // MIR for `subexpression_elimination` before GVN
++ // MIR for `subexpression_elimination` after GVN
+  
+  fn subexpression_elimination(_1: u64, _2: u64, _3: u64) -> () {
+      debug x => _1;
+      debug y => _2;
+      debug z => _3;
+      let mut _0: ();
+      let _4: ();
+      let mut _5: u64;
+      let mut _6: u64;
+      let mut _7: u64;
+      let _8: ();
+      let mut _9: u64;
+      let mut _10: u64;
+      let mut _11: u64;
+      let _12: ();
+      let mut _13: u64;
+      let mut _14: u64;
+      let mut _15: u64;
+      let _16: ();
+      let mut _17: u64;
+      let mut _18: u64;
+      let mut _19: u64;
+      let mut _20: bool;
+      let _21: ();
+      let mut _22: u64;
+      let mut _23: u64;
+      let mut _24: u64;
+      let mut _25: bool;
+      let _26: ();
+      let mut _27: u64;
+      let mut _28: u64;
+      let mut _29: u64;
+      let _30: ();
+      let mut _31: u64;
+      let mut _32: u64;
+      let mut _33: u64;
+      let _34: ();
+      let mut _35: u64;
+      let mut _36: u64;
+      let mut _37: u64;
+      let _38: ();
+      let mut _39: u64;
+      let mut _40: u64;
+      let mut _41: u64;
+      let _42: ();
+      let mut _43: u64;
+      let mut _44: u64;
+      let mut _45: u64;
+      let _46: ();
+      let mut _47: u32;
+      let mut _48: u64;
+      let _49: ();
+      let mut _50: f32;
+      let mut _51: u64;
+      let _52: ();
+      let mut _53: S<u64>;
+      let mut _54: u64;
+      let _55: ();
+      let mut _56: u64;
+      let mut _57: S<u64>;
+      let mut _58: u64;
+      let _59: ();
+      let mut _60: u64;
+      let mut _61: u64;
+      let mut _62: u64;
+      let mut _63: u64;
+      let mut _64: u64;
+      let _65: ();
+      let mut _66: u64;
+      let mut _67: u64;
+      let mut _68: u64;
+      let mut _69: u64;
+      let mut _70: u64;
+      let _71: ();
+      let mut _72: u64;
+      let mut _73: u64;
+      let mut _74: u64;
+      let mut _75: u64;
+      let mut _76: u64;
+      let _77: ();
+      let mut _78: u64;
+      let mut _79: u64;
+      let mut _80: u64;
+      let mut _81: u64;
+      let mut _82: bool;
+      let mut _83: u64;
+      let _84: ();
+      let mut _85: u64;
+      let mut _86: u64;
+      let mut _87: u64;
+      let mut _88: u64;
+      let mut _89: bool;
+      let mut _90: u64;
+      let _91: ();
+      let mut _92: u64;
+      let mut _93: u64;
+      let mut _94: u64;
+      let mut _95: u64;
+      let mut _96: u64;
+      let _97: ();
+      let mut _98: u64;
+      let mut _99: u64;
+      let mut _100: u64;
+      let mut _101: u64;
+      let mut _102: u64;
+      let _103: ();
+      let mut _104: u64;
+      let mut _105: u64;
+      let mut _106: u64;
+      let mut _107: u64;
+      let mut _108: u64;
+      let _109: ();
+      let mut _110: u64;
+      let mut _111: u64;
+      let mut _112: u64;
+      let mut _113: u64;
+      let mut _114: u64;
+      let _115: ();
+      let mut _116: u64;
+      let mut _117: u64;
+      let mut _118: u64;
+      let mut _119: u64;
+      let mut _120: u64;
+      let _121: ();
+      let mut _122: S<u64>;
+      let mut _123: u64;
+      let _124: ();
+      let mut _125: u64;
+      let mut _126: S<u64>;
+      let mut _127: u64;
+      let _128: &u64;
+      let _129: ();
+      let mut _130: u64;
+      let mut _131: u64;
+      let mut _132: u64;
+      let _133: ();
+      let mut _134: u64;
+      let mut _135: u64;
+      let mut _136: u64;
+      let _138: ();
+      let mut _139: u64;
+      let mut _140: u64;
+      let mut _141: u64;
+      let _142: ();
+      let mut _143: u64;
+      let mut _144: u64;
+      let mut _145: u64;
+      let _146: ();
+      let _148: ();
+      let mut _149: u64;
+      let mut _150: u64;
+      let mut _151: u64;
+      let _152: ();
+      let mut _153: u64;
+      let mut _154: u64;
+      let mut _155: u64;
+      let _157: ();
+      let mut _158: u64;
+      let mut _159: u64;
+      let mut _160: u64;
+      let _161: ();
+      let mut _162: u64;
+      let mut _163: u64;
+      let mut _164: u64;
+      let _166: ();
+      let mut _167: u64;
+      let mut _168: u64;
+      let mut _169: u64;
+      let _170: ();
+      let mut _171: u64;
+      let mut _172: u64;
+      let mut _173: u64;
+      scope 1 {
+          debug a => _128;
+          let _137: &mut u64;
+          scope 2 {
+              debug b => _137;
+              let _165: &u64;
+              scope 3 {
+                  let _147: *const u64;
+                  scope 4 {
+                      debug c => _147;
+                      let _156: *mut u64;
+                      scope 5 {
+                          debug d => _156;
+                      }
+                  }
+              }
+              scope 6 {
+                  debug e => _165;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_4);
+-         StorageLive(_5);
+-         StorageLive(_6);
+-         _6 = _1;
+-         StorageLive(_7);
+-         _7 = _2;
+-         _5 = Add(move _6, move _7);
+-         StorageDead(_7);
+-         StorageDead(_6);
+-         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind unreachable];
++         _5 = Add(_1, _2);
++         _4 = opaque::<u64>(_5) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+-         StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_8);
+-         StorageLive(_9);
+-         StorageLive(_10);
+-         _10 = _1;
+-         StorageLive(_11);
+-         _11 = _2;
+-         _9 = Mul(move _10, move _11);
+-         StorageDead(_11);
+-         StorageDead(_10);
+-         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind unreachable];
++         _9 = Mul(_1, _2);
++         _8 = opaque::<u64>(_9) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+-         StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_12);
+-         StorageLive(_13);
+-         StorageLive(_14);
+-         _14 = _1;
+-         StorageLive(_15);
+-         _15 = _2;
+-         _13 = Sub(move _14, move _15);
+-         StorageDead(_15);
+-         StorageDead(_14);
+-         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind unreachable];
++         _13 = Sub(_1, _2);
++         _12 = opaque::<u64>(_13) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+-         StorageDead(_13);
+          StorageDead(_12);
+          StorageLive(_16);
+-         StorageLive(_17);
+-         StorageLive(_18);
+-         _18 = _1;
+-         StorageLive(_19);
+-         _19 = _2;
+-         _20 = Eq(_19, const 0_u64);
+-         assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb4, unwind unreachable];
++         _20 = Eq(_2, const 0_u64);
++         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+-         _17 = Div(move _18, move _19);
+-         StorageDead(_19);
+-         StorageDead(_18);
+-         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind unreachable];
++         _17 = Div(_1, _2);
++         _16 = opaque::<u64>(_17) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+-         StorageDead(_17);
+          StorageDead(_16);
+          StorageLive(_21);
+-         StorageLive(_22);
+-         StorageLive(_23);
+-         _23 = _1;
+-         StorageLive(_24);
+-         _24 = _2;
+-         _25 = Eq(_24, const 0_u64);
+-         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", _23) -> [success: bb6, unwind unreachable];
++         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+-         _22 = Rem(move _23, move _24);
+-         StorageDead(_24);
+-         StorageDead(_23);
+-         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind unreachable];
++         _22 = Rem(_1, _2);
++         _21 = opaque::<u64>(_22) -> [return: bb7, unwind unreachable];
+      }
+  
+      bb7: {
+-         StorageDead(_22);
+          StorageDead(_21);
+          StorageLive(_26);
+-         StorageLive(_27);
+-         StorageLive(_28);
+-         _28 = _1;
+-         StorageLive(_29);
+-         _29 = _2;
+-         _27 = BitAnd(move _28, move _29);
+-         StorageDead(_29);
+-         StorageDead(_28);
+-         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind unreachable];
++         _27 = BitAnd(_1, _2);
++         _26 = opaque::<u64>(_27) -> [return: bb8, unwind unreachable];
+      }
+  
+      bb8: {
+-         StorageDead(_27);
+          StorageDead(_26);
+          StorageLive(_30);
+-         StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = _1;
+-         StorageLive(_33);
+-         _33 = _2;
+-         _31 = BitOr(move _32, move _33);
+-         StorageDead(_33);
+-         StorageDead(_32);
+-         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind unreachable];
++         _31 = BitOr(_1, _2);
++         _30 = opaque::<u64>(_31) -> [return: bb9, unwind unreachable];
+      }
+  
+      bb9: {
+-         StorageDead(_31);
+          StorageDead(_30);
+          StorageLive(_34);
+-         StorageLive(_35);
+-         StorageLive(_36);
+-         _36 = _1;
+-         StorageLive(_37);
+-         _37 = _2;
+-         _35 = BitXor(move _36, move _37);
+-         StorageDead(_37);
+-         StorageDead(_36);
+-         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind unreachable];
++         _35 = BitXor(_1, _2);
++         _34 = opaque::<u64>(_35) -> [return: bb10, unwind unreachable];
+      }
+  
+      bb10: {
+-         StorageDead(_35);
+          StorageDead(_34);
+          StorageLive(_38);
+-         StorageLive(_39);
+-         StorageLive(_40);
+-         _40 = _1;
+-         StorageLive(_41);
+-         _41 = _2;
+-         _39 = Shl(move _40, move _41);
+-         StorageDead(_41);
+-         StorageDead(_40);
+-         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind unreachable];
++         _39 = Shl(_1, _2);
++         _38 = opaque::<u64>(_39) -> [return: bb11, unwind unreachable];
+      }
+  
+      bb11: {
+-         StorageDead(_39);
+          StorageDead(_38);
+          StorageLive(_42);
+-         StorageLive(_43);
+-         StorageLive(_44);
+-         _44 = _1;
+-         StorageLive(_45);
+-         _45 = _2;
+-         _43 = Shr(move _44, move _45);
+-         StorageDead(_45);
+-         StorageDead(_44);
+-         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind unreachable];
++         _43 = Shr(_1, _2);
++         _42 = opaque::<u64>(_43) -> [return: bb12, unwind unreachable];
+      }
+  
+      bb12: {
+-         StorageDead(_43);
+          StorageDead(_42);
+          StorageLive(_46);
+          StorageLive(_47);
+-         StorageLive(_48);
+-         _48 = _1;
+-         _47 = move _48 as u32 (IntToInt);
+-         StorageDead(_48);
++         _47 = _1 as u32 (IntToInt);
+          _46 = opaque::<u32>(move _47) -> [return: bb13, unwind unreachable];
+      }
+  
+      bb13: {
+          StorageDead(_47);
+          StorageDead(_46);
+          StorageLive(_49);
+          StorageLive(_50);
+-         StorageLive(_51);
+-         _51 = _1;
+-         _50 = move _51 as f32 (IntToFloat);
+-         StorageDead(_51);
++         _50 = _1 as f32 (IntToFloat);
+          _49 = opaque::<f32>(move _50) -> [return: bb14, unwind unreachable];
+      }
+  
+      bb14: {
+          StorageDead(_50);
+          StorageDead(_49);
+          StorageLive(_52);
+          StorageLive(_53);
+-         StorageLive(_54);
+-         _54 = _1;
+-         _53 = S::<u64>(move _54);
+-         StorageDead(_54);
++         _53 = S::<u64>(_1);
+          _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind unreachable];
+      }
+  
+      bb15: {
+          StorageDead(_53);
+          StorageDead(_52);
+          StorageLive(_55);
+-         StorageLive(_56);
+          StorageLive(_57);
+-         StorageLive(_58);
+-         _58 = _1;
+-         _57 = S::<u64>(move _58);
+-         StorageDead(_58);
++         _57 = S::<u64>(_1);
+          _56 = (_57.0: u64);
+-         _55 = opaque::<u64>(move _56) -> [return: bb16, unwind unreachable];
++         _55 = opaque::<u64>(_56) -> [return: bb16, unwind unreachable];
+      }
+  
+      bb16: {
+-         StorageDead(_56);
+          StorageDead(_57);
+          StorageDead(_55);
+          StorageLive(_59);
+          StorageLive(_60);
+-         StorageLive(_61);
+-         StorageLive(_62);
+-         _62 = _1;
+-         StorageLive(_63);
+-         _63 = _2;
+-         _61 = Add(move _62, move _63);
+-         StorageDead(_63);
+-         StorageDead(_62);
+          StorageLive(_64);
+          _64 = _3;
+-         _60 = Add(move _61, move _64);
++         _60 = Add(_5, move _64);
+          StorageDead(_64);
+-         StorageDead(_61);
+          _59 = opaque::<u64>(move _60) -> [return: bb17, unwind unreachable];
+      }
+  
+      bb17: {
+          StorageDead(_60);
+          StorageDead(_59);
+          StorageLive(_65);
+          StorageLive(_66);
+-         StorageLive(_67);
+-         StorageLive(_68);
+-         _68 = _1;
+-         StorageLive(_69);
+-         _69 = _2;
+-         _67 = Mul(move _68, move _69);
+-         StorageDead(_69);
+-         StorageDead(_68);
+          StorageLive(_70);
+          _70 = _3;
+-         _66 = Add(move _67, move _70);
++         _66 = Add(_9, move _70);
+          StorageDead(_70);
+-         StorageDead(_67);
+          _65 = opaque::<u64>(move _66) -> [return: bb18, unwind unreachable];
+      }
+  
+      bb18: {
+          StorageDead(_66);
+          StorageDead(_65);
+          StorageLive(_71);
+          StorageLive(_72);
+-         StorageLive(_73);
+-         StorageLive(_74);
+-         _74 = _1;
+-         StorageLive(_75);
+-         _75 = _2;
+-         _73 = Sub(move _74, move _75);
+-         StorageDead(_75);
+-         StorageDead(_74);
+          StorageLive(_76);
+          _76 = _3;
+-         _72 = Add(move _73, move _76);
++         _72 = Add(_13, move _76);
+          StorageDead(_76);
+-         StorageDead(_73);
+          _71 = opaque::<u64>(move _72) -> [return: bb19, unwind unreachable];
+      }
+  
+      bb19: {
+          StorageDead(_72);
+          StorageDead(_71);
+          StorageLive(_77);
+          StorageLive(_78);
+-         StorageLive(_79);
+-         StorageLive(_80);
+-         _80 = _1;
+-         StorageLive(_81);
+-         _81 = _2;
+-         _82 = Eq(_81, const 0_u64);
+-         assert(!move _82, "attempt to divide `{}` by zero", _80) -> [success: bb20, unwind unreachable];
++         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind unreachable];
+      }
+  
+      bb20: {
+-         _79 = Div(move _80, move _81);
+-         StorageDead(_81);
+-         StorageDead(_80);
+          StorageLive(_83);
+          _83 = _3;
+-         _78 = Add(move _79, move _83);
++         _78 = Add(_17, move _83);
+          StorageDead(_83);
+-         StorageDead(_79);
+          _77 = opaque::<u64>(move _78) -> [return: bb21, unwind unreachable];
+      }
+  
+      bb21: {
+          StorageDead(_78);
+          StorageDead(_77);
+          StorageLive(_84);
+          StorageLive(_85);
+-         StorageLive(_86);
+-         StorageLive(_87);
+-         _87 = _1;
+-         StorageLive(_88);
+-         _88 = _2;
+-         _89 = Eq(_88, const 0_u64);
+-         assert(!move _89, "attempt to calculate the remainder of `{}` with a divisor of zero", _87) -> [success: bb22, unwind unreachable];
++         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind unreachable];
+      }
+  
+      bb22: {
+-         _86 = Rem(move _87, move _88);
+-         StorageDead(_88);
+-         StorageDead(_87);
+          StorageLive(_90);
+          _90 = _3;
+-         _85 = Add(move _86, move _90);
++         _85 = Add(_22, move _90);
+          StorageDead(_90);
+-         StorageDead(_86);
+          _84 = opaque::<u64>(move _85) -> [return: bb23, unwind unreachable];
+      }
+  
+      bb23: {
+          StorageDead(_85);
+          StorageDead(_84);
+          StorageLive(_91);
+          StorageLive(_92);
+-         StorageLive(_93);
+-         StorageLive(_94);
+-         _94 = _1;
+-         StorageLive(_95);
+-         _95 = _2;
+-         _93 = BitAnd(move _94, move _95);
+-         StorageDead(_95);
+-         StorageDead(_94);
+          StorageLive(_96);
+          _96 = _3;
+-         _92 = Add(move _93, move _96);
++         _92 = Add(_27, move _96);
+          StorageDead(_96);
+-         StorageDead(_93);
+          _91 = opaque::<u64>(move _92) -> [return: bb24, unwind unreachable];
+      }
+  
+      bb24: {
+          StorageDead(_92);
+          StorageDead(_91);
+          StorageLive(_97);
+          StorageLive(_98);
+-         StorageLive(_99);
+-         StorageLive(_100);
+-         _100 = _1;
+-         StorageLive(_101);
+-         _101 = _2;
+-         _99 = BitOr(move _100, move _101);
+-         StorageDead(_101);
+-         StorageDead(_100);
+          StorageLive(_102);
+          _102 = _3;
+-         _98 = Add(move _99, move _102);
++         _98 = Add(_31, move _102);
+          StorageDead(_102);
+-         StorageDead(_99);
+          _97 = opaque::<u64>(move _98) -> [return: bb25, unwind unreachable];
+      }
+  
+      bb25: {
+          StorageDead(_98);
+          StorageDead(_97);
+          StorageLive(_103);
+          StorageLive(_104);
+-         StorageLive(_105);
+-         StorageLive(_106);
+-         _106 = _1;
+-         StorageLive(_107);
+-         _107 = _2;
+-         _105 = BitXor(move _106, move _107);
+-         StorageDead(_107);
+-         StorageDead(_106);
+          StorageLive(_108);
+          _108 = _3;
+-         _104 = Add(move _105, move _108);
++         _104 = Add(_35, move _108);
+          StorageDead(_108);
+-         StorageDead(_105);
+          _103 = opaque::<u64>(move _104) -> [return: bb26, unwind unreachable];
+      }
+  
+      bb26: {
+          StorageDead(_104);
+          StorageDead(_103);
+          StorageLive(_109);
+          StorageLive(_110);
+-         StorageLive(_111);
+-         StorageLive(_112);
+-         _112 = _1;
+-         StorageLive(_113);
+-         _113 = _2;
+-         _111 = Shl(move _112, move _113);
+-         StorageDead(_113);
+-         StorageDead(_112);
+          StorageLive(_114);
+          _114 = _3;
+-         _110 = Add(move _111, move _114);
++         _110 = Add(_39, move _114);
+          StorageDead(_114);
+-         StorageDead(_111);
+          _109 = opaque::<u64>(move _110) -> [return: bb27, unwind unreachable];
+      }
+  
+      bb27: {
+          StorageDead(_110);
+          StorageDead(_109);
+          StorageLive(_115);
+          StorageLive(_116);
+-         StorageLive(_117);
+-         StorageLive(_118);
+-         _118 = _1;
+-         StorageLive(_119);
+-         _119 = _2;
+-         _117 = Shr(move _118, move _119);
+-         StorageDead(_119);
+-         StorageDead(_118);
+          StorageLive(_120);
+          _120 = _3;
+-         _116 = Add(move _117, move _120);
++         _116 = Add(_43, move _120);
+          StorageDead(_120);
+-         StorageDead(_117);
+          _115 = opaque::<u64>(move _116) -> [return: bb28, unwind unreachable];
+      }
+  
+      bb28: {
+          StorageDead(_116);
+          StorageDead(_115);
+          StorageLive(_121);
+          StorageLive(_122);
+-         StorageLive(_123);
+-         _123 = _1;
+-         _122 = S::<u64>(move _123);
+-         StorageDead(_123);
++         _122 = S::<u64>(_1);
+          _121 = opaque::<S<u64>>(move _122) -> [return: bb29, unwind unreachable];
+      }
+  
+      bb29: {
+          StorageDead(_122);
+          StorageDead(_121);
+          StorageLive(_124);
+-         StorageLive(_125);
+-         StorageLive(_126);
+-         StorageLive(_127);
+-         _127 = _1;
+-         _126 = S::<u64>(move _127);
+-         StorageDead(_127);
+-         _125 = (_126.0: u64);
+-         _124 = opaque::<u64>(move _125) -> [return: bb30, unwind unreachable];
++         _124 = opaque::<u64>(_56) -> [return: bb30, unwind unreachable];
+      }
+  
+      bb30: {
+-         StorageDead(_125);
+-         StorageDead(_126);
+          StorageDead(_124);
+          StorageLive(_128);
+          _128 = &_3;
+          StorageLive(_129);
+-         StorageLive(_130);
+-         StorageLive(_131);
+          _131 = (*_128);
+-         StorageLive(_132);
+-         _132 = _1;
+-         _130 = Add(move _131, move _132);
+-         StorageDead(_132);
+-         StorageDead(_131);
+-         _129 = opaque::<u64>(move _130) -> [return: bb31, unwind unreachable];
++         _130 = Add(_131, _1);
++         _129 = opaque::<u64>(_130) -> [return: bb31, unwind unreachable];
+      }
+  
+      bb31: {
+-         StorageDead(_130);
+          StorageDead(_129);
+          StorageLive(_133);
+-         StorageLive(_134);
+-         StorageLive(_135);
+-         _135 = (*_128);
+-         StorageLive(_136);
+-         _136 = _1;
+-         _134 = Add(move _135, move _136);
+-         StorageDead(_136);
+-         StorageDead(_135);
+-         _133 = opaque::<u64>(move _134) -> [return: bb32, unwind unreachable];
++         _133 = opaque::<u64>(_130) -> [return: bb32, unwind unreachable];
+      }
+  
+      bb32: {
+-         StorageDead(_134);
+          StorageDead(_133);
+          StorageLive(_137);
+          _137 = &mut _3;
+          StorageLive(_138);
+          StorageLive(_139);
+          StorageLive(_140);
+          _140 = (*_137);
+-         StorageLive(_141);
+-         _141 = _1;
+-         _139 = Add(move _140, move _141);
+-         StorageDead(_141);
++         _139 = Add(move _140, _1);
+          StorageDead(_140);
+          _138 = opaque::<u64>(move _139) -> [return: bb33, unwind unreachable];
+      }
+  
+      bb33: {
+          StorageDead(_139);
+          StorageDead(_138);
+          StorageLive(_142);
+          StorageLive(_143);
+          StorageLive(_144);
+          _144 = (*_137);
+-         StorageLive(_145);
+-         _145 = _1;
+-         _143 = Add(move _144, move _145);
+-         StorageDead(_145);
++         _143 = Add(move _144, _1);
+          StorageDead(_144);
+          _142 = opaque::<u64>(move _143) -> [return: bb34, unwind unreachable];
+      }
+  
+      bb34: {
+          StorageDead(_143);
+          StorageDead(_142);
+-         StorageLive(_146);
+          StorageLive(_147);
+          _147 = &raw const _3;
+          StorageLive(_148);
+          StorageLive(_149);
+          StorageLive(_150);
+          _150 = (*_147);
+-         StorageLive(_151);
+-         _151 = _1;
+-         _149 = Add(move _150, move _151);
+-         StorageDead(_151);
++         _149 = Add(move _150, _1);
+          StorageDead(_150);
+          _148 = opaque::<u64>(move _149) -> [return: bb35, unwind unreachable];
+      }
+  
+      bb35: {
+          StorageDead(_149);
+          StorageDead(_148);
+          StorageLive(_152);
+          StorageLive(_153);
+          StorageLive(_154);
+          _154 = (*_147);
+-         StorageLive(_155);
+-         _155 = _1;
+-         _153 = Add(move _154, move _155);
+-         StorageDead(_155);
++         _153 = Add(move _154, _1);
+          StorageDead(_154);
+          _152 = opaque::<u64>(move _153) -> [return: bb36, unwind unreachable];
+      }
+  
+      bb36: {
+          StorageDead(_153);
+          StorageDead(_152);
+          StorageLive(_156);
+          _156 = &raw mut _3;
+          StorageLive(_157);
+          StorageLive(_158);
+          StorageLive(_159);
+          _159 = (*_156);
+-         StorageLive(_160);
+-         _160 = _1;
+-         _158 = Add(move _159, move _160);
+-         StorageDead(_160);
++         _158 = Add(move _159, _1);
+          StorageDead(_159);
+          _157 = opaque::<u64>(move _158) -> [return: bb37, unwind unreachable];
+      }
+  
+      bb37: {
+          StorageDead(_158);
+          StorageDead(_157);
+          StorageLive(_161);
+          StorageLive(_162);
+          StorageLive(_163);
+          _163 = (*_156);
+-         StorageLive(_164);
+-         _164 = _1;
+-         _162 = Add(move _163, move _164);
+-         StorageDead(_164);
++         _162 = Add(move _163, _1);
+          StorageDead(_163);
+          _161 = opaque::<u64>(move _162) -> [return: bb38, unwind unreachable];
+      }
+  
+      bb38: {
+          StorageDead(_162);
+          StorageDead(_161);
+-         _146 = const ();
+          StorageDead(_156);
+          StorageDead(_147);
+-         StorageDead(_146);
+          StorageLive(_165);
+          _165 = &_3;
+          StorageLive(_166);
+-         StorageLive(_167);
+-         StorageLive(_168);
+          _168 = (*_165);
+-         StorageLive(_169);
+-         _169 = _1;
+-         _167 = Add(move _168, move _169);
+-         StorageDead(_169);
+-         StorageDead(_168);
+-         _166 = opaque::<u64>(move _167) -> [return: bb39, unwind unreachable];
++         _167 = Add(_168, _1);
++         _166 = opaque::<u64>(_167) -> [return: bb39, unwind unreachable];
+      }
+  
+      bb39: {
+-         StorageDead(_167);
+          StorageDead(_166);
+          StorageLive(_170);
+-         StorageLive(_171);
+-         StorageLive(_172);
+-         _172 = (*_165);
+-         StorageLive(_173);
+-         _173 = _1;
+-         _171 = Add(move _172, move _173);
+-         StorageDead(_173);
+-         StorageDead(_172);
+-         _170 = opaque::<u64>(move _171) -> [return: bb40, unwind unreachable];
++         _170 = opaque::<u64>(_167) -> [return: bb40, unwind unreachable];
+      }
+  
+      bb40: {
+-         StorageDead(_171);
+          StorageDead(_170);
+          _0 = const ();
+          StorageDead(_165);
+          StorageDead(_137);
+          StorageDead(_128);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff

@@ -0,0 +1,882 @@
+- // MIR for `subexpression_elimination` before GVN
++ // MIR for `subexpression_elimination` after GVN
+  
+  fn subexpression_elimination(_1: u64, _2: u64, _3: u64) -> () {
+      debug x => _1;
+      debug y => _2;
+      debug z => _3;
+      let mut _0: ();
+      let _4: ();
+      let mut _5: u64;
+      let mut _6: u64;
+      let mut _7: u64;
+      let _8: ();
+      let mut _9: u64;
+      let mut _10: u64;
+      let mut _11: u64;
+      let _12: ();
+      let mut _13: u64;
+      let mut _14: u64;
+      let mut _15: u64;
+      let _16: ();
+      let mut _17: u64;
+      let mut _18: u64;
+      let mut _19: u64;
+      let mut _20: bool;
+      let _21: ();
+      let mut _22: u64;
+      let mut _23: u64;
+      let mut _24: u64;
+      let mut _25: bool;
+      let _26: ();
+      let mut _27: u64;
+      let mut _28: u64;
+      let mut _29: u64;
+      let _30: ();
+      let mut _31: u64;
+      let mut _32: u64;
+      let mut _33: u64;
+      let _34: ();
+      let mut _35: u64;
+      let mut _36: u64;
+      let mut _37: u64;
+      let _38: ();
+      let mut _39: u64;
+      let mut _40: u64;
+      let mut _41: u64;
+      let _42: ();
+      let mut _43: u64;
+      let mut _44: u64;
+      let mut _45: u64;
+      let _46: ();
+      let mut _47: u32;
+      let mut _48: u64;
+      let _49: ();
+      let mut _50: f32;
+      let mut _51: u64;
+      let _52: ();
+      let mut _53: S<u64>;
+      let mut _54: u64;
+      let _55: ();
+      let mut _56: u64;
+      let mut _57: S<u64>;
+      let mut _58: u64;
+      let _59: ();
+      let mut _60: u64;
+      let mut _61: u64;
+      let mut _62: u64;
+      let mut _63: u64;
+      let mut _64: u64;
+      let _65: ();
+      let mut _66: u64;
+      let mut _67: u64;
+      let mut _68: u64;
+      let mut _69: u64;
+      let mut _70: u64;
+      let _71: ();
+      let mut _72: u64;
+      let mut _73: u64;
+      let mut _74: u64;
+      let mut _75: u64;
+      let mut _76: u64;
+      let _77: ();
+      let mut _78: u64;
+      let mut _79: u64;
+      let mut _80: u64;
+      let mut _81: u64;
+      let mut _82: bool;
+      let mut _83: u64;
+      let _84: ();
+      let mut _85: u64;
+      let mut _86: u64;
+      let mut _87: u64;
+      let mut _88: u64;
+      let mut _89: bool;
+      let mut _90: u64;
+      let _91: ();
+      let mut _92: u64;
+      let mut _93: u64;
+      let mut _94: u64;
+      let mut _95: u64;
+      let mut _96: u64;
+      let _97: ();
+      let mut _98: u64;
+      let mut _99: u64;
+      let mut _100: u64;
+      let mut _101: u64;
+      let mut _102: u64;
+      let _103: ();
+      let mut _104: u64;
+      let mut _105: u64;
+      let mut _106: u64;
+      let mut _107: u64;
+      let mut _108: u64;
+      let _109: ();
+      let mut _110: u64;
+      let mut _111: u64;
+      let mut _112: u64;
+      let mut _113: u64;
+      let mut _114: u64;
+      let _115: ();
+      let mut _116: u64;
+      let mut _117: u64;
+      let mut _118: u64;
+      let mut _119: u64;
+      let mut _120: u64;
+      let _121: ();
+      let mut _122: S<u64>;
+      let mut _123: u64;
+      let _124: ();
+      let mut _125: u64;
+      let mut _126: S<u64>;
+      let mut _127: u64;
+      let _128: &u64;
+      let _129: ();
+      let mut _130: u64;
+      let mut _131: u64;
+      let mut _132: u64;
+      let _133: ();
+      let mut _134: u64;
+      let mut _135: u64;
+      let mut _136: u64;
+      let _138: ();
+      let mut _139: u64;
+      let mut _140: u64;
+      let mut _141: u64;
+      let _142: ();
+      let mut _143: u64;
+      let mut _144: u64;
+      let mut _145: u64;
+      let _146: ();
+      let _148: ();
+      let mut _149: u64;
+      let mut _150: u64;
+      let mut _151: u64;
+      let _152: ();
+      let mut _153: u64;
+      let mut _154: u64;
+      let mut _155: u64;
+      let _157: ();
+      let mut _158: u64;
+      let mut _159: u64;
+      let mut _160: u64;
+      let _161: ();
+      let mut _162: u64;
+      let mut _163: u64;
+      let mut _164: u64;
+      let _166: ();
+      let mut _167: u64;
+      let mut _168: u64;
+      let mut _169: u64;
+      let _170: ();
+      let mut _171: u64;
+      let mut _172: u64;
+      let mut _173: u64;
+      scope 1 {
+          debug a => _128;
+          let _137: &mut u64;
+          scope 2 {
+              debug b => _137;
+              let _165: &u64;
+              scope 3 {
+                  let _147: *const u64;
+                  scope 4 {
+                      debug c => _147;
+                      let _156: *mut u64;
+                      scope 5 {
+                          debug d => _156;
+                      }
+                  }
+              }
+              scope 6 {
+                  debug e => _165;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_4);
+-         StorageLive(_5);
+-         StorageLive(_6);
+-         _6 = _1;
+-         StorageLive(_7);
+-         _7 = _2;
+-         _5 = Add(move _6, move _7);
+-         StorageDead(_7);
+-         StorageDead(_6);
+-         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind continue];
++         _5 = Add(_1, _2);
++         _4 = opaque::<u64>(_5) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+-         StorageDead(_5);
+          StorageDead(_4);
+          StorageLive(_8);
+-         StorageLive(_9);
+-         StorageLive(_10);
+-         _10 = _1;
+-         StorageLive(_11);
+-         _11 = _2;
+-         _9 = Mul(move _10, move _11);
+-         StorageDead(_11);
+-         StorageDead(_10);
+-         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind continue];
++         _9 = Mul(_1, _2);
++         _8 = opaque::<u64>(_9) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+-         StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_12);
+-         StorageLive(_13);
+-         StorageLive(_14);
+-         _14 = _1;
+-         StorageLive(_15);
+-         _15 = _2;
+-         _13 = Sub(move _14, move _15);
+-         StorageDead(_15);
+-         StorageDead(_14);
+-         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind continue];
++         _13 = Sub(_1, _2);
++         _12 = opaque::<u64>(_13) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+-         StorageDead(_13);
+          StorageDead(_12);
+          StorageLive(_16);
+-         StorageLive(_17);
+-         StorageLive(_18);
+-         _18 = _1;
+-         StorageLive(_19);
+-         _19 = _2;
+-         _20 = Eq(_19, const 0_u64);
+-         assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb4, unwind continue];
++         _20 = Eq(_2, const 0_u64);
++         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind continue];
+      }
+  
+      bb4: {
+-         _17 = Div(move _18, move _19);
+-         StorageDead(_19);
+-         StorageDead(_18);
+-         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind continue];
++         _17 = Div(_1, _2);
++         _16 = opaque::<u64>(_17) -> [return: bb5, unwind continue];
+      }
+  
+      bb5: {
+-         StorageDead(_17);
+          StorageDead(_16);
+          StorageLive(_21);
+-         StorageLive(_22);
+-         StorageLive(_23);
+-         _23 = _1;
+-         StorageLive(_24);
+-         _24 = _2;
+-         _25 = Eq(_24, const 0_u64);
+-         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", _23) -> [success: bb6, unwind continue];
++         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind continue];
+      }
+  
+      bb6: {
+-         _22 = Rem(move _23, move _24);
+-         StorageDead(_24);
+-         StorageDead(_23);
+-         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind continue];
++         _22 = Rem(_1, _2);
++         _21 = opaque::<u64>(_22) -> [return: bb7, unwind continue];
+      }
+  
+      bb7: {
+-         StorageDead(_22);
+          StorageDead(_21);
+          StorageLive(_26);
+-         StorageLive(_27);
+-         StorageLive(_28);
+-         _28 = _1;
+-         StorageLive(_29);
+-         _29 = _2;
+-         _27 = BitAnd(move _28, move _29);
+-         StorageDead(_29);
+-         StorageDead(_28);
+-         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind continue];
++         _27 = BitAnd(_1, _2);
++         _26 = opaque::<u64>(_27) -> [return: bb8, unwind continue];
+      }
+  
+      bb8: {
+-         StorageDead(_27);
+          StorageDead(_26);
+          StorageLive(_30);
+-         StorageLive(_31);
+-         StorageLive(_32);
+-         _32 = _1;
+-         StorageLive(_33);
+-         _33 = _2;
+-         _31 = BitOr(move _32, move _33);
+-         StorageDead(_33);
+-         StorageDead(_32);
+-         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind continue];
++         _31 = BitOr(_1, _2);
++         _30 = opaque::<u64>(_31) -> [return: bb9, unwind continue];
+      }
+  
+      bb9: {
+-         StorageDead(_31);
+          StorageDead(_30);
+          StorageLive(_34);
+-         StorageLive(_35);
+-         StorageLive(_36);
+-         _36 = _1;
+-         StorageLive(_37);
+-         _37 = _2;
+-         _35 = BitXor(move _36, move _37);
+-         StorageDead(_37);
+-         StorageDead(_36);
+-         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind continue];
++         _35 = BitXor(_1, _2);
++         _34 = opaque::<u64>(_35) -> [return: bb10, unwind continue];
+      }
+  
+      bb10: {
+-         StorageDead(_35);
+          StorageDead(_34);
+          StorageLive(_38);
+-         StorageLive(_39);
+-         StorageLive(_40);
+-         _40 = _1;
+-         StorageLive(_41);
+-         _41 = _2;
+-         _39 = Shl(move _40, move _41);
+-         StorageDead(_41);
+-         StorageDead(_40);
+-         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind continue];
++         _39 = Shl(_1, _2);
++         _38 = opaque::<u64>(_39) -> [return: bb11, unwind continue];
+      }
+  
+      bb11: {
+-         StorageDead(_39);
+          StorageDead(_38);
+          StorageLive(_42);
+-         StorageLive(_43);
+-         StorageLive(_44);
+-         _44 = _1;
+-         StorageLive(_45);
+-         _45 = _2;
+-         _43 = Shr(move _44, move _45);
+-         StorageDead(_45);
+-         StorageDead(_44);
+-         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind continue];
++         _43 = Shr(_1, _2);
++         _42 = opaque::<u64>(_43) -> [return: bb12, unwind continue];
+      }
+  
+      bb12: {
+-         StorageDead(_43);
+          StorageDead(_42);
+          StorageLive(_46);
+          StorageLive(_47);
+-         StorageLive(_48);
+-         _48 = _1;
+-         _47 = move _48 as u32 (IntToInt);
+-         StorageDead(_48);
++         _47 = _1 as u32 (IntToInt);
+          _46 = opaque::<u32>(move _47) -> [return: bb13, unwind continue];
+      }
+  
+      bb13: {
+          StorageDead(_47);
+          StorageDead(_46);
+          StorageLive(_49);
+          StorageLive(_50);
+-         StorageLive(_51);
+-         _51 = _1;
+-         _50 = move _51 as f32 (IntToFloat);
+-         StorageDead(_51);
++         _50 = _1 as f32 (IntToFloat);
+          _49 = opaque::<f32>(move _50) -> [return: bb14, unwind continue];
+      }
+  
+      bb14: {
+          StorageDead(_50);
+          StorageDead(_49);
+          StorageLive(_52);
+          StorageLive(_53);
+-         StorageLive(_54);
+-         _54 = _1;
+-         _53 = S::<u64>(move _54);
+-         StorageDead(_54);
++         _53 = S::<u64>(_1);
+          _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind continue];
+      }
+  
+      bb15: {
+          StorageDead(_53);
+          StorageDead(_52);
+          StorageLive(_55);
+-         StorageLive(_56);
+          StorageLive(_57);
+-         StorageLive(_58);
+-         _58 = _1;
+-         _57 = S::<u64>(move _58);
+-         StorageDead(_58);
++         _57 = S::<u64>(_1);
+          _56 = (_57.0: u64);
+-         _55 = opaque::<u64>(move _56) -> [return: bb16, unwind continue];
++         _55 = opaque::<u64>(_56) -> [return: bb16, unwind continue];
+      }
+  
+      bb16: {
+-         StorageDead(_56);
+          StorageDead(_57);
+          StorageDead(_55);
+          StorageLive(_59);
+          StorageLive(_60);
+-         StorageLive(_61);
+-         StorageLive(_62);
+-         _62 = _1;
+-         StorageLive(_63);
+-         _63 = _2;
+-         _61 = Add(move _62, move _63);
+-         StorageDead(_63);
+-         StorageDead(_62);
+          StorageLive(_64);
+          _64 = _3;
+-         _60 = Add(move _61, move _64);
++         _60 = Add(_5, move _64);
+          StorageDead(_64);
+-         StorageDead(_61);
+          _59 = opaque::<u64>(move _60) -> [return: bb17, unwind continue];
+      }
+  
+      bb17: {
+          StorageDead(_60);
+          StorageDead(_59);
+          StorageLive(_65);
+          StorageLive(_66);
+-         StorageLive(_67);
+-         StorageLive(_68);
+-         _68 = _1;
+-         StorageLive(_69);
+-         _69 = _2;
+-         _67 = Mul(move _68, move _69);
+-         StorageDead(_69);
+-         StorageDead(_68);
+          StorageLive(_70);
+          _70 = _3;
+-         _66 = Add(move _67, move _70);
++         _66 = Add(_9, move _70);
+          StorageDead(_70);
+-         StorageDead(_67);
+          _65 = opaque::<u64>(move _66) -> [return: bb18, unwind continue];
+      }
+  
+      bb18: {
+          StorageDead(_66);
+          StorageDead(_65);
+          StorageLive(_71);
+          StorageLive(_72);
+-         StorageLive(_73);
+-         StorageLive(_74);
+-         _74 = _1;
+-         StorageLive(_75);
+-         _75 = _2;
+-         _73 = Sub(move _74, move _75);
+-         StorageDead(_75);
+-         StorageDead(_74);
+          StorageLive(_76);
+          _76 = _3;
+-         _72 = Add(move _73, move _76);
++         _72 = Add(_13, move _76);
+          StorageDead(_76);
+-         StorageDead(_73);
+          _71 = opaque::<u64>(move _72) -> [return: bb19, unwind continue];
+      }
+  
+      bb19: {
+          StorageDead(_72);
+          StorageDead(_71);
+          StorageLive(_77);
+          StorageLive(_78);
+-         StorageLive(_79);
+-         StorageLive(_80);
+-         _80 = _1;
+-         StorageLive(_81);
+-         _81 = _2;
+-         _82 = Eq(_81, const 0_u64);
+-         assert(!move _82, "attempt to divide `{}` by zero", _80) -> [success: bb20, unwind continue];
++         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind continue];
+      }
+  
+      bb20: {
+-         _79 = Div(move _80, move _81);
+-         StorageDead(_81);
+-         StorageDead(_80);
+          StorageLive(_83);
+          _83 = _3;
+-         _78 = Add(move _79, move _83);
++         _78 = Add(_17, move _83);
+          StorageDead(_83);
+-         StorageDead(_79);
+          _77 = opaque::<u64>(move _78) -> [return: bb21, unwind continue];
+      }
+  
+      bb21: {
+          StorageDead(_78);
+          StorageDead(_77);
+          StorageLive(_84);
+          StorageLive(_85);
+-         StorageLive(_86);
+-         StorageLive(_87);
+-         _87 = _1;
+-         StorageLive(_88);
+-         _88 = _2;
+-         _89 = Eq(_88, const 0_u64);
+-         assert(!move _89, "attempt to calculate the remainder of `{}` with a divisor of zero", _87) -> [success: bb22, unwind continue];
++         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind continue];
+      }
+  
+      bb22: {
+-         _86 = Rem(move _87, move _88);
+-         StorageDead(_88);
+-         StorageDead(_87);
+          StorageLive(_90);
+          _90 = _3;
+-         _85 = Add(move _86, move _90);
++         _85 = Add(_22, move _90);
+          StorageDead(_90);
+-         StorageDead(_86);
+          _84 = opaque::<u64>(move _85) -> [return: bb23, unwind continue];
+      }
+  
+      bb23: {
+          StorageDead(_85);
+          StorageDead(_84);
+          StorageLive(_91);
+          StorageLive(_92);
+-         StorageLive(_93);
+-         StorageLive(_94);
+-         _94 = _1;
+-         StorageLive(_95);
+-         _95 = _2;
+-         _93 = BitAnd(move _94, move _95);
+-         StorageDead(_95);
+-         StorageDead(_94);
+          StorageLive(_96);
+          _96 = _3;
+-         _92 = Add(move _93, move _96);
++         _92 = Add(_27, move _96);
+          StorageDead(_96);
+-         StorageDead(_93);
+          _91 = opaque::<u64>(move _92) -> [return: bb24, unwind continue];
+      }
+  
+      bb24: {
+          StorageDead(_92);
+          StorageDead(_91);
+          StorageLive(_97);
+          StorageLive(_98);
+-         StorageLive(_99);
+-         StorageLive(_100);
+-         _100 = _1;
+-         StorageLive(_101);
+-         _101 = _2;
+-         _99 = BitOr(move _100, move _101);
+-         StorageDead(_101);
+-         StorageDead(_100);
+          StorageLive(_102);
+          _102 = _3;
+-         _98 = Add(move _99, move _102);
++         _98 = Add(_31, move _102);
+          StorageDead(_102);
+-         StorageDead(_99);
+          _97 = opaque::<u64>(move _98) -> [return: bb25, unwind continue];
+      }
+  
+      bb25: {
+          StorageDead(_98);
+          StorageDead(_97);
+          StorageLive(_103);
+          StorageLive(_104);
+-         StorageLive(_105);
+-         StorageLive(_106);
+-         _106 = _1;
+-         StorageLive(_107);
+-         _107 = _2;
+-         _105 = BitXor(move _106, move _107);
+-         StorageDead(_107);
+-         StorageDead(_106);
+          StorageLive(_108);
+          _108 = _3;
+-         _104 = Add(move _105, move _108);
++         _104 = Add(_35, move _108);
+          StorageDead(_108);
+-         StorageDead(_105);
+          _103 = opaque::<u64>(move _104) -> [return: bb26, unwind continue];
+      }
+  
+      bb26: {
+          StorageDead(_104);
+          StorageDead(_103);
+          StorageLive(_109);
+          StorageLive(_110);
+-         StorageLive(_111);
+-         StorageLive(_112);
+-         _112 = _1;
+-         StorageLive(_113);
+-         _113 = _2;
+-         _111 = Shl(move _112, move _113);
+-         StorageDead(_113);
+-         StorageDead(_112);
+          StorageLive(_114);
+          _114 = _3;
+-         _110 = Add(move _111, move _114);
++         _110 = Add(_39, move _114);
+          StorageDead(_114);
+-         StorageDead(_111);
+          _109 = opaque::<u64>(move _110) -> [return: bb27, unwind continue];
+      }
+  
+      bb27: {
+          StorageDead(_110);
+          StorageDead(_109);
+          StorageLive(_115);
+          StorageLive(_116);
+-         StorageLive(_117);
+-         StorageLive(_118);
+-         _118 = _1;
+-         StorageLive(_119);
+-         _119 = _2;
+-         _117 = Shr(move _118, move _119);
+-         StorageDead(_119);
+-         StorageDead(_118);
+          StorageLive(_120);
+          _120 = _3;
+-         _116 = Add(move _117, move _120);
++         _116 = Add(_43, move _120);
+          StorageDead(_120);
+-         StorageDead(_117);
+          _115 = opaque::<u64>(move _116) -> [return: bb28, unwind continue];
+      }
+  
+      bb28: {
+          StorageDead(_116);
+          StorageDead(_115);
+          StorageLive(_121);
+          StorageLive(_122);
+-         StorageLive(_123);
+-         _123 = _1;
+-         _122 = S::<u64>(move _123);
+-         StorageDead(_123);
++         _122 = S::<u64>(_1);
+          _121 = opaque::<S<u64>>(move _122) -> [return: bb29, unwind continue];
+      }
+  
+      bb29: {
+          StorageDead(_122);
+          StorageDead(_121);
+          StorageLive(_124);
+-         StorageLive(_125);
+-         StorageLive(_126);
+-         StorageLive(_127);
+-         _127 = _1;
+-         _126 = S::<u64>(move _127);
+-         StorageDead(_127);
+-         _125 = (_126.0: u64);
+-         _124 = opaque::<u64>(move _125) -> [return: bb30, unwind continue];
++         _124 = opaque::<u64>(_56) -> [return: bb30, unwind continue];
+      }
+  
+      bb30: {
+-         StorageDead(_125);
+-         StorageDead(_126);
+          StorageDead(_124);
+          StorageLive(_128);
+          _128 = &_3;
+          StorageLive(_129);
+-         StorageLive(_130);
+-         StorageLive(_131);
+          _131 = (*_128);
+-         StorageLive(_132);
+-         _132 = _1;
+-         _130 = Add(move _131, move _132);
+-         StorageDead(_132);
+-         StorageDead(_131);
+-         _129 = opaque::<u64>(move _130) -> [return: bb31, unwind continue];
++         _130 = Add(_131, _1);
++         _129 = opaque::<u64>(_130) -> [return: bb31, unwind continue];
+      }
+  
+      bb31: {
+-         StorageDead(_130);
+          StorageDead(_129);
+          StorageLive(_133);
+-         StorageLive(_134);
+-         StorageLive(_135);
+-         _135 = (*_128);
+-         StorageLive(_136);
+-         _136 = _1;
+-         _134 = Add(move _135, move _136);
+-         StorageDead(_136);
+-         StorageDead(_135);
+-         _133 = opaque::<u64>(move _134) -> [return: bb32, unwind continue];
++         _133 = opaque::<u64>(_130) -> [return: bb32, unwind continue];
+      }
+  
+      bb32: {
+-         StorageDead(_134);
+          StorageDead(_133);
+          StorageLive(_137);
+          _137 = &mut _3;
+          StorageLive(_138);
+          StorageLive(_139);
+          StorageLive(_140);
+          _140 = (*_137);
+-         StorageLive(_141);
+-         _141 = _1;
+-         _139 = Add(move _140, move _141);
+-         StorageDead(_141);
++         _139 = Add(move _140, _1);
+          StorageDead(_140);
+          _138 = opaque::<u64>(move _139) -> [return: bb33, unwind continue];
+      }
+  
+      bb33: {
+          StorageDead(_139);
+          StorageDead(_138);
+          StorageLive(_142);
+          StorageLive(_143);
+          StorageLive(_144);
+          _144 = (*_137);
+-         StorageLive(_145);
+-         _145 = _1;
+-         _143 = Add(move _144, move _145);
+-         StorageDead(_145);
++         _143 = Add(move _144, _1);
+          StorageDead(_144);
+          _142 = opaque::<u64>(move _143) -> [return: bb34, unwind continue];
+      }
+  
+      bb34: {
+          StorageDead(_143);
+          StorageDead(_142);
+-         StorageLive(_146);
+          StorageLive(_147);
+          _147 = &raw const _3;
+          StorageLive(_148);
+          StorageLive(_149);
+          StorageLive(_150);
+          _150 = (*_147);
+-         StorageLive(_151);
+-         _151 = _1;
+-         _149 = Add(move _150, move _151);
+-         StorageDead(_151);
++         _149 = Add(move _150, _1);
+          StorageDead(_150);
+          _148 = opaque::<u64>(move _149) -> [return: bb35, unwind continue];
+      }
+  
+      bb35: {
+          StorageDead(_149);
+          StorageDead(_148);
+          StorageLive(_152);
+          StorageLive(_153);
+          StorageLive(_154);
+          _154 = (*_147);
+-         StorageLive(_155);
+-         _155 = _1;
+-         _153 = Add(move _154, move _155);
+-         StorageDead(_155);
++         _153 = Add(move _154, _1);
+          StorageDead(_154);
+          _152 = opaque::<u64>(move _153) -> [return: bb36, unwind continue];
+      }
+  
+      bb36: {
+          StorageDead(_153);
+          StorageDead(_152);
+          StorageLive(_156);
+          _156 = &raw mut _3;
+          StorageLive(_157);
+          StorageLive(_158);
+          StorageLive(_159);
+          _159 = (*_156);
+-         StorageLive(_160);
+-         _160 = _1;
+-         _158 = Add(move _159, move _160);
+-         StorageDead(_160);
++         _158 = Add(move _159, _1);
+          StorageDead(_159);
+          _157 = opaque::<u64>(move _158) -> [return: bb37, unwind continue];
+      }
+  
+      bb37: {
+          StorageDead(_158);
+          StorageDead(_157);
+          StorageLive(_161);
+          StorageLive(_162);
+          StorageLive(_163);
+          _163 = (*_156);
+-         StorageLive(_164);
+-         _164 = _1;
+-         _162 = Add(move _163, move _164);
+-         StorageDead(_164);
++         _162 = Add(move _163, _1);
+          StorageDead(_163);
+          _161 = opaque::<u64>(move _162) -> [return: bb38, unwind continue];
+      }
+  
+      bb38: {
+          StorageDead(_162);
+          StorageDead(_161);
+-         _146 = const ();
+          StorageDead(_156);
+          StorageDead(_147);
+-         StorageDead(_146);
+          StorageLive(_165);
+          _165 = &_3;
+          StorageLive(_166);
+-         StorageLive(_167);
+-         StorageLive(_168);
+          _168 = (*_165);
+-         StorageLive(_169);
+-         _169 = _1;
+-         _167 = Add(move _168, move _169);
+-         StorageDead(_169);
+-         StorageDead(_168);
+-         _166 = opaque::<u64>(move _167) -> [return: bb39, unwind continue];
++         _167 = Add(_168, _1);
++         _166 = opaque::<u64>(_167) -> [return: bb39, unwind continue];
+      }
+  
+      bb39: {
+-         StorageDead(_167);
+          StorageDead(_166);
+          StorageLive(_170);
+-         StorageLive(_171);
+-         StorageLive(_172);
+-         _172 = (*_165);
+-         StorageLive(_173);
+-         _173 = _1;
+-         _171 = Add(move _172, move _173);
+-         StorageDead(_173);
+-         StorageDead(_172);
+-         _170 = opaque::<u64>(move _171) -> [return: bb40, unwind continue];
++         _170 = opaque::<u64>(_167) -> [return: bb40, unwind continue];
+      }
+  
+      bb40: {
+-         StorageDead(_171);
+          StorageDead(_170);
+          _0 = const ();
+          StorageDead(_165);
+          StorageDead(_137);
+          StorageDead(_128);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff

@@ -0,0 +1,45 @@
+- // MIR for `wrap_unwrap` before GVN
++ // MIR for `wrap_unwrap` after GVN
+  
+  fn wrap_unwrap(_1: T) -> T {
+      debug x => _1;
+      let mut _0: T;
+      let mut _2: std::option::Option<T>;
+      let mut _3: T;
+      let mut _4: isize;
+      let _5: T;
+      let mut _6: !;
+      scope 1 {
+          debug y => _5;
+      }
+  
+      bb0: {
+          StorageLive(_2);
+-         StorageLive(_3);
+-         _3 = _1;
+-         _2 = Option::<T>::Some(move _3);
+-         StorageDead(_3);
++         _2 = Option::<T>::Some(_1);
+          _4 = discriminant(_2);
+          switchInt(move _4) -> [0: bb1, 1: bb3, otherwise: bb2];
+      }
+  
+      bb1: {
+          StorageLive(_6);
+          _6 = begin_panic::<&str>(const "explicit panic") -> unwind unreachable;
+      }
+  
+      bb2: {
+          unreachable;
+      }
+  
+      bb3: {
+-         StorageLive(_5);
+          _5 = ((_2 as Some).0: T);
+          _0 = _5;
+-         StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff

@@ -0,0 +1,45 @@
+- // MIR for `wrap_unwrap` before GVN
++ // MIR for `wrap_unwrap` after GVN
+  
+  fn wrap_unwrap(_1: T) -> T {
+      debug x => _1;
+      let mut _0: T;
+      let mut _2: std::option::Option<T>;
+      let mut _3: T;
+      let mut _4: isize;
+      let _5: T;
+      let mut _6: !;
+      scope 1 {
+          debug y => _5;
+      }
+  
+      bb0: {
+          StorageLive(_2);
+-         StorageLive(_3);
+-         _3 = _1;
+-         _2 = Option::<T>::Some(move _3);
+-         StorageDead(_3);
++         _2 = Option::<T>::Some(_1);
+          _4 = discriminant(_2);
+          switchInt(move _4) -> [0: bb1, 1: bb3, otherwise: bb2];
+      }
+  
+      bb1: {
+          StorageLive(_6);
+          _6 = begin_panic::<&str>(const "explicit panic") -> unwind continue;
+      }
+  
+      bb2: {
+          unreachable;
+      }
+  
+      bb3: {
+-         StorageLive(_5);
+          _5 = ((_2 as Some).0: T);
+          _0 = _5;
+-         StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/inline/inline_generator.main.Inline.panic-abort.diff

@@ -26,8 +26,6 @@
 +         let mut _6: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8};
 +         let mut _7: u32;
 +         let mut _8: i32;
-+         let mut _9: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8};
-+         let mut _10: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8};
 +     }
   
       bb0: {
@@ -87,8 +85,7 @@
 + 
 +     bb6: {
 +         _1 = GeneratorState::<i32, bool>::Yielded(move _8);
-+         _9 = deref_copy (_2.0: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8});
++         discriminant((*_6)) = 3;
-+         discriminant((*_9)) = 3;
 +         goto -> bb1;
 +     }
 + 
@@ -100,8 +97,7 @@
 +         StorageLive(_8);
 +         StorageDead(_8);
 +         _1 = GeneratorState::<i32, bool>::Complete(_5);
-+         _10 = deref_copy (_2.0: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8});
++         discriminant((*_6)) = 1;
-+         discriminant((*_10)) = 1;
 +         goto -> bb1;
 +     }
 + 

tests/mir-opt/inline/inline_generator.main.Inline.panic-unwind.diff

@@ -26,8 +26,6 @@
 +         let mut _6: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8};
 +         let mut _7: u32;
 +         let mut _8: i32;
-+         let mut _9: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8};
-+         let mut _10: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8};
 +     }
   
       bb0: {
@@ -99,8 +97,7 @@
 + 
 +     bb8: {
 +         _1 = GeneratorState::<i32, bool>::Yielded(move _8);
-+         _9 = deref_copy (_2.0: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8});
++         discriminant((*_6)) = 3;
-+         discriminant((*_9)) = 3;
 +         goto -> bb1;
 +     }
 + 
@@ -112,8 +109,7 @@
 +         StorageLive(_8);
 +         StorageDead(_8);
 +         _1 = GeneratorState::<i32, bool>::Complete(_5);
-+         _10 = deref_copy (_2.0: &mut {generator@$DIR/inline_generator.rs:16:5: 16:8});
++         discriminant((*_6)) = 1;
-+         discriminant((*_10)) = 1;
 +         goto -> bb1;
 +     }
 + 

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

@@ -34,7 +34,6 @@
           _2 = move _3 as &[T] (PointerCoercion(Unsize));
           StorageDead(_3);
           _8 = const 3_usize;
-          _9 = const 3_usize;
           _10 = const true;
           goto -> bb2;
       }

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

@@ -34,7 +34,6 @@
           _2 = move _3 as &[T] (PointerCoercion(Unsize));
           StorageDead(_3);
           _8 = const 3_usize;
-          _9 = const 3_usize;
           _10 = const true;
           goto -> bb2;
       }

tests/mir-opt/simplify_if.main.SimplifyConstCondition-after-const-prop.panic-abort.diff

@@ -7,8 +7,6 @@
       let _2: ();
   
       bb0: {
-          StorageLive(_1);
-          _1 = const false;
 -         switchInt(const false) -> [0: bb3, otherwise: bb1];
 +         goto -> bb3;
       }
@@ -26,7 +24,6 @@
       }
   
       bb4: {
-          StorageDead(_1);
           return;
       }
   }

tests/mir-opt/simplify_if.main.SimplifyConstCondition-after-const-prop.panic-unwind.diff

@@ -7,8 +7,6 @@
       let _2: ();
   
       bb0: {
-          StorageLive(_1);
-          _1 = const false;
 -         switchInt(const false) -> [0: bb3, otherwise: bb1];
 +         goto -> bb3;
       }
@@ -26,7 +24,6 @@
       }
   
       bb4: {
-          StorageDead(_1);
           return;
       }
   }