Re: GNAT parameter passing, C-style?

["Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net>]

"Keith Thompson" <kst-u@mib.org> wrote in message
news:lnekul8ewd.fsf@nuthaus.mib.org...
> "Frank J. Lhota" <NOSPAM.FrankLho@rcn.com> writes:
> > I don't believe it was stated explicitly, but the standard C calling
> > convention (arguments pushed on the stack in reverse order, and popped
off
> > by the callee) is implied by the requirements for variable argument
> > functions.
> [...]
>
> No, it isn't.  In standard C, functions with variable argument lists
> have a special syntax ("..."), and don't have to use the same calling
> conventions as other functions.  In the body of such a function, it
> accesses its arguments using special macros defined in the header
> <stdarg.h>; these macros can do whatever compile-specific magic is
> necessary.

In vanilla (i.e. original K&R) C, there are no argument lists in function
declarations. For that matter, vanilla C does NOT even require functions
declarations. If an undeclared function is called in vanilla C, the
unconverted argument list is assumed to be OK, the calling convention is
assumed to be C, and it is assumed that the function returns an int.

ANSI C depreciates this loose approach to functions. ANSI C strongly
encourages the full declaration of all functions used, including argument
lists. For compatability, however, ANSI C accepts function declarations with
no argument lists (e.g. "double sin();"), as well as the calling of
undeclared functions. Since there is no requirement that the user will
declare a function's argument list (or the function for that matter), a C
compiler may not be able to tell whether a function accepts a variable
argument list or not. For that reason, C compilers have to assume the C
calling convention, unless the user indicates via declaration or command
line options.

Every C compiler that I have worked with uses the C calling convention by
default when compiling C (as opposed to C++) code. If you know of a C
compiler that works differently, please post the details. I'm not saying
this because out of fondness for the C calling convention. Although this
convention is required to handle variable argument lists, it is less
efficient for the vast majority of cases where the function has a fixed
parameter list.

Fortunately, C++ has resolved this problem by making a clean break from
vanilla C. They do require that functions must be declared, including its
parameter list, for it to be used. The compiler can always determine if a
function has a variable argument list, and hence can (and does) reserve the
C calling conventions for only those functions that require it.