in code that makes heavy use of (signed-byte 32) values, I would like to
try whether speed will improve significantly if such values do not have
to be tagged when passed as arguments to other functions.
Unfortunately, I am somewhat unclear about all the various calling
conventions in SBCL and how the compiler chooses between them, so I have
basically no idea where to start.
- Does SBCL support non-descriptor arguments in non-local function calls?
(I am guessing it does, but I am not sure under which circumstances.)
- ... for return values?
(Probably not, because out-of-line callers of the function object
would have to use some kind of trampoline to get the descriptor
- Would it be possible to extend whatever support the compiler already
has for all of this to situations involving FUNCALL where the
programmers knows the argument types the function accepts but does
not know in advance which function object the program will end up
calling at this point?
(For example, in my code vtable dispatch in done at runtime, so the
"method signature" is known, but not which method object it is.)
The code in question is automatically generated (both caller and callee
functions), so any possible solution would not have to be pretty.
Thanks for any hints to get me started,