Add missing runtime tests for SSE alias intrinsics

[ArunTamil21]

Add missing runtime tests for SSE alias intrinsics

While working through issue #798, I noticed several alias intrinsics had no
runtime tests even though their underlying functions were already tested.

This PR adds tests for:

• "test_mm_cvt_ss2si" (alias for "mm_cvtss_si32")
• "test_mm_cvtt_ss2si" (alias for "mm_cvttss_si32")
• "test_mm_cvt_si2ss" (alias for "mm_cvtsi32_ss")
• "test_mm_set_ps1" (alias for "mm_set1_ps")

Each test follows the same pattern as the existing tests for the underlying
functions, since these aliases just call them directly.

Part of #798.

[rustbot]

r? @folkertdev

rustbot has assigned @folkertdev.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

Why was this reviewer chosen?

The reviewer was selected based on:

• Owners of files modified in this PR: @Amanieu, @folkertdev, @sayantn
• @Amanieu, @folkertdev, @sayantn expanded to Amanieu, folkertdev, sayantn
• Random selection from Amanieu, folkertdev, sayantn

[sayantn]

Could you remove these lines too please

stdarch/crates/stdarch-verify/tests/x86-intel.rs

Lines 250 to 253 in 0e22a37

	"_mm_cvt_ss2si",
	"_mm_cvtt_ss2si",
	"_mm_cvt_si2ss",
	"_mm_set_ps1",

View changes since this review

[sayantn]

Also, personally, I think it is a bit weird (and error-prone) to fully repeat the tests for aliases, considering there are quite a few of them. I would prefer a macro-based approach, but take this as a completely personal opinion.

[ArunTamil21]

@sayantn Done, removed the lines from x86-intel.rs.

Regarding the macro-based approach, I agree it's cleaner.
Would you like me to refactor the tests in this PR, or should
I do that as a separate follow-up PR?

[sayantn]

I would prefer it to be a single PR, as this PR just copying the tests anyway. If you prefer you can keep them as different commits

[ArunTamil21]

@sayantn Thanks for the feedback. I'll refactor the tests using a macro-based approach.
Could you point me to an example of how you'd prefer the macro to look ?
I tried to check the sse.rs / sse2.rs couldn't find any macros based pattern.

[sayantn]

I don't think we use a macro like that exactly, but you can make a simple macro like

macro_rules! foo_gen {
    ($($test_name:ident : $alias:ident),*) => {$(
        #[simd_test(blah)]
        fn $test_name() {
            //<< the body, but with $alias as the function name >>
        }
    )*}
}

foo_gen(foo, foo_alias);

or you can create a "meta function" like

unsafe fn test_foo_gen(actual_fn: unsafe fn()) {
    // << the body, but using `actual_fn` in place of that >>
}

#[simd_test(blah)]
fn test_foo() {
    test_foo_gen(foo);
}

#[simd_test(blah)]
fn test_foo_alias() {
    test_foo_gen(foo_alias);
}

any of these work, or if you can think of a better approach that's even better

[ArunTamil21]

@sayantn
I've refactored all the alias tests using the meta function pattern as suggested. Each pair of alias intrinsics now shares a single impl function to avoid code duplication.
I also added the missing tests for _mm_load_ps1, _mm_store_ps1, _mm_undefined_ps, and _mm_prefetch as part of issue #798.
For the last two, since they don't produce verifiable output per Intel's docs (prefetch only affects cache behavior, and _mm_undefined_ps returns indeterminate elements), the tests just verify that the functions compile and execute without crashing. Added a comment in each test explaining why.
Let me know if anything needs adjustment!

[sayantn]

Thanks, looks nice. But I don't think we need tests for prefetch and undefined, we already have instruction tests to ensure that they produce the correct assembly

[ArunTamil21]

Thanks @sayantn for the clarification — removed both. Good to know assert_instr already covers correctness for intrinsics with no verifiable output.

[sayantn]

I apologize for not spotting this earlier, but using the "meta-function" technique doesn't work for functions that we const-test (e.g. _mm_set1_ps etc). The const attribute on any #[simd_test] function triggers its const-testing, and we cannot use fn pointers in const code. So it seems like we can only use macros for functions that we want to const-test, and for uniformity, I think it would be better to use macros everywhere. I apologize again for this confusion.

[ArunTamil21]

Thanks, no need to apologize — this is a good learning for me. I’ll refactor all the alias tests to use the macro pattern for uniformity and push the changes.

[rustbot]

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

[ArunTamil21]

@sayantn The CI is failing on intrinsic verification, looks like the verifier can't pick up macro-generated test functions. Is there another way to handle it ?

Edit: I traced the issue to stdarch-verify/src/lib.rs, the verifier finds tests by looking for functions starting with test_. Since these tests are now macro-generated, they don't show up as regular functions and the verifier misses them ? I might be wrong still trying to understand the codebase

[sayantn]

Sorry for the late response. Yes, we can't generate the tests from macros, as stdarch-verify runs before macro expansion. I did not notice this previously, but this has an easy solution, without code duplication. We can simply do

macro_rules! foo {
// body of the test
}

#[simd_test...]
fn test_bar() {
    foo!(bar);
}

#[simd_test...]
fn test_baz() {
    foo!(baz);
}

This approach minimizes duplication, while also making sure that stdarch-verify can work

[ArunTamil21]

@sayantn

Updated the implementation based on your suggestion, body macros for deduplication, wrapper functions kept visible for the verifier. Both runtime tests and intrinsic verification pass locally.

[sayantn]

thanks, just a small nit, please try to keep the const annotations on the tests, and try not to add more unsafe annotations, we removed most unsafe annotations from tests a few months back

View changes since this review

[ArunTamil21]

@sayantn Thanks for the feedback just updated the suggestions, used const fn where the intrinsic supports it, plain fn on the others, and removed unsafe from all wrapper signatures. Both runtime tests and verifier pass locally.