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

Co-authored-by: Vicente Romero <vromero@openjdk.org>
Reviewed-by: coleenp, fparain, liach

Author: 2 people

src/hotspot/share/classfile/stackMapFrame.cpp

@@ -31,10 +31,10 @@
 #include "runtime/handles.inline.hpp"
 #include "utilities/globalDefinitions.hpp"
 
-StackMapFrame::StackMapFrame(u2 max_locals, u2 max_stack, ClassVerifier* v) :
+StackMapFrame::StackMapFrame(u2 max_locals, u2 max_stack, AssertUnsetFieldTable* initial_strict_fields, ClassVerifier* v) :
                       _offset(0), _locals_size(0), _stack_size(0),
                       _stack_mark(0), _max_locals(max_locals),
-                      _max_stack(max_stack), _flags(0), _verifier(v) {
+                      _max_stack(max_stack), _flags(0), _assert_unset_fields(initial_strict_fields), _verifier(v) {
   Thread* thr = v->thread();
   _locals = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_locals);
   _stack = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_stack);
@@ -47,10 +47,23 @@ StackMapFrame::StackMapFrame(u2 max_locals, u2 max_stack, ClassVerifier* v) :
   }
 }
 
+void StackMapFrame::print_strict_fields(AssertUnsetFieldTable* table) {
+  ResourceMark rm;
+  auto printfields = [&] (const NameAndSig& key, const bool& value) {
+    log_info(verification)("Strict field: %s%s (Satisfied: %s)",
+                           key._name->as_C_string(),
+                           key._signature->as_C_string(),
+                           value ? "true" : "false");
+  };
+  table->iterate_all(printfields);
+}
+
 StackMapFrame* StackMapFrame::frame_in_exception_handler(u1 flags) {
   Thread* thr = _verifier->thread();
   VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, 1);
-  StackMapFrame* frame = new StackMapFrame(_offset, flags, _locals_size, 0, _max_locals, _max_stack, _locals, stack, _verifier);
+  StackMapFrame* frame = new StackMapFrame(_offset, flags, _locals_size, 0,
+                                           _max_locals, _max_stack, _locals, stack,
+                                           _assert_unset_fields, _verifier);
   return frame;
 }
 
@@ -188,6 +201,14 @@ bool StackMapFrame::is_assignable_to(
     return false;
   }
 
+  // Check that assert unset fields are compatible
+  bool compatible = verify_unset_fields_compatibility(target->assert_unset_fields());
+  if (!compatible) {
+    *ctx = ErrorContext::strict_fields_mismatch(target->offset(),
+        (StackMapFrame*)this, (StackMapFrame*)target);
+    return false;
+  }
+
   if ((_flags | target->flags()) == target->flags()) {
     return true;
   } else {

src/hotspot/share/classfile/stackMapFrame.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -41,6 +41,21 @@ enum {
 };
 
 class StackMapFrame : public ResourceObj {
+ public:
+  static unsigned int nameandsig_hash(NameAndSig const& field) {
+    Symbol* name = field._name;
+    return (unsigned int) name->identity_hash();
+  }
+
+  static inline bool nameandsig_equals(NameAndSig const& f1, NameAndSig const& f2) {
+    return f1._name == f2._name &&
+           f1._signature == f2._signature;
+  }
+
+  // Maps a strict field's name and signature to whether or not it was initialized
+  typedef ResourceHashtable<NameAndSig, bool, 17,
+                    AnyObj::RESOURCE_AREA, mtInternal,
+                    nameandsig_hash, nameandsig_equals> AssertUnsetFieldTable;
  private:
   int32_t _offset;
 
@@ -60,6 +75,8 @@ class StackMapFrame : public ResourceObj {
   VerificationType* _locals; // local variable type array
   VerificationType* _stack;  // operand stack type array
 
+  AssertUnsetFieldTable* _assert_unset_fields; // List of unsatisfied strict fields in the basic block
+
   ClassVerifier* _verifier;  // the verifier verifying this method
 
   StackMapFrame(const StackMapFrame& cp) :
@@ -85,6 +102,7 @@ class StackMapFrame : public ResourceObj {
         _stack[i] = VerificationType::bogus_type();
       }
     }
+    _assert_unset_fields = cp._assert_unset_fields;
     _verifier = nullptr;
   }
 
@@ -94,7 +112,7 @@ class StackMapFrame : public ResourceObj {
   // This constructor is used by the type checker to allocate frames
   // in type state, which have _max_locals and _max_stack array elements
   // in _locals and _stack.
-  StackMapFrame(u2 max_locals, u2 max_stack, ClassVerifier* verifier);
+  StackMapFrame(u2 max_locals, u2 max_stack, AssertUnsetFieldTable* initial_strict_fields, ClassVerifier* verifier);
 
   // This constructor is used to initialize stackmap frames in stackmap table,
   // which have _locals_size and _stack_size array elements in _locals and _stack.
@@ -106,13 +124,15 @@ class StackMapFrame : public ResourceObj {
                 u2 max_stack,
                 VerificationType* locals,
                 VerificationType* stack,
+                AssertUnsetFieldTable* assert_unset_fields,
                 ClassVerifier* v) : _offset(offset),
                                     _locals_size(locals_size),
                                     _stack_size(stack_size),
                                     _stack_mark(-1),
                                     _max_locals(max_locals),
                                     _max_stack(max_stack),  _flags(flags),
                                     _locals(locals), _stack(stack),
+                                    _assert_unset_fields(assert_unset_fields),
                                     _verifier(v) { }
 
   static StackMapFrame* copy(StackMapFrame* smf) {
@@ -136,6 +156,66 @@ class StackMapFrame : public ResourceObj {
   inline u2 max_stack() const                 { return _max_stack; }
   inline bool flag_this_uninit() const        { return _flags & FLAG_THIS_UNINIT; }
 
+  AssertUnsetFieldTable* assert_unset_fields() const {
+    return _assert_unset_fields;
+  }
+
+  void set_assert_unset_fields(AssertUnsetFieldTable* table) {
+    _assert_unset_fields = table;
+  }
+
+  // Called when verifying putfields to mark strict instance fields as satisfied
+  bool satisfy_unset_field(Symbol* name, Symbol* signature) {
+    NameAndSig dummy_field(name, signature);
+
+    if (_assert_unset_fields->contains(dummy_field)) {
+      _assert_unset_fields->put(dummy_field, true);
+      return true;
+    }
+    return false;
+  }
+
+  // Verify that all strict fields have been initialized
+  // Strict fields must be initialized before the super constructor is called
+  bool verify_unset_fields_satisfied() {
+    bool all_satisfied = true;
+    auto check_satisfied = [&] (const NameAndSig& key, const bool& value) {
+      all_satisfied &= value;
+    };
+    _assert_unset_fields->iterate_all(check_satisfied);
+    return all_satisfied;
+  }
+
+  // Merge incoming unset strict fields from StackMapTable with
+  // initial strict instance fields
+  AssertUnsetFieldTable* merge_unset_fields(AssertUnsetFieldTable* new_fields) {
+    auto merge_satisfied = [&] (const NameAndSig& key, const bool& value) {
+      if (!new_fields->contains(key)) {
+        new_fields->put(key, true);
+      }
+    };
+    _assert_unset_fields->iterate_all(merge_satisfied);
+    return new_fields;
+  }
+
+  // Verify that strict fields are compatible between the current frame and the successor
+  // Called during merging of frames
+  bool verify_unset_fields_compatibility(AssertUnsetFieldTable* target_table) const {
+    bool compatible = true;
+    auto is_unset = [&] (const NameAndSig& key, const bool& value) {
+      // Successor must have same debts as current frame
+      if (!value) {
+        if (*target_table->get(key) == true) {
+          compatible = false;
+        }
+      }
+    };
+    _assert_unset_fields->iterate_all(is_unset);
+    return compatible;
+  }
+
+  static void print_strict_fields(AssertUnsetFieldTable* table);
+
   // Set locals and stack types to bogus
   inline void reset() {
     int32_t i;

src/hotspot/share/classfile/stackMapTable.cpp

@@ -127,6 +127,7 @@ bool StackMapTable::match_stackmap(
     frame->set_stack_size(ssize);
     frame->copy_stack(stackmap_frame);
     frame->set_flags(stackmap_frame->flags());
+    frame->set_assert_unset_fields(stackmap_frame->assert_unset_fields());
   }
   return result;
 }
@@ -157,11 +158,13 @@ void StackMapTable::print_on(outputStream* str) const {
 StackMapReader::StackMapReader(ClassVerifier* v, StackMapStream* stream,
                                char* code_data, int32_t code_len,
                                StackMapFrame* init_frame,
-                               u2 max_locals, u2 max_stack, TRAPS) :
+                               u2 max_locals, u2 max_stack,
+                               StackMapFrame::AssertUnsetFieldTable* initial_strict_fields, TRAPS) :
                                   _verifier(v), _stream(stream), _code_data(code_data),
                                   _code_length(code_len), _parsed_frame_count(0),
                                   _prev_frame(init_frame), _max_locals(max_locals),
-                                  _max_stack(max_stack), _first(true) {
+                                  _max_stack(max_stack), _assert_unset_fields_buffer(initial_strict_fields),
+                                  _first(true) {
   methodHandle m = v->method();
   if (m->has_stackmap_table()) {
     _cp = constantPoolHandle(THREAD, m->constants());
@@ -245,6 +248,39 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
   int offset;
   VerificationType* locals = nullptr;
   u1 frame_type = _stream->get_u1(CHECK_NULL);
+  if (frame_type == ASSERT_UNSET_FIELDS) {
+    u2 num_unset_fields = _stream->get_u2(CHECK_NULL);
+    StackMapFrame::AssertUnsetFieldTable* new_fields = new StackMapFrame::AssertUnsetFieldTable();
+
+    for (u2 i = 0; i < num_unset_fields; i++) {
+      u2 index = _stream->get_u2(CHECK_NULL);
+      Symbol* name = _cp->symbol_at(_cp->name_ref_index_at(index));
+      Symbol* sig = _cp->symbol_at(_cp->signature_ref_index_at(index));
+      NameAndSig tmp(name, sig);
+
+      if (!_prev_frame->assert_unset_fields()->contains(tmp)) {
+        ResourceMark rm(THREAD);
+        log_info(verification)("Field %s%s is not found among initial strict instance fields", name->as_C_string(), sig->as_C_string());
+        StackMapFrame::print_strict_fields(_prev_frame->assert_unset_fields());
+        _prev_frame->verifier()->verify_error(
+            ErrorContext::bad_strict_fields(_prev_frame->offset(), _prev_frame),
+            "Strict fields not a subset of initial strict instance fields");
+      } else {
+        new_fields->put(tmp, false);
+      }
+    }
+
+    // Only modify strict instance fields the frame has uninitialized this
+    if (_prev_frame->flag_this_uninit()) {
+      _assert_unset_fields_buffer = _prev_frame->merge_unset_fields(new_fields);
+    } else if (new_fields->number_of_entries() > 0) {
+      _prev_frame->verifier()->verify_error(
+        ErrorContext::bad_strict_fields(_prev_frame->offset(), _prev_frame),
+        "Cannot have uninitialized strict fields after class initialization");
+    }
+
+    return nullptr;
+  }
   if (frame_type < 64) {
     // same_frame
     if (_first) {
@@ -260,7 +296,8 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
     }
     frame = new StackMapFrame(
       offset, _prev_frame->flags(), _prev_frame->locals_size(), 0,
-      _max_locals, _max_stack, locals, nullptr, _verifier);
+      _max_locals, _max_stack, locals, nullptr,
+      _assert_unset_fields_buffer, _verifier);
     if (_first && locals != nullptr) {
       frame->copy_locals(_prev_frame);
     }
@@ -292,7 +329,8 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
       stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
     frame = new StackMapFrame(
       offset, _prev_frame->flags(), _prev_frame->locals_size(), stack_size,
-      _max_locals, _max_stack, locals, stack, _verifier);
+      _max_locals, _max_stack, locals, stack,
+      _assert_unset_fields_buffer, _verifier);
     if (_first && locals != nullptr) {
       frame->copy_locals(_prev_frame);
     }
@@ -302,7 +340,7 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
 
   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));
@@ -333,7 +371,8 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
       stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
     frame = new StackMapFrame(
       offset, _prev_frame->flags(), _prev_frame->locals_size(), stack_size,
-      _max_locals, _max_stack, locals, stack, _verifier);
+      _max_locals, _max_stack, locals, stack,
+      _assert_unset_fields_buffer, _verifier);
     if (_first && locals != nullptr) {
       frame->copy_locals(_prev_frame);
     }
@@ -375,7 +414,8 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
     }
     frame = new StackMapFrame(
       offset, flags, new_length, 0, _max_locals, _max_stack,
-      locals, nullptr, _verifier);
+      locals, nullptr,
+      _assert_unset_fields_buffer, _verifier);
     if (_first && locals != nullptr) {
       frame->copy_locals(_prev_frame);
     }
@@ -409,7 +449,8 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
     }
     frame = new StackMapFrame(
       offset, flags, real_length, 0, _max_locals,
-      _max_stack, locals, nullptr, _verifier);
+      _max_stack, locals, nullptr,
+      _assert_unset_fields_buffer, _verifier);
     _first = false;
     return frame;
   }
@@ -457,7 +498,8 @@ StackMapFrame* StackMapReader::next_helper(TRAPS) {
     }
     frame = new StackMapFrame(
       offset, flags, real_locals_size, real_stack_size,
-      _max_locals, _max_stack, locals, stack, _verifier);
+      _max_locals, _max_stack, locals, stack,
+      _assert_unset_fields_buffer, _verifier);
     _first = false;
     return frame;
   }

src/hotspot/share/classfile/stackMapTable.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -127,6 +127,9 @@ class StackMapReader : StackObj {
   u2 _max_locals;
   u2 _max_stack;
 
+  // Contains assert_unset_fields generated from classfile
+  StackMapFrame::AssertUnsetFieldTable* _assert_unset_fields_buffer;
+
   // Check if reading first entry
   bool _first;
 
@@ -148,6 +151,7 @@ class StackMapReader : StackObj {
   }
 
   enum {
+    ASSERT_UNSET_FIELDS = 246,
     SAME_LOCALS_1_STACK_ITEM_EXTENDED = 247,
     SAME_EXTENDED = 251,
     FULL = 255
@@ -158,7 +162,8 @@ class StackMapReader : StackObj {
   StackMapReader(ClassVerifier* v, StackMapStream* stream,
                  char* code_data, int32_t code_len,
                  StackMapFrame* init_frame,
-                 u2 max_locals, u2 max_stack, TRAPS);
+                 u2 max_locals, u2 max_stack,
+                 StackMapFrame::AssertUnsetFieldTable* initial_strict_fields, TRAPS);
 
   inline int32_t get_frame_count()   const { return _frame_count; }
   inline StackMapFrame* prev_frame() const { return _prev_frame; }