Main constructor; other constructors delegate to this one.

For generating LambdaForm interpreter entry points.

For generating customized code for a single LambdaForm.

Update localClasses type map. Return true if the information is already present.

Emit a bogus method that just loads some string constants. This is to get the constants into the constant pool for debugging purposes.

Generates code to check that actual receiver and LambdaForm matches

Returns the class data object that will be passed to `Lookup.defineHiddenClassWithClassData`. The classData is loaded in the method of the generated class. If the class data contains only one single object, this method returns that single object. If the class data contains more than one objects, this method returns a List. This method returns null if no class data.

Set up class file generation.

Emit a boxing call.

Emit bytecode for the guardWithCatch idiom. The pattern looks like (Cf. MethodHandleImpl.makeGuardWithCatch):

guardWithCatch=Lambda(a0:L,a1:L,a2:L,a3:L,a4:L,a5:L,a6:L,a7:L)=>{
   t8:L=MethodHandle.invokeBasic(a4:L,a6:L,a7:L);
   t9:L=MethodHandleImpl.guardWithCatch(a1:L,a2:L,a3:L,t8:L);
  t10:I=MethodHandle.invokeBasic(a5:L,t9:L);t10:I}

try {
     return a1.invokeBasic(a6, a7);
 } catch (Throwable e) {
     if (!a2.isInstance(e)) throw e;
     return a3.invokeBasic(ex, a6, a7);
 }

Emit an implicit conversion for an argument which must be of the given pclass. This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.

Parameters

ptype:LambdaForm.BasicType

type of value present on stack

pclass:Class<?>

type of value required on stack

arg:Object

compile-time representation of value on stack (Node, constant) or null if none

Emit bytecode for the loop idiom.

The pattern looks like (Cf. MethodHandleImpl.loop):

// a0: BMH
// a1: LoopClauses (containing an array of arrays: inits, steps, preds, finis)
// a2: box, a3: unbox
// a4 (and following): arguments
loop=Lambda(a0:L,a1:L,a2:L,a3:L,a4:L)=>{
  t5:L=MethodHandle.invokeBasic(a2:L,a4:L);          // box the arguments into an Object[]
  t6:L=MethodHandleImpl.loop(bt:L,a1:L,t5:L);        // call the loop executor (with supplied types in bt)
  t7:L=MethodHandle.invokeBasic(a3:L,t6:L);t7:L}     // unbox the result; return the result

It is compiled into bytecode equivalent to the code seen in MethodHandleImpl#loop(BasicType[], MethodHandleImpl.LoopClauses, Object...), with the difference that no arrays will be used for local state storage. Instead, the local state will be mapped to actual stack slots.

Bytecode generation applies an unrolling scheme to enable better bytecode generation regarding local state type handling. The generated bytecode will have the following form (void types are ignored for convenience). Assume there are C clauses in the loop.

PREINIT: ALOAD_1
         CHECKCAST LoopClauses
         GETFIELD LoopClauses.clauses
         ASTORE clauseDataIndex          // place the clauses 2-dimensional array on the stack
INIT:    (INIT_SEQ for clause 1)
         ...
         (INIT_SEQ for clause C)
LOOP:    (LOOP_SEQ for clause 1)
         ...
         (LOOP_SEQ for clause C)
         GOTO LOOP
DONE:    ...

The INIT_SEQ_x sequence for clause x (with x ranging from 0 to C-1) has the following shape. Assume slot vx is used to hold the state for clause x.

INIT_SEQ_x:  ALOAD clauseDataIndex
             ICONST_0
             AALOAD      // load the inits array
             ICONST x
             AALOAD      // load the init handle for clause x
             load args
             INVOKEVIRTUAL MethodHandle.invokeBasic
             store vx

The LOOP_SEQ_x sequence for clause x (with x ranging from 0 to C-1) has the following shape. Again, assume slot vx is used to hold the state for clause x.

LOOP_SEQ_x:  ALOAD clauseDataIndex
             ICONST_1
             AALOAD              // load the steps array
             ICONST x
             AALOAD              // load the step handle for clause x
             load locals
             load args
             INVOKEVIRTUAL MethodHandle.invokeBasic
             store vx
             ALOAD clauseDataIndex
             ICONST_2
             AALOAD              // load the preds array
             ICONST x
             AALOAD              // load the pred handle for clause x
             load locals
             load args
             INVOKEVIRTUAL MethodHandle.invokeBasic
             IFNE LOOP_SEQ_x+1   // predicate returned false -> jump to next clause
             ALOAD clauseDataIndex
             ICONST_3
             AALOAD              // load the finis array
             ICONST x
             AALOAD              // load the fini handle for clause x
             load locals
             load args
             INVOKEVIRTUAL MethodHandle.invokeBasic
             GOTO DONE           // jump beyond end of clauses to return from loop

Emit a type conversion bytecode casting from "from" to "to".

Emits a return statement from a LF invoker. If required, the result type is cast to the correct return type.

Emit bytecode for the selectAlternative idiom. The pattern looks like (Cf. MethodHandleImpl.makeGuardWithTest):

Lambda(a0:L,a1:I)=>{
    t2:I=foo.test(a1:I);
    t3:L=MethodHandleImpl.selectAlternative(t2:I,(MethodHandle(int)int),(MethodHandle(int)int));
    t4:I=MethodHandle.invokeBasic(t3:L,a1:I);t4:I}

Store the name to its local, if necessary.

Emit bytecode for the tryFinally idiom.

The pattern looks like (Cf. MethodHandleImpl.makeTryFinally):

// a0: BMH
// a1: target, a2: cleanup
// a3: box, a4: unbox
// a5 (and following): arguments
tryFinally=Lambda(a0:L,a1:L,a2:L,a3:L,a4:L,a5:L)=>{
  t6:L=MethodHandle.invokeBasic(a3:L,a5:L);         // box the arguments into an Object[]
  t7:L=MethodHandleImpl.tryFinally(a1:L,a2:L,t6:L); // call the tryFinally executor
  t8:L=MethodHandle.invokeBasic(a4:L,t7:L);t8:L}    // unbox the result; return the result

It is compiled into bytecode equivalent to the following code:

Throwable t;
Object r;
try {
    r = a1.invokeBasic(a5);
} catch (Throwable thrown) {
    t = thrown;
    throw t;
} finally {
    r = a2.invokeBasic(t, r, a5);
}
return r;

Specifically, the bytecode will have the following form (the stack effects are given for the beginnings of blocks, and for the situations after executing the given instruction - the code will have a slightly different shape if the return type is void):

TRY:                 (--)
                     load target                             (-- target)
                     load args                               (-- args... target)
                     INVOKEVIRTUAL MethodHandle.invokeBasic  (depends)
FINALLY_NORMAL:      (-- r_2nd* r)
                     store returned value                    (--)
                     load cleanup                            (-- cleanup)
                     ACONST_NULL                             (-- t cleanup)
                     load returned value                     (-- r_2nd* r t cleanup)
                     load args                               (-- args... r_2nd* r t cleanup)
                     INVOKEVIRTUAL MethodHandle.invokeBasic  (-- r_2nd* r)
                     GOTO DONE
CATCH:               (-- t)
                     DUP                                     (-- t t)
FINALLY_EXCEPTIONAL: (-- t t)
                     load cleanup                            (-- cleanup t t)
                     SWAP                                    (-- t cleanup t)
                     load default for r                      (-- r_2nd* r t cleanup t)
                     load args                               (-- args... r_2nd* r t cleanup t)
                     INVOKEVIRTUAL MethodHandle.invokeBasic  (-- r_2nd* r t)
                     POP/POP2*                               (-- t)
                     ATHROW
DONE:                (-- r)

Emit an unboxing call (plus preceding checkcast).

Generate an invoker method for the passed LambdaForm.

Extract the MemberName of a newly-defined method.

Look up a method that may have been generated by GenerateJLIClassesHelper.