Function arguments

[Amit Sharma]

Hi,
I wanted to know when we call function with argument, Does the
arguments stored in stack always or it compiler specific and could be
stored in queue

e.g. Does this program's output depends upon the compiler specific or
always would be b a

#include<stdio.h>

int a()
{
printf("a\t");
return 0;
}
int b()
{
printf("b\t");
return 0;
}
void c(int a,int b)
{
}
int main()
{
c(a(),b());
return 1;
}
Thanks,
Amit

[Chris Dollin]

Amit Sharma wrote:

Hi,
I wanted to know when we call function with argument, Does the
arguments stored in stack always or it compiler specific and could be
stored in queue
They can be stored however the implementor likes. A common choice, on
machines where it's available, is to store at least the first few
arguments in registers.
c(a(),b());

The arguments of a function call can be evaluated in whatever order
the compiler (writer) finds convenient and effective.

--
Chris "electric hedgehog" Dollin
C FAQs at: http://www.faqs.org/faqs/by-newsgrou...mp.lang.c.html
C welcome: http://www.angelfire.com/ms3/bchambl...me_to_clc.html

[Dan Pop]

In <fe*************************@posting.google.com> sh*******@gmail.com (Amit Sharma) writes:

I wanted to know when we call function with argument, Does the
arguments stored in stack always or it compiler specific and could be
stored in queue
Why does it matter to you?
e.g. Does this program's output depends upon the compiler specific or
always would be b a

#include<stdio.h>

int a()
{
printf("a\t");
return 0;
}
int b()
{
printf("b\t");
return 0;
}
void c(int a,int b)
{
}
int main()
{
c(a(),b());
return 1;
}

I see no connection between your first question and the second one,
although the second was supposed to exemplify the first.

The output of the program is not affected by how and where the function
arguments are stored, but it is affected by the order in which the
function arguments are evaluated, which is something completely different.
The order of evaluation is unspecified, therefore the program can output
either "a\tb\t" or "b\ta\t". Or nothing at all, because the last line of
output is not newline terminated.

BTW, what is the effect of returning 1 from main?

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Currently looking for a job in the European Union

[Kevin D. Quitt]

On 30 Sep 2004 05:56:31 -0700, sh*******@gmail.com (Amit Sharma) wrote:

Hi,
I wanted to know when we call function with argument, Does the
arguments stored in stack always or it compiler specific and could be
stored in queue

Curious. I can't find the word "stack" anywhere in the C standard. So,
"no" would be the answer to the first part of the question.
--
#include <standard.disclaimer>
_
Kevin D Quitt USA 91387-4454 96.37% of all statistics are made up
Per the FCA, this address may not be added to any commercial mail list

[Jamie Lin]

The default calling convention for C is _cdecl. It means parameters are
pushed onto the stack in the reversed order (right to left) and the caller
needs to clean up the stack. There are other conventions, for example,
_stdcall is used for Win32 API functions. For your question, it is true when
you use gcc and run it on GNU/Linux systems. Since it's a default
convention, I assume other compliers will give you the same thing unless you
specify it. But again, I could be wrong in the second case.

-Jamie
"Amit Sharma" <sh*******@gmail.com> wrote in message
news:fe*************************@posting.google.co m...

Hi,
I wanted to know when we call function with argument, Does the
arguments stored in stack always or it compiler specific and could be
stored in queue

e.g. Does this program's output depends upon the compiler specific or
always would be b a

#include<stdio.h>

int a()
{
printf("a\t");
return 0;
}
int b()
{
printf("b\t");
return 0;
}
void c(int a,int b)
{
}
int main()
{
c(a(),b());
return 1;
}
Thanks,
Amit

-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 100,000 Newsgroups - 19 Different Servers! =-----

[Keith Thompson]

"Jamie Lin" <ja***@tildefoo.com> writes:

The default calling convention for C is _cdecl. It means parameters are
pushed onto the stack in the reversed order (right to left) and the caller
needs to clean up the stack. There are other conventions, for example,
_stdcall is used for Win32 API functions. For your question, it is true when
you use gcc and run it on GNU/Linux systems. Since it's a default
convention, I assume other compliers will give you the same thing unless you
specify it. But again, I could be wrong in the second case.

First, please don't top-post. Your response should follow, not
precede, any text you quote from previous messages. (See other
articles in this newsgroup for examples.)

Second, there is no such thing as "_cdecl" in standard C, nor does C
require the existence of a stack. As far as the standard is
concerned, parameters could be pushed onto the stack in forward,
reverse, or alphabetical order, stored in registers, or sent by
carrier pigeon. What you say may (or may not; I don't know) be valid
for some particular system, but I assure you there are plenty of
systems where it isn't.

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

[CBFalconer]

Jamie Lin wrote:

The default calling convention for C is _cdecl. It means parameters
are pushed onto the stack in the reversed order (right to left) and
the caller needs to clean up the stack. There are other conventions,
for example, _stdcall is used for Win32 API functions. For your
question, it is true when you use gcc and run it on GNU/Linux
systems. Since it's a default convention, I assume other compliers
will give you the same thing unless you specify it. But again, I
could be wrong in the second case.

Don't toppost. Your answer belongs after, or intermixed with, the
material to which you are replying, after snipping away anything
that is not relevant.

C has no default calling convention. _cdecl and _stdcall are
specific to some systems and are not portable. The parameter
order is not defined, and neither is the existence of a stack.

--
A: Because it fouls the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[John Bode]

"Jamie Lin" <ja***@tildefoo.com> wrote in message news:<41********@corp.newsgroups.com>...

The default calling convention for C [edit] on the Win32 platform [/edit] is
_cdecl.
Fixed that for you.
It means parameters are
pushed onto the stack in the reversed order (right to left) and the caller
needs to clean up the stack. There are other conventions, for example,
_stdcall is used for Win32 API functions. For your question, it is true when
you use gcc and run it on GNU/Linux systems. Since it's a default
convention, I assume other compliers will give you the same thing unless you
specify it. But again, I could be wrong in the second case.

-Jamie

There's a whole range of calling conventions available, many of which
do not conform to what you describe above. All The World Is *NOT*
Win32.

"Amit Sharma" <sh*******@gmail.com> wrote in message
news:fe*************************@posting.google.co m...

Hi,
I wanted to know when we call function with argument, Does the
arguments stored in stack always or it compiler specific and could be
stored in queue

It depends on your platform (hardware + OS). This is less a C
language question and more a platform-specific question.
e.g. Does this program's output depends upon the compiler specific or
always would be b a

#include<stdio.h>

int a()
{
printf("a\t");
return 0;
}
int b()
{
printf("b\t");
return 0;
}
void c(int a,int b)
{
}
int main()
{
c(a(),b());
return 1;
}
Thanks,
Amit

-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 100,000 Newsgroups - 19 Different Servers! =-----