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]

Theo R. wrote:

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.

--
Ian Collins.

[Sharath]

On Apr 2, 1:30 pm, "Theo R." <[e-mail]:

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/WG...docs/n1124.pdf

-Sharath

[J. J. Farrell]

On Apr 2, 1:30 am, "Theo R." <[e-mail]:

>
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]

Theo R. wrote:

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]

"Theo R." <sh*************@gmail.comwrites:

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.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[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]

Sharath wrote:

On Apr 2, 1:30 pm, "Theo R." <[e-mail]:

>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.

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.

--
Thad

[santosh]

ma**********@pobox.com wrote:

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]

In article <11**********************@q75g2000hsh.googlegroups .com>,
<ma**********@pobox.comwrote:

>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>
--
There are some ideas so wrong that only a very intelligent person
could believe in them. -- George Orwell

[Keith Thompson]

"santosh" <sa*********@gmail.comwrites:

ma**********@pobox.com wrote:

>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.

:-)

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?

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[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]

ma**********@pobox.com wrote:

>
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.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[CBFalconer]

"Theo R." wrote:

>
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$
--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[Stephen Sprunk]

"Theo R." <sh*************@gmail.comwrote in message
news:11*********************@e65g2000hsc.googlegro ups.com...

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

--
Stephen Sprunk "Those people who think they know everything
CCIE #3723 are a great annoyance to those of us who do."
K5SSS --Isaac Asimov
--
Posted via a free Usenet account from http://www.teranews.com

[Flash Gordon]

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

"Theo R." wrote:

>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$

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.
--
Flash Gordon

[Chris Dollin]

CBFalconer wrote:

"Theo R." wrote:

>>
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$

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