[TEST] Use a fallback impl instead of backend-specific ones

Author: sayantn

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -655,62 +655,6 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let res = fx.bcx.ins().rotr(x, y);
             ret.write_cvalue(fx, CValue::by_val(res, layout));
         }
-        sym::funnel_shl => {
-            intrinsic_args!(fx, args => (x, y, z); intrinsic);
-            let layout = x.layout();
-
-            let width_bits = layout.size.bits() as i64;
-
-            let lhs_bits = x.load_scalar(fx);
-            let rhs_bits = y.load_scalar(fx);
-            let raw_shift_bits = z.load_scalar(fx);
-
-            let ty = fx.bcx.func.dfg.value_type(lhs_bits);
-            let zero = fx.bcx.ins().iconst(ty, 0);
-
-            let shift_bits = fx.bcx.ins().band_imm(raw_shift_bits, width_bits - 1);
-            let inv_shift_bits = fx.bcx.ins().irsub_imm(shift_bits, width_bits);
-            let is_zero = fx.bcx.ins().icmp_imm(IntCC::Equal, shift_bits, 0);
-
-            // lhs_bits << shift_bits
-            let shl = fx.bcx.ins().ishl(lhs_bits, shift_bits);
-
-            // rhs_bits.unbounded_shr(inv_shift_bits)
-            // we don't need a modulo here because `ushr` implicitly does it
-            let shr = fx.bcx.ins().ushr(rhs_bits, inv_shift_bits);
-            let shr = fx.bcx.ins().select(is_zero, zero, shr);
-
-            let res = fx.bcx.ins().bor(shr, shl);
-            ret.write_cvalue(fx, CValue::by_val(res, layout));
-        }
-        sym::funnel_shr => {
-            intrinsic_args!(fx, args => (x, y, z); intrinsic);
-            let layout = x.layout();
-
-            let width_bits = layout.size.bits() as i64;
-
-            let lhs_bits = x.load_scalar(fx);
-            let rhs_bits = y.load_scalar(fx);
-            let raw_shift_bits = z.load_scalar(fx);
-
-            let ty = fx.bcx.func.dfg.value_type(lhs_bits);
-            let zero = fx.bcx.ins().iconst(ty, 0);
-
-            let shift_bits = fx.bcx.ins().band_imm(raw_shift_bits, width_bits - 1);
-            let inv_shift_bits = fx.bcx.ins().irsub_imm(shift_bits, width_bits);
-            let is_zero = fx.bcx.ins().icmp_imm(IntCC::Equal, shift_bits, 0);
-
-            // rhs_bits >> shift_bits
-            let shr = fx.bcx.ins().ushr(rhs_bits, shift_bits);
-
-            // lhs_bits.unbounded_shl(inv_shift_bits)
-            // we don't need a modulo here because `ishl` implicitly does it
-            let shl = fx.bcx.ins().ishl(lhs_bits, inv_shift_bits);
-            let shl = fx.bcx.ins().select(is_zero, zero, shl);
-
-            let res = fx.bcx.ins().bor(shr, shl);
-            ret.write_cvalue(fx, CValue::by_val(res, layout));
-        }
 
         // The only difference between offset and arith_offset is regarding UB. Because Cranelift
         // doesn't have UB both are codegen'ed the same way

compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

@@ -442,8 +442,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
             | sym::bitreverse
             | sym::rotate_left
             | sym::rotate_right
-            | sym::funnel_shl
-            | sym::funnel_shr
             | sym::saturating_add
             | sym::saturating_sub => {
                 match int_type_width_signed(args[0].layout.ty, self) {
@@ -507,53 +505,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                                 self.rotate_right(val, raw_shift, width)
                             }
                         }
-                        sym::funnel_shl => {
-                            let lhs_bits = args[0].immediate();
-                            let rhs_bits = args[1].immediate();
-                            let raw_shift_bits = args[2].immediate();
-
-                            let width_ty = raw_shift_bits.get_type();
-                            let width_bits = self.cx.gcc_uint(width_ty, width as u64);
-                            let shift_bits = self.gcc_urem(raw_shift_bits, width_bits);
-
-                            // lhs_bits << shift_bits
-                            let shl = self.gcc_shl(lhs_bits, shift_bits);
-
-                            // rhs_bits.bounded_shr(inv_shift_bits)
-                            let inv_shift_bits = self.gcc_sub(width_bits, shift_bits);
-                            let inv_shift_bits_mod = self.gcc_urem(inv_shift_bits, width_bits);
-                            let shr = self.gcc_lshr(rhs_bits, inv_shift_bits_mod);
-                            let zero = self.cx.gcc_uint(lhs_bits.get_type(), 0);
-                            let is_zero =
-                                self.gcc_icmp(IntPredicate::IntEQ, inv_shift_bits_mod, zero);
-                            let shr = self.select(is_zero, zero, shr);
-
-                            self.or(shl, shr)
-                        }
-                        sym::funnel_shr => {
-                            let lhs_bits = args[0].immediate();
-                            let rhs_bits = args[1].immediate();
-                            let raw_shift_bits = args[2].immediate();
-
-                            let width_ty = raw_shift_bits.get_type();
-                            let width_bits = self.cx.gcc_uint(width_ty, width as u64);
-                            let shift_bits = self.gcc_urem(raw_shift_bits, width_bits);
-
-                            // rhs_bits >> shift_bits
-                            let shr = self.gcc_lshr(rhs_bits, shift_bits);
-
-                            let inv_shift_bits = self.gcc_sub(width_bits, shift_bits);
-
-                            // lhs_bits.bounded_shl(inv_shift_bits)
-                            let inv_shift_bits_mod = self.gcc_urem(inv_shift_bits, width_bits);
-                            let shl = self.gcc_shl(lhs_bits, inv_shift_bits_mod);
-                            let zero = self.cx.gcc_uint(lhs_bits.get_type(), 0);
-                            let is_zero =
-                                self.gcc_icmp(IntPredicate::IntEQ, inv_shift_bits_mod, zero);
-                            let shl = self.select(is_zero, zero, shl);
-
-                            self.or(shl, shr)
-                        }
                         sym::saturating_add => self.saturating_add(
                             args[0].immediate(),
                             args[1].immediate(),

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -302,33 +302,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let result = Scalar::from_uint(truncated_bits, layout_val.size);
                 self.write_scalar(result, dest)?;
             }
-            sym::funnel_shl | sym::funnel_shr => {
-                // funnel_shl: (A << (S % BW)) | (B >> ((BW - S) % BW))
-                // funnel_shr: (A << ((BW - S) % BW)) | (B >> (S % BW))
-                let layout_val = self.layout_of(instance_args.type_at(0))?;
-
-                let lhs = self.read_scalar(&args[0])?;
-                let lhs_bits = lhs.to_bits(layout_val.size)?; // sign is ignored here
-
-                let rhs = self.read_scalar(&args[1])?;
-                let rhs_bits = rhs.to_bits(layout_val.size)?; // sign is ignored here
-
-                let raw_shift = self.read_scalar(&args[2])?;
-                let raw_shift_bits = raw_shift.to_u32()?;
-
-                // The funnel shifts modulo by T::BITS to circumvent panics/UB.
-                let width_bits = u32::try_from(layout_val.size.bits()).unwrap();
-                let shift_bits = raw_shift_bits % width_bits;
-                let inv_shift_bits = width_bits - shift_bits;
-                let result_bits = if intrinsic_name == sym::funnel_shl {
-                    (lhs_bits << shift_bits) | rhs_bits.unbounded_shr(inv_shift_bits)
-                } else {
-                    (rhs_bits >> shift_bits) | lhs_bits.unbounded_shl(inv_shift_bits)
-                };
-                let truncated_bits = layout_val.size.truncate(result_bits);
-                let result = Scalar::from_uint(truncated_bits, layout_val.size);
-                self.write_scalar(result, dest)?;
-            }
             sym::copy => {
                 self.copy_intrinsic(&args[0], &args[1], &args[2], /*nonoverlapping*/ false)?;
             }

library/core/src/intrinsics/mod.rs

@@ -56,6 +56,7 @@
 
 use crate::ffi::va_list::{VaArgSafe, VaListImpl};
 use crate::marker::{ConstParamTy, DiscriminantKind, PointeeSized, Tuple};
+use crate::ops::BitOr;
 use crate::ptr;
 
 mod bounds;
@@ -2105,7 +2106,7 @@ pub const fn saturating_sub<T: Copy>(a: T, b: T) -> T;
 /// Funnel Shift left.
 ///
 /// Concatenates `a` and `b` (with `a` in the most significant half),
-/// creating an integer twice as wide. Then shift this inetegr left
+/// creating an integer twice as wide. Then shift this integer left
 /// by `shift` (taken modulo the bit size of `T`), and extract the
 /// most significant half. If `a` and `b` are the same, this is equivalent
 /// to a rotate left operation.
@@ -2121,7 +2122,22 @@ pub const fn saturating_sub<T: Copy>(a: T, b: T) -> T;
 #[rustc_nounwind]
 #[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
 #[unstable(feature = "funnel_shifts", issue = "145686")]
-pub const fn funnel_shl<T: Copy>(a: T, b: T, shift: u32) -> T;
+#[miri::intrinsic_fallback_is_spec]
+pub const fn funnel_shl<T: Copy + BitOr<Output = T>>(a: T, b: T, shift: u32) -> T {
+    let width = 8 * size_of::<T>();
+    let shift = shift & width as u32;
+
+    // SAFETY: `shift` is less than `width`
+    let shl = unsafe { unchecked_shl(a, shift) };
+    let shr = if shift == 0 {
+        0
+    } else {
+        // SAFETY: `(width - shift)` is less than `width`, because `shift > 0`
+        unsafe { unchecked_shr(b, width - shift) }
+    };
+
+    shl | shr
+}
 
 /// Funnel Shift right.
 ///
@@ -2142,7 +2158,22 @@ pub const fn funnel_shl<T: Copy>(a: T, b: T, shift: u32) -> T;
 #[rustc_nounwind]
 #[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
 #[unstable(feature = "funnel_shifts", issue = "145686")]
-pub const fn funnel_shr<T: Copy>(a: T, b: T, shift: u32) -> T;
+#[miri::intrinsic_fallback_is_spec]
+pub const fn funnel_shr<T: Copy + BitOr<Output = T>>(a: T, b: T, shift: u32) -> T {
+    let width = 8 * size_of::<T>();
+    let shift = shift & width;
+
+    // SAFETY: `shift` is less than `width`
+    let shr = unsafe { unchecked_shr(b, shift) };
+    let shl = if shift == 0 {
+        0
+    } else {
+        // SAFETY: `(width - shift)` is less than `width`, because `shift > 0`
+        unsafe { unchecked_shl(a, width - shift) }
+    };
+
+    shr | shl
+}
 
 /// This is an implementation detail of [`crate::ptr::read`] and should
 /// not be used anywhere else.  See its comments for why this exists.