Intercept calls to libm (EmbarkStudios#264)

* Intercept calls to libm

* Switch to using function names instead of symbols

* remove forgotten comment

Author: khyperia

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -12,6 +12,7 @@ use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{BuilderMethods, ConstMethods, LayoutTypeMethods, OverflowOp};
 use rustc_codegen_ssa::MemFlags;
+use rustc_middle::bug;
 use rustc_middle::ty::Ty;
 use rustc_span::Span;
 use rustc_target::abi::{Abi, Align, Scalar, Size};
@@ -1973,11 +1974,26 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         for (argument, argument_type) in args.iter().zip(argument_types) {
             assert_ty_eq!(self, argument.ty, argument_type);
         }
-        let args = args.iter().map(|arg| arg.def(self)).collect::<Vec<_>>();
-        self.emit()
-            .function_call(result_type, None, llfn.def(self), args)
-            .unwrap()
-            .with_type(result_type)
+        let llfn_def = llfn.def(self);
+        let libm_intrinsic = self.libm_intrinsics.borrow().get(&llfn_def).cloned();
+        if let Some(libm_intrinsic) = libm_intrinsic {
+            let result = self.call_libm_intrinsic(libm_intrinsic, result_type, args);
+            if result_type != result.ty {
+                bug!(
+                    "Mismatched libm result type for {:?}: expected {}, got {}",
+                    libm_intrinsic,
+                    self.debug_type(result_type),
+                    self.debug_type(result.ty),
+                );
+            }
+            result
+        } else {
+            let args = args.iter().map(|arg| arg.def(self)).collect::<Vec<_>>();
+            self.emit()
+                .function_call(result_type, None, llfn_def, args)
+                .unwrap()
+                .with_type(result_type)
+        }
     }
 
     fn zext(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value {

crates/rustc_codegen_spirv/src/builder/ext_inst.rs

@@ -53,33 +53,43 @@ impl ExtInst {
 }
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
-    pub fn gl_op(&mut self, op: GLOp, args: impl AsRef<[SpirvValue]>) -> SpirvValue {
+    pub fn gl_op(
+        &mut self,
+        op: GLOp,
+        result_type: Word,
+        args: impl AsRef<[SpirvValue]>,
+    ) -> SpirvValue {
         let args = args.as_ref();
         let glsl = self.ext_inst.borrow_mut().import_glsl(self);
         self.emit()
             .ext_inst(
-                args[0].ty,
+                result_type,
                 None,
                 glsl,
                 op as u32,
                 args.iter().map(|a| Operand::IdRef(a.def(self))),
             )
             .unwrap()
-            .with_type(args[0].ty)
+            .with_type(result_type)
     }
 
-    pub fn cl_op(&mut self, op: CLOp, args: impl AsRef<[SpirvValue]>) -> SpirvValue {
+    pub fn cl_op(
+        &mut self,
+        op: CLOp,
+        result_type: Word,
+        args: impl AsRef<[SpirvValue]>,
+    ) -> SpirvValue {
         let args = args.as_ref();
         let opencl = self.ext_inst.borrow_mut().import_opencl(self);
         self.emit()
             .ext_inst(
-                args[0].ty,
+                result_type,
                 None,
                 opencl,
                 op as u32,
                 args.iter().map(|a| Operand::IdRef(a.def(self))),
             )
             .unwrap()
-            .with_type(args[0].ty)
+            .with_type(result_type)
     }
 }