Use core::intrinsics::powi{f32,f64} for powi instead of num-traits

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -3389,8 +3389,6 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
         let libm_intrinsic =
             instance_def_id.and_then(|def_id| self.libm_intrinsics.borrow().get(&def_id).copied());
-        let num_traits_intrinsics = instance_def_id
-            .and_then(|def_id| self.num_traits_intrinsics.borrow().get(&def_id).copied());
         let buffer_load_intrinsic = instance_def_id
             .is_some_and(|def_id| self.buffer_load_intrinsics.borrow().contains(&def_id));
         let buffer_store_intrinsic = instance_def_id
@@ -3400,7 +3398,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         let from_trait_impl =
             instance_def_id.and_then(|def_id| self.from_trait_impls.borrow().get(&def_id).copied());
 
-        if let Some(libm_intrinsic) = libm_intrinsic.or(num_traits_intrinsics) {
+        if let Some(libm_intrinsic) = libm_intrinsic {
             let result = self.call_libm_intrinsic(libm_intrinsic, result_type, args);
             if result_type != result.ty {
                 bug!(

crates/rustc_codegen_spirv/src/builder/libm_intrinsics.rs

@@ -30,7 +30,6 @@ pub enum LibmCustomIntrinsic {
     Tgamma,
     Log1p,
     NextAfter,
-    Powi,
     Remainder,
     RemQuo,
     Scalbn,
@@ -199,9 +198,6 @@ pub const LIBM_TABLE: &[(&str, LibmIntrinsic)] = &[
     ("truncf", LibmIntrinsic::GLOp(GLOp::Trunc)),
 ];
 
-pub const NUM_TRAITS_TABLE: &[(&str, LibmIntrinsic)] =
-    &[("powi", LibmIntrinsic::Custom(LibmCustomIntrinsic::Powi))];
-
 impl Builder<'_, '_> {
     pub fn call_libm_intrinsic(
         &mut self,
@@ -310,12 +306,6 @@ impl Builder<'_, '_> {
             LibmIntrinsic::Custom(LibmCustomIntrinsic::NextAfter) => {
                 self.undef_zombie(result_type, "NextAfter not supported yet")
             }
-            LibmIntrinsic::Custom(LibmCustomIntrinsic::Powi) => {
-                assert_eq!(args.len(), 2);
-                // Convert integer exponent to float, then use GLOp::Pow
-                let float_exp = self.sitofp(args[1], args[0].ty);
-                self.gl_op(GLOp::Pow, result_type, [args[0], float_exp])
-            }
             LibmIntrinsic::Custom(LibmCustomIntrinsic::Remainder) => {
                 self.undef_zombie(result_type, "Remainder not supported yet")
             }

crates/rustc_codegen_spirv/src/codegen_cx/declare.rs

@@ -181,16 +181,6 @@ impl<'tcx> CodegenCx<'tcx> {
             }
         }
 
-        // Check for usage of `num_traits` intrinsics (like Float::powi) that we can optimize
-        if self.tcx.crate_name(def_id.krate) == self.sym.num_traits && !def_id.is_local() {
-            let item_name = self.tcx.item_name(def_id);
-            if let Some(&intrinsic) = self.sym.num_traits_intrinsics.get(&item_name) {
-                self.num_traits_intrinsics
-                    .borrow_mut()
-                    .insert(def_id, intrinsic);
-            }
-        }
-
         // Check if this is a From trait implementation
         if let Some(impl_def_id) = self.tcx.impl_of_assoc(def_id)
             && let Some(trait_ref) = self.tcx.impl_opt_trait_ref(impl_def_id)

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -89,8 +89,6 @@ pub struct CodegenCx<'tcx> {
     // FIXME(eddyb) should the maps exist at all, now that the `DefId` is known
     // at `call` time, and presumably its high-level details can be looked up?
     pub libm_intrinsics: RefCell<FxHashMap<DefId, super::builder::libm_intrinsics::LibmIntrinsic>>,
-    pub num_traits_intrinsics:
-        RefCell<FxHashMap<DefId, super::builder::libm_intrinsics::LibmIntrinsic>>,
 
     /// All `panic!(...)`s and builtin panics (from MIR `Assert`s) call into one
     /// of these lang items, which we always replace with an "abort".
@@ -239,7 +237,6 @@ impl<'tcx> CodegenCx<'tcx> {
             sym,
             instruction_table: InstructionTable::new(),
             libm_intrinsics: Default::default(),
-            num_traits_intrinsics: Default::default(),
             panic_entry_points: Default::default(),
             fmt_args_new_fn_ids: Default::default(),
             fmt_rt_arg_new_fn_ids_to_ty_and_spec: Default::default(),

crates/rustc_codegen_spirv/src/symbols.rs

@@ -18,7 +18,6 @@ pub struct Symbols {
     pub vector: Symbol,
     pub v1: Symbol,
     pub libm: Symbol,
-    pub num_traits: Symbol,
     pub entry_point_name: Symbol,
     pub spv_khr_vulkan_memory_model: Symbol,
 
@@ -34,7 +33,6 @@ pub struct Symbols {
     pub attributes: FxHashMap<Symbol, SpirvAttribute>,
     pub execution_modes: FxHashMap<Symbol, (ExecutionMode, ExecutionModeExtraDim)>,
     pub libm_intrinsics: FxHashMap<Symbol, libm_intrinsics::LibmIntrinsic>,
-    pub num_traits_intrinsics: FxHashMap<Symbol, libm_intrinsics::LibmIntrinsic>,
 }
 
 const BUILTINS: &[(&str, BuiltIn)] = {
@@ -416,20 +414,13 @@ impl Symbols {
             assert!(old.is_none());
         }
 
-        let mut num_traits_intrinsics = FxHashMap::default();
-        for &(a, b) in libm_intrinsics::NUM_TRAITS_TABLE {
-            let old = num_traits_intrinsics.insert(Symbol::intern(a), b);
-            assert!(old.is_none());
-        }
-
         Self {
             discriminant: Symbol::intern("discriminant"),
             rust_gpu: Symbol::intern("rust_gpu"),
             spirv_attr_with_version: Symbol::intern(&spirv_attr_with_version()),
             vector: Symbol::intern("vector"),
             v1: Symbol::intern("v1"),
             libm: Symbol::intern("libm"),
-            num_traits: Symbol::intern("num_traits"),
             entry_point_name: Symbol::intern("entry_point_name"),
             spv_khr_vulkan_memory_model: Symbol::intern("SPV_KHR_vulkan_memory_model"),
 
@@ -445,7 +436,6 @@ impl Symbols {
             attributes,
             execution_modes,
             libm_intrinsics,
-            num_traits_intrinsics,
         }
     }
 

crates/spirv-std/src/float.rs

@@ -3,6 +3,28 @@
 use crate::glam::{Vec2, Vec4};
 #[cfg(target_arch = "spirv")]
 use core::arch::asm;
+#[cfg(target_arch = "spirv")]
+use core::intrinsics;
+
+#[cfg(target_arch = "spirv")]
+impl f32 {
+    /// Raises a number to an integer power.
+    #[inline]
+    #[rustc_allow_incoherent_impl]
+    pub fn powi(self, n: i32) -> f32 {
+        intrinsics::powif32(self, n)
+    }
+}
+
+#[cfg(target_arch = "spirv")]
+impl f64 {
+    /// Raises a number to an integer power.
+    #[inline]
+    #[rustc_allow_incoherent_impl]
+    pub fn powi(self, n: i32) -> f64 {
+        intrinsics::powif64(self, n)
+    }
+}
 
 /// Converts two f32 values (floats) into two f16 values (halfs). The result is a u32, with the low
 /// 16 bits being the first f16, and the high 16 bits being the second f16.

crates/spirv-std/src/lib.rs

@@ -2,7 +2,7 @@
 #![cfg_attr(
     target_arch = "spirv",
     allow(internal_features),
-    feature(asm_experimental_arch, lang_items)
+    feature(asm_experimental_arch, core_intrinsics, lang_items, rustc_attrs)
 )]
 // FIXME(eddyb) update/review these lints.
 //

tests/compiletests/ui/dis/powi.rs

@@ -4,7 +4,6 @@
 // build-pass
 // compile-flags: -C llvm-args=--disassemble-entry=main
 
-use spirv_std::num_traits::Float;
 use spirv_std::spirv;
 
 #[spirv(fragment)]

tests/compiletests/ui/dis/powi.stderr

@@ -1,12 +1,12 @@
           %1 = OpFunction %2 None %3
           %4 = OpLabel
-               OpLine %5 11 12
+               OpLine %5 10 12
           %6 = OpLoad %7 %8
-               OpLine %5 12 20
-          %9 = OpConvertSToF %7 %10
-         %11 = OpExtInst %7 %12 26 %6 %9
-               OpLine %5 12 4
-               OpStore %13 %11
+               OpLine %9 15 8
+         %10 = OpConvertSToF %7 %11
+         %12 = OpExtInst %7 %13 26 %6 %10
+               OpLine %5 11 4
+               OpStore %14 %12
                OpNoLine
                OpReturn
                OpFunctionEnd