Parameter Passing via a Stack

[Theo R.]

Hi all,

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?

As an example, the ARM9 processor recommends Core Registers R0-R3 be
used when passing less than four parameters. However some compilers
for ARM9 do not follow this recommendation and place all parameters on
the stack. Therefore, the question arises if the compilers were
following the C Standard instead.

I remember that order of evaludation is right to left. Is this part of
the standard or is it an implementation detail?

Thanks,
Theo.

 

[Ian Collins]

Hi all,

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?

No, it is an implementation detail.

 

[Sharath]

Hi all,

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?
No.

I remember that order of evaludation is right to left. Is this part of
the standard or is it an implementation detail?

Wrong. Order of evaluation is unspecified.

Why don't you get yourself a copy of standard and see yourself?
http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1124.pdf

-Sharath

 

[J. J. Farrell]

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?

It's an implementation detail - C doesn't need a stack at all.

...

I remember that order of evaludation is right to left. Is this part of
the standard or is it an implementation detail?

It's an implementation detail, and the implementation is not required
to document it.

 

[santosh]

Hi all,

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?
No.

As an example, the ARM9 processor recommends Core Registers R0-R3 be
used when passing less than four parameters. However some compilers
for ARM9 do not follow this recommendation and place all parameters on
the stack. Therefore, the question arises if the compilers were
following the C Standard instead.

The Standard says nothing about how function parameters are managed,
just that they're made available to the function itself.

 

[Keith Thompson]

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?

The word "stack" appears nowhere in the C99 standard (nor does the
word "heap"). Argument passing mechanisms are
implementation-specific.

[...]

I remember that order of evaludation is right to left. Is this part of
the standard or is it an implementation detail?

That's also implementation-specific.

 

[mark_bluemel]

My glasses must be playing up - I initially read the subject line as
"Parameter Passing via a Stick". Anyone for an April 1st RFC? Would it
be possible to produce a compliant implementation using a Stick for
passing parameters?

 

[Thad Smith]

Wrong. Order of evaluation is unspecified.

It is an implementation detail.

The question makes it obvious that right-to-left evaluation is for a
particular implementation and asks whether such behavior is standard.
The answer "wrong" is wrong for the question asked.

 

[santosh]

My glasses must be playing up - I initially read the subject line as
"Parameter Passing via a Stick". Anyone for an April 1st RFC? Would it
be possible to produce a compliant implementation using a Stick for
passing parameters?

Yes. Those are just implementation details. Currently the most popular
parameter passing mechanism for the DS9k are wormholes, and carrier
pigeons for variable length args.

 

[Walter Roberson]

My glasses must be playing up - I initially read the subject line as
"Parameter Passing via a Stick".

<OT>
In networking, there is a not-uncommon configuration called
"Router on a Stick", which refers to using a router to route
between different subnets on the same physical segment, with
the packets going into the router and back out by the same
physical interface. Used when you have multiple IP ranges on the
same LAN. As contrasted to routing between different
physical interfaces, which is traditionally used when there
is an "inside" and an "outside" such as routing between a LAN
and the Internet.
</OT>

 

[Stephen Sprunk]

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?

As an example, the ARM9 processor recommends Core
Registers R0-R3 be used when passing less than four
parameters. However some compilers for ARM9 do not follow
this recommendation and place all parameters on the stack.
Therefore, the question arises if the compilers were following
the C Standard instead.

The C Standard says nothing about this, nor does it require that an
implementation have "registers" or a "stack" (or a "heap") at all.

Each platform (OS/CPU combination) does tend to have an Application Binary
Interface (ABI) standard, and compilers/linkers are expected to conform to
that. However, the ABI is not part of the C Standard, so an implementation
can disregard the accepted ABI and still be conforming according to
ISO/ANSI.

(Some ABIs, e.g. x86, even define multiple calling conventions, but they'll
specify one as the default. It's up to the programmer to make sure the
right compiler extensions or options are used if a non-default calling
convention is needed.)

S

 

[Keith Thompson]

Yes. Those are just implementation details. Currently the most popular
parameter passing mechanism for the DS9k are wormholes, and carrier
pigeons for variable length args.

Are those "wormholes" in the sense of discontinuities in the
space-time continuum, or "wormholes" in the sense of holes dug by
worms? Or is it a compile-time option?

 

[Gordon Burditt]

My glasses must be playing up - I initially read the subject line as

"Parameter Passing via a Stick". Anyone for an April 1st RFC? Would it
be possible to produce a compliant implementation using a Stick for
passing parameters?

Yes (and I don't mean that as an April 1st joke). You spear the
arguments in the correct order on the stick, and then pass the stick
(with the arguments attached) to the function.

But I think "Parameter Passing via Federal Express" is more
interesting. For a related method, see RFC2549.

 

[CBFalconer]

Does the C99 Standard explicitly mention the need for a stack for
passing arguments or Is this platform specific?

bash-2.04$ grep stack /stds/n869.txt
bash-2.04$

 

[CBFalconer]

My glasses must be playing up - I initially read the subject line as
"Parameter Passing via a Stick". Anyone for an April 1st RFC? Would it
be possible to produce a compliant implementation using a Stick for
passing parameters?

Sure. For example, come up with conventions for the spacing and
sizes of the whittled notches. Hire small boys with penknives.
The system would probably be fairly slow, but then there are no C
standards for speed.

 

[Flash Gordon]

CBFalconer wrote, On 03/04/07 01:59:

bash-2.04$ grep stack /stds/n869.txt
bash-2.04$

Although the result is correct in this case, you really should use a
case insensitive search to demonstrate it. Or just answer the question
since the OP might not know about grep.

 

[Chris Dollin]

bash-2.04$ grep stack /stds/n869.txt
bash-2.04$

Perhaps all occurrences of Stack were spelt with at least one
capital letter?

--
The second Jena user conference! http://hpl.hp.com/conferences/juc2007/
"If there is a problem, you must confess it, Mr Chaplin"/The Beiderbeck Affair/

Hewlett-Packard Limited registered office: Cain Road, Bracknell,
registered no: 690597 England Berks RG12 1HN