Bytecode locals compaction

src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeGenerator.java

@@ -33,6 +33,7 @@
 import java.lang.reflect.code.op.CoreOp.*;
 
 import java.lang.classfile.ClassBuilder;
+import java.lang.classfile.ClassModel;
 import java.lang.classfile.Opcode;
 import java.lang.classfile.TypeKind;
 import java.lang.classfile.attribute.ConstantValueAttribute;
@@ -129,7 +130,9 @@ public static <O extends Op & Op.Invokable> MethodHandle generate(MethodHandles.
      * @return the class file bytes
      */
     public static byte[] generateClassData(MethodHandles.Lookup lookup, FuncOp fop) {
-        return generateClassData(lookup, fop.funcName(), fop);
+        ClassModel generatedModel = ClassFile.of().parse(generateClassData(lookup, fop.funcName(), fop));
+        // Compact locals of the generated bytecode
+        return ClassFile.of().transform(generatedModel, LocalsCompactor.INSTANCE);
     }
 
     /**
@@ -204,6 +207,7 @@ private record ExceptionRegionWithBlocks(ExceptionRegionEnter ere, BitSet blocks
     private final Map<Block.Parameter, Value> singlePredecessorsValues;
     private final List<LambdaOp> lambdaSink;
     private final BitSet quotable;
+    private final Map<Op, Boolean> deferCache;
     private Value oprOnStack;
 
     private BytecodeGenerator(MethodHandles.Lookup lookup,
@@ -230,6 +234,7 @@ private BytecodeGenerator(MethodHandles.Lookup lookup,
         this.singlePredecessorsValues = new HashMap<>();
         this.lambdaSink = lambdaSink;
         this.quotable = quotable;
+        this.deferCache = new HashMap<>();
     }
 
     private void setExceptionRegionStack(Block.Reference target, BitSet activeRegionStack) {
@@ -347,13 +352,18 @@ private void processOperands(List<Value> operands) {
     }
 
     // Some of the operations can be deferred
-    private static boolean canDefer(Op op) {
-        return switch (op) {
-            case ConstantOp cop -> canDefer(cop);
-            case VarOp vop -> canDefer(vop);
-            case VarAccessOp.VarLoadOp vlop -> canDefer(vlop);
-            default -> false;
-        };
+    private boolean canDefer(Op op) {
+        Boolean can = deferCache.get(op);
+        if (can == null) {
+            can = switch (op) {
+                case ConstantOp cop -> canDefer(cop);
+                case VarOp vop -> canDefer(vop);
+                case VarAccessOp.VarLoadOp vlop -> canDefer(vlop);
+                default -> false;
+            };
+            deferCache.put(op, can);
+        }
+        return can;
     }
 
     // Constant can be deferred, except for loading of a class constant, which  may throw an exception
@@ -413,7 +423,7 @@ private static boolean isDominatedBy(Op.Result n, Set<Op.Result> doms) {
     }
 
     // Var load can be deferred when not used as immediate operand
-    private static boolean canDefer(VarAccessOp.VarLoadOp op) {
+    private boolean canDefer(VarAccessOp.VarLoadOp op) {
         return !isNextUse(op.result());
     }
 
@@ -445,7 +455,7 @@ case ConditionalBranchOp op when getConditionForCondBrOp(op) instanceof BinaryTe
     }
 
     // Determines if the operation result is immediatelly used by the next operation and so can stay on stack
-    private static boolean isNextUse(Value opr) {
+    private boolean isNextUse(Value opr) {
         Op nextOp = switch (opr) {
             case Block.Parameter p -> p.declaringBlock().firstOp();
             case Op.Result r -> r.declaringBlock().nextOp(r.op());

src/java.base/share/classes/java/lang/reflect/code/bytecode/BytecodeLift.java

@@ -73,10 +73,13 @@
 import java.util.stream.Stream;
 
 import static java.lang.classfile.attribute.StackMapFrameInfo.SimpleVerificationTypeInfo.*;
+import java.lang.invoke.MethodHandles;
 import java.util.BitSet;
 
 public final class BytecodeLift {
 
+    public static boolean DUMP = false; // @@@ only for debugging purpose
+
     private record ExceptionRegion(Label startLabel, Label endLabel, Label handlerLabel) {}
     private record ExceptionRegionEntry(Op.Result enter, Block.Builder startBlock, ExceptionRegion region) {}
 
@@ -134,7 +137,7 @@ private BytecodeLift(Block.Builder entryBlock, ClassModel classModel, CodeModel
                 initLocalValues.add(null);
             }
         });
-        this.codeTracker = new LocalsTypeMapper(classModel.thisClass().asSymbol(), initLocalTypes, codeModel.exceptionHandlers(), smta, elements);
+        this.codeTracker = new LocalsTypeMapper(classModel.thisClass().asSymbol(), initLocalTypes, codeModel.exceptionHandlers(), smta, elements, codeAttribtue);
         this.blockMap = smta.map(sma ->
                 sma.entries().stream().collect(Collectors.toUnmodifiableMap(
                         StackMapFrameInfo::target,
@@ -423,35 +426,13 @@ private void liftBody() {
                     endOfFlow();
                 }
                 case LoadInstruction inst -> {
-                    LocalsTypeMapper.Variable var = codeTracker.getVarOf(i);
-                    if (var.isSingleValue) {
-                        assert var.value != null;
-                        stack.push(var.value);
-                    } else {
-                        assert var.value instanceof Op.Result r && r.op() instanceof CoreOp.VarOp;
-                        stack.push(op(CoreOp.varLoad(var.value)));
-                    }
+                    stack.push(load(i));
                 }
                 case StoreInstruction inst -> {
-                    LocalsTypeMapper.Variable var = codeTracker.getVarOf(i);
-                    if (var.isSingleValue) {
-                        assert var.value == null;
-                        var.value = stack.pop();
-                    } else {
-                        if (var.value == null) {
-                            var.value = op(CoreOp.var("slot#" + inst.slot(), var.type(), stack.pop()));
-                        } else {
-                            assert var.value instanceof Op.Result r && r.op() instanceof CoreOp.VarOp;
-                            op(CoreOp.varStore(var.value, stack.pop()));
-                        }
-                    }
+                    store(i, inst.slot(), stack.pop());
                 }
                 case IncrementInstruction inst -> {
-                    LocalsTypeMapper.Variable var = codeTracker.getVarOf(i);
-                    assert !var.isSingleValue && var.value instanceof Op.Result r && r.op() instanceof CoreOp.VarOp;
-                    op(CoreOp.varStore(var.value, op(CoreOp.add(
-                            op(CoreOp.varLoad(var.value)),
-                            liftConstant(inst.constant())))));
+                    store(i, inst.slot(), op(CoreOp.add(load(-i - 1), liftConstant(inst.constant()))));
                 }
                 case ConstantInstruction inst -> {
                     stack.push(liftConstant(inst.constantValue()));
@@ -835,6 +816,32 @@ yield op(CoreOp._new(
         }
     }
 
+    private Value load(int i) {
+        LocalsTypeMapper.Variable var = codeTracker.getVarOf(i);
+        if (var.isSingleValue) {
+            assert var.value != null;
+            return var.value;
+        } else {
+            assert var.value instanceof Op.Result r && r.op() instanceof CoreOp.VarOp;
+            return op(CoreOp.varLoad(var.value));
+        }
+    }
+
+    private void store(int i, int slot, Value value) {
+        LocalsTypeMapper.Variable var = codeTracker.getVarOf(i);
+        if (var.isSingleValue) {
+            assert var.value == null;
+            var.value = value;
+        } else {
+            if (var.value == null) {
+                var.value = op(CoreOp.var("slot#" + slot, var.type(), value));
+            } else {
+                assert var.value instanceof Op.Result r && r.op() instanceof CoreOp.VarOp;
+                op(CoreOp.varStore(var.value, value));
+            }
+        }
+    }
+
     private Op.Result lookup() {
         return constantCache.computeIfAbsent(LOOKUP, _ -> op(CoreOp.invoke(LOOKUP)));
     }