Add f16-f128 support for SIMD intrinsics

 - refactor float rounding intrinsics a bit

Author: sayantn

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -1010,6 +1010,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(())
     }
 
+    fn float_round<F>(
+        &mut self,
+        x: Scalar<M::Provenance>,
+        mode: rustc_apfloat::Round,
+    ) -> InterpResult<'tcx, F>
+    where
+        F: rustc_apfloat::Float + rustc_apfloat::FloatConvert<F>,
+    {
+        let x: F = x.to_float()?;
+        let res = x.round_to_integral(mode).value;
+        let res = self.adjust_nan(res, &[x]);
+        interp_ok(res)
+    }
+
     fn float_round_intrinsic<F>(
         &mut self,
         args: &[OpTy<'tcx, M::Provenance>],
@@ -1019,9 +1033,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     where
         F: rustc_apfloat::Float + rustc_apfloat::FloatConvert<F> + Into<Scalar<M::Provenance>>,
     {
-        let x: F = self.read_scalar(&args[0])?.to_float()?;
-        let res = x.round_to_integral(mode).value;
-        let res = self.adjust_nan(res, &[x]);
+        let res = self.float_round::<F>(self.read_scalar(&args[0])?, mode)?;
         self.write_scalar(res, dest)?;
         interp_ok(())
     }

compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs

@@ -119,10 +119,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                             let op = op.to_scalar();
                             // "Bitwise" operation, no NaN adjustments
                             match float_ty {
-                                FloatTy::F16 => unimplemented!("f16_f128"),
+                                FloatTy::F16 => Scalar::from_f16(op.to_f16()?.abs()),
                                 FloatTy::F32 => Scalar::from_f32(op.to_f32()?.abs()),
                                 FloatTy::F64 => Scalar::from_f64(op.to_f64()?.abs()),
-                                FloatTy::F128 => unimplemented!("f16_f128"),
+                                FloatTy::F128 => Scalar::from_f128(op.to_f128()?.abs()),
                             }
                         }
                         Op::Round(rounding) => {
@@ -133,21 +133,12 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                                     intrinsic_name
                                 )
                             };
+                            let op = op.to_scalar();
                             match float_ty {
-                                FloatTy::F16 => unimplemented!("f16_f128"),
-                                FloatTy::F32 => {
-                                    let f = op.to_scalar().to_f32()?;
-                                    let res = f.round_to_integral(rounding).value;
-                                    let res = self.adjust_nan(res, &[f]);
-                                    Scalar::from_f32(res)
-                                }
-                                FloatTy::F64 => {
-                                    let f = op.to_scalar().to_f64()?;
-                                    let res = f.round_to_integral(rounding).value;
-                                    let res = self.adjust_nan(res, &[f]);
-                                    Scalar::from_f64(res)
-                                }
-                                FloatTy::F128 => unimplemented!("f16_f128"),
+                                FloatTy::F16 => Scalar::from_f16(self.float_round(op, rounding)?),
+                                FloatTy::F32 => Scalar::from_f32(self.float_round(op, rounding)?),
+                                FloatTy::F64 => Scalar::from_f64(self.float_round(op, rounding)?),
+                                FloatTy::F128 => Scalar::from_f128(self.float_round(op, rounding)?),
                             }
                         }
                         Op::Numeric(name) => {
@@ -724,10 +715,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     };
 
                     let val = match float_ty {
-                        FloatTy::F16 => unimplemented!("f16_f128"),
+                        FloatTy::F16 => Scalar::from_f16(self.float_muladd(a, b, c, typ)?),
                         FloatTy::F32 => Scalar::from_f32(self.float_muladd(a, b, c, typ)?),
                         FloatTy::F64 => Scalar::from_f64(self.float_muladd(a, b, c, typ)?),
-                        FloatTy::F128 => unimplemented!("f16_f128"),
+                        FloatTy::F128 => Scalar::from_f128(self.float_muladd(a, b, c, typ)?),
                     };
                     self.write_scalar(val, &dest)?;
                 }