/*

    The layout of a register frame looks like this:

    For

    function f(x, y) {

        var v1;

        function g() { }

        var v2;

        return (x) * (y);

    }

    assuming (x) and (y) generated temporaries t1 and t2, you would have

    ------------------------------------

    |  x |  y |  g | v2 | v1 | t1 | t2 | <-- value held

    ------------------------------------

    | -5 | -4 | -3 | -2 | -1 | +0 | +1 | <-- register index

    ------------------------------------

    | params->|<-locals      | temps->

    Because temporary registers are allocated in a stack-like fashion, we

    can reclaim them with a simple popping algorithm. The same goes for labels.

    (We never reclaim parameter or local registers, because parameters and

    locals are DontDelete.)

    The register layout before a function call looks like this:

    For

    function f(x, y)

    {

    }

    f(1);

    >                        <------------------------------

    <                        >  reserved: call frame  |  1 | <-- value held

    >         >snip<         <------------------------------

    <                        > +0 | +1 | +2 | +3 | +4 | +5 | <-- register index

    >                        <------------------------------

    | params->|<-locals      | temps->

    The call instruction fills in the "call frame" registers. It also pads

    missing arguments at the end of the call:

    >                        <-----------------------------------

    <                        >  reserved: call frame  |  1 |  ? | <-- value held ("?" stands for "undefined")

    >         >snip<         <-----------------------------------

    <                        > +0 | +1 | +2 | +3 | +4 | +5 | +6 | <-- register index

    >                        <-----------------------------------

    | params->|<-locals      | temps->

    After filling in missing arguments, the call instruction sets up the new

    stack frame to overlap the end of the old stack frame:

                             |---------------------------------->                        <

                             |  reserved: call frame  |  1 |  ? <                        > <-- value held ("?" stands for "undefined")

                             |---------------------------------->         >snip<         <

                             | -7 | -6 | -5 | -4 | -3 | -2 | -1 <                        > <-- register index

                             |---------------------------------->                        <

                             |                        | params->|<-locals       | temps->

    That way, arguments are "copied" into the callee's stack frame for free.

    If the caller supplies too many arguments, this trick doesn't work. The

    extra arguments protrude into space reserved for locals and temporaries.

    In that case, the call instruction makes a real copy of the call frame header,

    along with just the arguments expected by the callee, leaving the original

    call frame header and arguments behind. (The call instruction can't just discard

    extra arguments, because the "arguments" object may access them later.)

    This copying strategy ensures that all named values will be at the indices

    expected by the callee.

*/