Add LLVM and Miri backend support for funnel_sh{l,r}

Author: sayantn

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -383,7 +383,9 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             | sym::rotate_left
             | sym::rotate_right
             | sym::saturating_add
-            | sym::saturating_sub => {
+            | sym::saturating_sub
+            | sym::funnel_shl
+            | sym::funnel_shr => {
                 let ty = args[0].layout.ty;
                 if !ty.is_integral() {
                     tcx.dcx().emit_err(InvalidMonomorphization::BasicIntegerType {
@@ -437,6 +439,19 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
 
                         self.call_intrinsic(llvm_name, &[llty], &[val, val, raw_shift])
                     }
+                    sym::funnel_shl | sym::funnel_shr => {
+                        let is_left = name == sym::funnel_shl;
+                        let lhs = args[0].immediate();
+                        let rhs = args[1].immediate();
+                        let raw_shift = args[2].immediate();
+                        let llvm_name = format!("llvm.fsh{}", if is_left { 'l' } else { 'r' });
+
+                        // llvm expects shift to be the same type as the values, but rust
+                        // always uses `u32`.
+                        let raw_shift = self.intcast(raw_shift, self.val_ty(lhs), false);
+
+                        self.call_intrinsic(llvm_name, &[llty], &[lhs, rhs, raw_shift])
+                    }
                     sym::saturating_add | sym::saturating_sub => {
                         let is_add = name == sym::saturating_add;
                         let lhs = args[0].immediate();

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -302,6 +302,37 @@ 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 layout_raw_shift = self.layout_of(self.tcx.types.u32)?;
+                let raw_shift = self.read_scalar(&args[2])?;
+                let raw_shift_bits = raw_shift.to_bits(layout_raw_shift.size)?;
+
+                let width_bits = u128::from(layout_val.size.bits());
+                let shift_bits = raw_shift_bits % width_bits;
+                let inv_shift_bits = (width_bits - shift_bits) % width_bits;
+                let result_bits = if shift_bits == 0 {
+                    if intrinsic_name == sym::funnel_shl { lhs_bits } else { rhs_bits }
+                } else {
+                    if intrinsic_name == sym::rotate_left {
+                        (lhs_bits << shift_bits) | (rhs_bits >> inv_shift_bits)
+                    } else {
+                        (rhs_bits >> shift_bits) | (lhs_bits << 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)?;
             }

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -449,6 +449,9 @@ pub(crate) fn check_intrinsic_type(
         }
         sym::unchecked_shl | sym::unchecked_shr => (2, 0, vec![param(0), param(1)], param(0)),
         sym::rotate_left | sym::rotate_right => (1, 0, vec![param(0), tcx.types.u32], param(0)),
+        sym::funnel_shl | sym::funnel_shr => {
+            (1, 0, vec![param(0), param(0), tcx.types.u32], param(0))
+        }
         sym::unchecked_add | sym::unchecked_sub | sym::unchecked_mul => {
             (1, 0, vec![param(0), param(0)], param(0))
         }

compiler/rustc_span/src/symbol.rs

@@ -1096,6 +1096,8 @@ symbols! {
         fsub_fast,
         full,
         fundamental,
+        funnel_shl,
+        funnel_shr,
         fused_iterator,
         future,
         future_drop_poll,