Auto merge of rust-lang#140117 - dianqk:mir-nop, r=<try>

[experiment] eliminate dead statements while retaining debugging information

I don't have a clear idea yet, but I'd like to take a look at perf first.

r? ghost

Author: bors

compiler/rustc_borrowck/src/dataflow.rs

@@ -626,7 +626,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
             | mir::StatementKind::Intrinsic(..)
             | mir::StatementKind::ConstEvalCounter
             | mir::StatementKind::BackwardIncompatibleDropHint { .. }
-            | mir::StatementKind::Nop => {}
+            | mir::StatementKind::Nop(_) => {}
         }
     }
 

compiler/rustc_borrowck/src/lib.rs

@@ -770,7 +770,7 @@ impl<'a, 'tcx> ResultsVisitor<'a, 'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<
                     state,
                 );
             }
-            StatementKind::Nop
+            StatementKind::Nop(_)
             | StatementKind::Retag { .. }
             | StatementKind::Deinit(..)
             | StatementKind::SetDiscriminant { .. } => {

compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs

@@ -82,7 +82,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'a, 'tcx> {
                 );
             }
             StatementKind::ConstEvalCounter
-            | StatementKind::Nop
+            | StatementKind::Nop(_)
             | StatementKind::Retag { .. }
             | StatementKind::Deinit(..)
             | StatementKind::BackwardIncompatibleDropHint { .. }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -731,7 +731,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | StatementKind::ConstEvalCounter
             | StatementKind::PlaceMention(..)
             | StatementKind::BackwardIncompatibleDropHint { .. }
-            | StatementKind::Nop => {}
+            | StatementKind::Nop(_) => {}
             StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(..))
             | StatementKind::Deinit(..)
             | StatementKind::SetDiscriminant { .. } => {

compiler/rustc_codegen_cranelift/src/base.rs

@@ -946,7 +946,7 @@ fn codegen_stmt<'tcx>(
         | StatementKind::StorageDead(_)
         | StatementKind::Deinit(_)
         | StatementKind::ConstEvalCounter
-        | StatementKind::Nop
+        | StatementKind::Nop(_)
         | StatementKind::FakeRead(..)
         | StatementKind::Retag { .. }
         | StatementKind::PlaceMention(..)

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -591,7 +591,7 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
                         | StatementKind::Coverage(_)
                         | StatementKind::ConstEvalCounter
                         | StatementKind::BackwardIncompatibleDropHint { .. }
-                        | StatementKind::Nop => {}
+                        | StatementKind::Nop(_) => {}
                     }
                 }
                 match &bb_data.terminator().kind {

compiler/rustc_codegen_gcc/src/debuginfo.rs

@@ -26,7 +26,8 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
         &mut self,
         _dbg_var: Self::DIVariable,
         _dbg_loc: Self::DILocation,
-        _variable_alloca: Self::Value,
+        _is_declared: bool,
+        _val: Self::Value,
         _direct_offset: Size,
         _indirect_offsets: &[Size],
         _fragment: Option<Range<Size>>,

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -154,7 +154,8 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         &mut self,
         dbg_var: &'ll DIVariable,
         dbg_loc: &'ll DILocation,
-        variable_alloca: Self::Value,
+        is_declared: bool,
+        val: Self::Value,
         direct_offset: Size,
         indirect_offsets: &[Size],
         fragment: Option<Range<Size>>,
@@ -183,17 +184,30 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
             addr_ops.push((fragment.end - fragment.start).bits() as u64);
         }
 
-        unsafe {
-            // FIXME(eddyb) replace `llvm.dbg.declare` with `llvm.dbg.addr`.
-            llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
-                DIB(self.cx()),
-                variable_alloca,
-                dbg_var,
-                addr_ops.as_ptr(),
-                addr_ops.len() as c_uint,
-                dbg_loc,
-                self.llbb(),
-            );
+        if is_declared {
+            unsafe {
+                llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
+                    DIB(self.cx()),
+                    val,
+                    dbg_var,
+                    addr_ops.as_ptr(),
+                    addr_ops.len() as c_uint,
+                    dbg_loc,
+                    self.llbb(),
+                );
+            }
+        } else {
+            unsafe {
+                llvm::LLVMRustDIBuilderInsertDbgValueAtEnd(
+                    DIB(self.cx()),
+                    val,
+                    dbg_var,
+                    addr_ops.as_ptr(),
+                    addr_ops.len() as c_uint,
+                    dbg_loc,
+                    self.llbb(),
+                );
+            }
         }
     }
 

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2301,6 +2301,16 @@ unsafe extern "C" {
         InsertAtEnd: &'a BasicBlock,
     );
 
+    pub(crate) fn LLVMRustDIBuilderInsertDbgValueAtEnd<'a>(
+        Builder: &DIBuilder<'a>,
+        Val: &'a Value,
+        VarInfo: &'a DIVariable,
+        AddrOps: *const u64,
+        AddrOpsCount: c_uint,
+        DL: &'a DILocation,
+        InsertAtEnd: &'a BasicBlock,
+    );
+
     pub(crate) fn LLVMRustDIBuilderCreateEnumerator<'a>(
         Builder: &DIBuilder<'a>,
         Name: *const c_char,

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -205,7 +205,8 @@ fn calculate_debuginfo_offset<
             _ => {
                 // Sanity check for `can_use_in_debuginfo`.
                 assert!(!elem.can_use_in_debuginfo());
-                bug!("unsupported var debuginfo projection `{:?}`", projection)
+                // TODO: Temporarily disabled for testing purposes.
+                // bug!("unsupported var debuginfo projection `{:?}`", projection)
             }
         }
     }
@@ -377,6 +378,52 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         }
     }
 
+    pub(crate) fn debug_new_value_to_local(
+        &self,
+        bx: &mut Bx,
+        local: mir::Local,
+        base: PlaceValue<Bx::Value>,
+        layout: TyAndLayout<'tcx>,
+        projection: &[mir::PlaceElem<'tcx>],
+    ) {
+        let full_debug_info = bx.sess().opts.debuginfo == DebugInfo::Full;
+        if !full_debug_info {
+            return;
+        }
+
+        let vars = match &self.per_local_var_debug_info {
+            Some(per_local) => &per_local[local],
+            None => return,
+        };
+
+        for var in vars.iter().cloned() {
+            self.debug_new_value_to_local_as_var(bx, base, layout, projection, var);
+        }
+    }
+
+    fn debug_new_value_to_local_as_var(
+        &self,
+        bx: &mut Bx,
+        base: PlaceValue<Bx::Value>,
+        layout: TyAndLayout<'tcx>,
+        projection: &[mir::PlaceElem<'tcx>],
+        var: PerLocalVarDebugInfo<'tcx, Bx::DIVariable>,
+    ) {
+        let Some(dbg_var) = var.dbg_var else { return };
+        let Some(dbg_loc) = self.dbg_loc(var.source_info) else { return };
+        let DebugInfoOffset { direct_offset, indirect_offsets, result: _ } =
+            calculate_debuginfo_offset(bx, projection, layout);
+        bx.dbg_var_addr(
+            dbg_var,
+            dbg_loc,
+            false,
+            base.llval,
+            direct_offset,
+            &indirect_offsets,
+            var.fragment,
+        );
+    }
+
     fn debug_introduce_local_as_var(
         &self,
         bx: &mut Bx,
@@ -386,7 +433,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     ) {
         let Some(dbg_var) = var.dbg_var else { return };
         let Some(dbg_loc) = self.dbg_loc(var.source_info) else { return };
-
         let DebugInfoOffset { direct_offset, indirect_offsets, result: _ } =
             calculate_debuginfo_offset(bx, var.projection, base.layout);
 
@@ -421,6 +467,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             bx.dbg_var_addr(
                 dbg_var,
                 dbg_loc,
+                true,
                 alloca.val.llval,
                 Size::ZERO,
                 &[Size::ZERO],
@@ -430,6 +477,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             bx.dbg_var_addr(
                 dbg_var,
                 dbg_loc,
+                true,
                 base.val.llval,
                 direct_offset,
                 &indirect_offsets,
@@ -455,7 +503,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let base = FunctionCx::spill_operand_to_stack(operand, Some(name), bx);
                 bx.clear_dbg_loc();
 
-                bx.dbg_var_addr(dbg_var, dbg_loc, base.val.llval, Size::ZERO, &[], fragment);
+                bx.dbg_var_addr(dbg_var, dbg_loc, true, base.val.llval, Size::ZERO, &[], fragment);
             }
         }
     }