static int compare(Type[] arr1,
    Type[] arr2,
    Types types) 
{
            int diff_length = arr1.length - arr2.length;
            if (diff_length  > MAX_LOCAL_LENGTH_DIFF || diff_length <  -MAX_LOCAL_LENGTH_DIFF) {
                return Integer.MAX_VALUE;
            }
            int len = (diff_length  > 0) ? arr2.length : arr1.length;
            for (int i=0; i< len; i++) {
                if (!isSameType(arr1[i], arr2[i], types)) {
                    return Integer.MAX_VALUE;
                }
            }
            return diff_length;
}

 abstract int getFrameType()

 static StackMapTableFrame getInstance(StackMapFrame this_frame,
    int prev_pc,
    Type[] prev_locals,
    Types types) 
{
            Type[] locals = this_frame.locals;
            Type[] stack = this_frame.stack;
            int offset_delta = this_frame.pc - prev_pc - 1;
            if (stack.length == 1) {
                if (locals.length == prev_locals.length
                    && compare(prev_locals, locals, types) == 0) {
                    return new SameLocals1StackItemFrame(offset_delta, stack[0]);
                }
            } else if (stack.length == 0) {
                int diff_length = compare(prev_locals, locals, types);
                if (diff_length == 0) {
                    return new SameFrame(offset_delta);
                } else if (-MAX_LOCAL_LENGTH_DIFF <  diff_length && diff_length <  0) {
                    // APPEND
                    Type[] local_diff = new Type[-diff_length];
                    for (int i=prev_locals.length, j=0; i< locals.length; i++,j++) {
                        local_diff[j] = locals[i];
                    }
                    return new AppendFrame(SAME_FRAME_EXTENDED - diff_length,
                                           offset_delta,
                                           local_diff);
                } else if (0 <  diff_length && diff_length <  MAX_LOCAL_LENGTH_DIFF) {
                    // CHOP
                    return new ChopFrame(SAME_FRAME_EXTENDED - diff_length,
                                         offset_delta);
                }
            }
            // FULL_FRAME
            return new FullFrame(offset_delta, locals, stack);
}

Compare this frame with the previous frame and produce an entry of compressed stack map frame.

 static boolean isInt(Type t) 
{
            return (t.tag <  TypeTags.INT || t.tag == TypeTags.BOOLEAN);
}

 static boolean isSameType(Type t1,
    Type t2,
    Types types) 
{
            if (t1 == null) { return t2 == null; }
            if (t2 == null) { return false; }
            if (isInt(t1) && isInt(t2)) { return true; }
            if (t1.tag == UNINITIALIZED_THIS) {
                return t2.tag == UNINITIALIZED_THIS;
            } else if (t1.tag == UNINITIALIZED_OBJECT) {
                if (t2.tag == UNINITIALIZED_OBJECT) {
                    return ((UninitializedType)t1).offset == ((UninitializedType)t2).offset;
                } else {
                    return false;
                }
            } else if (t2.tag == UNINITIALIZED_THIS || t2.tag == UNINITIALIZED_OBJECT) {
                return false;
            }
            return types.isSameType(t1, t2);
}

  void write(ClassWriter writer) 
{
            int frameType = getFrameType();
            writer.databuf.appendByte(frameType);
            if (writer.debugstackmap) System.out.print(" frame_type=" + frameType);
}