Note about try/catch/finally:

The presence of an exception handler is handled in some way external to the
bytecode stream; some mapping between each bytecode location and the bytecode
offset of the start of the exception handler.  A catch block will fetch the
caught exception into a register using the ESI_CATCH instruction.  A finally
block will not use ESI_CATCH, leaving the "caught" exception untouched; instead
it uses a ESI_RETHROW (with no operands) to throw it upwards when it ends (if it
at all caught an exception -- finally will run regardless of whether an
exception was thrown or not.)

Other constructs that internally needs to clean up at stack unwinds, primarily
with statements, will register exception handlers and catch exceptions like
finally (no ESI_CATCH but ending with ESI_RETHROW.)

Note about property access caching:

The instructions ESI_GETN_IMM_CACHED, ESI_PUTN_IMM_CACHED and
ESI_PUTN_IMM_CACHED_NEW are never emitted by the compiler.  Instead, the VM
dynamicly replaces ESI_GETN_IMM and ESI_PUTN_IMM instructions with the cached
variants when it has performed a successful operation to enable caching.  To
enable simple replacement, the GET variants have 5 operands and the PUT variants
6, even in cases when not all are used by the actual instruction.

Note about operand types:

'reg()' operands are unsigned indeces into the register array.  There are no
special values to enable use without range checking.  The name within the
parentheses is just documentation and has no special meaning.

Note about function calling convention:

A function call sets up the top of the register frame so that register N is the
this object, register N+1 is the function object, and register N+2 through
N+1+argc are the arguments.  This range of register then forms registers 0
through 1+argc in the called function's register frame.  Register N (0 in the
called function's register frame) is used to pass the return value from the
function when it returns.  Note that the "top" of the register frame is not
necessarily the absolute end of the calling functions register frame; it will
typically use registers with as low indeces as possible.

The ESI_CALL instruction has two operands: register N/0 and argc.  Unlike other
register type operands, the first argument to the ESI_CALL instruction is not
used as a single register, but rather as a pointer to the first register in an
array of registers (though it's still just a register index in the bytecode
stream.)

The ESI_CONSTRUCT instruction works exactly the same way, operand-wise.  The
difference is that the 'this' register is not populated initially, but instead
is set to a newly created object by the instruction itself prior to the actual
call.
