perf improvement

Author: x17jiri

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -323,18 +323,11 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             return None;
         };
 
-        let no_expect = self.mir[bb].statements.iter().all(|stmt| {
-            let is_expect =
-                if let mir::StatementKind::Intrinsic(box mir::NonDivergingIntrinsic::Expect(..)) =
-                    stmt.kind
-                {
-                    true
-                } else {
-                    false
-                };
-            !is_expect
-        });
-        if no_expect {
+        if let Some(ref blocks) = self.blocks_with_expect {
+            if !blocks.contains(bb) {
+                return None;
+            }
+        } else {
             return None;
         }
 
@@ -1234,7 +1227,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             debug!("codegen_block({:?}={:?})", bb, data);
 
             for statement in &data.statements {
-                self.codegen_statement(bx, statement);
+                self.codegen_statement(bx, bb, statement);
             }
 
             let merging_succ = self.codegen_terminator(bx, bb, data.terminator());

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -110,6 +110,9 @@ pub struct FunctionCx<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
 
     /// Caller location propagated if this function has `#[track_caller]`.
     caller_location: Option<OperandRef<'tcx, Bx::Value>>,
+
+    /// The set of blocks that contain `expect` intrinsics.
+    blocks_with_expect: Option<Box<BitSet<mir::BasicBlock>>>,
 }
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
@@ -207,6 +210,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         debug_context,
         per_local_var_debug_info: None,
         caller_location: None,
+        blocks_with_expect: None,
     };
 
     // It may seem like we should iterate over `required_consts` to ensure they all successfully

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -1,3 +1,4 @@
+use rustc_index::bit_set::BitSet;
 use rustc_middle::mir;
 use rustc_middle::mir::NonDivergingIntrinsic;
 
@@ -7,7 +8,12 @@ use crate::traits::*;
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     #[instrument(level = "debug", skip(self, bx))]
-    pub fn codegen_statement(&mut self, bx: &mut Bx, statement: &mir::Statement<'tcx>) {
+    pub fn codegen_statement(
+        &mut self,
+        bx: &mut Bx,
+        bb: mir::BasicBlock,
+        statement: &mir::Statement<'tcx>,
+    ) {
         self.set_debug_loc(bx, statement.source_info);
         match statement.kind {
             mir::StatementKind::Assign(box (ref place, ref rvalue)) => {
@@ -72,7 +78,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
             // The Expect intrinsic is processed with the BB terminator
             // in codegen_switchint_terminator()
-            mir::StatementKind::Intrinsic(box NonDivergingIntrinsic::Expect(..)) => {}
+            mir::StatementKind::Intrinsic(box NonDivergingIntrinsic::Expect(..)) => {
+                if !self.blocks_with_expect.is_some() {
+                    self.blocks_with_expect =
+                        Some(Box::new(BitSet::new_empty(self.mir.basic_blocks.len())));
+                }
+                self.blocks_with_expect.as_mut().unwrap().insert(bb);
+            }
             mir::StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(
                 mir::CopyNonOverlapping { ref count, ref src, ref dst },
             )) => {