llvm dev - Aug 2011 - [LLVMdev] Accessing arguments in a caller

I need some advice on "forwarding" arguments to a callee. Suppose I
have
a function F that is called at the beginning of all other functions in 
the module. From F I need to access (read) the arguments passed to its 
immediate caller. Right now I do something like boxing all arguments in 
the caller inside a struct and passing a pointer to the struct to F, 
alongside an identifier telling which caller F is being called from. F 
has then a giant switch that branches to the appropriate unboxing code. 
This is obviously suboptimal because I need to allocate the struct on 
the stack, copy the arguments inside of it and then passing an 
additional pointer to F.
I was wondering if there's a better way to do this, e.g. a way to access 
the stack frame of the caller (knowing, thanks to the identifier, which 
caller F was called from) or, more in general, arbitrary values defined 
in the caller. Any suggestions?
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20110818/aec20d75/attachment.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: cafxx.vcf
Type: text/x-vcard
Size: 230 bytes
Desc: not available
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20110818/aec20d75/attachment.vcf>

Nella citazione giovedì 18 agosto 2011 09:11:36, Carlo Alberto Ferraris 
ha scritto:
> I need some advice on "forwarding" arguments to a callee. Suppose
I have
> a function F that is called at the beginning of all other functions in 
> the module. From F I need to access (read) the arguments passed to its 
> immediate caller. Right now I do something like boxing all arguments in 
> the caller inside a struct and passing a pointer to the struct to F, 
> alongside an identifier telling which caller F is being called from. F 
> has then a giant switch that branches to the appropriate unboxing code. 
> This is obviously suboptimal because I need to allocate the struct on 
> the stack, copy the arguments inside of it and then passing an 
> additional pointer to F.
> I was wondering if there's a better way to do this, e.g. a way to
access
> the stack frame of the caller (knowing, thanks to the identifier, which 
> caller F was called from) or, more in general, arbitrary values d
efined 
> in the caller. Any suggestions?
Are there really no better ways of doing this?
-------------- next part --------------
A non-text attachment was scrubbed...
Name: cafxx.vcf
Type: text/x-vcard
Size: 230 bytes
Desc: not available
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20110821/ab01c6a7/attachment.vcf>

What I can think of:
1. Anonymous struct, to avoid a copy.
2. Use stdarg.h...dangerous but accomplishes what you're looking for.
3. Split up F: giant switch statements often indicate that your function is
doing several different things. (IMHO...)
4. Don't worry about it, it's probably not a bottleneck. (Or rather,
profile first...)

But no, there's no standard way to do this. Even C++11's variadic
templates don't avoid the copy, and initializer lists are pretty much
equivalent to an anonymous struct / const struct reference.

(Why not? Because calling conventions differ from platform to platform; often
the first few arguments of a function are passed in registers, not on the
stack.)

Jordy


On Aug 21, 2011, at 6:23, Carlo Alberto Ferraris wrote:
> Nella citazione giovedì 18 agosto 2011 09:11:36, Carlo Alberto Ferraris ha
scritto:
>> I need some advice on "forwarding" arguments to a callee.
Suppose I have a function F that is called at the beginning of all other
functions in the module. From F I need to access (read) the arguments passed to
its immediate caller. Right now I do something like boxing all arguments in the
caller inside a struct and passing a pointer to the struct to F, alongside an
identifier telling which caller F is being called from. F has then a giant
switch that branches to the appropriate unboxing code. This is obviously
suboptimal because I need to allocate the struct on the stack, copy the
arguments inside of it and then passing an additional pointer to F.
>> I was wondering if there's a better way to do this, e.g. a way to
access the stack frame of the caller (knowing, thanks to the identifier, which
caller F was called from) or, more in general, arbitrary values d
> efined 
>> in the caller. Any suggestions?
> 
> Are there really no better ways of doing this?
> <cafxx.vcf>_______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev