Asm blocks only allow identifiers to specify input/output

[tyler569]

Currently, Zig only accepts identifiers as output/output parameters to asm blocks, which is very limiting compared to the range of options available in gcc/clang, and makes a range of x86 asm instructions unusable.

I see this is currently expected, per the syntax description: LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN

I understand that the asm block syntax is in flux, but I believe widening the range of acceptable inputs/outputs is orthogonal to that effort.

As motivating examples:
in C I can have an asm block output directly to a struct field:

struct foo {
    long x;
};
struct foo x = {};
struct foo* y = &x;

int save_rsp() {
    asm volatile (
        "movq %%rsp, %[foo]"
        : [foo] "=r" (y->x)
    );
}

More subtly, in my operating system project, I have a need to save and restore floating point context, which is done with fxsave/fxrstor on x86. Due to the way these are encoded and the way gcc/clang choose to implement them, you have to pass the value at the location where the context should be stored as opposed to a pointer. Take the following C code:

typedef long fp_ctx[64];

int square(fp_ctx *ctx) {
    asm volatile (
        "fxsaveq %0"
        :
        : [ctx] "m" (*ctx)
    );
}

Notice how I have to dereference the context inside the asm block, and the generated instruction then somehow gets a pointer to that value:

square:                                 # @square
        push    rbp
        mov     rbp, rsp
        mov     qword ptr [rbp - 16], rdi
        mov     rax, qword ptr [rbp - 16]
        fxsave64        [rax]
        mov     eax, dword ptr [rbp - 4]
        pop     rbp
        ret

Compare that to the equivalent zig code, where I can't dereference that ctx:

const fp_ctx = [64]u64;

export fn square(ctx: *fp_ctx) void {
    asm volatile (
        \\ fxsaveq %[fpctx]
        :
        : [fpctx] "m" (ctx)
    );
}

In Zig, no matter what I try, the generated asm always tries to dump the floating point context onto the stack:

square:
        push    rbp
        mov     rbp, rsp
        mov     qword ptr [rbp - 8], rdi
        mov     rdi, qword ptr [rbp - 8]
        mov     qword ptr [rbp - 16], rdi
        fxsave64        [rbp - 16]   ; <<<--
        pop     rbp
        ret

I hope this is at least somewhat clear, I don't fully understand why the fp* instructions behave this way, but I hope the struct example at least serves as a more approachable motivating example for why more expressiveness in asm input/outputs would be great to have.