Don't codegen expect in opt-level=0

clubby789 · clubby789 · commit 5b96ae7106e0 · 2024-09-04T11:49:00.000Z
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -187,9 +187,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     Some(instance),
                 )
             }
-            sym::likely => {
-                self.call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(true)])
-            }
+            sym::likely => self.expect(args[0].immediate(), true),
             sym::is_val_statically_known => {
                 let intrinsic_type = args[0].layout.immediate_llvm_type(self.cx);
                 let kind = self.type_kind(intrinsic_type);
@@ -210,8 +208,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     self.const_bool(false)
                 }
             }
-            sym::unlikely => self
-                .call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(false)]),
+            sym::unlikely => self.expect(args[0].immediate(), false),
             sym::select_unpredictable => {
                 let cond = args[0].immediate();
                 assert_eq!(args[1].layout, args[2].layout);
@@ -604,11 +601,17 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     }
 
     fn assume(&mut self, val: Self::Value) {
-        self.call_intrinsic("llvm.assume", &[val]);
+        if self.cx.sess().opts.optimize != rustc_session::config::OptLevel::No {
+            self.call_intrinsic("llvm.assume", &[val]);
+        }
     }
 
     fn expect(&mut self, cond: Self::Value, expected: bool) -> Self::Value {
-        self.call_intrinsic("llvm.expect.i1", &[cond, self.const_bool(expected)])
+        if self.cx.sess().opts.optimize != rustc_session::config::OptLevel::No {
+            self.call_intrinsic("llvm.expect.i1", &[cond, self.const_bool(expected)])
+        } else {
+            cond
+        }
     }
 
     fn type_test(&mut self, pointer: Self::Value, typeid: Self::Value) -> Self::Value {
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -382,7 +382,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         scalar: abi::Scalar,
         backend_ty: Bx::Type,
     ) {
-        if matches!(self.cx.sess().opts.optimize, OptLevel::No | OptLevel::Less)
+        if matches!(self.cx.sess().opts.optimize, OptLevel::No)
             // For now, the critical niches are all over `Int`eger values.
             // Should floating-point values or pointers ever get more complex
             // niches, then this code will probably want to handle them too.
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -1,6 +1,5 @@
 use rustc_middle::mir::{self, NonDivergingIntrinsic};
 use rustc_middle::span_bug;
-use rustc_session::config::OptLevel;
 use tracing::instrument;
 
 use super::{FunctionCx, LocalRef};
@@ -68,10 +67,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 self.codegen_coverage(bx, kind, statement.source_info.scope);
             }
             mir::StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(ref op)) => {
-                if !matches!(bx.tcx().sess.opts.optimize, OptLevel::No | OptLevel::Less) {
-                    let op_val = self.codegen_operand(bx, op);
-                    bx.assume(op_val.immediate());
-                }
+                let op_val = self.codegen_operand(bx, op);
+                bx.assume(op_val.immediate());
             }
             mir::StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(
                 mir::CopyNonOverlapping { ref count, ref src, ref dst },
diff --git a/tests/codegen/intrinsics/likely.rs b/tests/codegen/intrinsics/likely.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -C no-prepopulate-passes
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=1
 
 #![crate_type = "lib"]
 #![feature(core_intrinsics)]

Original file line number	Diff line number	Diff line change
`@@ -187,9 +187,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {`
`187`	`187`	`Some(instance),`
`188`	`188`	`)`
`189`	`189`	`}`
`190`		`- sym::likely => {`
`191`		`- self.call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(true)])`
`192`		`- }`
	`190`	`+ sym::likely => self.expect(args[0].immediate(), true),`
`193`	`191`	`sym::is_val_statically_known => {`
`194`	`192`	`let intrinsic_type = args[0].layout.immediate_llvm_type(self.cx);`
`195`	`193`	`let kind = self.type_kind(intrinsic_type);`
`@@ -210,8 +208,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {`
`210`	`208`	`self.const_bool(false)`
`211`	`209`	`}`
`212`	`210`	`}`
`213`		`- sym::unlikely => self`
`214`		`- .call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(false)]),`
	`211`	`+ sym::unlikely => self.expect(args[0].immediate(), false),`
`215`	`212`	`sym::select_unpredictable => {`
`216`	`213`	`let cond = args[0].immediate();`
`217`	`214`	`assert_eq!(args[1].layout, args[2].layout);`
`@@ -604,11 +601,17 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {`
`604`	`601`	`}`
`605`	`602`
`606`	`603`	`fn assume(&mut self, val: Self::Value) {`
`607`		`- self.call_intrinsic("llvm.assume", &[val]);`
	`604`	`+ if self.cx.sess().opts.optimize != rustc_session::config::OptLevel::No {`
	`605`	`+ self.call_intrinsic("llvm.assume", &[val]);`
	`606`	`+ }`
`608`	`607`	`}`
`609`	`608`
`610`	`609`	`fn expect(&mut self, cond: Self::Value, expected: bool) -> Self::Value {`
`611`		`- self.call_intrinsic("llvm.expect.i1", &[cond, self.const_bool(expected)])`
	`610`	`+ if self.cx.sess().opts.optimize != rustc_session::config::OptLevel::No {`
	`611`	`+ self.call_intrinsic("llvm.expect.i1", &[cond, self.const_bool(expected)])`
	`612`	`+ } else {`
	`613`	`+ cond`
	`614`	`+ }`
`612`	`615`	`}`
`613`	`616`
`614`	`617`	`fn type_test(&mut self, pointer: Self::Value, typeid: Self::Value) -> Self::Value {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-//@ compile-flags: -C no-prepopulate-passes`
	`1`	`+//@ compile-flags: -C no-prepopulate-passes -Copt-level=1`
`2`	`2`
`3`	`3`	`#![crate_type = "lib"]`
`4`	`4`	`#![feature(core_intrinsics)]`