Fix test verification and allow for generic types in intrinsics

Author: dheaton-arm

crates/core_arch/src/aarch64/mte.rs

@@ -130,42 +130,42 @@ mod test {
     #[cfg_attr(test, assert_instr(irg))]
     #[allow(dead_code)]
     #[target_feature(enable = "mte")]
-    pub unsafe fn __test_create_random_tag(src: *const (), mask: u64) -> *const () {
+    unsafe fn test_arm_mte_create_random_tag(src: *const (), mask: u64) -> *const () {
         __arm_mte_create_random_tag(src, mask)
     }
 
     #[cfg_attr(test, assert_instr(addg))]
     #[allow(dead_code)]
     #[target_feature(enable = "mte")]
-    pub unsafe fn __test_increment_tag(src: *const ()) -> *const () {
+    unsafe fn test_arm_mte_increment_tag(src: *const ()) -> *const () {
         __arm_mte_increment_tag::<1, _>(src)
     }
 
     #[cfg_attr(test, assert_instr(gmi))]
     #[allow(dead_code)]
     #[target_feature(enable = "mte")]
-    pub unsafe fn __test_exclude_tag(src: *const (), excluded: u64) -> u64 {
+    unsafe fn test_arm_mte_exclude_tag(src: *const (), excluded: u64) -> u64 {
         __arm_mte_exclude_tag(src, excluded)
     }
 
     #[cfg_attr(test, assert_instr(stg))]
     #[allow(dead_code)]
     #[target_feature(enable = "mte")]
-    pub unsafe fn __test_set_tag(src: *const ()) {
+    unsafe fn test_arm_mte_set_tag(src: *const ()) {
         __arm_mte_set_tag(src)
     }
 
     #[cfg_attr(test, assert_instr(ldg))]
     #[allow(dead_code)]
     #[target_feature(enable = "mte")]
-    pub unsafe fn __test_get_tag(src: *const ()) -> *const () {
+    unsafe fn test_arm_mte_get_tag(src: *const ()) -> *const () {
         __arm_mte_get_tag(src)
     }
 
     #[cfg_attr(test, assert_instr(subp))]
     #[allow(dead_code)]
     #[target_feature(enable = "mte")]
-    pub unsafe fn __test_ptrdiff(a: *const (), b: *const ()) -> i64 {
+    unsafe fn test_arm_mte_ptrdiff(a: *const (), b: *const ()) -> i64 {
         __arm_mte_ptrdiff(a, b)
     }
 }

crates/stdarch-verify/src/lib.rs

@@ -97,11 +97,11 @@ fn functions(input: TokenStream, dirs: &[&str]) -> TokenStream {
                 arguments.push(to_type(ty));
             }
             for generic in f.sig.generics.params.iter() {
-                let ty = match *generic {
-                    syn::GenericParam::Const(ref c) => &c.ty,
+                match *generic {
+                    syn::GenericParam::Const(ref c) => const_arguments.push(to_type(&c.ty)),
+                    syn::GenericParam::Type(ref _t) => (),
                     _ => panic!("invalid generic argument on {name}"),
                 };
-                const_arguments.push(to_type(ty));
             }
             let ret = match f.sig.output {
                 syn::ReturnType::Default => quote! { None },
@@ -345,6 +345,10 @@ fn to_type(t: &syn::Type) -> proc_macro2::TokenStream {
             "v4f32" => quote! { &v4f32 },
             "v2f64" => quote! { &v2f64 },
 
+            // Generic types
+            "T" => quote! { &GENERICT },
+            "U" => quote! { &GENERICU },
+
             s => panic!("unsupported type: \"{s}\""),
         },
         syn::Type::Ptr(syn::TypePtr {

crates/stdarch-verify/tests/arm.rs

@@ -28,6 +28,8 @@ static U32: Type = Type::PrimUnsigned(32);
 static U64: Type = Type::PrimUnsigned(64);
 static U8: Type = Type::PrimUnsigned(8);
 static NEVER: Type = Type::Never;
+static GENERICT: Type = Type::GenericParam("T");
+static GENERICU: Type = Type::GenericParam("U");
 
 static F16X4: Type = Type::F(16, 4, 1);
 static F16X4X2: Type = Type::F(16, 4, 2);
@@ -157,6 +159,7 @@ enum Type {
     PrimPoly(u8),
     MutPtr(&'static Type),
     ConstPtr(&'static Type),
+    GenericParam(&'static str),
     I(u8, u8, u8),
     U(u8, u8, u8),
     P(u8, u8, u8),
@@ -456,6 +459,7 @@ fn verify_all_signatures() {
                     && !rust.file.ends_with("v7.rs\"")
                     && !rust.file.ends_with("v8.rs\"")
                     && !rust.file.ends_with("tme.rs\"")
+                    && !rust.file.ends_with("mte.rs\"")
                     && !rust.file.ends_with("ex.rs\"")
                     && !skip_intrinsic_verify.contains(&rust.name)
                 {