C function with incomplete declaration

Question

I can build this example with no errors with gcc -std=C99 -Wall:

void dummy() {}

int main(void) {
    dummy(1, 2, 3);
    dummy(120, 144);
}

The disassembly shows that the function is indeed called twice:

main:
.LFB1:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    $15, %edx
        movl    $14, %esi
        movl    $12, %edi
        movl    $0, %eax
        call    foo
        movl    $300, %esi
        movl    $200, %edi
        movl    $0, %eax
        call    foo
        movl    $0, %eax
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc

I admit that this code should not exist, but, it is allowed and I am wondering in which special case it would be useful.

Any clues?

EDIT

The question calling-c-functions-with-too-many-arguments does not answer this question. It gives information about how to use varadic but it does not provide an example in which an incomplete declaration can be useful.

The question func-vs-funcvoid-in-c99 also does not answer the question. It explains the difference between incomplete and complete prototype which is not my question.

So, it seems my question is not clear enough and I am going to give another example:

Let's imagine I would really leverage an incomplete declaration to use variable arguments without using the varadic method so I wrote my example as:

int main(void) {
    dummy(1, 2, 3);
    dummy(1, 2, 3, 4, 5, 6, 7, 8);
}

Accoding to the calling conventions, the first function will use the CPU registers to pass the parameters while the second call will use the stack.

Now in my dummy function, how can I read these arguements and know whether or not the stack was used?

*"I admit that this code should not exist"* - why is that? You wrote it, compiled it. and your declaration is not as the title of your question claims (i.e. "incomplete". In C, that prototype declares a function `dummy` that accepts an arbitrary number of arguments, including zero. That you later exercise that, and the code reflects that, isn't surprising at all. Or is your question simple "What are possible reasons for allowing arbitrary argument lists in C functions like `void dummy()` ? — WhozCraig, Jul 26 '19 at 09:30
@WhozCraig, how would you intercept these arguments then? Whether I am passing 3 or more than 3 arguments, the calling conventions would be different and some arguments are passed on the stack. How the function, with no complete prototype can get the correct values? — nowox, Jul 26 '19 at 09:32
Fundamentally, you can't, and shouldn't. In reality you can, but not easily. It was intended for a much older version of the language, and has never been pulled, but is strongly discouraged. The feature is a holdover from C before it was standardized eons ago. The current C standard itself even drives that home with a hammer in 6.11.6. I'm sure there is a duplicate of this somewhere on this site. It may take a minute or two to find. — WhozCraig, Jul 26 '19 at 09:37
I agree it is discouraged, but it is allowed by C99, C11, C18 so it could be used and this is exacly why I asked this question. — nowox, Jul 26 '19 at 09:39
@nowox it is not *allowed*, on the contrary - behaviour is undefined. — Antti Haapala -- Слава Україні, Jul 26 '19 at 10:33
@AnttiHaapala not really because in this case I have a warning: `warning: assignment of read-only location ‘"foo"[42]’` — nowox, Jul 26 '19 at 10:36
@nowox it doesn't matter, behaviour is undefined. If you insist, then `int main(void) { char *foo = "foo"; foo[42] = 255; } ` — Antti Haapala -- Слава Україні, Jul 26 '19 at 10:45
@AnttiHaapala It matters, because it is the reason for my question. Usually undefined behaviors are connected to warning or errors. Not in this case. If the behavior is undefined, it MUST be explained in the standard. — nowox, Jul 26 '19 at 10:46
@nowox no they are not required to have diagnostics. In any case this case is very much explained in my answer to the duplicate. — Antti Haapala -- Слава Україні, Jul 26 '19 at 10:46
@AnttiHaapala Is `f(); f(1);` undefined behavior with `f(int i) {return 1;}` somewhere else? — Peter - Reinstate Monica, Aug 07 '19 at 05:56
@AnttiHaapala Quote? I believe it has been correct since abut 1977. — Peter - Reinstate Monica, Aug 07 '19 at 05:57
Idk why this was reopened. I hammered it to another question ... — Antti Haapala -- Слава Україні, Aug 07 '19 at 05:58
@PeterA.Schneider `f(int i) {}` returns implicit int. Incompatible declaration. You didn't see void in 1977 — Antti Haapala -- Слава Україні, Aug 07 '19 at 05:58
@PeterA.Schneider now it isn't iirc, if types after promotion matches proto. But you didn't see protos in 1977, they were an ansi invention. — Antti Haapala -- Слава Україні, Aug 07 '19 at 06:00
@AnttiHaapala Oh I see, the OP has an empty body in it. Yeah, that won't work. — Peter - Reinstate Monica, Aug 07 '19 at 06:01
It was closed as a duplicate then nowox added this part on "how to read the arguments" nonsense :D well, ok. At least Kamil answers it nicely — Antti Haapala -- Слава Україні, Aug 07 '19 at 06:02

KamilCuk · Accepted Answer · 2019-08-07T06:49:59.733

2

From C11 standard 6.7.5.3p14:

An empty list in a function declarator that is part of a definition of that function specifies that the function has no parameters.

The void dummy() {} is a function declarator and it is a function definition (it has the {} function body definition). The dummy function has an empty identifier list - there is nothing inside ( ) braces inside the function declaration. That means that the function takes no parameters.

int main(void) {
    dummy(1, 2, 3);
    dummy(120, 144);
}

Calling dummy with any parameters is invalid, because the parameters do not match function declaration. This is undefined behavior.

Now in my dummy function, how can I read these arguments and know whether or not the stack was used?

You cannot. Unless you do some hardware/compiler specific assembly/pointer tricks. C standard does not use a term "stack" and the usage of stack, if it exists and/or is used at all and how it is used, this is architecture and compiler dependent. The stack may not exists on a architecture. To read function arguments you have to declare them in the parameter list inside the function definition.

edited Aug 07 '19 at 06:49

answered Aug 07 '19 at 05:50

KamilCuk

120,984
8
59
111

Can you name a C implementation without a stack? Note that I am not talking about conventionally designating a specific hardware register as stack pointer; I simply contend that *all* C implementations known to man employ a stack-based mechanism to deal with automatic variables and parameters. (That this mechanism may not be used in certain situations, e.g. when parameters are passed in registers, is a different matter, and the OP is well aware of it because he addresses it specifically in the question.) – Peter - Reinstate Monica Aug 07 '19 at 06:05
@PeterA.Schneider not having a stack of activation records could allow doing fancy things. It is not implausible to think of an implementation like that but it wouldn't be a common one. I do not know one myself. – Antti Haapala -- Слава Україні Aug 07 '19 at 06:10
The [DeathStation 9000](http://wikibin.org/articles/deathstation-9000.html) (or [archived page](https://web.archive.org/web/20020802041201/http://dialspace.dial.pipex.com/town/green/gfd34/art/)) :) – pmg Aug 07 '19 at 07:53

C function with incomplete declaration

1 Answers1

Linked