[sve][abi] gcc and llvm don't have the same call conventions

[vfdff]

• test: https://gcc.godbolt.org/z/5o8YofrrG

class SimdFloat
{
private:
    typedef svfloat32_t simdInternalType_
            __attribute__((arm_sve_vector_bits(512)));

public:
    SimdFloat() {}

    SimdFloat(const float f) { this->simdInternal_ = svdup_n_f32(f); }

    SimdFloat(svfloat32_t simd) : simdInternal_(simd) {}

    simdInternalType_ simdInternal_;
};
...

SimdFloat foo (SimdFloat a , SimdFloat b, const float* m, const float* n) {
    SimdFloat mc =  simdLoadFloat(m);
    SimdFloat nc =  simdLoadFloat(n);
    return a + b + nc + mc;
}

• For above test case, the gcc use register z0 and z1 to pass the argument a and b, while llvm pass them with memory

Smaller example: https://gcc.godbolt.org/z/K484P4zEr

[llvmbot]

@llvm/issue-subscribers-backend-aarch64

Author: Allen (vfdff)

* test: https://gcc.godbolt.org/z/5o8YofrrG ``` SimdFloat foo (SimdFloat a , SimdFloat b, const float* m, const float* n) { SimdFloat mc = simdLoadFloat(m); SimdFloat nc = simdLoadFloat(n); return a + b + nc + mc; } ``` * For above test case, the gcc use register z0 and z1 to pass the argument a and b, while llvm pass them with memory

[aemerson]

@sdesmalen-arm @davemgreen

[pinskia]

https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst#pure-scalable-types-psts
Since svfloat32_t is a Pure Scalable Type, then SimdFloat should be too; specifically: "and without regard to access control or other source language restrictions. " So GCC argument passing here seems correct and LLVM is wrong.

[vfdff]

Thanks , a little simplified test: https://gcc.godbolt.org/z/jKjcY5sK1

#include<arm_sve.h>
typedef svfloat32_t fvec32 __attribute__((arm_sve_vector_bits(256)));

typedef class SimdFloat {
public:
     fvec32 vect_f32;
} __m256, __m256d;

SimdFloat _mm256_mul_ps1(SimdFloat a, SimdFloat b) {
    __m256 res;
    res.vect_f32 = svmul_f32_z(svptrue_b32(), a.vect_f32, b.vect_f32);
    return res;
}

[sdesmalen-arm]

https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst#pure-scalable-types-psts Since svfloat32_t is a Pure Scalable Type, then SimdFloat should be too; specifically: "and without regard to access control or other source language restrictions. " So GCC argument passing here seems correct and LLVM is wrong.

In combination with https://github.com/ARM-software/acle/blob/main/main/acle.md?plain=1#L6845 I'm tempted to agree that LLVM should have mapped this type to a pure scalable type.

[whokeke]

Has it been fixed now? Which PR?

[davemgreen]

I believe this was fixed in #112747 from @momchil-velikov.