8343846: [lworld] implement spec changes to stack map tables

src/hotspot/share/classfile/stackMapTable.cpp

@@ -273,7 +273,7 @@ StackMapFrame* StackMapReader::next(
 
   u2 offset_delta = _stream->get_u2(CHECK_NULL);
 
-  if (frame_type < SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
+  if (frame_type < ASSERT_UNSET_FIELDS) {
     // reserved frame types
     _stream->stackmap_format_error(
       "reserved frame type", CHECK_VERIFY_(_verifier, nullptr));

src/hotspot/share/classfile/stackMapTable.hpp

@@ -134,6 +134,7 @@ class StackMapReader : StackObj {
   }
 
   enum {
+    ASSERT_UNSET_FIELDS = 246,
     SAME_LOCALS_1_STACK_ITEM_EXTENDED = 247,
     SAME_EXTENDED = 251,
     FULL = 255

src/java.base/share/classes/java/lang/classfile/attribute/StackMapFrameInfo.java

@@ -27,6 +27,7 @@
 
 import java.lang.classfile.Label;
 import java.lang.classfile.constantpool.ClassEntry;
+import java.lang.classfile.constantpool.NameAndTypeEntry;
 import java.lang.constant.ClassDesc;
 import java.util.List;
 
@@ -61,6 +62,13 @@ public sealed interface StackMapFrameInfo
      */
     List<VerificationTypeInfo> stack();
 
+    /**
+     * {@return the expanded unset fields}
+     *
+     * @see <a href="https://cr.openjdk.org/~dlsmith/jep401/jep401-20241108/specs/value-objects-jvms.html">Specs</a>
+     */
+    List<NameAndTypeEntry> unsetFields();
+
     /**
      * {@return a new stack map frame}
      * @param target the location of the frame
@@ -71,7 +79,22 @@ public static StackMapFrameInfo of(Label target,
             List<VerificationTypeInfo> locals,
             List<VerificationTypeInfo> stack) {
 
-        return new StackMapDecoder.StackMapFrameImpl(255, target, locals, stack);
+        return of(target, locals, stack, List.of());
+    }
+
+    /**
+     * {@return a new stack map frame}
+     * @param target the location of the frame
+     * @param locals the complete list of frame locals
+     * @param stack the complete frame stack
+     * @param unsetFields the complete list of unset fields
+     */
+    public static StackMapFrameInfo of(Label target,
+                                       List<VerificationTypeInfo> locals,
+                                       List<VerificationTypeInfo> stack,
+                                       List<NameAndTypeEntry> unsetFields) {
+
+        return new StackMapDecoder.StackMapFrameImpl(255, target, locals, stack, unsetFields);
     }
 
     /**

src/java.base/share/classes/jdk/internal/classfile/impl/CodeImpl.java

@@ -280,7 +280,7 @@ private void inflateJumpTargets() {
         int p = stackMapPos + 2;
         for (int i = 0; i < nEntries; ++i) {
             int frameType = classReader.readU1(p);
-            int offsetDelta;
+            int offsetDelta = -1;
             if (frameType < 64) {
                 offsetDelta = frameType;
                 ++p;
@@ -289,8 +289,14 @@ else if (frameType < 128) {
                 offsetDelta = frameType & 0x3f;
                 p = adjustForObjectOrUninitialized(p + 1);
             }
-            else
+            else {
                 switch (frameType) {
+                    case 246 -> {
+                        int numberOfUnsetFields = classReader.readU2(p + 1);
+                        p += 3;
+                        p += 2 * numberOfUnsetFields;
+                        continue; // do not move bci/create label
+                    }
                     case 247 -> {
                         offsetDelta = classReader.readU2(p + 1);
                         p = adjustForObjectOrUninitialized(p + 3);
@@ -323,6 +329,7 @@ else if (frameType < 128) {
                     }
                     default -> throw new IllegalArgumentException("Bad frame type: " + frameType);
                 }
+            }
             bci += offsetDelta + 1;
             inflateLabel(bci);
         }

src/java.base/share/classes/jdk/internal/classfile/impl/StackMapDecoder.java

@@ -35,23 +35,30 @@
 import java.lang.classfile.attribute.StackMapFrameInfo.UninitializedVerificationTypeInfo;
 import java.lang.classfile.attribute.StackMapFrameInfo.VerificationTypeInfo;
 import java.lang.classfile.constantpool.ClassEntry;
+import java.lang.classfile.constantpool.NameAndTypeEntry;
+import java.lang.classfile.constantpool.PoolEntry;
 import java.lang.constant.ConstantDescs;
 import java.lang.constant.MethodTypeDesc;
 import java.lang.reflect.AccessFlag;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
 
+import jdk.internal.access.SharedSecrets;
+
 import static java.lang.classfile.ClassFile.ACC_STATIC;
 import static java.lang.classfile.attribute.StackMapFrameInfo.VerificationTypeInfo.*;
 import static java.util.Objects.requireNonNull;
 
 public class StackMapDecoder {
 
     private static final int
+                    ASSERT_UNSET_FIELDS = 246,
                     SAME_LOCALS_1_STACK_ITEM_EXTENDED = 247,
                     SAME_EXTENDED = 251;
+    private static final int RESERVED_TAGS_UPPER_LIMIT = ASSERT_UNSET_FIELDS; // not inclusive
     private static final StackMapFrameInfo[] NO_STACK_FRAME_INFOS = {};
 
     private final ClassReader classReader;
@@ -181,12 +188,29 @@ private static void writeTypeInfo(BufWriterImpl bw, VerificationTypeInfo vti) {
         }
     }
 
+    // Copied from BoundAttribute
+    <E extends PoolEntry> List<E> readEntryList(int p, Class<E> type) {
+        int cnt = classReader.readU2(p);
+        p += 2;
+        var entries = new Object[cnt];
+        int end = p + (cnt * 2);
+        for (int i = 0; p < end; i++, p += 2) {
+            entries[i] = classReader.readEntry(p, type);
+        }
+        return SharedSecrets.getJavaUtilCollectionAccess().listFromTrustedArray(entries);
+    }
+
     List<StackMapFrameInfo> entries() {
         p = pos;
         List<VerificationTypeInfo> locals = initFrameLocals, stack = List.of();
+        List<NameAndTypeEntry> unsetFields = List.of();
         int bci = -1;
-        var entries = new StackMapFrameInfo[u2()];
-        for (int ei = 0; ei < entries.length; ei++) {
+        int len = u2();
+        var entries = new ArrayList<StackMapFrameInfo>(len);
+        List<List<NameAndTypeEntry>> deferredUnsetFields = new ArrayList<>();
+        for (int ei = 0; ei < len; ei++) {
+            var oldLocals = locals;
+            var oldStack = stack;
             int frameType = classReader.readU1(p++);
             if (frameType < 64) {
                 bci += frameType + 1;
@@ -195,8 +219,14 @@ List<StackMapFrameInfo> entries() {
                 bci += frameType - 63;
                 stack = List.of(readVerificationTypeInfo());
             } else {
-                if (frameType < SAME_LOCALS_1_STACK_ITEM_EXTENDED)
+                if (frameType < RESERVED_TAGS_UPPER_LIMIT)
                     throw new IllegalArgumentException("Invalid stackmap frame type: " + frameType);
+                if (frameType == ASSERT_UNSET_FIELDS) {
+                    unsetFields = readEntryList(p, NameAndTypeEntry.class);
+                    p += 2 + unsetFields.size() * 2;
+                    deferredUnsetFields.add(unsetFields);
+                    continue; // defer entry until we can get the bci
+                }
                 bci += u2() + 1;
                 if (frameType == SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
                     stack = List.of(readVerificationTypeInfo());
@@ -223,12 +253,22 @@ List<StackMapFrameInfo> entries() {
                     stack = List.of(newStack);
                 }
             }
-            entries[ei] = new StackMapFrameImpl(frameType,
-                        ctx.getLabel(bci),
+            Label label = ctx.getLabel(bci);
+            if (!deferredUnsetFields.isEmpty()) {
+                // technically we only have one assert at once, just in case
+                // of duplicate asserts...
+                for (var deferredList : deferredUnsetFields) {
+                    entries.add(new StackMapFrameImpl(ASSERT_UNSET_FIELDS,
+                                label, oldLocals, oldStack, deferredList));
+                }
+                deferredUnsetFields.clear();
+            }
+            entries.add(new StackMapFrameImpl(frameType,
+                        label,
                         locals,
-                        stack);
+                        stack));
         }
-        return List.of(entries);
+        return List.copyOf(entries);
     }
 
     private VerificationTypeInfo readVerificationTypeInfo() {
@@ -299,12 +339,21 @@ private int u2() {
     public static record StackMapFrameImpl(int frameType,
                                            Label target,
                                            List<VerificationTypeInfo> locals,
-                                           List<VerificationTypeInfo> stack)
+                                           List<VerificationTypeInfo> stack,
+                                           List<NameAndTypeEntry> unsetFields)
             implements StackMapFrameInfo {
         public StackMapFrameImpl {
             requireNonNull(target);
             locals = List.copyOf(locals);
             stack = List.copyOf(stack);
+            unsetFields = List.copyOf(unsetFields);
+        }
+
+        public StackMapFrameImpl(int frameType,
+                                 Label target,
+                                 List<VerificationTypeInfo> locals,
+                                 List<VerificationTypeInfo> stack) {
+            this(frameType, target, locals, stack, List.of());
         }
     }
 }

src/java.base/share/classes/jdk/internal/classfile/impl/verifier/VerificationTable.java

@@ -159,9 +159,11 @@ void check_verification_type_array_size(int size, int max_size) {
         }
 
         private static final int
+                        ASSERT_UNSET_FIELDS = 246,
                         SAME_LOCALS_1_STACK_ITEM_EXTENDED = 247,
                         SAME_EXTENDED = 251,
                         FULL = 255;
+        private static final int RESERVED_TAGS_UPPER_LIMIT = ASSERT_UNSET_FIELDS; // not inclusive
 
         public int get_frame_count() {
             return _frame_count;
@@ -278,7 +280,7 @@ public VerificationFrame next(VerificationFrame pre_frame, boolean first, int ma
                 return frame;
             }
             int offset_delta = _stream.get_u2();
-            if (frame_type < SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
+            if (frame_type < RESERVED_TAGS_UPPER_LIMIT) {
                 _verifier.classError("reserved frame type");
             }
             if (frame_type == SAME_LOCALS_1_STACK_ITEM_EXTENDED) {

src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Flow.java

@@ -27,14 +27,14 @@
 
 package com.sun.tools.javac.comp;
 
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.function.Consumer;
 
-import com.sun.source.tree.CaseTree;
 import com.sun.source.tree.LambdaExpressionTree.BodyKind;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Scope.WriteableScope;
@@ -60,8 +60,6 @@
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
 import com.sun.tools.javac.util.JCDiagnostic.Fragment;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -218,6 +216,7 @@ public class Flow {
     private Env<AttrContext> attrEnv;
     private       Lint lint;
     private final Infer infer;
+    private final UnsetFieldsInfo unsetFieldsInfo;
 
     public static Flow instance(Context context) {
         Flow instance = context.get(flowKey);
@@ -344,7 +343,7 @@ protected Flow(Context context) {
         infer = Infer.instance(context);
         rs = Resolve.instance(context);
         diags = JCDiagnostic.Factory.instance(context);
-        Source source = Source.instance(context);
+        unsetFieldsInfo = UnsetFieldsInfo.instance(context);
     }
 
     /**
@@ -2298,11 +2297,21 @@ void uninit(VarSymbol sym) {
          *  record an initialization of the variable.
          */
         void letInit(JCTree tree) {
+            letInit(tree, (JCAssign) null);
+        }
+
+        void letInit(JCTree tree, JCAssign assign) {
             tree = TreeInfo.skipParens(tree);
             if (tree.hasTag(IDENT) || tree.hasTag(SELECT)) {
                 Symbol sym = TreeInfo.symbol(tree);
                 if (sym.kind == VAR) {
                     letInit(tree.pos(), (VarSymbol)sym);
+                    if (isConstructor && sym.isStrict()) {
+                        /* we are initializing a strict field inside of a constructor, we now need to find which fields
+                         * haven't been initialized yet
+                         */
+                        unsetFieldsInfo.addUnsetFieldsInfo(classDef.sym, assign != null ? assign : tree, findUninitStrictFields());
+                    }
                 }
             }
         }
@@ -2534,6 +2543,13 @@ public void visitMethodDef(JCMethodDecl tree) {
                          */
                         initParam(def);
                     }
+                    if (isConstructor) {
+                        Set<VarSymbol> unsetFields = findUninitStrictFields();
+                        if (unsetFields != null && !unsetFields.isEmpty()) {
+                            unsetFieldsInfo.addUnsetFieldsInfo(classDef.sym, tree.body, unsetFields);
+                        }
+                    }
+
                     // else we are in an instance initializer block;
                     // leave caught unchanged.
                     scan(tree.body);
@@ -2589,6 +2605,17 @@ public void visitMethodDef(JCMethodDecl tree) {
             }
         }
 
+        Set<VarSymbol> findUninitStrictFields() {
+            Set<VarSymbol> unsetFields = new LinkedHashSet<>();
+            for (int i = uninits.nextBit(0); i >= 0; i = uninits.nextBit(i + 1)) {
+                JCVariableDecl variableDecl = vardecls[i];
+                if (variableDecl.sym.isStrict()) {
+                    unsetFields.add(variableDecl.sym);
+                }
+            }
+            return unsetFields;
+        }
+
         private void clearPendingExits(boolean inMethod) {
             List<PendingExit> exits = pendingExits.toList();
             pendingExits = new ListBuffer<>();
@@ -3153,7 +3180,7 @@ public void visitAssign(JCAssign tree) {
             if (!TreeInfo.isIdentOrThisDotIdent(tree.lhs))
                 scanExpr(tree.lhs);
             scanExpr(tree.rhs);
-            letInit(tree.lhs);
+            letInit(tree.lhs, tree);
         }
 
         // check fields accessed through this.<field> are definitely