[avianes]

That's quite interesting.

I see two possible implementations:

- either the struct is replicated at the function call (not really efficient, but the semantics are straightforward);

- either the struct is used to prepare directly the stack for the function call (more efficient, but the semantics must be defined).

One of the issues of the second approach is that if the structure/variable is a classical one, what should happen if we use the variable after the call?

If we have to read the values inserted before the call then we have to keep a copy of the structure in the stack (so it's the same as the first approach). Or we can consider that the variable no longer exists in the scope. Which corresponds to the ownership concept in Rust for example. (but, to my knowledge, this does not exist in C++)

What is the best option? Or are there other options?

Another question, what sizeof(foo::args) should return ?

[marvy]

I think foo::args should be a normal struct type, so sizeof(foo::args) would follow the usual rules, just as if someone had manually written

struct foo_args{char a; short b; long c; float d; etc...}

and then asked for sizeof(foo_args).

[avianes]

I have thought about it a little more, and I think it's the right solution as well.

From the first proposal the compiler can directly prepare the stack for the call.

As in this example: https://godbolt.org/z/f17szP