Hi,

Well typically that's why you have calling convection, which determines the
order and use of
the registered and stack, when run out of registers, there are various
different calling convection for which c/C++ code can be compiled.
There is no guarantee, they would choose to pass that in a register of on
the stack, in a future specification to be defined.
 This is not dynamically done as far as I am where its all determine at
compile time.

Typically the calling convention can be thought of as determined the common
interface for how the code before the function being called should
communicate with the code
in the function that was called, because many things can call that
function, and they be using register and stack all differently for which
variables and parameters are a store where,
thus have to have a common exchange interface.

I would and my next proposal is something along the lines of dynamic
remapping of programs instructions for called functions to eliminate this
interface for long-running functions, overhead,
but that like introducing dynamically compiled sections of codes, but other
ways can envisage hardware could achieving this. would almost be like
giving c/C++ partial V8 engine.
Would be good for function calls in loops and that, where they call
millions of times.

Whether using register or not is faster than the stack, totally depends on
the code usage of register or them implicitly being in the right register
for the right function call.

Hope that helps.

Wesley Oliver

On Sat, Feb 6, 2021 at 5:28 AM Thiago Macieira via Std-Proposals <
std-proposals_at_[hidden]> wrote:

> On Friday, 5 February 2021 05:53:44 PST Wesley Oliver via Std-Proposals
> wrote:
> > The other think that I feel go give a lot more room for improv code speed
> > execution would be gotoReturn, where basically just like a normal
> function
> > call, however, return address is placed on the stack and non of the
> > parameters, which would allow for the same speed improvements as inline
> and
> > optimizing as if there was no function boundaries for register and
> > parameter usage.
>
> Parameter passing in registers is already the case in all modern platforms
> and
> has been for 15 years.
>
> --
> Thiago Macieira - thiago (AT) macieira.info - thiago (AT) kde.org
> Software Architect - Intel DPG Cloud Engineering
>
>
>
> --
> Std-Proposals mailing list
> Std-Proposals_at_[hidden]
> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>

-- 
----
GitHub:https://github.com/wesleyolis
LinkedIn:https://www.linkedin.com/in/wesley-walter-anton-oliver-85466613b/
Blog/Website:https://sites.google.com/site/wiprogamming/Home
Skype: wezley_oliver
MSN messenger: wesley.olis_at_[hidden]