change implementation of rust intrinsics to use the new api

Author: sayantn

compiler/rustc_codegen_gcc/src/builder.rs

@@ -897,7 +897,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
     fn checked_binop(
         &mut self,
         oop: OverflowOp,
-        typ: Ty<'_>,
+        typ: Ty<'tcx>,
         lhs: Self::Value,
         rhs: Self::Value,
     ) -> (Self::Value, Self::Value) {

compiler/rustc_codegen_llvm/src/abi.rs

@@ -328,6 +328,54 @@ pub(crate) trait FnAbiLlvmExt<'ll, 'tcx> {
     fn apply_attrs_callsite(&self, bx: &mut Builder<'_, 'll, 'tcx>, callsite: &'ll Value);
 }
 
+fn equate_ty<'ll>(cx: &CodegenCx<'ll, '_>, rust_ty: &'ll Type, llvm_ty: &'ll Type) -> bool {
+    if rust_ty == llvm_ty {
+        return true;
+    }
+    match cx.type_kind(llvm_ty) {
+        TypeKind::X86_AMX => {
+            // we will insert casts from/to x86amx in callsite, so this is fine
+            if cx.type_kind(rust_ty) == TypeKind::Vector {
+                let element_count = cx.vector_length(rust_ty);
+                let element_ty = cx.element_type(rust_ty);
+                let element_size_bits = match cx.type_kind(element_ty) {
+                    TypeKind::Half => 16,
+                    TypeKind::Float => 32,
+                    TypeKind::Double => 64,
+                    TypeKind::FP128 => 128,
+                    TypeKind::Integer => cx.int_width(element_ty),
+                    TypeKind::Pointer => cx.int_width(cx.isize_ty),
+                    _ => bug!(
+                        "Vector element type `{element_ty:?}` not one of integer, float or pointer"
+                    ),
+                };
+                element_size_bits * element_count as u64 == 8192
+            } else {
+                false
+            }
+        }
+        TypeKind::BFloat => rust_ty == cx.type_i16(),
+        TypeKind::Vector => {
+            let element_count = cx.vector_length(llvm_ty);
+            let element_ty = cx.element_type(llvm_ty);
+
+            if element_ty == cx.type_bf16() {
+                rust_ty == cx.type_vector(cx.type_i16(), element_count as u64)
+            } else {
+                false
+            }
+        }
+        _ => false,
+    }
+}
+
+macro_rules! error_exit {
+    ($($t:tt)*) => {
+        eprintln!($($t)*);
+        ::std::process::exit(101)
+    };
+}
+
 impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
     fn llvm_return_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
         match &self.ret.mode {
@@ -405,78 +453,58 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
         let actual_return_ty = self.llvm_return_type(cx);
         let actual_argument_tys = self.llvm_argument_types(cx);
 
-        if name.starts_with(b"llvm.")
-            && let Some((intrinsic, type_params)) = cx.parse_intrinsic_name(name)
-        {
-            let fn_ty = cx.intrinsic_type(intrinsic, &type_params);
+        let is_llvm_intrinsic = name.starts_with(b"llvm.");
 
+        if is_llvm_intrinsic && let Some((fn_ty, _)) = cx.get_intrinsic_from_name(name) {
             let expected_return_ty = cx.get_return_type(fn_ty);
             let expected_argument_tys = cx.func_params_types(fn_ty);
 
-            let equate_ty = |rust_ty, llvm_ty| {
-                if rust_ty == llvm_ty {
-                    return true;
-                }
-                match cx.type_kind(llvm_ty) {
-                    TypeKind::X86_AMX => {
-                        // we will insert casts from/to x86amx in callsite, so this is fine
-                        if cx.type_kind(rust_ty) == TypeKind::Vector {
-                            let element_count = cx.vector_length(rust_ty);
-                            let element_ty = cx.element_type(rust_ty);
-                            let element_size_bits = match cx.type_kind(element_ty) {
-                                TypeKind::Half => 16,
-                                TypeKind::Float => 32,
-                                TypeKind::Double => 64,
-                                TypeKind::FP128 => 128,
-                                TypeKind::Integer => cx.int_width(element_ty),
-                                TypeKind::Pointer => cx.int_width(cx.isize_ty),
-                                _ => bug!(
-                                    "Vector element type `{element_ty:?}` not one of integer, float or pointer"
-                                ),
-                            };
-                            element_size_bits * element_count as u64 == 8192
-                        } else {
-                            false
-                        }
-                    }
-                    TypeKind::BFloat => rust_ty == cx.type_i16(),
-                    TypeKind::Vector => {
-                        let element_count = cx.vector_length(llvm_ty);
-                        let element_ty = cx.element_type(llvm_ty);
-
-                        if element_ty == cx.type_bf16() {
-                            rust_ty == cx.type_vector(cx.type_i16(), element_count as u64)
-                        } else {
-                            false
-                        }
-                    }
-                    _ => false,
-                }
-            };
-
             if actual_argument_tys.len() != expected_argument_tys.len() {
-                todo!("A very friendly error msg")
+                error_exit!(
+                    "Intrinsic signature mismatch: expected {} arguments for `{}`, found {} arguments",
+                    expected_argument_tys.len(),
+                    str::from_utf8(name).unwrap(),
+                    actual_argument_tys.len(),
+                );
             }
 
-            if !equate_ty(actual_return_ty, expected_return_ty) {
-                todo!("A very friendly error msg")
+            if !equate_ty(cx, actual_return_ty, expected_return_ty) {
+                error_exit!(
+                    "Intrinsic signature mismatch: expected {expected_return_ty:?} as return type for `{}`, found {actual_return_ty:?}",
+                    str::from_utf8(name).unwrap()
+                );
             }
-            for (actual_argument_ty, expected_argument_ty) in
-                zip(actual_argument_tys, expected_argument_tys)
+            for (idx, (actual_argument_ty, expected_argument_ty)) in
+                zip(actual_argument_tys, expected_argument_tys).enumerate()
             {
-                if !equate_ty(actual_argument_ty, expected_argument_ty) {
-                    todo!("A very friendly error msg")
+                if !equate_ty(cx, actual_argument_ty, expected_argument_ty) {
+                    error_exit!(
+                        "Intrinsic signature mismatch: expected {expected_argument_ty:?} as argument {idx} for `{}`, found {actual_argument_ty:?}",
+                        str::from_utf8(name).unwrap()
+                    );
                 }
             }
 
-            fn_ty
+            // todo: check validity of the intrinsic via `getIntrinsicSignature`
+            return fn_ty;
+        }
+
+        let llfn = if self.c_variadic {
+            cx.type_variadic_func(&actual_argument_tys, actual_return_ty)
         } else {
-            if self.c_variadic {
-                cx.type_variadic_func(&actual_argument_tys, actual_return_ty)
-            } else {
-                cx.type_func(&actual_argument_tys, actual_return_ty)
-            }
+            cx.type_func(&actual_argument_tys, actual_return_ty)
+        };
+
+        if is_llvm_intrinsic {
+            // either the intrinsic is invalid or it needs to be upgraded
+            tracing::error!(
+                "Using invalid or upgradeable intrinsic `{}`",
+                str::from_utf8(name).unwrap()
+            );
+            // todo: check if it's upgradeable, otherwise error
         }
+
+        llfn
     }
 
     fn ptr_to_llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {