8350578: Refactor useless Parse and Template Assertion Predicate elimination code by using a PredicateVisitor #24013

chhagedorn · 2025-03-12T16:18:53Z

This patch cleans the Parse and Template Assertion Predicate elimination code up. We now use a single PredicateVisitor and share code in a new EliminateUselessPredicates class which contains the code previously found in PhaseIdealLoop::eliminate_useless_predicates().

Unified Logic to Clean Up Parse and Template Assertion Predicates

We now use the following algorithm:

jdk/src/hotspot/share/opto/predicates.cpp

Lines 1174 to 1179 in 5e4b6ca

    
           // Do the following to find and eliminate useless Parse and Template Assertion Predicates: 
        
           // 1. Mark all Parse and Template Assertion Predicates "maybe useful". 
        
           // 2. Walk through the loop tree and iterate over all Predicates above each loop head. All found Parse and Template 
        
           //    Assertion Predicates are marked "useful" 
        
           // 3. Those Parse and Template Assertion Predicates that are still marked "maybe useful" are now marked "useless" and 
        
           //    removed in the next round of IGVN.

This is different from the old algorithm where we used a single boolean state _useless. But that does no longer work because when we first mark Template Assertion Predicates useless, we are no longer visiting them when iterating through predicates:

jdk/src/hotspot/share/opto/predicates.hpp

Lines 704 to 708 in a21fa46

    
           TemplateAssertionPredicate template_assertion_predicate(_current_node->as_IfTrue()); 
        
           if (!template_assertion_predicate.is_useless()) { 
        
             // Only visit if not useless. Otherwise, just skip over it to possibly process other predicates above. 
        
             predicate_visitor.visit(template_assertion_predicate); 
        
           }

We therefore require a third state. Thus, I introduced a new tri-state PredicateState that provides a special MaybeUseful value which we can set each Predicate to.

Ignoring Useless Parse Predicates

While working on this patch, I've noticed that we are always visiting Parse Predicates - even when they useless. We should change that to align it with what we have for the other Predicates (changed in JDK-8351280). To make this work, we also replace the _useless state in ParsePredicateNode with a new PredicateState.

Sharing Code for Parse and Template Assertion Predicates

With all the mentioned changes in place, I could nicely share code for the elimination of Parse and Template Assertion Predicates in EliminateUselessPredicates by using templates. The following additional changes were required:

Changing the template parameter of _template_assertion_predicate_opaques to the more specific OpaqueTemplateAssertionPredicateNode type.
Adding accessor methods to get the Predicate lists from Compile.
Updating ParsePredicate::mark_useless() to pass in PhaseIterGVN, as done for Assertion Predicates

Note that we still do not directly replace the useless Predicates but rather mark them useless as initiated by JDK-8351280.

Other Included Changes

During the various refactoring steps, I somehow dropped the code to add newly cloned Template Assertion Predicate to the _template_assertion_predicate_opaques list. It was done directly in the old cloning methods. This is not relevant for correctness but could hinder some optimizations. I've added the code now in Node::clone() to make sure we do not miss any Template Assertion Predicates (similar to what we do for Parse Predicates already):

jdk/src/hotspot/share/opto/node.cpp

Lines 514 to 516 in 5e4b6ca

    
           if (n->is_OpaqueTemplateAssertionPredicate()) { 
        
             C->add_template_assertion_predicate_opaque(n->as_OpaqueTemplateAssertionPredicate()); 
        
           }

Adding verification code to TemplateAssertionPredicate::is_predicate() and InitializedAssertionPredicate::is_predicate() to verify that when we find an Opaque*AssertionPredicate node that we also find the associated Halt node.
Some small refactorings here and there like renamings.

Thanks,
Christian

Progress

Change must be properly reviewed (1 review required, with at least 1 Reviewer)
Change must not contain extraneous whitespace
Commit message must refer to an issue

Issue

JDK-8350578: Refactor useless Parse and Template Assertion Predicate elimination code by using a PredicateVisitor (Sub-task - P4)

Reviewers

Vladimir Kozlov (@vnkozlov - Reviewer) Review applies to 1508a3be
Roland Westrelin (@rwestrel - Reviewer) Review applies to 1508a3be
Emanuel Peter (@eme64 - Reviewer)

Reviewing

Using git

Checkout this PR locally:
$ git fetch https://git.openjdk.org/jdk.git pull/24013/head:pull/24013
$ git checkout pull/24013

Update a local copy of the PR:
$ git checkout pull/24013
$ git pull https://git.openjdk.org/jdk.git pull/24013/head

Using Skara CLI tools

Checkout this PR locally:
$ git pr checkout 24013

View PR using the GUI difftool:
$ git pr show -t 24013

Using diff file

Download this PR as a diff file:
https://git.openjdk.org/jdk/pull/24013.diff

Using Webrev

Link to Webrev Comment

bridgekeeper · 2025-03-12T16:19:42Z

👋 Welcome back chagedorn! A progress list of the required criteria for merging this PR into master will be added to the body of your pull request. There are additional pull request commands available for use with this pull request.

openjdk · 2025-03-12T16:19:48Z

@chhagedorn This change now passes all automated pre-integration checks.

ℹ️ This project also has non-automated pre-integration requirements. Please see the file CONTRIBUTING.md for details.

After integration, the commit message for the final commit will be:

8350578: Refactor useless Parse and Template Assertion Predicate elimination code by using a PredicateVisitor

Reviewed-by: epeter, kvn, roland

You can use pull request commands such as /summary, /contributor and /issue to adjust it as needed.

At the time when this comment was updated there had been 106 new commits pushed to the master branch:

a37d843: 8352015: LIBVERIFY_OPTIMIZATION remove special optimization settings
b891bfa: 8352022: RISC-V: Support Zfa fminm_h/fmaxm_h for float16
20f1bca: 8351187: Add JFR monitor notification event
46b3d1d: 8351382: New test containers/docker/TestMemoryWithSubgroups.java is failing
558c015: 8351921: G1: Pinned regions with pinned objects only reachable by native code crash VM
f8c2122: 8352138: G1: Remove G1AddMetaspaceDependency.java test
e1bcff3: 8345687: Improve the implementation of SegmentFactories::allocateSegment
f4ddac5: 8331201: UBSAN enabled build reports on Linux x86_64 runtime error: shift exponent 65 is too large for 64-bit type 'long unsigned int'
38499b3: 8352084: Add more test code in TestSetupAOT.java
19154f7: 8351970: Retire JavaLangAccess::exit
... and 96 more: https://git.openjdk.org/jdk/compare/d90b79a2bd2f8bb6e50aa32aafe47748ef6ebeff...master

As there are no conflicts, your changes will automatically be rebased on top of these commits when integrating. If you prefer to avoid this automatic rebasing, please check the documentation for the /integrate command for further details.

➡️ To integrate this PR with the above commit message to the master branch, type /integrate in a new comment.

openjdk · 2025-03-12T16:20:28Z

@chhagedorn The following label will be automatically applied to this pull request:

hotspot-compiler

When this pull request is ready to be reviewed, an "RFR" email will be sent to the corresponding mailing list. If you would like to change these labels, use the /label pull request command.

chhagedorn · 2025-03-13T06:40:27Z

src/hotspot/share/opto/cfgnode.hpp

+  bool is_useless() const;
+  void mark_useless(PhaseIterGVN& igvn);
+  void mark_maybe_useful();
+  bool is_useful() const;
+  void mark_useful();


Needed to move these definitions to the source file because I cannot include predicates.hpp here due to circular dependencies. I solved this by forward declaring PredicateState and moving the definitions to the source file.

Same for these methods for OpaqueTemplateAssertionPredicate further down.

Can you add predicates.inline.hpp for this?

Do you mean the enum definition for PredicateState? That could work, so I can just include that header when I need to use the enum. Should I then rather name the hpp file something like predicates_enums.hpp? IIUC, xyz.inline.hpp should be used primarily for inline methods.

Having the separate enum header also allows us to put this one there which makes things cleaner:

jdk/src/hotspot/share/opto/predicates.hpp

Lines 203 to 211 in e3c29c9

// Assertion Predicates are either emitted to check the initial value of a range check in the first iteration or the last

// value of a range check in the last iteration of a loop.

enum class AssertionPredicateType {

None, // Not an Assertion Predicate

InitValue,

LastValue,

// Used for the Initialized Assertion Predicate emitted during Range Check Elimination for the final IV value.

FinalIv

};

I've pushed an update introducing predicates_enums.hpp and also moving some typedefs for predicates in there. Let me know if that's what you had in mind. I could now move almost all definitions back to the header file except for mark_useless() which uses PhaseIterGVN which is not a complete type in the header file - I guess that's okay to just move this one to the source file.

chhagedorn · 2025-03-13T06:42:18Z

src/hotspot/share/opto/ifnode.cpp

+  assert(_predicate_state != PredicateState::MaybeUseful, "should only be MaybeUseful when eliminating useless "
+                                                          "predicates during loop opts");


Best effort assert to ensure we are not seeing MaybeUseful anywhere else except during Predicate elimination. Same for OpaqueTemplateAssertionPredicate.

chhagedorn · 2025-03-13T06:42:52Z

src/hotspot/share/opto/ifnode.cpp

      fatal("unknown kind");
  }
-  if (_useless) {
+  if (_predicate_state == PredicateState::Useless) {


I only print useless since MaybeUseful is only set for a very brief moment and should normally not be visible when dumping/in IGV dumps.

chhagedorn · 2025-03-13T06:43:30Z

src/hotspot/share/opto/node.cpp

+  if (n->is_OpaqueTemplateAssertionPredicate()) {
+    C->add_template_assertion_predicate_opaque(n->as_OpaqueTemplateAssertionPredicate());
+  }


See PR description "Other Included Changes".

chhagedorn · 2025-03-13T06:45:31Z

src/hotspot/share/opto/predicates.cpp

+  assert(!is_template_assertion_predicate || AssertionPredicate::has_halt(maybe_success_proj->as_IfTrue()),
+         "Template Assertion Predicate must have a Halt Node on the failing path");


New verification - see "Other Included Changes" in PR description.

chhagedorn · 2025-03-13T06:45:55Z

src/hotspot/share/opto/predicates.cpp

+  // Or we have a Region that merges serval paths to a single Halt node. Even though OpaqueInitializedAssertionPredicate
+  // nodes do not common up (i.e. NO_HASH), we could have Initialized Assertion Predicates from already folded loops
+  // being now part of the innermost loop. When then further splitting this loop, we could be cloning the If node
+  // of the Initialized Assertion Predicate (part of the loop body) while the OpaqueInitializedAssertionPredicate is not
+  // cloned because it's outside the loop body. We end up sharing the OpaqueInitializedAssertionPredicate between the
+  // original and the cloned If. This should be fine.


Reason for not reusing AssertionPredicate::has_halt(). I will revisit the AssertionPredicate class in a future PR, so I have not tried to unify these methods in a way.

chhagedorn · 2025-03-13T06:46:14Z

src/hotspot/share/opto/opaquenode.cpp

  return phase->type(in(1));
 }

+OpaqueTemplateAssertionPredicateNode::OpaqueTemplateAssertionPredicateNode(BoolNode* bol): Node(nullptr, bol),


Moved some methods to source file - see comment above for ParsePredicateNode.

chhagedorn · 2025-03-13T06:46:35Z

src/hotspot/share/opto/opaquenode.hpp

+#include "opto/subnode.hpp"
+


Noticed that opcodes.hpp was unused and subnode.hpp missed the opto prefix. Fixed here as well.

chhagedorn · 2025-03-13T06:48:26Z

src/hotspot/share/opto/predicates.hpp

+  // the ParsePredicateNode is not marked useless.
  bool is_valid() const {
-    return _parse_predicate_node != nullptr;
+    return _parse_predicate_node != nullptr && !_parse_predicate_node->is_useless();


Avoids visiting useless Parse Predicates during Predicate iteration.

When can _parse_predicate_node be null?

When iterating through predicates, we use a PredicateBlockIterator for each Predicate Block, which consists of an optional Parse Predicate and a number of Regular Predicates (Runtime and Assertion Predicates). We could have either already removed the Parse Predicate before here:

jdk/src/hotspot/share/opto/loopnode.cpp

Lines 5055 to 5066 in e3c29c9

// Keep loop predicates and perform optimizations with them

// until no more loop optimizations could be done.

// After that switch predicates off and do more loop optimizations.

if (!C->major_progress() && (C->parse_predicate_count() > 0)) {

C->mark_parse_predicate_nodes_useless(_igvn);

assert(C->parse_predicate_count() == 0, "should be zero now");

if (TraceLoopOpts) {

tty->print_cr("PredicatesOff");

}

C->set_major_progress();

}

}

or there is just no Parse Predicate for this loop. So, when initializing the PredicateBlockIterator, we could pass here a non-Parse-Predicate projection to the constructor of ParsePredicate:

jdk/src/hotspot/share/opto/predicates.hpp

Line 747 in e3c29c9

_parse_predicate(start_node, deopt_reason),

We then set _parse_predicate_node to null here due to this mismatch:

jdk/src/hotspot/share/opto/predicates.hpp

Lines 293 to 296 in e3c29c9

static IfTrueNode* init_success_proj(const Node* parse_predicate_proj) {

assert(parse_predicate_proj != nullptr, "must not be null");

return parse_predicate_proj->isa_IfTrue();

}

Is the last code snippet the relevant one?

Sorry, I copy-pasted the wrong snippet. The null is coming from here:

jdk/src/hotspot/share/opto/predicates.cpp

Lines 71 to 82 in e3c29c9

// Returns the Parse Predicate node if the provided node is a Parse Predicate success proj. Otherwise, return null.

ParsePredicateNode* ParsePredicate::init_parse_predicate(const Node* parse_predicate_proj,

Deoptimization::DeoptReason deopt_reason) {

assert(parse_predicate_proj != nullptr, "must not be null");

if (parse_predicate_proj->is_IfTrue() && parse_predicate_proj->in(0)->is_ParsePredicate()) {

ParsePredicateNode* parse_predicate_node = parse_predicate_proj->in(0)->as_ParsePredicate();

if (parse_predicate_node->deopt_reason() == deopt_reason) {

return parse_predicate_node;

}

}

return nullptr;

}

mlbridge · 2025-03-13T06:55:01Z

Webrevs

vnkozlov

This looks good to me.

chhagedorn · 2025-03-17T07:09:22Z

Thanks Vladimir for your review!

rwestrel

Looks good to me.

eme64

Generally looks good, I only gave it a quick scan. I'm wondering if there is a naming inconsistency, see below ;)

eme64 · 2025-03-18T14:14:40Z

src/hotspot/share/opto/predicates.cpp

+void EliminateUselessPredicates::mark_all_predicates_non_useful() const {
+  mark_predicates_on_list_maybe_useful(_parse_predicates);
+  mark_predicates_on_list_maybe_useful(_template_assertion_predicate_opaques);
+}


Suggested change

void EliminateUselessPredicates::mark_all_predicates_non_useful() const {

mark_predicates_on_list_maybe_useful(_parse_predicates);

mark_predicates_on_list_maybe_useful(_template_assertion_predicate_opaques);

}

void EliminateUselessPredicates::mark_all_predicates_maybe_useful() const {

mark_predicates_on_list_maybe_useful(_parse_predicates);

mark_predicates_on_list_maybe_useful(_template_assertion_predicate_opaques);

}

For consistency?

Definitely an inconsistency, good catch! Will update this and the other occurrences.

eme64 · 2025-03-18T14:16:15Z

src/hotspot/share/opto/predicates.cpp

+void EliminateUselessPredicates::eliminate() const {
+  mark_all_predicates_non_useful();
+  if (C->has_loops()) {
+    mark_loop_associated_predicates_useful();
+  }
+  mark_non_useful_predicates_useless();
+}


I would replace non_useful to maybe_useful to keep it consistent with the comments above.

chhagedorn · 2025-03-18T15:00:32Z

Thanks Roland and Emanuel for your reviews! I've pushed an updated with your suggestions Emanuel.

eme64

Thanks for the updates. I'm rubber stamping this, only did a quick scan ;)

chhagedorn · 2025-03-18T15:21:46Z

Thanks Emanuel! I will run some testing again with the recent updates before integration.

chhagedorn · 2025-03-19T07:40:24Z

/integrate

openjdk · 2025-03-19T07:41:07Z

Going to push as commit e57b272.
Since your change was applied there have been 115 commits pushed to the master branch:

577ede7: 8352302: Test sun/security/tools/jarsigner/TimestampCheck.java is failing
20d4fe3: 8351464: Shenandoah: Hang on ShenandoahController::handle_alloc_failure when run test TestAllocHumongousFragment#generational
8e53063: 8352275: Clean up dead code in jpackage revealed with improved negative test coverage
c8a11f2: 8352293: jpackage tests build rpm packages on Ubuntu test machines after JDK-8351372
4a02de8: 8352098: -Xrunjdwp fails on static JDK
355b2f3: 8351374: Improve comment about queue.remove timeout in CleanerImpl.run
a3540be: 8352163: [AIX] SIGILL in AttachOperation::ReplyWriter::write_fully after 8319055
53c5b93: 8352180: AttachListenerThread causes many tests to timeout on Windows
b025d8c: 8350663: AArch64: Enable UseSignumIntrinsic by default
a37d843: 8352015: LIBVERIFY_OPTIMIZATION remove special optimization settings
... and 105 more: https://git.openjdk.org/jdk/compare/d90b79a2bd2f8bb6e50aa32aafe47748ef6ebeff...master

Your commit was automatically rebased without conflicts.

openjdk · 2025-03-19T07:41:14Z

@chhagedorn Pushed as commit e57b272.

💡 You may see a message that your pull request was closed with unmerged commits. This can be safely ignored.

chhagedorn added 3 commits March 12, 2025 14:28

8350578: Refactor useless Template Assertion Predicate elimination code

580bab2

cleanup

f06cc5f

Revert has_halt() verification

5e4b6ca

chhagedorn changed the title ~~eibccbtbjbkcbuchvfueljrhftgfvhetnhvvinckgdreJdk 8350578~~ 8350578: Refactor useless Parse and Template Assertion Predicate elimination code by using a PredicateVisitor Mar 12, 2025

openjdk bot added the hotspot-compiler hotspot-compiler-dev@openjdk.org label Mar 12, 2025

Typos etc.

a5611e3

chhagedorn commented Mar 13, 2025

View reviewed changes

chhagedorn marked this pull request as ready for review March 13, 2025 06:51

openjdk bot added the rfr Pull request is ready for review label Mar 13, 2025

Introduce predicates_enums.hpp

1508a3b

vnkozlov approved these changes Mar 14, 2025

View reviewed changes

openjdk bot added the ready Pull request is ready to be integrated label Mar 14, 2025

rwestrel approved these changes Mar 18, 2025

View reviewed changes

eme64 reviewed Mar 18, 2025

View reviewed changes

Emanuel's review

4c9f516

openjdk bot removed the ready Pull request is ready to be integrated label Mar 18, 2025

eme64 approved these changes Mar 18, 2025

View reviewed changes

openjdk bot added the ready Pull request is ready to be integrated label Mar 18, 2025

openjdk bot added the integrated Pull request has been integrated label Mar 19, 2025

openjdk bot closed this Mar 19, 2025

openjdk bot removed the ready Pull request is ready to be integrated label Mar 19, 2025

openjdk bot removed the rfr Pull request is ready for review label Mar 19, 2025

chhagedorn mentioned this pull request Mar 19, 2025

8350579: Remove Template Assertion Predicates belonging to a loop once it is folded away #23823

Closed

3 tasks

	// Do the following to find and eliminate useless Parse and Template Assertion Predicates:
	// 1. Mark all Parse and Template Assertion Predicates "maybe useful".
	// 2. Walk through the loop tree and iterate over all Predicates above each loop head. All found Parse and Template
	// Assertion Predicates are marked "useful"
	// 3. Those Parse and Template Assertion Predicates that are still marked "maybe useful" are now marked "useless" and
	// removed in the next round of IGVN.

	TemplateAssertionPredicate template_assertion_predicate(_current_node->as_IfTrue());
	if (!template_assertion_predicate.is_useless()) {
	// Only visit if not useless. Otherwise, just skip over it to possibly process other predicates above.
	predicate_visitor.visit(template_assertion_predicate);
	}

	if (n->is_OpaqueTemplateAssertionPredicate()) {
	C->add_template_assertion_predicate_opaque(n->as_OpaqueTemplateAssertionPredicate());
	}

	// Assertion Predicates are either emitted to check the initial value of a range check in the first iteration or the last
	// value of a range check in the last iteration of a loop.
	enum class AssertionPredicateType {
	None, // Not an Assertion Predicate
	InitValue,
	LastValue,
	// Used for the Initialized Assertion Predicate emitted during Range Check Elimination for the final IV value.
	FinalIv
	};

		assert(_predicate_state != PredicateState::MaybeUseful, "should only be MaybeUseful when eliminating useless "
		"predicates during loop opts");

		assert(!is_template_assertion_predicate \|\| AssertionPredicate::has_halt(maybe_success_proj->as_IfTrue()),
		"Template Assertion Predicate must have a Halt Node on the failing path");

	// Keep loop predicates and perform optimizations with them
	// until no more loop optimizations could be done.
	// After that switch predicates off and do more loop optimizations.
	if (!C->major_progress() && (C->parse_predicate_count() > 0)) {
	C->mark_parse_predicate_nodes_useless(_igvn);
	assert(C->parse_predicate_count() == 0, "should be zero now");
	if (TraceLoopOpts) {
	tty->print_cr("PredicatesOff");
	}
	C->set_major_progress();
	}
	}

	static IfTrueNode* init_success_proj(const Node* parse_predicate_proj) {
	assert(parse_predicate_proj != nullptr, "must not be null");
	return parse_predicate_proj->isa_IfTrue();
	}

	// Returns the Parse Predicate node if the provided node is a Parse Predicate success proj. Otherwise, return null.
	ParsePredicateNode* ParsePredicate::init_parse_predicate(const Node* parse_predicate_proj,
	Deoptimization::DeoptReason deopt_reason) {
	assert(parse_predicate_proj != nullptr, "must not be null");
	if (parse_predicate_proj->is_IfTrue() && parse_predicate_proj->in(0)->is_ParsePredicate()) {
	ParsePredicateNode* parse_predicate_node = parse_predicate_proj->in(0)->as_ParsePredicate();
	if (parse_predicate_node->deopt_reason() == deopt_reason) {
	return parse_predicate_node;
	}
	}
	return nullptr;
	}

		#include "opto/subnode.hpp"

8350578: Refactor useless Parse and Template Assertion Predicate elimination code by using a PredicateVisitor #24013

8350578: Refactor useless Parse and Template Assertion Predicate elimination code by using a PredicateVisitor #24013

Uh oh!

Conversation

chhagedorn commented Mar 12, 2025 • edited by openjdk bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Unified Logic to Clean Up Parse and Template Assertion Predicates

Ignoring Useless Parse Predicates

Sharing Code for Parse and Template Assertion Predicates

Other Included Changes

Progress

Issue

Reviewers

Reviewing

Uh oh!

bridgekeeper bot commented Mar 12, 2025

Uh oh!

openjdk bot commented Mar 12, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

openjdk bot commented Mar 12, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mlbridge bot commented Mar 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Webrevs

Uh oh!

vnkozlov left a comment

Choose a reason for hiding this comment

Uh oh!

chhagedorn commented Mar 17, 2025

Uh oh!

rwestrel left a comment

Choose a reason for hiding this comment

Uh oh!

eme64 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

chhagedorn commented Mar 18, 2025

Uh oh!

eme64 left a comment

chhagedorn commented Mar 12, 2025 •

edited by openjdk bot

Loading

openjdk bot commented Mar 12, 2025 •

edited

Loading

mlbridge bot commented Mar 13, 2025 •

edited

Loading