add -Zforce-intrinsic-fallback flag

Author: folkertdev

compiler/rustc_codegen_ssa/src/mir/intrinsic.rs

@@ -63,6 +63,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         result_place: Option<PlaceValue<Bx::Value>>,
         source_info: SourceInfo,
     ) -> IntrinsicResult<'tcx, Bx::Value> {
+        // When `-Zforce-intrinsic-fallback` is enabled, always use the fallback body if it exists,
+        if bx.tcx().sess.opts.unstable_opts.force_intrinsic_fallback
+            && let Some(def) = bx.tcx().intrinsic(instance.def_id())
+            && !def.must_be_overridden
+        {
+            return IntrinsicResult::Fallback(ty::Instance::new_raw(
+                instance.def_id(),
+                instance.args,
+            ));
+        }
+
         let span = source_info.span;
 
         let name = bx.tcx().item_name(instance.def_id());

compiler/rustc_monomorphize/src/collector.rs

@@ -995,11 +995,18 @@ fn visit_instance_use<'tcx>(
                 output.push(create_fn_mono_item(tcx, panic_instance, source));
             }
         } else if !intrinsic.must_be_overridden
-            && !tcx.sess.replaced_intrinsics.contains(&intrinsic.name)
+            && (tcx.sess.opts.unstable_opts.force_intrinsic_fallback
+                || !tcx.sess.replaced_intrinsics.contains(&intrinsic.name))
         {
             // Codegen the fallback body of intrinsics with fallback bodies.
             // We have to skip this otherwise as there's no body to codegen.
-            // We also skip intrinsics the backend handles, to reduce monomorphizations.
+            //
+            // We also skip `replaced_intrinsics` which are always replaced by the backend and hence
+            // monomorphizing the fallback body would be pointless.
+            //
+            // However, when -Zforce-intrinsic-fallback is set (e.g. to test the fallback
+            // implementations) we ignore the optimization hint and do monomorphize
+            // the fallback body.
             let instance = ty::Instance::new_raw(instance.def_id(), instance.args);
             if tcx.should_codegen_locally(instance) {
                 output.push(create_fn_mono_item(tcx, instance, source));

compiler/rustc_session/src/options.rs

@@ -2413,6 +2413,9 @@ options! {
     fmt_debug: FmtDebug = (FmtDebug::Full, parse_fmt_debug, [TRACKED],
         "how detailed `#[derive(Debug)]` should be. `full` prints types recursively, \
         `shallow` prints only type names, `none` prints nothing and disables `{:?}`. (default: `full`)"),
+    force_intrinsic_fallback: bool = (false, parse_bool, [TRACKED],
+        "always use the fallback body of an intrinsic, if it has one, instead of lowering \
+        the intrinsic in the codegen backend (default: no)."),
     force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
         "force all crates to be `rustc_private` unstable (default: no)"),
     function_return: FunctionReturn = (FunctionReturn::default(), parse_function_return, [TRACKED],

src/doc/unstable-book/src/compiler-flags/force-intrinsic-fallback.md

@@ -0,0 +1,6 @@
+## `force-intrinsic-fallback`
+
+Configures codegen to always use the fallback body of an intrinsic, if it has one,
+instead of lowering the intrinsic in the codegen backend.
+
+This is useful for testing the fallback implementation.

tests/codegen-llvm/force-intrinsic-fallback.rs

@@ -0,0 +1,71 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3
+//
+//@ revisions: NORMAL FALLBACK
+//@ [FALLBACK] compile-flags: -Zforce-intrinsic-fallback
+//
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=x86_64-unknown-linux-gnu
+#![feature(no_core, rustc_attrs, intrinsics)]
+#![no_core]
+
+extern crate minicore;
+// use minicore::*;
+
+// Check the effect of `-Zforce-intrinsic-fallback`.
+//
+// When enabled, the backend should insert a libcall. When enabled, for the setup of this test,
+// the dedicated instruction should be used instead.
+
+#[no_mangle]
+fn call_sqrtf32(x: f32) -> f32 {
+    // CHECK-LABEL: call_sqrtf32
+
+    // Without the flag: dedicated instruction, no libcall.
+    // NORMAL: tail call float @llvm.sqrt.f32
+    // NORMAL-NOT: sqrtf
+
+    // With the flag: libcall
+    // FALLBACK: tail call noundef float @sqrtf
+    sqrtf32(x)
+}
+
+#[inline]
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub fn sqrtf32(x: f32) -> f32 {
+    sqrtf(x)
+}
+
+unsafe extern "C" {
+    safe fn sqrtf(_: f32) -> f32;
+}
+
+// Codegen backends can return a list of `replaced_intrinsics`, for which codegen of the fallback is
+// normally skipped. The unchecked_funnel_shl is skipped by the LLVM backend, so we test it here to
+// ensure that with the flag enabled the fallback body is actually code generated.
+
+#[no_mangle]
+fn call_funnel_shl(a: u32, b: u32, shift: u32) -> u32 {
+    // CHECK-LABEL: call_funnel_shl
+
+    // Without the flag: dedicated instruction, no libcall.
+    // NORMAL: tail call i32 @llvm.fshl.i32
+    // NORMAL-NOT: custom_funnel_shl
+
+    // With the flag: libcall
+    // FALLBACK: tail call void @custom_funnel_shl
+    unsafe { unchecked_funnel_shl(a, b, shift) }
+}
+
+#[inline]
+#[rustc_intrinsic]
+#[rustc_nounwind]
+unsafe fn unchecked_funnel_shl<T>(_: T, _: T, shift: u32) -> T {
+    custom_funnel_shl(shift)
+}
+
+unsafe extern "C" {
+    safe fn custom_funnel_shl(_: u32) -> !;
+}