Genericize sqrt

Author: N1ark

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -322,10 +322,6 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::exp2f32 => ("exp2f", 1, fx.tcx.types.f32, types::F32),
         sym::exp2f64 => ("exp2", 1, fx.tcx.types.f64, types::F64),
         sym::exp2f128 => ("exp2f128", 1, fx.tcx.types.f128, types::F128),
-        sym::sqrtf16 => ("sqrtf16", 1, fx.tcx.types.f16, types::F16),
-        sym::sqrtf32 => ("sqrtf", 1, fx.tcx.types.f32, types::F32),
-        sym::sqrtf64 => ("sqrt", 1, fx.tcx.types.f64, types::F64),
-        sym::sqrtf128 => ("sqrtf128", 1, fx.tcx.types.f128, types::F128),
         sym::powif16 => ("__powisf2", 2, fx.tcx.types.f16, types::F16), // compiler-builtins
         sym::powif32 => ("__powisf2", 2, fx.tcx.types.f32, types::F32), // compiler-builtins
         sym::powif64 => ("__powidf2", 2, fx.tcx.types.f64, types::F64), // compiler-builtins
@@ -409,7 +405,6 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::copysignf16 => codegen_f16_f128::copysign_f16(fx, args[0], args[1]),
         sym::copysignf128 => codegen_f16_f128::copysign_f128(fx, args[0], args[1]),
         sym::copysignf32 | sym::copysignf64 => fx.bcx.ins().fcopysign(args[0], args[1]),
-        sym::sqrtf32 | sym::sqrtf64 => fx.bcx.ins().sqrt(args[0]),
 
         // These intrinsics aren't supported natively by Cranelift.
         // Lower them to a libcall.
@@ -1121,6 +1116,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
 
         // Float unop intrinsics
         sym::fabs
+        | sym::sqrt
         | sym::floor
         | sym::ceil
         | sym::trunc
@@ -1145,6 +1141,9 @@ fn codegen_regular_intrinsic_call<'tcx>(
                 // backend lowerings are implemented.
                 (sym::fabs, F16) => Ok(codegen_f16_f128::abs_f16(fx, x)),
                 (sym::fabs, F128) => Ok(codegen_f16_f128::abs_f128(fx, x)),
+                (sym::sqrt, F32 | F64) => Ok(fx.bcx.ins().sqrt(x)),
+                (sym::sqrt, F16) => Err("sqrtf16"),
+                (sym::sqrt, F128) => Err("sqrtf128"),
                 (sym::floor, F32 | F64) => Ok(fx.bcx.ins().floor(x)),
                 (sym::floor, F16) => Err("floorf16"),
                 (sym::floor, F128) => Err("floorf128"),

compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

@@ -45,8 +45,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
     name: Symbol,
 ) -> Option<Function<'gcc>> {
     let gcc_name = match name {
-        sym::sqrtf32 => "sqrtf",
-        sym::sqrtf64 => "sqrt",
         sym::powif32 => "__builtin_powif",
         sym::powif64 => "__builtin_powi",
         sym::sinf32 => "sinf",
@@ -180,26 +178,6 @@ fn get_simple_function<'gcc, 'tcx>(
     ))
 }
 
-fn get_simple_function_f128<'gcc, 'tcx>(
-    span: Span,
-    cx: &CodegenCx<'gcc, 'tcx>,
-    name: Symbol,
-) -> Function<'gcc> {
-    let f128_type = cx.type_f128();
-    let func_name = match name {
-        sym::sqrtf128 => "sqrtf128",
-        _ => span_bug!(span, "used get_simple_function_f128 for non-unary f128 intrinsic"),
-    };
-    cx.context.new_function(
-        None,
-        FunctionType::Extern,
-        f128_type,
-        &[cx.context.new_parameter(None, f128_type, "a")],
-        func_name,
-        false,
-    )
-}
-
 fn f16_builtin<'gcc, 'tcx>(
     cx: &CodegenCx<'gcc, 'tcx>,
     name: Symbol,
@@ -217,7 +195,6 @@ fn f16_builtin<'gcc, 'tcx>(
             let result = cx.context.new_call(None, func, &args);
             return cx.context.new_cast(None, result, cx.type_f16());
         }
-        sym::sqrtf16 => "__builtin_sqrtf",
         _ => unreachable!(),
     };
 
@@ -262,30 +239,8 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                     &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
                 )
             }
-            sym::ceilf16
-            | sym::copysignf16
-            | sym::floorf16
-            | sym::fmaf16
-            | sym::powf16
-            | sym::powif16
-            | sym::roundf16
-            | sym::round_ties_even_f16
-            | sym::sqrtf16
-            | sym::truncf16 => f16_builtin(self, name, args),
-            sym::ceilf128
-            | sym::floorf128
-            | sym::truncf128
-            | sym::roundf128
-            | sym::round_ties_even_f128
-            | sym::sqrtf128
-                if self.cx.supports_f128_type =>
-            {
-                let func = get_simple_function_f128(span, self, name);
-                self.cx.context.new_call(
-                    self.location,
-                    func,
-                    &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
-                )
+            sym::copysignf16 | sym::fmaf16 | sym::powf16 | sym::powif16 => {
+                f16_builtin(self, name, args)
             }
             sym::copysignf128 if self.cx.supports_f128_type => {
                 let f128_type = self.cx.type_f128();
@@ -465,6 +420,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
             }
             // float unary intrinsics
             sym::fabs
+            | sym::sqrt
             | sym::floor
             | sym::ceil
             | sym::trunc
@@ -489,6 +445,10 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                     (sym::fabs, F32) => Builtin("fabsf"),
                     (sym::fabs, F64) => Builtin("fabs"),
                     (sym::fabs, F128) => Extern("fabsf128"),
+                    (sym::sqrt, F16) => BuiltinF16Cast("__builtin_sqrtf"),
+                    (sym::sqrt, F32) => Builtin("sqrtf"),
+                    (sym::sqrt, F64) => Builtin("sqrt"),
+                    (sym::sqrt, F128) => Extern("sqrtf128"),
                     (sym::floor, F16) => BuiltinF16Cast("__builtin_floorf"),
                     (sym::floor, F32) => Builtin("floorf"),
                     (sym::floor, F64) => Builtin("floor"),

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -48,11 +48,6 @@ fn call_simple_intrinsic<'ll, 'tcx>(
     args: &[OperandRef<'tcx, &'ll Value>],
 ) -> Option<&'ll Value> {
     let (base_name, type_params): (&'static str, &[&'ll Type]) = match name {
-        sym::sqrtf16 => ("llvm.sqrt", &[bx.type_f16()]),
-        sym::sqrtf32 => ("llvm.sqrt", &[bx.type_f32()]),
-        sym::sqrtf64 => ("llvm.sqrt", &[bx.type_f64()]),
-        sym::sqrtf128 => ("llvm.sqrt", &[bx.type_f128()]),
-
         sym::powif16 => ("llvm.powi", &[bx.type_f16(), bx.type_i32()]),
         sym::powif32 => ("llvm.powi", &[bx.type_f32(), bx.type_i32()]),
         sym::powif64 => ("llvm.powi", &[bx.type_f64(), bx.type_i32()]),
@@ -470,6 +465,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             }
 
             sym::fabs
+            | sym::sqrt
             | sym::floor
             | sym::ceil
             | sym::trunc
@@ -482,6 +478,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 let llty = self.type_float_from_ty(*f);
                 let llvm_name = match name {
                     sym::fabs => "llvm.fabs",
+                    sym::sqrt => "llvm.sqrt",
                     sym::floor => "llvm.floor",
                     sym::ceil => "llvm.ceil",
                     sym::trunc => "llvm.trunc",

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -187,10 +187,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::sinf64
         | sym::sinf128
         | sym::size_of
-        | sym::sqrtf16
-        | sym::sqrtf32
-        | sym::sqrtf64
-        | sym::sqrtf128
+        | sym::sqrt
         | sym::sub_with_overflow
         | sym::three_way_compare
         | sym::trunc
@@ -381,10 +378,7 @@ pub(crate) fn check_intrinsic_type(
             tcx.types.unit,
         ),
 
-        sym::sqrtf16 => (0, 0, vec![tcx.types.f16], tcx.types.f16),
-        sym::sqrtf32 => (0, 0, vec![tcx.types.f32], tcx.types.f32),
-        sym::sqrtf64 => (0, 0, vec![tcx.types.f64], tcx.types.f64),
-        sym::sqrtf128 => (0, 0, vec![tcx.types.f128], tcx.types.f128),
+        sym::sqrt => (1, 0, vec![param(0)], param(0)),
 
         sym::powif16 => (0, 0, vec![tcx.types.f16, tcx.types.i32], tcx.types.f16),
         sym::powif32 => (0, 0, vec![tcx.types.f32, tcx.types.i32], tcx.types.f32),

compiler/rustc_span/src/symbol.rs

@@ -1917,10 +1917,7 @@ symbols! {
         speed,
         spirv,
         spotlight,
-        sqrtf16,
-        sqrtf32,
-        sqrtf64,
-        sqrtf128,
+        sqrt,
         sreg,
         sreg_low16,
         sse,

library/core/src/intrinsics/mod.rs

@@ -1019,34 +1019,13 @@ pub unsafe fn unaligned_volatile_load<T>(src: *const T) -> T;
 #[rustc_diagnostic_item = "intrinsics_unaligned_volatile_store"]
 pub unsafe fn unaligned_volatile_store<T>(dst: *mut T, val: T);
 
-/// Returns the square root of an `f16`
+/// Returns the square root of a floating point value.
 ///
-/// The stabilized version of this intrinsic is
-/// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn sqrtf16(x: f16) -> f16;
-/// Returns the square root of an `f32`
-///
-/// The stabilized version of this intrinsic is
-/// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn sqrtf32(x: f32) -> f32;
-/// Returns the square root of an `f64`
-///
-/// The stabilized version of this intrinsic is
-/// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn sqrtf64(x: f64) -> f64;
-/// Returns the square root of an `f128`
-///
-/// The stabilized version of this intrinsic is
-/// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)
+/// The stabilized versions of this intrinsic are available on the float
+/// primitives via the `sqrt` method. For example, [`f32::sqrt`].
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sqrtf128(x: f128) -> f128;
+pub fn sqrt<T: bounds::FloatPrimitive>(x: T) -> T;
 
 /// Raises an `f16` to an integer power.
 ///

library/core/src/num/f128.rs

@@ -1927,6 +1927,6 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(self) -> f128 {
-        intrinsics::sqrtf128(self)
+        intrinsics::sqrt(self)
     }
 }

library/core/src/num/f16.rs

@@ -1911,7 +1911,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(self) -> f16 {
-        intrinsics::sqrtf16(self)
+        intrinsics::sqrt(self)
     }
 
     /// Returns the cube root of a number.

library/core/src/num/f32.rs

@@ -2039,7 +2039,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(x: f32) -> f32 {
-        intrinsics::sqrtf32(x)
+        intrinsics::sqrt(x)
     }
 
     /// Experimental version of `abs_sub` in `core`. See [`f32::abs_sub`] for details.

library/core/src/num/f64.rs

@@ -2037,7 +2037,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(x: f64) -> f64 {
-        intrinsics::sqrtf64(x)
+        intrinsics::sqrt(x)
     }
 
     /// Experimental version of `abs_sub` in `core`. See [`f64::abs_sub`] for details.