Method Invocation:
   Caller:
      a0: object ID
      a1: method ID

      a2: pointer to args (low addr to high, padded as in a struct):
          Out arrays can be preallocated.  Scalar outs are ignored,
          but space is made for them.  NULL array params and arrays
          which are larger than the preallocated buffer are
          allocated by the callee.  Arrays are passed as a pointer
          and a 64-bit element count, in that order.  Objects are
          passed as pointers.
      
      Call a special symbol TBD to invoke the method.
      
      Upon return:
      params on stack, with out params filled in and out params clobbered

      t0-t11, at, ra clobbered
      v0: pointer to exception, or NULL if none.
      a2: pointer to args, with out params filled in; in params
          may be clobbered
      
   Callee:
      params on stack (low addr to high), ids replaced with pointers,
      at least 8 bytes of spare space beyond the high element

      a0: object pointer
      a1: pointer to caller information struct, if such was
          requested
      ra: return address
      
      Upon return:
      
      params on stack (low addr to high), in params may be clobbered
      t0-t11, at, ra may be clobbered
      v0: pointer to exception, or NULL if none.

Stack:
   sp is stack pointer, grows down, decrement before store
      
Object structure:
   The object ID is stored as a 64-bit quantity at an offset
   specified by calling a method TBD.

Wrapper object creation:
	The function to create wrapper objects is specified by calling a
   method TBD.  The function shall conform to the local ABI, and
   takes an ID as a 64-bit integer as the first parameter, and a
   pointer to the class as the second. It returns a pointer.
   
   Wrapper objects may be preemptively declared to avoid infinite
   loops by calling a method TBD.

Struct padding:
   All fields are padded so that basic types are naturally aligned.