aarch64-gcc simd inline asm, result always 0

Question

I try to do SIMD multiplication with inline assembler. However, the result is always zero or (in other cases) gets ununderstandable (for me) values.

#include <stdio.h>

int main(void)
{
        double x[2] = {2.0, 3.0};
        double y[2] = {0.0, 0.0};

        asm volatile (
              "fmul %[y].2d, %[x].2d, %[x].2d\n"
        : /* outputs */
          [y] "=&w" (y)
        : /* inputs */
          [x] "w" (x)
        : /* clobbers */
          "cc"
        );

        printf("result = (%f, %f)\n",
               y[0], y[1]);

        return 0;
}

Compiled with

aarch64-linux-gnu-gcc -mcpu=cortex-a73 -march='armv8-a'

I always get the output

result = (0.000000, 0.000000)

but I would expect (4.0, 9.0). Please help!

First of all, don't do this. Use vector support. Anyway, you are passing the address of the array as input. I couldn't get the compiler to do the load, so you might have to do that by hand. — Jester, May 19 '22 at 11:42
Even if you put a load instruction inside the inline asm with an `"r"` input for the pointer, you'd still have the problem of [How can I indicate that the memory \*pointed\* to by an inline ASM argument may be used?](https://stackoverflow.com/q/56432259) - as Jester said don't do this, but if you do, ask the compiler for a vector value, not an address. — Peter Cordes, May 19 '22 at 15:39

score 2 · Accepted Answer · answered May 19 '22 at 11:59

2

As Jester said, you have to pass a value to the asm statement, not a pointer to the datum in question. The correct type for this value is float64x2_t from arm_neon.h. So proceed as follows:

#include <stdio.h>
#include <arm_neon.h>

int main(void)
{
        double x[2] = {2.0, 3.0};
        double y[2] = {0.0, 0.0};

        asm volatile (
              "fmul %[y].2d, %[x].2d, %[x].2d\n"
        : /* outputs */
          [y] "=&w" (*(float64x2_t *)y)
        : /* inputs */
          [x] "w" (*(float64x2_t *)x)
        : /* clobbers */
          "cc"
        );

        printf("result = (%f, %f)\n",
               y[0], y[1]);

        return 0;
}

Note that when you include the intrinsics header, you might as well just use intrinsics directly:

int bar(void)
{
        double x[2] = {2.0, 3.0};
        double y[2] = {0.0, 0.0};
        float64x2_t *xx = x, *yy = y;

        *yy = vmulq_f64(*xx, *xx);

        printf("result = (%f, %f)\n",
               y[0], y[1]);

        return 0;
}

answered May 19 '22 at 11:59

fuz

88,405
25
200
352

Thank you very much :) Trivial in the end, but I couldn't see it... – andi8086 May 19 '22 at 12:08
You don't even need the intrinsics for a multiplication, a plain simple `*` will do. – Jester May 19 '22 at 12:10
Does deref of an intrinsic vector imply aligned access? If so, you should use `alignas(16) double x[] = {...}`. Or `alignas(float64x2_t) double x[] = {...}`. (Include `` if this is C rather than C++). – Peter Cordes May 19 '22 at 15:41
Does `fmul` write the condition codes? You can probably omit `"cc"` if you want. – Peter Cordes May 19 '22 at 15:42

aarch64-gcc simd inline asm, result always 0

1 Answers1