Support fma

Author: cijiugechu

src/intrinsic/llvm.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use gccjit::{CType, Context, Field, Function, FunctionPtrType, RValue, ToRValue, Type};
+use gccjit::{Context, Field, Function, FunctionPtrType, RValue, ToRValue, Type};
 use rustc_codegen_ssa::traits::BuilderMethods;
 
 use crate::builder::Builder;
@@ -806,13 +806,6 @@ pub fn adjust_intrinsic_arguments<'a, 'b, 'gcc, 'tcx>(
                 ]
                 .into();
             }
-            "fma" => {
-                let mut new_args = args.to_vec();
-                new_args[0] = builder.context.new_cast(None, new_args[0], builder.double_type);
-                new_args[1] = builder.context.new_cast(None, new_args[1], builder.double_type);
-                new_args[2] = builder.context.new_cast(None, new_args[2], builder.double_type);
-                args = new_args.into();
-            }
             "__builtin_ia32_sqrtsh_mask_round"
             | "__builtin_ia32_vcvtss2sh_mask_round"
             | "__builtin_ia32_vcvtsd2sh_mask_round"
@@ -933,10 +926,6 @@ pub fn adjust_intrinsic_return_value<'a, 'gcc, 'tcx>(
                 &[first_mask, second_mask],
             );
         }
-        "fma" => {
-            let f16_type = builder.context.new_c_type(CType::Float16);
-            return_value = builder.context.new_cast(None, return_value, f16_type);
-        }
         "__builtin_ia32_encodekey128_u32" => {
             // The builtin __builtin_ia32_encodekey128_u32 writes the result in its pointer argument while
             // llvm.x86.encodekey128 returns a value.

src/intrinsic/mod.rs

@@ -150,10 +150,7 @@ fn generic_f16_builtin<'gcc, 'tcx>(
         _ => unreachable!(),
     };
 
-    let func = cx.context.get_builtin_function(builtin_name);
-    let args: Vec<_> = args.iter().map(|arg| f16_to_f32(cx, arg.immediate())).collect();
-    let result = cx.context.new_call(None, func, &args);
-    float_to_f16(cx, result, cx.f16_abi_type)
+    call_f32_builtin_for_f16(cx, builtin_name, args)
 }
 
 fn f16_builtin<'gcc, 'tcx>(
@@ -179,6 +176,14 @@ fn f16_builtin<'gcc, 'tcx>(
         _ => unreachable!(),
     };
 
+    call_f32_builtin_for_f16(cx, builtin_name, args)
+}
+
+fn call_f32_builtin_for_f16<'gcc, 'tcx>(
+    cx: &CodegenCx<'gcc, 'tcx>,
+    builtin_name: &str,
+    args: &[OperandRef<'tcx, RValue<'gcc>>],
+) -> RValue<'gcc> {
     let func = cx.context.get_builtin_function(builtin_name);
     let args: Vec<_> = args.iter().map(|arg| f16_to_f32(cx, arg.immediate())).collect();
     let result = cx.context.new_call(None, func, &args);
@@ -617,24 +622,20 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
         args: &[OperandRef<'tcx, Self::Value>],
         is_cleanup: bool,
     ) -> Self::Value {
+        let sym = self.tcx.symbol_name(instance).name;
+        if sym == "llvm.fma.f16" {
+            return call_f32_builtin_for_f16(self.cx, "fmaf", args);
+        }
+
         let func = if let Some(&func) = self.intrinsic_instances.borrow().get(&instance) {
             func
         } else {
-            let sym = self.tcx.symbol_name(instance).name;
-
             let func = if let Some(func) = self.intrinsics.borrow().get(sym) {
                 *func
             } else {
                 self.linkage.set(FunctionType::Extern);
 
-                let func = match sym {
-                    "llvm.fma.f16" => {
-                        // fma is not a target builtin, but a normal builtin, so we handle it differently
-                        // here.
-                        self.context.get_builtin_function("fma")
-                    }
-                    _ => llvm::intrinsic(sym, self),
-                };
+                let func = llvm::intrinsic(sym, self);
 
                 self.intrinsics.borrow_mut().insert(sym.to_string(), func);
 

tests/run/f16.rs

@@ -3,13 +3,18 @@
 // Run-time:
 //   status: 0
 
-#![feature(core_intrinsics, f16, float_algebraic)]
+#![feature(core_intrinsics, f16, float_algebraic, link_llvm_intrinsics)]
 #![allow(internal_features)]
 
 use std::cmp::Ordering;
 use std::hint::black_box;
 use std::intrinsics::{fmaf16, powif16};
 
+unsafe extern "C" {
+    #[link_name = "llvm.fma.f16"]
+    fn llvm_fma_f16(a: f16, b: f16, c: f16) -> f16;
+}
+
 fn assert_f16_bits(value: f16, bits: u16) {
     assert_eq!(value.to_bits(), bits);
 }
@@ -41,6 +46,7 @@ fn main() {
     assert_f16_bits(two / one, 0x4000);
     assert_f16_bits(-three, 0xc200);
     assert_f16_bits(fmaf16(one, two, -three), 0xbc00);
+    assert_f16_bits(unsafe { llvm_fma_f16(one, two, -three) }, 0xbc00);
     assert_f16_bits(powif16(two, 3), 0x4800);
 
     assert_f16_bits(black_box(123.0f16).algebraic_add(black_box(456.0f16)), 0x6086);