Genericize sin and cos

Author: N1ark

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -355,14 +355,6 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::copysignf32 => ("copysignf", 2, fx.tcx.types.f32, types::F32),
         sym::copysignf64 => ("copysign", 2, fx.tcx.types.f64, types::F64),
         sym::copysignf128 => ("copysignf128", 2, fx.tcx.types.f128, types::F128),
-        sym::sinf16 => ("sinf16", 1, fx.tcx.types.f16, types::F16),
-        sym::sinf32 => ("sinf", 1, fx.tcx.types.f32, types::F32),
-        sym::sinf64 => ("sin", 1, fx.tcx.types.f64, types::F64),
-        sym::sinf128 => ("sinf128", 1, fx.tcx.types.f128, types::F128),
-        sym::cosf16 => ("cosf16", 1, fx.tcx.types.f16, types::F16),
-        sym::cosf32 => ("cosf", 1, fx.tcx.types.f32, types::F32),
-        sym::cosf64 => ("cos", 1, fx.tcx.types.f64, types::F64),
-        sym::cosf128 => ("cosf128", 1, fx.tcx.types.f128, types::F128),
         _ => return false,
     };
 
@@ -1117,6 +1109,8 @@ fn codegen_regular_intrinsic_call<'tcx>(
         // Float unop intrinsics
         sym::fabs
         | sym::sqrt
+        | sym::sin
+        | sym::cos
         | sym::floor
         | sym::ceil
         | sym::trunc
@@ -1144,6 +1138,14 @@ fn codegen_regular_intrinsic_call<'tcx>(
                 (sym::sqrt, F32 | F64) => Ok(fx.bcx.ins().sqrt(x)),
                 (sym::sqrt, F16) => Err("sqrtf16"),
                 (sym::sqrt, F128) => Err("sqrtf128"),
+                (sym::sin, F16) => Err("sinf16"),
+                (sym::sin, F32) => Err("sinf"),
+                (sym::sin, F64) => Err("sin"),
+                (sym::sin, F128) => Err("sinf128"),
+                (sym::cos, F16) => Err("cosf16"),
+                (sym::cos, F32) => Err("cosf"),
+                (sym::cos, F64) => Err("cos"),
+                (sym::cos, F128) => Err("cosf128"),
                 (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

@@ -47,10 +47,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
     let gcc_name = match name {
         sym::powif32 => "__builtin_powif",
         sym::powif64 => "__builtin_powi",
-        sym::sinf32 => "sinf",
-        sym::sinf64 => "sin",
-        sym::cosf32 => "cosf",
-        sym::cosf64 => "cos",
         sym::powf32 => "powf",
         sym::powf64 => "pow",
         sym::expf32 => "expf",
@@ -421,6 +417,8 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
             // float unary intrinsics
             sym::fabs
             | sym::sqrt
+            | sym::sin
+            | sym::cos
             | sym::floor
             | sym::ceil
             | sym::trunc
@@ -449,6 +447,10 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                     (sym::sqrt, F32) => Builtin("sqrtf"),
                     (sym::sqrt, F64) => Builtin("sqrt"),
                     (sym::sqrt, F128) => Extern("sqrtf128"),
+                    (sym::sin, F32) => Builtin("sinf"),
+                    (sym::sin, F64) => Builtin("sin"),
+                    (sym::cos, F32) => Builtin("cosf"),
+                    (sym::cos, F64) => Builtin("cos"),
                     (sym::floor, F16) => BuiltinF16Cast("__builtin_floorf"),
                     (sym::floor, F32) => Builtin("floorf"),
                     (sym::floor, F64) => Builtin("floor"),

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -53,16 +53,6 @@ fn call_simple_intrinsic<'ll, 'tcx>(
         sym::powif64 => ("llvm.powi", &[bx.type_f64(), bx.type_i32()]),
         sym::powif128 => ("llvm.powi", &[bx.type_f128(), bx.type_i32()]),
 
-        sym::sinf16 => ("llvm.sin", &[bx.type_f16()]),
-        sym::sinf32 => ("llvm.sin", &[bx.type_f32()]),
-        sym::sinf64 => ("llvm.sin", &[bx.type_f64()]),
-        sym::sinf128 => ("llvm.sin", &[bx.type_f128()]),
-
-        sym::cosf16 => ("llvm.cos", &[bx.type_f16()]),
-        sym::cosf32 => ("llvm.cos", &[bx.type_f32()]),
-        sym::cosf64 => ("llvm.cos", &[bx.type_f64()]),
-        sym::cosf128 => ("llvm.cos", &[bx.type_f128()]),
-
         sym::powf16 => ("llvm.pow", &[bx.type_f16()]),
         sym::powf32 => ("llvm.pow", &[bx.type_f32()]),
         sym::powf64 => ("llvm.pow", &[bx.type_f64()]),
@@ -466,6 +456,8 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
 
             sym::fabs
             | sym::sqrt
+            | sym::sin
+            | sym::cos
             | sym::floor
             | sym::ceil
             | sym::trunc
@@ -479,6 +471,8 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 let llvm_name = match name {
                     sym::fabs => "llvm.fabs",
                     sym::sqrt => "llvm.sqrt",
+                    sym::sin => "llvm.sin",
+                    sym::cos => "llvm.cos",
                     sym::floor => "llvm.floor",
                     sym::ceil => "llvm.ceil",
                     sym::trunc => "llvm.trunc",

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -92,10 +92,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::copysignf32
         | sym::copysignf64
         | sym::copysignf128
-        | sym::cosf16
-        | sym::cosf32
-        | sym::cosf64
-        | sym::cosf128
+        | sym::cos
         | sym::ctlz
         | sym::ctpop
         | sym::cttz
@@ -182,10 +179,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::saturating_add
         | sym::saturating_sub
         | sym::select_unpredictable
-        | sym::sinf16
-        | sym::sinf32
-        | sym::sinf64
-        | sym::sinf128
+        | sym::sin
         | sym::size_of
         | sym::sqrt
         | sym::sub_with_overflow
@@ -385,15 +379,7 @@ pub(crate) fn check_intrinsic_type(
         sym::powif64 => (0, 0, vec![tcx.types.f64, tcx.types.i32], tcx.types.f64),
         sym::powif128 => (0, 0, vec![tcx.types.f128, tcx.types.i32], tcx.types.f128),
 
-        sym::sinf16 => (0, 0, vec![tcx.types.f16], tcx.types.f16),
-        sym::sinf32 => (0, 0, vec![tcx.types.f32], tcx.types.f32),
-        sym::sinf64 => (0, 0, vec![tcx.types.f64], tcx.types.f64),
-        sym::sinf128 => (0, 0, vec![tcx.types.f128], tcx.types.f128),
-
-        sym::cosf16 => (0, 0, vec![tcx.types.f16], tcx.types.f16),
-        sym::cosf32 => (0, 0, vec![tcx.types.f32], tcx.types.f32),
-        sym::cosf64 => (0, 0, vec![tcx.types.f64], tcx.types.f64),
-        sym::cosf128 => (0, 0, vec![tcx.types.f128], tcx.types.f128),
+        sym::sin | sym::cos => (1, 0, vec![param(0)], param(0)),
 
         sym::powf16 => (0, 0, vec![tcx.types.f16, tcx.types.f16], tcx.types.f16),
         sym::powf32 => (0, 0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),

compiler/rustc_span/src/symbol.rs

@@ -712,10 +712,7 @@ symbols! {
         coroutine_state,
         coroutine_yield,
         coroutines,
-        cosf16,
-        cosf32,
-        cosf64,
-        cosf128,
+        cos,
         count,
         coverage,
         coverage_attribute,
@@ -1891,11 +1888,8 @@ symbols! {
         simd_trunc,
         simd_with_exposed_provenance,
         simd_xor,
+        sin,
         since,
-        sinf16,
-        sinf32,
-        sinf64,
-        sinf128,
         size,
         size_of,
         size_of_val,

library/core/src/intrinsics/mod.rs

@@ -1057,63 +1057,23 @@ pub fn powif64(a: f64, x: i32) -> f64;
 #[rustc_nounwind]
 pub fn powif128(a: f128, x: i32) -> f128;
 
-/// Returns the sine of an `f16`.
+/// Returns the sine of a floating point value.
 ///
-/// The stabilized version of this intrinsic is
-/// [`f16::sin`](../../std/primitive.f16.html#method.sin)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn sinf16(x: f16) -> f16;
-/// Returns the sine of an `f32`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f32::sin`](../../std/primitive.f32.html#method.sin)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn sinf32(x: f32) -> f32;
-/// Returns the sine of an `f64`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f64::sin`](../../std/primitive.f64.html#method.sin)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn sinf64(x: f64) -> f64;
-/// Returns the sine of an `f128`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f128::sin`](../../std/primitive.f128.html#method.sin)
+/// The stabilized versions of this intrinsic are available on the float
+/// primitives via the `sin` method.
+/// For example, [`f32::sin`](../../std/primitive.f32.html#method.sin).
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sinf128(x: f128) -> f128;
+pub fn sin<T: bounds::FloatPrimitive>(x: T) -> T;
 
-/// Returns the cosine of an `f16`.
+/// Returns the cosine of a floating point value.
 ///
-/// The stabilized version of this intrinsic is
-/// [`f16::cos`](../../std/primitive.f16.html#method.cos)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn cosf16(x: f16) -> f16;
-/// Returns the cosine of an `f32`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f32::cos`](../../std/primitive.f32.html#method.cos)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn cosf32(x: f32) -> f32;
-/// Returns the cosine of an `f64`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f64::cos`](../../std/primitive.f64.html#method.cos)
-#[rustc_intrinsic]
-#[rustc_nounwind]
-pub fn cosf64(x: f64) -> f64;
-/// Returns the cosine of an `f128`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f128::cos`](../../std/primitive.f128.html#method.cos)
+/// The stabilized versions of this intrinsic are available on the float
+/// primitives via the `cos` method.
+/// For example, [`f32::cos`](../../std/primitive.f32.html#method.cos).
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn cosf128(x: f128) -> f128;
+pub fn cos<T: bounds::FloatPrimitive>(x: T) -> T;
 
 /// Raises an `f16` to an `f16` power.
 ///

library/std/src/num/f128.rs

@@ -392,7 +392,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sin(self) -> f128 {
-        intrinsics::sinf128(self)
+        intrinsics::sin(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -421,7 +421,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn cos(self) -> f128 {
-        intrinsics::cosf128(self)
+        intrinsics::cos(self)
     }
 
     /// Computes the tangent of a number (in radians).

library/std/src/num/f16.rs

@@ -357,7 +357,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sin(self) -> f16 {
-        intrinsics::sinf16(self)
+        intrinsics::sin(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -386,7 +386,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn cos(self) -> f16 {
-        intrinsics::cosf16(self)
+        intrinsics::cos(self)
     }
 
     /// Computes the tangent of a number (in radians).

library/std/src/num/f32.rs

@@ -697,7 +697,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn sin(self) -> f32 {
-        intrinsics::sinf32(self)
+        intrinsics::sin(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -721,7 +721,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn cos(self) -> f32 {
-        intrinsics::cosf32(self)
+        intrinsics::cos(self)
     }
 
     /// Computes the tangent of a number (in radians).

library/std/src/num/f64.rs

@@ -697,7 +697,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn sin(self) -> f64 {
-        intrinsics::sinf64(self)
+        intrinsics::sin(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -721,7 +721,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn cos(self) -> f64 {
-        intrinsics::cosf64(self)
+        intrinsics::cos(self)
     }
 
     /// Computes the tangent of a number (in radians).