Re: [9fans] calling function with (variable number of) parameters

Re: [9fans] calling function with (variable number of) parameters

[rog]

> So save space for n + 1 parameters on the stack; the last won't be used
> by your called function, and you could store the number of parameters in
> it.  When you return, pop the last item off the stack, and use that to
> recalculate the frame pointer.

no actually, parameters are pushed on last first, so the last one
you've pushed (the one you've got access after the return) is the first
parameter to the function (which doesn't expect it).

i think that probably the only way of getting around the problem is to
change the prototype of the called function so that the first parameter
signifies the number of parameters.

the only other alternative is if the function is guaranteed to be
non-reentrant (fat chance) in which case you could store the number of
params in a static variable.

of course, that then makes it incompatible with the original...

  cheers,
    rog.

Re: [9fans] calling function with (variable number of) parameters

[Dan Cross]

In article <20010621142423.D9AFF199EB@mail.cse.psu.edu> you write:
>no actually, parameters are pushed on last first, so the last one
>you've pushed (the one you've got access after the return) is the first
>parameter to the function (which doesn't expect it).

Oh, yeah; dang, I was thinking backwards.

	- Dan C.

Re: [9fans] calling function with (variable number of) parameters

[Latchesar Ionkov]

Both suggestions are not really alternatives in that case. I am trying to
implement already defined interface, I don't have control on the way the
called functions are declared and they are definitely reentrant. :((

I can, though, hope that nobody in his mind will wrote a function with more
that 15 arguments. Then reserve space for 15 integers in the stack, put as
many argument as needed, call the function and remove 15 integers from the
stack. Of course I'll check and signall error if somebody is crazy enough to
try to use the code with more than 15 arguments.

Thanks again,

	Lucho

On Thu, Jun 21, 2001 at 03:33:15PM +0100, rog@vitanuova.com said:
> > So save space for n + 1 parameters on the stack; the last won't be used
> > by your called function, and you could store the number of parameters in
> > it.  When you return, pop the last item off the stack, and use that to
> > recalculate the frame pointer.
> 
> no actually, parameters are pushed on last first, so the last one
> you've pushed (the one you've got access after the return) is the first
> parameter to the function (which doesn't expect it).
> 
> i think that probably the only way of getting around the problem is to
> change the prototype of the called function so that the first parameter
> signifies the number of parameters.
> 
> the only other alternative is if the function is guaranteed to be
> non-reentrant (fat chance) in which case you could store the number of
> params in a static variable.
> 
> of course, that then makes it incompatible with the original...
> 
>   cheers,
>     rog.

Re: [9fans] calling function with (variable number of) parameters

[Boyd Roberts]

strangely enough, yes are singing:

    think it over

good advice i'd say.

Re: [9fans] calling function with (variable number of) parameters

[Dan Cross]

In article <20010620155421.A1669@gmx.net> you write:
>I've already tried to write it in assembler. The problem is that after the
>function returns, I don't know how many args I have to pop from the stack.
>And I can't get the number from a local variable, because I don't know the
>frame pointer anymore (I modified SP pushing the args before I called the
>function).

So save space for n + 1 parameters on the stack; the last won't be used
by your called function, and you could store the number of parameters in
it.  When you return, pop the last item off the stack, and use that to
recalculate the frame pointer.

	- Dan C.

Re: [9fans] calling function with (variable number of) parameters

[Latchesar Ionkov]

On Thu, Jun 21, 2001 at 12:39:50PM +0000, Douglas A. Gwyn said:
> Latchesar Ionkov wrote:
> > function returns, I don't know how many args I have to pop from the stack.
> > And I can't get the number from a local variable, because I don't know the
> > frame pointer anymore
>
> So use a global variable.  It's already a crock anyway..

the function has to be reentrant.

thanks for all the suggestions. obviously i'll reserve constant space in the
stack for the arguments.

	Lucho

Re: [9fans] calling function with (variable number of) parameters

[Douglas A. Gwyn]

Latchesar Ionkov wrote:
> function returns, I don't know how many args I have to pop from the stack.
> And I can't get the number from a local variable, because I don't know the
> frame pointer anymore

So use a global variable.  It's already a crock anyway..

Re: [9fans] calling function with (variable number of) parameters

[Latchesar Ionkov]

On Wed, Jun 20, 2001 at 08:51:03PM +0100, rog@vitanuova.com said:
> > The interface is called JNI and I can't change it.
> 
> presumably you could write a bit of assembler to get around the
> problem. you'd have to do it for each platform, but it wouldn't be hard
> and as far as i can see there wouldn't be a problem doing it: just push
> all the args on the stack (last first) & call the fn.

I've already tried to write it in assembler. The problem is that after the
function returns, I don't know how many args I have to pop from the stack.
And I can't get the number from a local variable, because I don't know the
frame pointer anymore (I modified SP pushing the args before I called the
function).

Thanks,
	Lucho

Re: [9fans] calling function with (variable number of) parameters

[rog]

> The interface is called JNI and I can't change it.

presumably you could write a bit of assembler to get around the
problem. you'd have to do it for each platform, but it wouldn't be hard
and as far as i can see there wouldn't be a problem doing it: just push
all the args on the stack (last first) & call the fn.

  cheers,
    rog.

Re: [9fans] calling function with (variable number of) parameters

[Latchesar Ionkov]

On Wed, Jun 20, 2001 at 04:30:21PM +0000, Douglas A. Gwyn said:
> Latchesar Ionkov wrote:
> > I am trying to write a function
> >         int callf(void *f, int nargs, int *args)
> > f is a pointer to a function of a type
> >         int f(int, int, int, ..., int)
> 
> No, it isn't; at least, not as you have declared callf.
> 
> Also, that is not a proper variadic declaration for the type of f.
> I think what you mean is that the actual function definition uses
> a *fixed* number of arguments, different for different values of
> f, and you're hoping that the passed nargs happens to be
> consistent with the function that the passed f points to.

You understood what I meant, which was the purpose of the two pseudo
declarations.

> > callf should copy nargs number of ints from args to the stack and call f,
> > and then return f's return value.
> 
> > Is this possible with Plan9 C calling convention? ...
> > Do I miss something? Any ideas how to implement it?
> 
> It's an abuse of C under any linkage convention.

I know, but that knowledge doesn't help me.

> > Unfortunately I don't have any control on the requirements or the way f gets
> > its parameters. If there is no way to do it for any number of args, I'll
> > limit nargs (and hope nobody will write function with more than 15
> > arguments) and will modify SP with a constant value.
> 
> That will probably be your best bet.
> Other solutions would require changes to the interface.

The interface is called JNI and I can't change it.

	Lucho

Re: [9fans] calling function with (variable number of) parameters

[Douglas A. Gwyn]

Latchesar Ionkov wrote:
> I am trying to write a function
>         int callf(void *f, int nargs, int *args)
> f is a pointer to a function of a type
>         int f(int, int, int, ..., int)

No, it isn't; at least, not as you have declared callf.

Also, that is not a proper variadic declaration for the type of f.
I think what you mean is that the actual function definition uses
a *fixed* number of arguments, different for different values of
f, and you're hoping that the passed nargs happens to be
consistent with the function that the passed f points to.

> callf should copy nargs number of ints from args to the stack and call f,
> and then return f's return value.

> Is this possible with Plan9 C calling convention? ...
> Do I miss something? Any ideas how to implement it?

It's an abuse of C under any linkage convention.

> Unfortunately I don't have any control on the requirements or the way f gets
> its parameters. If there is no way to do it for any number of args, I'll
> limit nargs (and hope nobody will write function with more than 15
> arguments) and will modify SP with a constant value.

That will probably be your best bet.
Other solutions would require changes to the interface.

[9fans] calling function with (variable number of) parameters

[Latchesar Ionkov]

Hi,

I am trying to write a function

	int callf(void *f, int nargs, int *args)
	
f is a pointer to a function of a type

	int f(int, int, int, ..., int)
	
callf should copy nargs number of ints from args to the stack and call f,
and then return f's return value.

The requirement is to not restrict nargs -- theoretically f can have 1000+
arguments.

Is this possible with Plan9 C calling convention? The caller function saves
the registers that it needs (obviously in the stack), then SP is modified
with a non-constant value, f is called, and after the execution returns in
callf, there is no any way go guess, what that value was.

Do I miss something? Any ideas how to implement it?

Unfortunately I don't have any control on the requirements or the way f gets
its parameters. If there is no way to do it for any number of args, I'll
limit nargs (and hope nobody will write function with more than 15
arguments) and will modify SP with a constant value.

Thanks,
	Lucho