RELEASE NOTES: JDK 25

Notes generated: Wed Sep 17 15:10:32 CEST 2025

JEPs

Issue Description
JDK-8300911 JEP 470: PEM Encodings of Cryptographic Objects (Preview)
Introduce an API for encoding objects that represent cryptographic keys, certificates, and certificate revocation lists into the widely-used Privacy-Enhanced Mail transport format, and for decoding from that format back into objects. This is a preview API.
JDK-8312611 JEP 502: Stable Values (Preview)
Error processing the description: String index out of range: 13
JDK-8345168 JEP 503: Remove the 32-bit x86 Port
Remove the source code and build support for the 32-bit x86 port. This port was deprecated for removal in JDK 24 (JEP 501) with the express intent to remove it in a future release.
JDK-8340343 JEP 505: Structured Concurrency (Fifth Preview)
Simplify concurrent programming by introducing an API for structured concurrency. Structured concurrency treats groups of related tasks running in different threads as single units of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability. This is a preview API.
JDK-8352695 JEP 506: Scoped Values
Introduce scoped values, which enable a method to share immutable data both with its callees within a thread, and with child threads. Scoped values are easier to reason about than thread-local variables. They also have lower space and time costs, especially when used together with virtual threads (JEP 444) and structured concurrency (JEP 505).
JDK-8349215 JEP 507: Primitive Types in Patterns, instanceof, and switch (Third Preview)
Enhance pattern matching by allowing primitive types in all pattern contexts, and extend instanceof and switch to work with all primitive types. This is a preview language feature.
JDK-8353296 JEP 508: Vector API (Tenth Incubator)
Introduce an API to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPUs, thus achieving performance superior to equivalent scalar computations.
JDK-8337789 JEP 509: JFR CPU-Time Profiling (Experimental)
Enhance the JDK Flight Recorder (JFR) to capture more accurate CPU-time profiling information on Linux. This is an experimental feature.
JDK-8353275 JEP 510: Key Derivation Function API
Introduce an API for Key Derivation Functions (KDFs), which are cryptographic algorithms for deriving additional keys from a secret key and other data.
JDK-8344700 JEP 511: Module Import Declarations
Enhance the Java programming language with the ability to succinctly import all of the packages exported by a module. This simplifies the reuse of modular libraries, but does not require the importing code to be in a module itself.
JDK-8344699 JEP 512: Compact Source Files and Instance Main Methods
Evolve the Java programming language so that beginners can write their first programs without needing to understand language features designed for large programs. Far from using a separate dialect of the language, beginners can write streamlined declarations for single-class programs and then seamlessly expand their programs to use more advanced features as their skills grow. Experienced developers can likewise enjoy writing small programs succinctly, without the need for constructs intended for programming in the large.
JDK-8344702 JEP 513: Flexible Constructor Bodies
In the body of a constructor, allow statements to appear before an explicit constructor invocation, i.e., super(...) or this(...). Such statements cannot reference the object under construction, but they can initialize its fields and perform other safe computations. This change allows many constructors to be expressed more naturally. It also allows fields to be initialized before they become visible to other code in the class, such as methods called from a superclass constructor, thereby improving safety.
JDK-8350022 JEP 514: Ahead-of-Time Command-Line Ergonomics
Make it easier to create ahead-of-time caches, which accelerate the startup of Java applications, by simplifying the commands required for common use cases.
JDK-8325147 JEP 515: Ahead-of-Time Method Profiling
Improve warmup time by making method-execution profiles from a previous run of an application instantly available, when the HotSpot Java Virtual Machine starts. This will enable the JIT compiler to generate native code immediately upon application startup, rather than having to wait for profiles to be collected.
JDK-8350338 JEP 518: JFR Cooperative Sampling
Improve the stability of the JDK Flight Recorder (JFR) when it asynchronously samples Java thread stacks. Achieve this by walking call stacks only at safepoints, while minimizing safepoint bias.
JDK-8354672 JEP 519: Compact Object Headers
Change compact object headers from an experimental feature to a product feature.
JDK-8328610 JEP 520: JFR Method Timing & Tracing
Extend the JDK Flight Recorder (JFR) with facilities for method timing and tracing via bytecode instrumentation.
JDK-8356990 JEP 521: Generational Shenandoah
Change the generational mode of the Shenandoah garbage collector from an experimental feature to a product feature.

RELEASE NOTES

tools/javac

Issue Description
JDK-8338675

JAR Files on Classpath Are Never Modified by javac


Under some conditions, javac could have modified jar or zip files places on the classpath, by writing classfile(s) to them.

The specific conditions are: - no output directory specified (that is, no -d option) - no -sourcepath specified - the jar or zip file on the classpath contains source file(s), which are compiled implicitly

This is no longer the case. Classfiles will never be written to jar or zip files. Those that would be written into the jar or zip file will be placed to the current working directory. This mimics the JDK 8 behavior.


JDK-8164714

Inner Classes Must Not Have `null` as their Immediately Enclosing Instance


In Java programs, every instance of an inner class has an immediately enclosing instance. When an inner class is instantiated with the new keyword, the immediately enclosing instance is passed to the inner class's constructor via a parameter not visible in source code. The Java Language Specification (§15.9.4) requires that the immediately enclosing instance is not null.

Prior to JDK 25, javac inserted a null check on the immediately enclosing instance before it was passed to the inner class's constructor. No null check was performed in the body of the inner class's constructor. As a result, it was possible to use core reflection, e.g., java.lang.reflect.Constructor::newInstance, or specially crafted class files to invoke an inner class's constructor with null as the immediately enclosing instance. This could lead to unexpected program failures.

In JDK 25, javac inserts an additional null check on the immediately enclosing instance. This check occurs in the body of the inner class's constructor. As a result, there is no way to instantiate an inner class with null as the immediately enclosing instance.

In the extremely rare case of needing to run legacy code that passes null as the immediately enclosing instance, developers can, at their own risk, use the unsupported option -XDnullCheckOuterThis=false. This prevents javac from inserting the additional null check in inner class constructor bodies.


JDK-8354908

javac Mishandles Supplementary Character in Character Literal


In the Java source code, character literals can only contain a single UTF-16 character. The javac compiler was incorrectly accepting character literals consisting of two UTF-16 surrogate characters, only using the first surrogate, and ignoring the second surrogate. This has now been corrected, and javac will produce a compile-time error when it detects a character literal which consists of two UTF-16 surrogate characters.


JDK-8352612

The -Xlint:none Compiler Flag No Longer Implies -nowarn


The -Xlint command line flag for javac is used to enable or disable categories of lint warnings generated during compilation. For example, -Xlint:all,-serial enables all lint categories and then disables the serial category, while the converse -Xlint:none,serial disables all lint categories and then enables the serial category.

For historical reasons, the appearance of -Xlint:none also had the invisible side effect of disabling _all_ non-mandatory warnings, exactly as if the flag -nowarn had also been given. As a result, the effect of a flag like -Xlint:none,serial was to simply disable all non-mandatory warnings; in particular, no warnings in the serial category would be generated.

This invisible side-effect has been eliminated. Now -Xlint:none simply disables all lint categories, and a flag like -Xlint:none,serial will allow serial warnings to appear as expected.


JDK-8322810

The javac Compiler Should Not Accept a Lambda Expression Type to Be a Class


Prior to JDK 25, the javac compiler was allowing the type of lambda expressions to be classes in some cases. This implies that the javac compiler was accepting code like:

` class Test { void m() { Test r = (Test & Runnable) () -> System.out.println("Hello, World!"); } } `

Starting from JDK 25 the javac compiler will reject lambda expressions which type is a class


JDK-8356057

-Xprint Output Includes Type Variable Bounds and Annotated Object Supertypes


The output for -Xprint has been updated to include bounds for type variables and java.lang.Object as a supertype, if the supertype is annotated.

For example, this code: ` public class PrintingTest<T extends CharSequence> extends @TA Object { } `

now produces this output: ``` $ java -Xprint PrintingTest.java public class PrintingTest extends java.lang.@TA Object {

public PrintingTest(); } ```


client-libs/java.beans

Issue Description
JDK-8347008

Deprecation of the `java.beans.beancontext` Package


The java.beans.beancontext.* package was added in the JDK 1.2 release, well in advance of new language features such as annotations, lambdas, and modules, as well as programming paradigms such as "Declarative Configuration", "Dependency Injection", and "Inversion of Control".

Based on concepts from OpenDoc, developed by Apple Computer in the mid to late 1990's, this package was intended to provide mechanisms for the assembly of JavaBeans(tm) components into hierarchies. This enabled individual components to produce and consume services expressed as interfaces by their peers, ancestors, and descendants.

With the advancements in the language, these APIs are now both obsolete and express an "anti-pattern" of component assembly and interaction. They are therefore deprecated for removal in a future release.

Developers should no longer use these APIs. They should plan to migrate any existing code dependent on this package to an alternate solution in anticipation of their future removal.


core-libs/java.net

Issue Description
JDK-8353642

Various Permission Classes Deprecated for Removal


The following permission classes have been deprecated for removal:

  • java.security.UnresolvedPermission
  • javax.net.ssl.SSLPermission
  • javax.security.auth.AuthPermission
  • javax.security.auth.PrivateCredentialPermission
  • javax.security.auth.kerberos.DelegationPermission
  • javax.security.auth.kerberos.ServicePermission
  • com.sun.security.jgss.InquireSecContextPermission
  • java.lang.RuntimePermission
  • java.lang.reflect.ReflectPermission
  • java.io.FilePermission
  • java.io.SerializablePermission
  • java.nio.file.LinkPermission
  • java.util.logging.LoggingPermission
  • java.util.PropertyPermission
  • jdk.jfr.FlightRecorderPermission
  • java.net.NetPermission
  • java.net.URLPermission
  • jdk.net.NetworkPermission
  • com.sun.tools.attach.AttachPermission
  • com.sun.jdi.JDIPermission
  • java.lang.management.ManagementPermission
  • javax.management.MBeanPermission
  • javax.management.MBeanTrustPermission
  • javax.management.MBeanServerPermission
  • javax.management.remote.SubjectDelegationPermission

In addition, the getPermission method defined in java.net.URLConnection and its subclass java.net.HttpURLConnection has been deprecated for removal.

These permission classes and associated methods were only useful in conjunction with the Security Manager, which is no longer supported.


JDK-8350279

New connectionLabel Method in java.net.http.HttpResponse to Identify Connections


A new connectionLabel method has been added to java.net.http.HttpResponse. This new method returns an opaque connection label that callers can leverage to associate a response with the connection it is carried on. This is useful to determine whether two requests were carried on the same connection or on different connections.


JDK-8348986

Networking Exception Messages can be Filtered to Remove Sensitive Information


Usage of the jdk.includeInExceptions security and system property has been expanded to include more networking exception messages and more categories that can be configured as enabled or disabled. Please refer to the Enhanced exception message information section of the conf/security/java.security configuration file for more information.


JDK-8356154

java.net.Socket Constructors Can No Longer Be Used to Create a Datagram Socket


The two deprecated java.net.Socket constructors that accept the stream parameter have been updated to throw an IllegalArgumentException if stream is false. These constructors can no longer be used to create datagram sockets. Instead use java.net.DatagramSocket for datagram sockets. These two constructors will be removed in a future release.


JDK-8328919

New Methods on BodyHandlers and BodySubscribers to Limit the Number of Response Body Bytes Accepted by the HttpClient


Two new methods, java.net.http.HttpResponse.BodyHandlers.limiting(BodyHandler downstreamHandler, long capacity) and java.net.http.HttpResponse.BodySubsribers.limiting(BodySubscriber downstreamSubscriber, long capacity), are added to the HttpClient API. These methods extend an existing BodyHandler or BodySubscriber with the ability to limit the number of response body bytes that the application is willing to accept in response to an HTTP request. Upon reaching the limit when reading the response body, an IOException will be raised and reported to the downstream subscriber. The subscription will be cancelled. Any further response body bytes will be discarded. This makes it possible for the application to control the maximum amount of bytes that it wants to accept from the server.


JDK-8354276

java.net.http.HttpClient is Enhanced to Reject Responses with Prohibited Headers


The java.net.http.HttpClient will now reject HTTP/2 responses that contain header fields prohibited by the HTTP/2 specification (RFC 9113). This is an implementation detail that should be transparent to the users of the HttpClient API, but could result in failed requests if connecting to a non-conformant HTTP/2 server.

The headers that are now rejected in HTTP/2 responses include: - connection-specific header fields (Connection, Proxy-Connection, Keep-Alive, Transfer-Encoding, and Upgrade) - request pseudo-header fields (:method, :authority, :path, and :scheme)


JDK-8355360

The `jwebserver` Tool `-d` Command Line Option Now Accepts Directories Specified With a Relative Path


The jwebserver tool is updated to allow the -d and --directory command line options, configuring the directory to serve, to accept a directory specified with a relative path. This is made available both when jwebserver is invoked as an executable:

` jwebserver --directory some/relative/path `

and as a module:

` java --module jdk.httpserver --directory some/relative/path `

As earlier, -d and --directory command line options also still support absolute paths.


JDK-8353440

FTP Fallback for Non-Local File URLs Is Disabled by Default


The unspecified, but long-standing, fallback to FTP connections for non-local file URLs is disabled by default.

The method URL::openConnection called for non-local file URLs of the form "file://server[/path]", where server is anything but "localhost", no longer falls back to FTP and no longer returns an FTP URL Connection. A MalformedURLException is now thrown by the URL::openConnection method instead in such cases.

Code expecting the URL::openConnection to succeed, but expecting a delayed exception to be raised when actually using the connection, such as catching an UnknownHostException while reading streams, may need to be updated to handle the immediate rejection via MalformedURLException instead.

The legacy FTP fallback behavior can be reenabled by setting the system property -Djdk.net.file.ftpfallback=true on the java command line. Support for resolving non-local, existing UNC paths on Windows is not affected by this change.


hotspot/jvmti

Issue Description
JDK-8346460

NotifyFramePop Should Return JVMTI_ERROR_DUPLICATE


The JVMTI function NotifyFramePop returns JVMTI_ERROR_DUPLICATE in the case a FramePop event was already requested at the specified depth.


core-svc/tools

Issue Description
JDK-8351224

Various Permission Classes Deprecated for Removal


The following permission classes have been deprecated for removal:

  • java.security.UnresolvedPermission
  • javax.net.ssl.SSLPermission
  • javax.security.auth.AuthPermission
  • javax.security.auth.PrivateCredentialPermission
  • javax.security.auth.kerberos.DelegationPermission
  • javax.security.auth.kerberos.ServicePermission
  • com.sun.security.jgss.InquireSecContextPermission
  • java.lang.RuntimePermission
  • java.lang.reflect.ReflectPermission
  • java.io.FilePermission
  • java.io.SerializablePermission
  • java.nio.file.LinkPermission
  • java.util.logging.LoggingPermission
  • java.util.PropertyPermission
  • jdk.jfr.FlightRecorderPermission
  • java.net.NetPermission
  • java.net.URLPermission
  • jdk.net.NetworkPermission
  • com.sun.tools.attach.AttachPermission
  • com.sun.jdi.JDIPermission
  • java.lang.management.ManagementPermission
  • javax.management.MBeanPermission
  • javax.management.MBeanTrustPermission
  • javax.management.MBeanServerPermission
  • javax.management.remote.SubjectDelegationPermission

In addition, the getPermission method defined in java.net.URLConnection and its subclass java.net.HttpURLConnection has been deprecated for removal.

These permission classes and associated methods were only useful in conjunction with the Security Manager, which is no longer supported.


hotspot/other

Issue Description
JDK-8345168

The 32-bit x86 Port Has Been Removed


The 32-bit x86 port is removed in JDK 25, following the deprecation in JDK 24. The architecture-agnostic Zero port is the only remaining way to run Java programs on 32-bit x86 processors going forward. Systems that run on 32-bit x86 today need to either consider upgrading to 64-bit x86, or switch to 32-bit x86 Zero, or stay on previous JDKs.


core-libs/java.util:i18n

Issue Description
JDK-8353118

Deprecate the Use of `java.locale.useOldISOCodes` System Property


The java.locale.useOldISOCodes system property has been deprecated. Introduced in JDK 17, it allowed users to revert to the legacy ISO 639 language codes for Hebrew, Indonesian, and Yiddish. Since its purpose was to facilitate a transition to the updated codes, we believe it is now time to retire it. In JDK 25, setting this property to true has no effect, and a warning about its future removal is displayed at runtime.


JDK-8345213

Changes to the Default Time Zone Detection on Debian-based Linux


On Debian-based Linux distributions such as Ubuntu, the /etc/timezone file was previously used to determine the JDK's default time zone (TimeZone.getDefault()). According to Debian's Wiki, /etc/localtime is now the primary source for the system's default time zone, making /etc/timezone redundant. As a result, the JDK's default time zone detection logic has been updated to use /etc/localtime instead of /etc/timezone. If /etc/localtime and /etc/timezone are inconsistent for any reason, the JDK's default time zone is now determined solely based on /etc/localtime file.


JDK-8346948

Support for CLDR Version 47


The locale data based on the Unicode Consortium's CLDR has been upgraded to version 47. Besides the usual addition of new locale data and translation changes, there are notable changes from the upstream CLDR, affecting Date/Time/Number formattings:

  • CLDR-9791: Add language for South Georgia and Bouvet Islands (#4166)
  • CLDR-16821: Fix Australian time zone names (#4301)
  • CLDR-17484: English day periods are wrong (#4375)
  • CLDR-18099: Add European English locales with data (#4276, (#4302)
  • CLDR-18268: Add timeData for GS (#4319)

Note that locale data is subject to change in a future release of the CLDR. Although not all locale data changes affect the JDK, users should not assume stability across releases. For more details, please refer to the Unicode Consortium's CLDR release notes and their locale data deltas.


JDK-8350646

Japanese Imperial Calendar Exception Change for Era too Large


Calling Calendar.computeTime() with a Japanese Imperial Calendar for a Calendar.ERA field value that is too large now throws IllegalArgumentException instead of ArrayIndexOutOfBoundsException. Thus, any operations requiring time recomputation for a Japanese Imperial Calendar are now affected. For example, at the time of this release note, new Calendar.Builder().setCalendarType("japanese").set(Calendar.ERA, 6).build() now throws IllegalArgumentException.


core-libs/java.lang

Issue Description
JDK-8350703

Add Standard System Property stdin.encoding


A new system property, stdin.encoding, has been added. This property contains the name of the recommended Charset for reading character data from System.in, for example, when using InputStreamReader or Scanner. By default, the property is set in a system-specific fashion based on querying the OS and user environment. Note that its value may differ from the value of the file.encoding property, the default Charset, and the value of the native.encoding property. The value of stdin.encoding may be overridden to be UTF-8 by providing the argument -Dstdin.encoding=UTF-8 on the command line.


JDK-8343110

New getChars(int, int, char[], int) Method in CharSequence and CharBuffer


A new method, getChars(int, int, char[], int), has been added to java.lang.CharSequence and java.nio.CharBuffer to bulk-read characters from a region of a CharSequence into a region of a char[]. String, StringBuilder, and CharBuffer implement CharSequence. Code that operates on a CharSequence should no longer need to special-case and cast to String when needing to bulk-read from a sequence. The new method may be more efficient than a loop over characters of the sequence.


JDK-8357179

Deprecate VFORK Launch Mechanism from Process Implementation (linux)


On Linux, the -Djdk.lang.Process.launchMechanism=VFORK option has been deprecated due to being inherently dangerous. It will be removed in a future release.

Customers are advised to avoid using this property. If possible, they should remove it and use the default launch mechanism based on posix_spawn. In case that is not possible, they should use -Djdk.lang.Process.launchMechanism=FORK instead.


JDK-8138614

Relax String Creation Requirements in StringBuilder and StringBuffer


The specifications of the substring, subSequence, and toString methods of the StringBuilder and StringBuffer classes have changed not to require a new String instance to be returned every time. This allows implementations to improve performance by returning an already-existing string, such as the empty string, when that is appropriate. In all cases, a String containing the expected value will be returned. However, applications should not depend on these methods to return a new String instance every time.


client-libs/2d

Issue Description
JDK-8346465

JDK Provided Instances of ICC_Profile Cannot Be Modified


The desktop module provides the ICC_Profile class used in Color Management for image processing applications. Previously, an ICC_Profile instance would always allow an application to modify the raw color profile data which the ICC_Profile encapsulates. However, instances of this class provided by the desktop module itself are shared and should never be modified. JDK now enforces this restriction on these shared instances. As a result, application code which modifies a shared instance of ICC_Profile will cause an exception to be thrown.


security-libs/javax.crypto:pkcs11

Issue Description
JDK-8348732

Removal of SunPKCS11 Provider's PBE-related SecretKeyFactory Implementations


Starting with JDK 21, the SunPKCS11 provider added several password-based SecretKeyFactory implementations, such as:

  • SecretKeyFactory.PBEWithHmac[MD]AndAES_128
  • SecretKeyFactory.PBEWithHmac[MD]AndAES_256
  • SecretKeyFactory.HmacPBE[MD]

where [MD] is one of the SHA1, SHA224, SHA256, SHA384, and SHA512 algorithms.

However, the key objects produced by these implementations use the PBKDF2-derived values as key encodings. This is different than the SunJCE counterparts which use the password bytes as key encodings. These differences can be very confusing and may cause interoperability issues since both keys have the same algorithm and format, but different encodings. Thus, for consistency sake, these SunPKCS11 password-based SecretKeyFactory implementations have been removed.


SunJCE Provider's PBE-related SecretKeyFactory Implementations Enhanced with Unicode Support


The password-based SecretKeyFactory implementations from the SunJCE provider used to reject non-ASCII passwords. They have been enhanced to use UTF-8 and thus allow Unicode characters to be used as passwords.


JDK-8328119

Support for HKDF in SunPKCS11


The SunPKCS11 security provider now supports the following algorithms for the new Key Derivation Function API: HKDF-SHA256, HKDF-SHA384 and HKDF-SHA512. Please refer to JDK-8344464 for further details. Additional information can be found in SunPKCS11 Provider Supported Algorithms.


core-svc

Issue Description
JDK-8356870

Thread Dumps Generated by HotSpotDiagnosticMXBean.dumpThreads and jcmd Thread.dump_to_file Updated to Include Lock Information


The thread dump generated by the com.sun.management.HotSpotDiagnosticMXBean.dumpThreads API, and the diagnostic command jcmd <pid> Thread.dump_to_file, now includes lock information.

The HotSpotDiagnosticMXBean.dumpThreads API is also updated to link to a JSON schema that describes the JSON format thread dump. The JSON format thread dump is intended to be read and processed by diagnostic tools.

Unlike the traditional thread dump generated by jstack and jcmd <pid> Thread.print, the thread dump generated by the HotSpotDiagnosticMXBean.dumpThreads and jcmd <pid> Thread.dump_to_file does not print information about deadlocks in this release.


specification/language

Issue Description
JDK-8344702

JEP 492: Flexible Constructor Bodies (Third Preview)


Summary

In constructors in the Java programming language, allow statements to appear before an explicit constructor invocation, i.e., super(..) or this(..). The statements cannot reference the instance under construction, but they can initialize its fields. Initializing fields before invoking another constructor makes a class more reliable when methods are overridden. This is a preview language feature.

History

This feature first previewed in JDK 22 via JEP 447, under a different title. It previewed for a second time in JDK 23 via JEP 482. We here propose to preview it for a third time, without significant change.

Goals

  • Reimagine the role of constructors in the process of object initialization, enabling developers to more naturally place logic that they currently must factor into auxiliary static methods, auxiliary intermediate constructors, or constructor arguments.

  • Introduce two distinct phases in a constructor body: The prologue contains code that executes before the superclass constructor is invoked, and the epilogue executes after the superclass constructor has been invoked.

  • Preserve the existing guarantee that code in a subclass constructor cannot interfere with superclass instantiation.

Motivation

The constructors of a class are responsible for creating valid instances of that class. For example, suppose that instances of a Person class have an age field whose value must never be negative. A constructor which takes an age-related parameter (e.g., a birth date) must validate it and either write it to the age field, thereby ensuring a valid instance, or else throw an exception.

The constructors of a class are, furthermore, responsible for ensuring validity in the presence of subclassing. For example, suppose that Employee is a subclass of Person. Every Employee constructor will invoke, either implicitly or explicitly, a Person constructor. The two constructors must work together to ensure a valid instance: The Employee constructor is responsible for the fields declared in the Employee class, while the Person constructor is responsible for the fields declared in the Person class. Since code in the Employee constructor can refer to fields declared in the Person class, it is important to ensure that those fields are properly initialized before the Employee constructor is allowed to access them.

The Java programming language provides this guarantee using a simple solution, which is to require that constructors must run from the top down: A constructor in a superclass must run first, ensuring the validity of the fields declared in the superclass, before a constructor in a subclass runs. In the previous example, the Person constructor must run in its entirety before the Employee constructor, to guarantee that the Employee constructor always sees a valid age field.

To guarantee that constructors run from the top down, the Java language requires the first statement in a constructor body to be an explicit invocation of another constructor, i.e., either super(..) or this(..). If no explicit constructor invocation appears in the constructor body, then the compiler inserts super() as the first statement in the constructor body.

The language further requires that, for any explicit constructor invocation, none of its arguments can use the instance under construction in any way.

These two requirements guarantee some predictability and hygiene in the construction of new instances. They are, however, heavy-handed because they outlaw certain familiar programming patterns, as illustrated by the following examples.

Example: Validating superclass constructor arguments

Sometimes we need to validate an argument that is passed to a superclass constructor. We can validate the argument after calling the superclass constructor, but that means potentially doing unnecessary work:

``` public class PositiveBigInteger extends BigInteger {

public PositiveBigInteger(long value) {
    super(value);                 // Potentially unnecessary work
    if (value <= 0) throw new IllegalArgumentException(..);
}

} ```

It would be better to declare a constructor that fails fast, by validating its argument before it invokes the superclass constructor. Today we can only do that by calling an auxiliary method in-line, as part of the super(..) call:

``` public class PositiveBigInteger extends BigInteger {

private static long verifyPositive(long value) {
    if (value <= 0) throw new IllegalArgumentException(..);
    return value;
}

public PositiveBigInteger(long value) {
    super(verifyPositive(value));
}

} ```

The code would be more readable if we could place the validation logic in the constructor body:

``` public class PositiveBigInteger extends BigInteger {

public PositiveBigInteger(long value) {
    if (value <= 0) throw new IllegalArgumentException(..);
    super(value);
}

} ```

Example: Preparing superclass constructor arguments

Sometimes we must perform non-trivial computation to prepare arguments for a superclass constructor. Again, we must resort to calling an auxiliary method in-line, as part of the super(..) call. For example, suppose a constructor takes a Certificate argument but must convert it to a byte array for a superclass constructor:

``` public class Sub extends Super {

private static byte[] prepareByteArray(Certificate certificate) {
    var publicKey = certificate.getPublicKey();
    if (publicKey == null) throw new IllegalArgumentException(..);
    return switch (publicKey) {
        case RSAKey rsaKey -> ...
        case DSAPublicKey dsaKey -> ...
        default -> ...
    };
}

public Sub(Certificate certificate) {
    super(prepareByteArray(certificate));
}

} ```

The code would be more readable if we could prepare the arguments directly in the constructor body:

` public Sub(Certificate certificate) { var publicKey = certificate.getPublicKey(); if (publicKey == null) throw ... byte[] certBytes = switch (publicKey) { case RSAKey rsaKey -> ... case DSAPublicKey dsaKey -> ... default -> ... }; super(certBytes ); } `

Example: Sharing superclass constructor arguments

Sometimes we need to pass the same value to a superclass constructor more than once, in different arguments. The only way to do this is via an auxiliary constructor:

``` public class Super { public Super(C x, C y) { ... } }

public class Sub extends Super { private Sub(C x) { super(x, x); } // Pass the argument twice to Super's constructor public Sub(int i) { this(new C(i)); } // Prepare the argument for Super's constructor } ```

The code would be more maintainable if we could arrange for the sharing in the constructor body, obviating the need for an auxiliary constructor:

` public class Sub extends Super { public Sub(int i) { var x = new C(i); super(x, x); } } `

Summary

In all of these examples, the constructor body that we would like to write contains a distinct phase that we would like to run before invoking another constructor. This initial phase consists of code that does not use the instance being constructed, and so it would be safe to run it before the explicit constructor invocation. Unfortunately, even though all these constructor bodies ensure safe object initialization, they are all currently forbidden in the Java language.

If the language could guarantee safe object initialization with more flexible rules then constructor bodies would be easier to write and easier to maintain. Constructor bodies could more naturally do argument validation, argument preparation, and argument sharing without calling upon clumsy auxiliary methods or constructors. It is time to reimagine how constructor bodies can be written to safely perform object initialization.

Description

We propose to move beyond the simplistic syntactic requirement, enforced since Java 1.0, that super(..) or this(..) must be the first statement in a constructor body. In the new model, a constructor body has two distinct phases: The prologue is the code before the constructor invocation, and the epilogue is the code after the constructor invocation.

To illustrate, consider this class hierarchy:

``` class Object { Object() { // Object constructor body } }

class A extends Object { A() { super(); // A constructor body } }

class B extends A { B() { super(); // B constructor body } }

class C extends B { C() { super(); // C constructor body } }

class D extends C { D() { super(); // D constructor body } } ```

Currently, when creating a new instance of class D, via new D(), the execution of the constructor bodies can be visualized as:

` D --> C --> B --> A --> Object constructor body --> A constructor body --> B constructor body --> C constructor body D constructor body `

This is why the Java language's current approach to safe object initialization is characterized as being top-down: The constructor bodies are run starting at the top of the hierarchy, with the class Object, moving down one-by-one through the subclasses.

When constructor bodies have both a prologue and an epilogue, we can generalize the class declarations:

``` class Object { Object() { // Object constructor body } }

class A extends Object { A() { // A prologue super(); // A epilogue } }

class B extends A { B() { // B prologue super(); // B epilogue } }

class C extends B { C() { // C prologue super(); // C epilogue } }

class D extends C { D() { // D prologue super(); // D epilogue } } ```

The corresponding execution of the constructor bodies when evaluating new D() can be visualized as:

` D prologue --> C prologue --> B prologue --> A prologue --> Object constructor body --> A epilogue --> B epilogue --> C epilogue D epilogue `

This new approach, rather than running the constructor bodies top-down, first runs the prologues bottom-up and then runs the epilogues top-down.

This is a preview language feature, disabled by default

To try the examples below in JDK 24, you must enable preview features:

  • Compile the program with javac --release 24 --enable-preview Main.java and run it with java --enable-preview Main; or,

  • When using the source code launcher, run the program with java --enable-preview Main.java; or,

  • When using jshell, start it with jshell --enable-preview.

Syntax

We revise the grammar of a constructor body to allow statements before an explicit constructor invocation, that is, from:

` ConstructorBody: { [ExplicitConstructorInvocation] [BlockStatements] } `

to:

` ConstructorBody: { [BlockStatements] ExplicitConstructorInvocation [BlockStatements] } { [BlockStatements] } `

Eliding some details, an explicit constructor invocation is either super(..) or this(..).

The statements that appear before an explicit constructor invocation constitute the prologue of the constructor body.

The statements that appear after an explicit constructor invocation constitute the epilogue of the constructor body.

An explicit constructor invocation in a constructor body may be omitted. In this case the prologue is empty, and all the statements in the constructor body constitute the epilogue.

A return statement is permitted in the epilogue of a constructor body if it does not include an expression. That is, return; is allowed but return e; is not. It is a compile-time error for a return statement to appear in the prologue of a constructor body.

Throwing an exception in the prologue or epilogue of a constructor body is permitted. Throwing an exception in the prologue will be typical in fail-fast scenarios.

Early construction contexts

Currently, in the Java language, code that appears in the argument list of an explicit constructor invocation is said to appear in a static context. This means that the arguments to the explicit constructor invocation are treated as if they were code in a static method; in other words, as if no instance is available. The technical restrictions of a static context are stronger than necessary, however, and they prevent code that is useful and safe from appearing as constructor arguments.

Rather than revise the concept of a static context, we introduce the concept of an early construction context that covers both the argument list of an explicit constructor invocation and any statements that appear before it in the constructor body, i.e., in the prologue. Code in an early construction context must not use the instance under construction, except to initialize fields that do not have their own initializers.

This means that any explicit or implicit use of this to refer to the current instance, or to access fields or invoke methods of the current instance, is disallowed in an early construction context:

``` class A {

int i;

A() {

    System.out.print(this);  // Error - refers to the current instance

    var x = this.i;          // Error - explicitly refers to field of the current instance
    this.hashCode();         // Error - explicitly refers to method of the current instance

    var x = i;               // Error - implicitly refers to field of the current instance
    hashCode();              // Error - implicitly refers to method of the current instance

    super();

}

} ```

Similarly, any field access, method invocation, or method reference qualified by super is disallowed in an early construction context:

``` class B { int i; void m() { ... } }

class C extends B {

C() {
    var x = super.i;         // Error
    super.m();               // Error
    super();
}

} ```

Using enclosing instances in early construction contexts

When class declarations are nested, the code of an inner class can refer to the instance of an enclosing class. This is because the instance of the enclosing class is created before the instance of the inner class. The code of the inner class — including constructor bodies — can access fields and invoke methods of the enclosing instance, using either simple names or qualified this expressions. Accordingly, operations on an enclosing instance are permitted in an early construction context.

In the code below, the declaration of Inner is nested in the declaration of Outer, so every instance of Inner has an enclosing instance of Outer. In the constructor of Inner, code in the early construction context can refer to the enclosing instance and its members, either via simple names or via Outer.this.

``` class Outer {

int i;

void hello() { System.out.println("Hello"); }

class Inner {

    int j;

    Inner() {
        var x = i;             // OK - implicitly refers to field of enclosing instance
        var y = Outer.this.i;  // OK - explicitly refers to field of enclosing instance
        hello();               // OK - implicitly refers to method of enclosing instance
        Outer.this.hello();    // OK - explicitly refers to method of enclosing instance
        super();
    }

}

} ```

By contrast, in the constructor of Outer shown below, code in the early construction context cannot instantiate the Inner class with new Inner(). This expression is really this.new Inner(), meaning that it uses the current instance of Outer as the enclosing instance for the Inner object. Per the earlier rule, any explicit or implicit use of this to refer to the current instance is disallowed in an early construction context.

``` class Outer {

class Inner {}

Outer() {
    var x = new Inner();       // Error - implicitly refers to the current instance of Outer
    var y = this.new Inner();  // Error - explicitly refers to the current instance of Outer
    super();
}

} ```

Early assignment to fields

Accessing fields of the current instance is disallowed in an early construction context, but what about assigning to fields of the current instance while it is still under construction?

Allowing such assignments would be useful as a way for a constructor in a subclass to defend against a constructor in a superclass seeing uninitialized fields in the subclass. This can occur when a constructor in a superclass invokes a method in the superclass that is overridden by a method in the subclass. Although the Java language allows constructors to invoke overridable methods, it is considered bad practice: Item 19 of Effective Java (Third Edition) advises that "Constructors must not invoke overridable methods." To see why it is considered bad practice, consider the following class hierarchy:

``` class Super {

Super() { overriddenMethod(); }

void overriddenMethod() { System.out.println("hello"); }

}

class Sub extends Super {

final int x;

Sub(int x) {
    /* super(); */    // Implicit invocation
    this.x = x;
}

@Override
void overriddenMethod() { System.out.println(x); }

} ```

What does new Sub(42) print? You might expect it to print 42, but it actually prints 0. This is because the Super constructor is implicitly invoked before the field assignment in the Sub constructor body. The Super constructor then invokes overriddenMethod, causing that method in Sub to run before the Sub constructor body has had a chance to assign 42 to the field. As a result, the method in Sub sees the default value of the field, which is 0.

This pattern is a source of many bugs and errors. While it is considered bad programming practice, it is not uncommon, and it presents a conundrum for subclasses — especially when modifying the superclass is not an option.

We solve the conundrum by allowing the Sub constructor to initialize the field in Sub before invoking the Super constructor explicitly. The example can be rewritten as follows, where only the Sub class is changed:

``` class Super {

Super() { overriddenMethod(); }

void overriddenMethod() { System.out.println("hello"); }

}

class Sub extends Super {

final int x;

Sub(int x) {
    this.x = x;    // Initialize the field
    super();       // Then invoke the Super constructor explicitly
}

@Override
void overriddenMethod() { System.out.println(x); }

} ```

Now, new Sub(42) will print 42, because the field in Sub is assigned to 42 before overriddenMethod is invoked.

In a constructor body, a simple assignment to a field declared in the same class is allowed in an early construction context, provided the field declaration lacks an initializer. This means that a constructor body can initialize the class's own fields in an early construction context, but not the fields of a superclass. Again, this ensures safe object initialization.

As discussed earlier, a constructor body cannot read any of the fields of the current instance — whether declared in the same class as the constructor, or in a superclass — until after the explicit constructor invocation, i.e., in the epilogue.

Records

Constructors of record classes are already subject to more restrictions than constructors of normal classes. In particular,

  • Canonical record constructors must not contain any explicit constructor invocation, and

  • Non-canonical record constructors must contain an alternate constructor invocation (this(..)) and not a superclass constructor invocation (super(..)).

These restrictions remain. Otherwise, record constructors will benefit from the changes described above, primarily because non-canonical record constructors will be able to contain statements before the alternative constructor invocation.

Enums

Constructors of enum classes can contain alternate constructor invocations but not superclass constructor invocations. Enum classes will benefit from the changes described above, primarily because their constructors will be able to contain statements before the alternate constructor invocation.

Testing

  • We will test the compiler changes with existing unit tests, unchanged except for those tests that verify changed behavior, plus new positive and negative test cases as appropriate.

  • We will compile all JDK classes using the previous and new versions of the compiler and verify that the resulting bytecode is identical.

  • No platform-specific testing should be required.

Risks and Assumptions

The changes we propose above are source- and behavior-compatible. They strictly expand the set of legal Java programs while preserving the meaning of all existing Java programs.

These changes, though modest in themselves, represent a significant change in how constructors participate in safe object initialization. They relax the long-standing requirement that a constructor invocation, if present, must always appear as the first statement in a constructor body. This requirement is deeply embedded in code analyzers, style checkers, syntax highlighters, development environments, and other tools in the Java ecosystem. As with any language change, there may be a period of pain as tools are updated.

Dependencies

Flexible constructor bodies in the Java language depend on the ability of the JVM to verify and execute arbitrary code that appears before constructor invocations in constructors, so long as that code does not reference the instance under construction. Fortunately, the JVM already supports a more flexible treatment of constructor bodies:

  • Multiple constructor invocations may appear in a constructor body provided on any code path there is exactly one invocation;

  • Arbitrary code may appear before constructor invocations so long as that code does not reference the instance under construction except to assign fields; and

  • Explicit constructor invocations may not appear within a try block, i.e., within a bytecode exception range.

The JVM's rules still ensure safe object initialization:

  • Superclass initialization always happens exactly once, either directly via a superclass constructor invocation or indirectly via an alternate constructor invocation; and

  • Uninitialized instances are off-limits except for field assignments, which do not affect outcomes, until superclass initialization is complete.

As a result, this proposal does not include any changes to the Java Virtual Machine Specification, only to the Java Language Specification.

The existing mismatch between the JVM, which allows flexible constructor bodies, and the Java language, which is more restrictive, is an historical artifact. Originally the JVM was more restrictive, but this led to issues with the initialization of compiler-generated fields for new language features such as inner classes and captured free variables. To accommodate compiler-generated code, we relaxed the JVM Specification many years ago, but we never revised the Java Language Specification to leverage this new flexibility.


JDK-8351401

Deprecation of Boxed Primitive Constructors


Classes Boolean, Byte, Short, Character, Integer, Long, Float, and Double are "box" classes that correspond to primitive types. The constructors of these classes have been deprecated.

Given a value of the corresponding primitive type, it is generally unnecessary to construct new instances of these box classes. The recommended alternatives to construction are autoboxing or the valueOf static factory methods. In most cases, autoboxing will work, so an expression whose type is a primitive can be used in locations where a box class is required. This is covered in the Java Language Specification, section 5.1.7, "Boxing Conversion." For example, given List<Integer> intList, the code to add an Integer might be as follows: ` intList.add(new Integer(347)); This can be replaced with: `` intList.add(347); ` Autoboxing should not be used in places where it might affect overload resolution. For example, there are two overloads of the `List.remove` method: List.remove(int i) // removes the element at index i List.remove(Object obj) // removes an element equal to obj `` The code to remove the Integer value 347 might be as follows: ` intList.remove(new Integer(347)); If this code is changed in an attempt to use autoboxing: `` intList.remove(347); `` This will not remove theInteger` value 347, but instead it will resolve to the other overloaded method, and it will attempt to remove the element at index 347.

Autoboxing cannot be used in such cases. Instead, code should be changed to use the valueOf static factory method: ` intList.remove(Integer.valueOf(347)); `

Autoboxing is preferable from a readability standpoint, but a safer transformation is to replace calls to the box constructors with calls to the valueOf static factory method.

Using autoboxing or the valueOf method reduces memory footprint compared to the constructors, as the integral box types will generally cache and reuse instances corresponding to small values. The special case of Boolean has static fields for the two cached instances, namely Boolean.FALSE and Boolean.TRUE.

With the exception of Character, the box classes also have constructors that take a String argument. These parse and convert the string value and return a new instance of the box class. A valueOf overload taking a String is the equivalent static factory method for this constructor. Usually it's preferable to call one of the parse methods (Integer.parseInt, Double.parseDouble, etc.) which convert the string and return primitive values instead of boxed instances.


core-libs/java.lang.classfile

Issue Description
JDK-8347472

CodeModel Now Delivers Custom and Unknown Attributes


In the previous release, when a java.lang.classfile.CodeModel is traversed by a forEach, CustomAttribute and UnknownAttribute were not delivered. Now, they are delivered, bringing their delivery behavior in parity with ClassModel, FieldModel, and MethodModel.

Users who traverse a CodeModel should review their handling of these two attributes when they are delivered as CodeElement. In particular, users using exhaustive pattern matching switches to handle CodeElement will encounter a compile error and must update their code.


core-svc/javax.management

Issue Description
JDK-8347985

Various Permission Classes Deprecated for Removal


The following permission classes have been deprecated for removal:

  • java.security.UnresolvedPermission
  • javax.net.ssl.SSLPermission
  • javax.security.auth.AuthPermission
  • javax.security.auth.PrivateCredentialPermission
  • javax.security.auth.kerberos.DelegationPermission
  • javax.security.auth.kerberos.ServicePermission
  • com.sun.security.jgss.InquireSecContextPermission
  • java.lang.RuntimePermission
  • java.lang.reflect.ReflectPermission
  • java.io.FilePermission
  • java.io.SerializablePermission
  • java.nio.file.LinkPermission
  • java.util.logging.LoggingPermission
  • java.util.PropertyPermission
  • jdk.jfr.FlightRecorderPermission
  • java.net.NetPermission
  • java.net.URLPermission
  • jdk.net.NetworkPermission
  • com.sun.tools.attach.AttachPermission
  • com.sun.jdi.JDIPermission
  • java.lang.management.ManagementPermission
  • javax.management.MBeanPermission
  • javax.management.MBeanTrustPermission
  • javax.management.MBeanServerPermission
  • javax.management.remote.SubjectDelegationPermission

In addition, the getPermission method defined in java.net.URLConnection and its subclass java.net.HttpURLConnection has been deprecated for removal.

These permission classes and associated methods were only useful in conjunction with the Security Manager, which is no longer supported.


JDK-8344969

Removal of Old JMX System Properties


Some very old JMX System Properties have been removed. These were compatibility aids that were intended as transitional, for later removal. New behavior will be the same as current behavior with the property unset. The removals are:

jmx.extend.open.types which was provided to aid compatibility, since overriding javax.management.openmbean.OpenType.getClassName() was made illegal in JDK 6.

jmx.invoke.getters was introduced in JDK 6 for compatibility with code which depended on previous, incorrect behavior, calling invoke on getters and setters.

jdk.jmx.mbeans.allowNonPublic was introduced in JDK 8 for compatibility with previous, incorrect behavior where it was not enforced that MBean and MXBean interfaces must be public.

jmx.mxbean.multiname was introduced in JDK 7 for compatibility with code which may have depended on previous, incorrect behavior relating to multiple registrations of an MXBean object.

jmx.tabular.data.hash.map, which was for compatibility with JDK 1.3 clients due to use of LinkedHashMap.

jmx.remote.x.buffer.size was a System Property and a JMX environment property. The correct name was always jmx.remote.x.notification.buffer.size and was correct from JDK 6, but the alternate name was recognized to aid compatibility.


JDK-8344966

Removal of Old JMX System Properties


Some very old JMX System Properties have been removed. These were compatibility aids that were intended as transitional, for later removal. New behavior will be the same as current behavior with the property unset. The removals are:

jmx.extend.open.types which was provided to aid compatibility, since overriding javax.management.openmbean.OpenType.getClassName() was made illegal in JDK 6.

jmx.invoke.getters was introduced in JDK 6 for compatibility with code which depended on previous, incorrect behavior, calling invoke on getters and setters.

jdk.jmx.mbeans.allowNonPublic was introduced in JDK 8 for compatibility with previous, incorrect behavior where it was not enforced that MBean and MXBean interfaces must be public.

jmx.mxbean.multiname was introduced in JDK 7 for compatibility with code which may have depended on previous, incorrect behavior relating to multiple registrations of an MXBean object.

jmx.tabular.data.hash.map, which was for compatibility with JDK 1.3 clients due to use of LinkedHashMap.

jmx.remote.x.buffer.size was a System Property and a JMX environment property. The correct name was always jmx.remote.x.notification.buffer.size and was correct from JDK 6, but the alternate name was recognized to aid compatibility.


JDK-8347433

Deprecate XML Interchange in JMX DescriptorSupport for Removal


The JMX class javax.management.modelmbean.DescriptorSupport represents MBean metadata. It has a constructor and a method providing creation from, and export to, XML. These are unused in the JDK and have no commonly known wider usage, and are deprecated for removal. The class javax.management.modelmbean.XMLParseException, which is only thrown by DescriptorSupport, is also deprecated for removal. This will have no impact on JMX features in general.


JDK-8345049

Removal of Old JMX System Properties


Some very old JMX System Properties have been removed. These were compatibility aids that were intended as transitional, for later removal. New behavior will be the same as current behavior with the property unset. The removals are:

jmx.extend.open.types which was provided to aid compatibility, since overriding javax.management.openmbean.OpenType.getClassName() was made illegal in JDK 6.

jmx.invoke.getters was introduced in JDK 6 for compatibility with code which depended on previous, incorrect behavior, calling invoke on getters and setters.

jdk.jmx.mbeans.allowNonPublic was introduced in JDK 8 for compatibility with previous, incorrect behavior where it was not enforced that MBean and MXBean interfaces must be public.

jmx.mxbean.multiname was introduced in JDK 7 for compatibility with code which may have depended on previous, incorrect behavior relating to multiple registrations of an MXBean object.

jmx.tabular.data.hash.map, which was for compatibility with JDK 1.3 clients due to use of LinkedHashMap.

jmx.remote.x.buffer.size was a System Property and a JMX environment property. The correct name was always jmx.remote.x.notification.buffer.size and was correct from JDK 6, but the alternate name was recognized to aid compatibility.


JDK-8345045

Removal of Old JMX System Properties


Some very old JMX System Properties have been removed. These were compatibility aids that were intended as transitional, for later removal. New behavior will be the same as current behavior with the property unset. The removals are:

jmx.extend.open.types which was provided to aid compatibility, since overriding javax.management.openmbean.OpenType.getClassName() was made illegal in JDK 6.

jmx.invoke.getters was introduced in JDK 6 for compatibility with code which depended on previous, incorrect behavior, calling invoke on getters and setters.

jdk.jmx.mbeans.allowNonPublic was introduced in JDK 8 for compatibility with previous, incorrect behavior where it was not enforced that MBean and MXBean interfaces must be public.

jmx.mxbean.multiname was introduced in JDK 7 for compatibility with code which may have depended on previous, incorrect behavior relating to multiple registrations of an MXBean object.

jmx.tabular.data.hash.map, which was for compatibility with JDK 1.3 clients due to use of LinkedHashMap.

jmx.remote.x.buffer.size was a System Property and a JMX environment property. The correct name was always jmx.remote.x.notification.buffer.size and was correct from JDK 6, but the alternate name was recognized to aid compatibility.


JDK-8345048

Removal of Old JMX System Properties


Some very old JMX System Properties have been removed. These were compatibility aids that were intended as transitional, for later removal. New behavior will be the same as current behavior with the property unset. The removals are:

jmx.extend.open.types which was provided to aid compatibility, since overriding javax.management.openmbean.OpenType.getClassName() was made illegal in JDK 6.

jmx.invoke.getters was introduced in JDK 6 for compatibility with code which depended on previous, incorrect behavior, calling invoke on getters and setters.

jdk.jmx.mbeans.allowNonPublic was introduced in JDK 8 for compatibility with previous, incorrect behavior where it was not enforced that MBean and MXBean interfaces must be public.

jmx.mxbean.multiname was introduced in JDK 7 for compatibility with code which may have depended on previous, incorrect behavior relating to multiple registrations of an MXBean object.

jmx.tabular.data.hash.map, which was for compatibility with JDK 1.3 clients due to use of LinkedHashMap.

jmx.remote.x.buffer.size was a System Property and a JMX environment property. The correct name was always jmx.remote.x.notification.buffer.size and was correct from JDK 6, but the alternate name was recognized to aid compatibility.


JDK-8344976

Removal of Old JMX System Properties


Some very old JMX System Properties have been removed. These were compatibility aids that were intended as transitional, for later removal. New behavior will be the same as current behavior with the property unset. The removals are:

jmx.extend.open.types which was provided to aid compatibility, since overriding javax.management.openmbean.OpenType.getClassName() was made illegal in JDK 6.

jmx.invoke.getters was introduced in JDK 6 for compatibility with code which depended on previous, incorrect behavior, calling invoke on getters and setters.

jdk.jmx.mbeans.allowNonPublic was introduced in JDK 8 for compatibility with previous, incorrect behavior where it was not enforced that MBean and MXBean interfaces must be public.

jmx.mxbean.multiname was introduced in JDK 7 for compatibility with code which may have depended on previous, incorrect behavior relating to multiple registrations of an MXBean object.

jmx.tabular.data.hash.map, which was for compatibility with JDK 1.3 clients due to use of LinkedHashMap.

jmx.remote.x.buffer.size was a System Property and a JMX environment property. The correct name was always jmx.remote.x.notification.buffer.size and was correct from JDK 6, but the alternate name was recognized to aid compatibility.


hotspot/runtime

Issue Description
JDK-8351654

Class Files Provided With The JVMTI ClassFileLoadHook Event Are Verified


When providing a class with JVMTI ClassFileLoadHook, the new bytecodes are verified with the Class File Verifier even if they are provided on the bootclass path, and regardless of the setting of the deprecated -Xverify option.


JDK-8348829

Removal of sun.rt._sync* Performance Counters


This release removes old object monitor performance counters, exposed in the sun.rt._sync* namespace. These counters were seldom used, and they contributed to performance problems in related VM code. Users who want to track monitor performance are advised to use related JFR events instead.

The suggested replacements are: - _sync_ContendedLockAttempts: JavaMonitorEnter JFR event - _sync_FutileWakeups: no replacement - _sync_Parks: JavaMonitorWait JFR event - _sync_Notifications: JavaMonitorNotify JFR event - _sync_Inflations: JavaMonitorInflate JFR event - _sync_Deflations: JavaMonitorDeflate JFR event - _sync_MonExtant: JavaMonitorStatistics JFR event


JDK-8241678

Removal of PerfData Sampling


The periodic sampling functionality in PerfData has been removed, including the StatSampler and its controlling flag -XX:PerfDataSamplingInterval.

PerfData sampling was a rarely used mechanism that periodically updated a small set of counters in the PerfData file. For most garbage collectors, like in the G1 and ZGC collectors, it only recorded a timestamp.

With this change:

  • Heap usage counters in PerfData for the Serial and Parallel garbage collectors are now only updated after each garbage collection cycle. As a result, the Eden space usage counter (sun.gc.generation.0.space.0.used) will always show zero, since the space is empty after collection. Accurate values are still available through tools such as the Java Flight Recorder (JFR) and Java Management Extensions (JMX)
  • The sun.os.hrt.ticks counter tracking time since JVM startup has been removed. This can instead be derived from sun.rt.createVmBeginTime.
  • The -XX:PerfDataSamplingInterval flag has been made obsolete, and will be removed in a future release.

This change only affects tools that read data directly from the PerfData file. Other monitoring programs and tools remain unaffected.


JDK-8350457

UseCompactObjectHeaders Is a Product Option


The flag -XX:+/-UseCompactObjectHeaders is now a product option. This allows users to enable compact object headers without the use of the -XX:+UnlockExperimentalVMOptions flag. Compact object headers are a feature introduced in JDK 24 under JEP 450. Enabling this feature reduces the Java heap footprint of applications and potentially provides performance benefits. The feature remains disabled by default in this release but may become the default in a future release.

To support use of compact object headers, two additional CDS archives for the JDK image called classes_coh.jsa and classes_nocoops_coh.jsa are provided to allow equivalent startup performance when UseCompactObjectHeaders is turned on.


Compact Object Headers CDS Archive Generation and jlink Instruction


If using -XX:+UseCompactObjectHeaders with a custom image created with jlink, an additional step is needed to create the CDS archives for this configuration. After creating the image, do:

`<image>/bin/java -XX:+UseCompactObjectHeaders -Xshare:dump`

to create the classes_coh.jsa file. In the unlikely case that you wish to use UseCompactObjectHeaders without UseCompressedOops, also create a CDS archive image by:

`<image>/bin/java -XX:+UseCompactObjectHeaders -XX:-UseCompressedOops -Xshare:dump`


JDK-8350753

The UseCompressedClassPointers Option is Deprecated


The option UseCompressedClassPointers is deprecated in Java SE 25 and will be removed in a future Java version.

This option was used to switch between two modes:

  • The compressed class pointer mode (-XX:+UseCompressedClassPointers, default if the switch is not specified)
  • The uncompressed class pointer mode (-XX:-UseCompressedClassPointers)

The uncompressed class pointer mode will be removed in a future version of Java. Since that only leaves the default compressed class pointer mode, the switch will also be removed.

The uncompressed class pointer mode causes the JVM to use more memory. It serves very little purpose today.

The default compressed class pointer mode causes the JVM to place classes into the class space. The class space is limited by default to 1GB and can hold up to about 1.5 million classes. In the rare case that an application must load more than that, the class space can be extended up to 4 GB with -XX:CompressedClassSpaceSize . That increases the number of classes the class space can hold to approximately 6 million classes.

Note that these numbers are extremely high. It is rare even for a huge Java application to even load more than 100,000 classes. If your application loads significantly more classes than that, it is very likely a pathological situation, such as a class loader leak.

The class space is reserved up front when the JVM starts. However, that memory is virtual; no actual memory is used until classes are loaded, and then, only as many pages are allocated as are needed to hold the class data.

If your application specifies -XX:+UseCompressedClassPointers, remove that option. It is superfluous since enabling compressed class pointers is the default.

If your application specifies -XX:-UseCompressedClassPointers, remove that option. In all likelihood, the application will just continue to work. Should the application exhaust the class space, you may want to examine whether that situation is pathological. If it is not pathological, increase the class space to 4GB using -XX:CompressedClassSpaceSize=4g.


security-libs/java.security

Issue Description
JDK-8359170

Added 4 New Root Certificates from Sectigo Limited


The following root certificates have been added to the cacerts truststore: ``` + Sectigo Limited + sectigocodesignroote46 DN: CN=Sectigo Public Code Signing Root E46, O=Sectigo Limited, C=GB

  • Sectigo Limited

  • sectigocodesignrootr46 DN: CN=Sectigo Public Code Signing Root R46, O=Sectigo Limited, C=GB

  • Sectigo Limited

  • sectigotlsroote46 DN: CN=Sectigo Public Server Authentication Root E46, O=Sectigo Limited, C=GB

  • Sectigo Limited

  • sectigotlsrootr46 DN: CN=Sectigo Public Server Authentication Root R46, O=Sectigo Limited, C=GB ```


JDK-8354305

SHAKE128-256 and SHAKE256-512 as MessageDigest Algorithms


Two new MessageDigest algorithms, SHAKE128-256 and SHAKE256-512, have been added to the SUN provider. These are fixed-length versions of the SHAKE128 and SHAKE256 Extendable-Output Functions (XOFs) defined in NIST FIPS 202. For more information, see the SUN Provider.


JDK-8350498

Removed Two Camerfirma Root Certificates


The following root certificates, which are terminated and no longer in use, have been removed from the cacerts keystore: ``` + alias name "camerfirmachamberscommerceca [jdk]" Distinguished Name: CN=Chambers of Commerce Root, OU=http://www.chambersign.org, O=AC Camerfirma SA CIF A82743287, C=EU

  • alias name "camerfirmachambersignca [jdk]" Distinguished Name: CN=Global Chambersign Root - 2008, O=AC Camerfirma S.A., SERIALNUMBER=A82743287, L=Madrid (see current address at www.camerfirma.com/address), C=EU

```


JDK-8283795

Added TLSv1.3 and CNSA 1.0 Algorithms to Implementation Requirements


TLSv1.3 and CNSA 1.0 algorithms have been added to the list of cryptographic requirements all Java SE implementations must support. All cryptographic algorithms that are needed to implement the TLSv1.3 cipher suites and signature mechanisms and that are defined by RFC 8446 as MUST or SHOULD requirements have been added. All algorithms that are required by CNSA 1.0 have also been added. No required algorithms or protocols are being removed at this time.

The following requirements have been added to the Security Algorithm Implementation Requirements section of the Java Security Standard Algorithm Names specification and to the class summary of each of the APIs below.

  • AlgorithmParameters

  • ChaCha20-Poly1305

  • EC with secp256r1 or secp384r1 curves

  • RSASSA-PSS with MGF1 mask generation function and SHA-256 or SHA-384 hash algorithm

  • Cipher

  • AES/GCM/NoPadding with 256 bit key size

  • ChaCha20-Poly1305

  • KeyAgreement

  • ECDH with secp256r1 or secp384r1 curves

  • X25519

  • KeyFactory

  • EC

  • RSASSA-PSS

  • X25519

  • KeyGenerator

  • AES with 256 bit key size

  • ChaCha20

  • KeyPairGenerator

  • DH with 3072 bit key size

  • EC with secp256r1 or secp384r1 curves

  • RSA with 3072 bit key size

  • RSASSA-PSS with 2048, 3072, 4096 bit key sizes

  • X25519

  • MessageDigest

  • SHA-384

  • Signature

  • RSASSA-PSS with MGF1 mask generation function and SHA-256 or SHA-384 hash algorithm

  • SHA256WithECDSA with secp256r1 curve

  • SHA384WithECDSA with secp384r1 curve

  • SHA384WithRSA

  • SSLContext

  • TLSv1.3


JDK-8347596

Updated HSS/LMS Public Key Encoding


The X.509 encoded format for HSS/LMS public keys has been updated to align with the latest standard outlined in RFC 9708. Notably, the additional OCTET STRING wrapping around the public key value has been removed. For compatibility, public key encodings generated by earlier JDK releases are still recognized.


JDK-8303770

Removed Baltimore CyberTrust Root Certificate After Expiry Date


The following expired root certificate has been removed from the cacerts keystore: ` + alias name "baltimorecybertrustca [jdk]" Distinguished Name: CN=Baltimore CyberTrust Root, OU=CyberTrust, O=Baltimore, C=IE `


JDK-8348967

Various Permission Classes Deprecated for Removal


The following permission classes have been deprecated for removal:

  • java.security.UnresolvedPermission
  • javax.net.ssl.SSLPermission
  • javax.security.auth.AuthPermission
  • javax.security.auth.PrivateCredentialPermission
  • javax.security.auth.kerberos.DelegationPermission
  • javax.security.auth.kerberos.ServicePermission
  • com.sun.security.jgss.InquireSecContextPermission
  • java.lang.RuntimePermission
  • java.lang.reflect.ReflectPermission
  • java.io.FilePermission
  • java.io.SerializablePermission
  • java.nio.file.LinkPermission
  • java.util.logging.LoggingPermission
  • java.util.PropertyPermission
  • jdk.jfr.FlightRecorderPermission
  • java.net.NetPermission
  • java.net.URLPermission
  • jdk.net.NetworkPermission
  • com.sun.tools.attach.AttachPermission
  • com.sun.jdi.JDIPermission
  • java.lang.management.ManagementPermission
  • javax.management.MBeanPermission
  • javax.management.MBeanTrustPermission
  • javax.management.MBeanServerPermission
  • javax.management.remote.SubjectDelegationPermission

In addition, the getPermission method defined in java.net.URLConnection and its subclass java.net.HttpURLConnection has been deprecated for removal.

These permission classes and associated methods were only useful in conjunction with the Security Manager, which is no longer supported.


JDK-8350689

Turn on Timestamp and Thread Details by Default for java.security.debug


The debug output from the java.security.debug system property now includes thread id, caller information, and timestamp information.

Each debug output statement generated with the java.security.debug option is now formatted as:

componentValue[threadId|threadName|sourceCodeLocation|timestamp]: <debug statement>

where: * componentValue is the security component value being logged. * threadId is the hexadecimal value of the thread ID. * threadName is the name of the thread executing the log statement. * sourceCodeLocation is the source file and line number making this log call, in the format "filename:lineNumber". * timestamp is the date and time in the format "yyyy-MM-dd kk:mm:ss.SSS". * <debug statement> corresponds to the debug output from the security component.

The +thread and +timestamp options introduced in JDK 23 will no longer have an impact and are ignored.

More information on those legacy options is available in the JDK 23 release notes. Additional information can be found in Debug Statement Output Format.


JDK-8347946

Added API Note on Validating Signers to the getCertificates and getCodeSigners Methods of JarEntry and JarURLConnection


An API note has been added to the getCertificates() method of the java.util.jar.JarEntry and java.net.JarURLConnection classes and the getCodeSigners() method of the JarEntry class recommending that the caller should perform further validation steps on the code signers that signed the JAR file, such as validating the code signer's certificate chain, and determining if the signer should be trusted.

In addition, the JarURLConnection.getCertificates() method has been updated to specify the order of the returned array of certificates. It is the same order as specified by java.util.jar.JarEntry.getCertificates().


JDK-8347506

Compatible OCSP readtimeout Property with OCSP Timeout


In JDK 21, an enhanced syntax for various timeout properties was released through JDK-8179502. This included a new system property, com.sun.security.ocsp.readtimeout, which allows users to control the timeout while reading OCSP responses after a successful TCP connection has been established.

This changes the default posture of this property to be the value of the com.sun.security.ocsp.timeout system property from its original default of 15 seconds. If the com.sun.security.ocsp.timeout system property is also not set, then its default 15 second timeout is propagated to the default for com.sun.security.ocsp.readtimeout.

For more information, see Appendix B: CertPath Implementation in SUN Provider.


xml/jaxp

Issue Description
JDK-8354084

Streamline XPath API's Extension Function Control


Restrictions on extension functions has been removed in the XPath API, specifically those imposed by FEATURESECUREPROCESSING (FSP) and the jdk.xml.enableExtensionFunctions property. Previously, for extension functions to work, even with a user-defined XPathFunctionResolver, FSP had to be set to false and jdk.xml.enableExtensionFunctions true. For example, an XPath created via the following factory would fail with an XPathExpressionException when encountering an Extension Function:

        XPathFactory xpf = XPathFactory.newInstance();
        xpf.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);

With this change, extension functions now work solely based on the presence of a properly registered XPathFunctionResolver, making extension straightforward:

        XPathFactory xpf = XPathFactory.newInstance();
        xpf.setXPathFunctionResolver(new MyXPathFunctionResolver());

The default value of FSP has also been changed from false to true. Since extension functions are no longer governed by this setting, and the default XPath limits already conform to the secure configurations, this update has no effect on standard XPath behavior.

Additional information can be found in The FEATURESECUREPROCESSING Security Directive and The JAXP Property for Extension Functions.


core-libs/java.util.concurrent

Issue Description
JDK-8319447

Updates to ForkJoinPool and CompletableFuture


java.util.concurrent.ForkJoinPool is updated in this release to implement ScheduledExecutorService. This API update can help the performance of delayed task handling in network and other applications where delayed tasks are used for timeout handling, and where most timeouts are cancelled.

In addition to the schedule methods defined by ScheduledExecutorService, ForkJoinPool now defines a new method submitWithTimeout to submit a task that is cancelled (or some other action executed) if the timeout expires before the task completes.

As part of the update, CompletableFuture and SubmissionPublisher are changed so that all async methods without an explicit Executor are performed using the ForkJoinPool common pool. This differs to previous releases where a new thread was created for each async task when the ForkJoinPool common pool was configured with parallelism less than 2.


tools/jar

Issue Description
JDK-8345431

Enhanced jar File Validation


The jar --validate command has been enhanced to identify and generate a warning message for: - Duplicate entry names - Entry names which: - contain a drive or device letter, - contain a leading slash - contain backward slashes '' - the entry name or any path element is "." or ".." - Inconsistencies in the ordering of entries between the LOC and CEN headers


security-libs/javax.xml.crypto

Issue Description
JDK-8344137

Update XML Security for Java to 3.0.5


The XML Signature implementation has been updated to Santuario 3.0.5. Support for four new SHA-3 based ECDSA SignatureMethod algorithms have been added: SignatureMethod.ECDSA_SHA3_224, SignatureMethod.ECDSA_SHA3_256, SignatureMethod.ECDSA_SHA3_384, and SignatureMethod.ECDSA_SHA3_512.


tools/jpackage

Issue Description
JDK-8345185

jpackage No Longer Includes Service Bindings by Default for Generated Run-Time Images


Starting with JDK 25, jpackage no longer includes service bindings for a run-time image that it creates. Prior to JDK 25, jpackage would include service bindings for run-time images. As a result, the generated run-time images produced by jpackage might not include the same set of modules as it did in prior versions.

The previous behavior can be achieved by adding the --bind-services jlink option to the default jlink options jpackage uses:

` jpackage [...] --jlink-options \ "--strip-native-commands --strip-debug --no-man-pages --no-header-files --bind-services" `

For more information, see Java Runtime Requirements.


core-libs

Issue Description
JDK-8353641

Various Permission Classes Deprecated for Removal


The following permission classes have been deprecated for removal:

  • java.security.UnresolvedPermission
  • javax.net.ssl.SSLPermission
  • javax.security.auth.AuthPermission
  • javax.security.auth.PrivateCredentialPermission
  • javax.security.auth.kerberos.DelegationPermission
  • javax.security.auth.kerberos.ServicePermission
  • com.sun.security.jgss.InquireSecContextPermission
  • java.lang.RuntimePermission
  • java.lang.reflect.ReflectPermission
  • java.io.FilePermission
  • java.io.SerializablePermission
  • java.nio.file.LinkPermission
  • java.util.logging.LoggingPermission
  • java.util.PropertyPermission
  • jdk.jfr.FlightRecorderPermission
  • java.net.NetPermission
  • java.net.URLPermission
  • jdk.net.NetworkPermission
  • com.sun.tools.attach.AttachPermission
  • com.sun.jdi.JDIPermission
  • java.lang.management.ManagementPermission
  • javax.management.MBeanPermission
  • javax.management.MBeanTrustPermission
  • javax.management.MBeanServerPermission
  • javax.management.remote.SubjectDelegationPermission

In addition, the getPermission method defined in java.net.URLConnection and its subclass java.net.HttpURLConnection has been deprecated for removal.

These permission classes and associated methods were only useful in conjunction with the Security Manager, which is no longer supported.


core-svc/debugger

Issue Description
JDK-8351310

Various Permission Classes Deprecated for Removal


The following permission classes have been deprecated for removal:

  • java.security.UnresolvedPermission
  • javax.net.ssl.SSLPermission
  • javax.security.auth.AuthPermission
  • javax.security.auth.PrivateCredentialPermission
  • javax.security.auth.kerberos.DelegationPermission
  • javax.security.auth.kerberos.ServicePermission
  • com.sun.security.jgss.InquireSecContextPermission
  • java.lang.RuntimePermission
  • java.lang.reflect.ReflectPermission
  • java.io.FilePermission
  • java.io.SerializablePermission
  • java.nio.file.LinkPermission
  • java.util.logging.LoggingPermission
  • java.util.PropertyPermission
  • jdk.jfr.FlightRecorderPermission
  • java.net.NetPermission
  • java.net.URLPermission
  • jdk.net.NetworkPermission
  • com.sun.tools.attach.AttachPermission
  • com.sun.jdi.JDIPermission
  • java.lang.management.ManagementPermission
  • javax.management.MBeanPermission
  • javax.management.MBeanTrustPermission
  • javax.management.MBeanServerPermission
  • javax.management.remote.SubjectDelegationPermission

In addition, the getPermission method defined in java.net.URLConnection and its subclass java.net.HttpURLConnection has been deprecated for removal.

These permission classes and associated methods were only useful in conjunction with the Security Manager, which is no longer supported.


core-libs/java.util.jar

Issue Description
JDK-8225763

`java.util.zip.Inflater` and `java.util.zip.Deflater` Enhanced To Implement `AutoCloseable`


java.util.zip.Inflater and java.util.zip.Deflater now implement AutoCloseable and can be used with the try-with-resources statement. Applications could previously invoke the end() method to release the resources held by the Inflater/Deflater instance. Now, either the end() or the close() method can be invoked to do the same.


hotspot/compiler

Issue Description
JDK-8348561

ML-DSA Performance Improved


The performance of the ML-DSA key generation, sign, and verify operations has been improved significantly, 1.5 - 2.5 times depending on operation type and input, on the aarch64 and AVX-512 platforms.


JDK-8349721

ML-KEM Performance Improved


The performance of the ML-KEM key generation, encapsulation, and decapsulation operations has been improved significantly, 1.9 - 2.7 times depending on operation type and platform, on the aarch64 and AVX-512 platforms.


JDK-8351412

ML-KEM Performance Improved


The performance of the ML-KEM key generation, encapsulation, and decapsulation operations has been improved significantly, 1.9 - 2.7 times depending on operation type and platform, on the aarch64 and AVX-512 platforms.


JDK-8349637

Incorrect result of Integer.numberOfLeadingZeros


Integer.numberOfLeadingZeros may return an incorrect result on x86_64 with AVX2. The issue is caused by an incorrect JIT compiler optimization. As a workaround, the following command-line options can be used -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_numberOfLeadingZeros_i.


JDK-8351034

ML-DSA Performance Improved


The performance of the ML-DSA key generation, sign, and verify operations has been improved significantly, 1.5 - 2.5 times depending on operation type and input, on the aarch64 and AVX-512 platforms.


JDK-8350459

MontgomeryIntegerPolynomialP256 Multiply Intrinsic with AVX2 on x86_64


This feature delivers optimized intrinsics using AVX2 instructions on x8664 platforms for the P256 Elliptic Curve field operations in the SunEC provider. This optimization is enabled by default on supporting x8664 platforms and when the AVX512 intrinsic cannot be used. It may be disabled by providing the -XX:+UnlockDiagnosticVMOptions -XX:-UseIntPolyIntrinsics command-line options.


security-libs/javax.net.ssl

Issue Description
JDK-8349583

Mechanism to Disable Signature Schemes Based on Their TLS Scope


TLS protocol specific usage constraints are now supported by the jdk.tls.disabledAlgorithms property in the java.security configuration file, as follows: ``` UsageConstraint: usage UsageType { UsageType }

UsageType: HandshakeSignature | CertificateSignature `` HandshakeSignaturerestricts the use of the algorithm in TLS handshake signatures.CertificateSignaturerestricts the use of the algorithm in certificate signatures. An algorithm with this constraint cannot include other usage types defined in thejdk.certpath.disabledAlgorithms` property. The usage type follows the keyword and more than one usage type can be specified with a whitespace delimiter.


JDK-8340321

Disabled SHA-1 in TLS 1.2 and DTLS 1.2 Handshake Signatures


The SHA-1 algorithm has been disabled by default in TLS 1.2 and DTLS 1.2 handshake signatures, by adding "rsa_pkcs1_sha1 usage HandshakeSignature, ecdsa_sha1 usage HandshakeSignature, dsa_sha1 usage HandshakeSignature" to the jdk.tls.disabledAlgorithms security property in the java.security config file. RFC 9155 deprecates the use of SHA-1 in TLS 1.2 and DTLS 1.2 digital signatures. Users can, at their own risk, re-enable the SHA-1 algorithm in TLS 1.2 and DTLS 1.2 handshake signatures by removing "rsa_pkcs1_sha1 usage HandshakeSignature, ecdsa_sha1 usage HandshakeSignature, dsa_sha1 usage HandshakeSignature" from the jdk.tls.disabledAlgorithms security property.


JDK-8346587

Distrust TLS Server Certificates Anchored by Camerfirma Root Certificates and Issued After April 15, 2025


The JDK will stop trusting TLS server certificates issued after April 15, 2025 and anchored by Camerfirma root certificates, in line with similar plans announced by Google, Mozilla, Apple, and Microsoft.

TLS server certificates issued on or before April 15, 2025 will continue to be trusted until they expire. Certificates issued after that date, and anchored by any of the Certificate Authorities in the table below, will be rejected.

The restrictions are enforced in the JDK implementation (the SunJSSE Provider) of the Java Secure Socket Extension (JSSE) API. A TLS session will not be negotiated if the server's certificate chain is anchored by any of the Certificate Authorities in the table below and the certificate has been issued after April 15, 2025.

An application will receive an exception with a message indicating the trust anchor is not trusted, for example:

` "TLS Server certificate issued after 2025-04-15 and anchored by a distrusted legacy Camerfirma root CA: CN=Chambers of Commerce Root - 2008, O=AC Camerfirma S.A., SERIALNUMBER=A82743287, L=Madrid (see current address at www.camerfirma.com/address), C=EU" `

The JDK can be configured to trust these certificates again by removing "CAMERFIRMA_TLS" from the jdk.security.caDistrustPolicies security property in the java.security configuration file.

The restrictions are imposed on the following Camerfirma Root certificates included in the JDK:

Root Certificates distrusted after 2025-04-15
Distinguished Name SHA-256 Fingerprint
CN=Chambers of Commerce Root, OU=http://www.chambersign.org, O=AC Camerfirma SA CIF A82743287, C=EU

0C:25:8A:12:A5:67:4A:EF:25:F2:8B:A7:DC:FA:EC:EE:A3:48:E5:41:E6:F5:CC:4E:E6:3B:71:B3:61:60:6A:C3

CN=Chambers of Commerce Root - 2008, O=AC Camerfirma S.A., SERIALNUMBER=A82743287, L=Madrid (see current address at www.camerfirma.com/address), C=EU

06:3E:4A:FA:C4:91:DF:D3:32:F3:08:9B:85:42:E9:46:17:D8:93:D7:FE:94:4E:10:A7:93:7E:E2:9D:96:93:C0

CN=Global Chambersign Root - 2008, O=AC Camerfirma S.A., SERIALNUMBER=A82743287, L=Madrid (see current address at www.camerfirma.com/address), C=EU

13:63:35:43:93:34:A7:69:80:16:A0:D3:24:DE:72:28:4E:07:9D:7B:52:20:BB:8F:BD:74:78:16:EE:BE:BA:CA

You can also use the keytool utility from the JDK to print out details of the certificate chain, as follows:

keytool -v -list -alias <your_server_alias> -keystore <your_keystore_filename>

If any of the certificates in the chain are issued by one of the root CAs in the table above are listed in the output you will need to update the certificate or contact the organization that manages the server.


JDK-8341346

Add Support for TLS Keying Material Exporters to JSSE and SunJSSE Provider


This enhancement adds support for TLS (Transport Layer Security) Keying Material Exporters, which allow applications to generate additional application-level keying material from a connection's negotiated TLS keys.

This change enables support for several additional protocols, including those labels registered in the IANA TLS Parameters-Exporter Label document.

This functionality is described in RFC 5705 for TLSv1-TLSv1.2, and RFC 8446 for TLSv1.3. The feature can be accessed via two new APIs in the javax.net.ssl.ExtendedSSLSession class:

public SecretKey exportKeyingMaterialKey(String keyAlg,
        String label, byte[] context, int length) throws SSLKeyException
public byte[] exportKeyingMaterialData(
        String label, byte[] context, int length) throws SSLKeyException 

For more information, see TLS Keying Material Exporters.


core-libs/java.nio

Issue Description
JDK-8350880

New Property to Construct ZIP FileSystem as Read-only


The ZIP file system provider is updated to allow a ZIP file system be created as a read-only or read-write file system. When creating a ZIP file system, the property name "accessMode" can be used with a value of "readOnly" or " readWrite" to specify the desired mode. If the property is not provided then the file system is created as a read-write file system if possible.

The following example creates a read-only file system:

` FileSystem zipfs = FileSystems.newFileSystem(pathToZipFile, Map.of("accessMode","readOnly")); `

See the jdk.zipfs module description for more information on this and other properties supported by the ZIP file system provider.


JDK-8345432

The Default Thread Pool Used for Asynchronous Channel Operations Now Uses Innocuous Threads


The default thread pool for the system-wide default AsynchronousChannelGroup is changed to create threads that do not inherit anything from threads that initiate asynchronous I/O operations. Historically, threads in the default thread pool inherited the Thread Context ClassLoader (TCCL) and inheritable-ThreadLocals from the first thread to initiate an asynchronous I/O operation. The change in this release avoids potential memory leak and retention issues that arose when a TCCL or a thread local kept a large graph of objects reachable.


hotspot/jfr

Issue Description
JDK-8356698

New JFR Annotation for Contextual Information


A new annotation, jdk.jfr.Contextual, has been introduced to mark fields in custom JFR events that contain contextual information relevant to other events occurring in the same thread. For example, fields in a user-defined HTTP request event can be annotated with @Contextual to associate its URL and trace ID with events that occur during its execution, such as a jdk.JavaMonitorEnter event due to a contended logger.

Tools can now pair higher-level information, such as span and trace IDs, with lower-level events. The print command of the jfr tool, included in the JDK, displays this contextual information alongside JVM and JDK events, for example, in events for lock contention, I/O, or exceptions that occur during a trace span or an HTTP request event.


JDK-8351594

Socket, File, and Exception Events for JFR Are Throttled by Default


Previously, the events jdk.SocketRead, jdk.SocketWrite, jdk.FileRead, and jdk.FileWrite were recorded if the duration exceeded 20 ms in the default configuration (default.jfc). The threshold has been lowered to 1 ms. To prevent a high volume of events, a rate limit of 100 events per second is imposed on these events. To restore the previous behavior, you can set the throttle setting to "off" and the threshold to "20 ms". For example:

-XX:StartFlightRecording:jdk.SocketRead#threshold=20ms,jdk.SocketRead#throttle=off

The jdk.JavaExceptionThrow event was previously disabled by default, but is now enabled by default with a rate limit of 100 events per second. To disable this event, use:

-XX:StartFlightRecording:jdk.JavaExceptionThrow#enabled=false


JDK-8353856

Various Permission Classes Deprecated for Removal


The following permission classes have been deprecated for removal:

  • java.security.UnresolvedPermission
  • javax.net.ssl.SSLPermission
  • javax.security.auth.AuthPermission
  • javax.security.auth.PrivateCredentialPermission
  • javax.security.auth.kerberos.DelegationPermission
  • javax.security.auth.kerberos.ServicePermission
  • com.sun.security.jgss.InquireSecContextPermission
  • java.lang.RuntimePermission
  • java.lang.reflect.ReflectPermission
  • java.io.FilePermission
  • java.io.SerializablePermission
  • java.nio.file.LinkPermission
  • java.util.logging.LoggingPermission
  • java.util.PropertyPermission
  • jdk.jfr.FlightRecorderPermission
  • java.net.NetPermission
  • java.net.URLPermission
  • jdk.net.NetworkPermission
  • com.sun.tools.attach.AttachPermission
  • com.sun.jdi.JDIPermission
  • java.lang.management.ManagementPermission
  • javax.management.MBeanPermission
  • javax.management.MBeanTrustPermission
  • javax.management.MBeanServerPermission
  • javax.management.remote.SubjectDelegationPermission

In addition, the getPermission method defined in java.net.URLConnection and its subclass java.net.HttpURLConnection has been deprecated for removal.

These permission classes and associated methods were only useful in conjunction with the Security Manager, which is no longer supported.


tools/javadoc(tool)

Issue Description
JDK-8254622

Hide Superclasses from Conditionally Exported Packages


JavaDoc now treats classes and interfaces from packages that are not exported or exported by qualified export as hidden unless they are explicitly included in the documentation. Such classes and interfaces do not appear in the generated documentation, even if they are extended or implemented by a documented type. Other instances of hidden types are private or package-private types, or types marked with the @hidden JavaDoc tag.


JDK-8350638

Keyboard Navigation


API documentation generated by javadoc no longer sets the keyboard focus to the search input field on page load. Instead, it provides keyboard shortcuts to manage keyboard focus. Press the / key to set the focus on the search input, the . key to set the focus on the filter input in the sidebar, and the Esc key to release the focus from either input field. Furthermore, content in the sidebar and search page can now be navigated using the Tab and arrow keys. For more information, see Keyboard Navigation in the JavaDoc API documentation.


JDK-8348282

Syntax Highlighting for Code Fragments


JavaDoc provides a new --syntax-highlight option to enable syntax highlighting in {@snippet} tags and <pre><code> HTML elements. The option takes no arguments and adds the Highlight.js library to the generated documentation in a configuration that supports Java, Properties, JSON, HTML and XML code fragments.


JDK-8352249

Whitespace Normalization in Traditional Documentation Comments


JavaDoc now strips common indentation from the beginning of lines in traditional documentation comments, as it already does in Markdown documentation comments. This prevents unintentional whitespace in preformatted code samples using the HTML <pre> element while preserving the relative indentation of lines.


client-libs/javax.swing

Issue Description
JDK-8334581

Removal of No-Argument Constructor for BasicSliderUI()


Several hundred classes in the java.desktop module used to rely on default constructors as part of their public API. Explicit constructors were added to these classes in JDK-8250852.

As a result, a no-argument constructor, BasicSliderUI(), for the BasicSliderUI class was added in JDK 16. This missed that there already was a constructor BasicSliderUI(JSlider b). Thus, there was no need for another constructor.

The BasicSliderUI() constructor was deprecated in JDK 23 and is removed in JDK 25.


core-libs/java.math

Issue Description
JDK-8341402

Method `BigDecimal.sqrt()` Might Now Throw on Powers of 100 and Huge Precisions


The method BigDecimal.sqrt() has been reimplemented to perform much better.

However, in some very rare and quite artificial cases involving powers of 100 and huge precisions, the new implementation throws whereas the old one returns a result.

For example ` BigDecimal.valueOf(100).sqrt(new MathContext(1_000_000_000, RoundingMode.UP)) returns10in the old implementation. Note, however, that rather than returning11, it throws when evaluating `` BigDecimal.valueOf(121).sqrt(new MathContext(1000000_000, RoundingMode.UP)) ```

Indeed, the old implementation treats powers of 100 as special cases (see 1st example). Other exact squares are treated normally, so throw when the requested precision is too high (see 2nd example). This special behavior for powers of 100 is not recommended, as it is more confusing than helpful when compared to other exact squares.

The new implementation is agnostic about powers of 100, and throws whenever internal intermediate results would exceed supported ranges. In particular, it uniformly throws on both the examples above.


core-libs/java.io

Issue Description
JDK-8354450

File Operations with Directory or File Names Ending in a Space Now Consistently Fail on Windows


File operations on a path with a trailing space in a directory or file name, such as "C:\SomeFolder\SomeFile ", now fail consistently on Windows. For example, File::mkdir will return false, or File::createNewFile will throw IOException if an element in the path has a trailing space. Such pathnames are not legal on Windows. Prior to JDK 25, operations on a File created from such an illegal abstract pathname could appear to succeed when in fact they did not.


JDK-8024695

java.io.File Treats the Empty Pathname As the Current User Directory


The java.io.File class is changed so that an instance of File created from the empty abstract pathname ("") now behaves consistently like a File created from the current user directory. Long standing behavior was for some methods to fail for the empty pathname. The change means that the canRead, exists, and isDirectory methods return true instead of failing with false, and the getFreeSpace, lastModified, and length methods return the expected values instead of zero. Methods such as setReadable and setLastModified will attempt to change the file's attributes instead of failing. WIth this change, java.io.File now matches the behavior of the java.nio.file API.


JDK-8354724

Support for reading all remaining characters from a Reader


New methods have been added to the java.io.Reader class to read all remaining characters. The new method Reader.readAllAsString() reads all remaining characters into a String. The new method Reader.readAllLines() reads all remaining characters as lines of text represented as a List<String>. These methods are intended for simple cases where it is appropriate to read all remaining content.


JDK-8351435

Default Console Implementation No Longer Based On JLine


The default Console obtained via System.console() is no longer based on JLine. Since JDK 20, the JDK has included a JLine-based Console implementation, offering a richer user experience and better support for virtual terminal environments, such as IDEs. This implementation was initially opt-in via a system property in JDK 20 and JDK 21 and became the default in JDK 22. However, maintaining the JLine-based Console proved challenging. As a result, in JDK 25, it has reverted to being opt-in, as it was in JDK 20 and JDK 21.


JDK-8355954

java.io.File.delete No Longer Deletes Read-only Files on Windows


File.delete is changed on Windows so that it now fails and returns false for regular files when the DOS read-only attribute is set. Prior to JDK 25, File.delete deleted read-only files by removing this DOS attribute before attempting to delete. As removing the attribute and deleting the file do not comprise a single atomic operation, this could result in the file still existing but with modified attributes if the deletion were to fail. Applications that depend on long standing behavior should be changed to clear the file attributes prior to deletion.

As part of the change, a system property has been introduced to restore long standing behavior. Running with -Djdk.io.File.allowDeleteReadOnlyFiles=true will restore old behavior so that File.delete removes the DOS read-only attribute before attempting to delete the file.


hotspot/gc

Issue Description
JDK-8356848

Information About Metaspace Has Been Moved Away from Heap Logging


Most information about Metaspace that was previously printed by the Garbage Collector (GC) is now available in Metaspace-specific logging.

To get information about Metaspace that was formerly part of the GC.heap_info jcmd, use the existing VM.metaspace jcmd instead.


JDK-8351405

G1 Reduces Pause Time Spikes by Improving Region Selection


The G1 garbage collector now addresses pause time spikes during Mixed GCs by improving the selection of memory regions to reclaim during those. Regions that are expected to be costly to collect due to high inter-region references may be excluded during this region selection.

Using additional information gathered during the marking phase, G1 can better estimate the cost of collecting each region and skip those that would significantly impact pause times. The result is reduced pause time spikes, particularly toward the end of a Mixed GC cycle, improving overall application performance.


JDK-8350441

ZGC: Enhanced Methods for Dealing With Fragmentation


ZGC has been improved to better deal with virtual address space fragmentation. This is especially impactful for programs with a large heap, where virtual address space fragmentation could be a noticeable issue.

ZGC no longer reports inflated RSS-usage of the Java heap. This comes as a consequence of removing asynchronous unmapping, which was the last usage of multi-mapped memory.


JDK-8347337

ZGC Now Avoids String Deduplication for Short-Lived Strings


ZGC's String Deduplication feature has been updated to skip deduplication for young, short-lived strings. This change reduces unnecessary processing and can improve performance in applications that frequently allocate temporary strings.


JDK-8343782

G1 Reduces Remembered Set Overhead by Grouping Regions into Shared Card Sets


The G1 garbage collector further reduces remembered set memory overhead and pause-time by allowing multiple regions to share a single internal structure (G1CardSet) when they are likely to be collected together during a Mixed GC.

Previously, each region maintained its own G1CardSet, resulting in high memory overhead and redundant tracking of references between regions that would eventually be collected as a group. In the new design, regions expected to be evacuated together are grouped after the Remark phase and assigned a shared G1CardSet, eliminating the need to track references between them individually.

This improves memory efficiency and reduces merge time during collection pauses.


JDK-8192647

No More OutOfMemoryErrors Due to JNI in Serial/Parallel GC


Serial and Parallel garbage collectors now ensure that no Java threads are in a JNI critical region before initiating a garbage collection eliminating unnecessary OutOfMemoryErrors.

Previously, garbage collection could early-return without reclaiming any memory if any thread remained in such a region. This could lead to unexpected OutOfMemoryErrors (OOMEs), as garbage collection might not have had a chance to reclaim memory even after a few retries. Increasing GCLockerRetryAllocationCount has often been suggested as a workaround for avoiding this kind of premature OOME.

With this change, a pending garbage collection request will wait for all Java threads to exit JNI critical regions and block new entries. This guarantees that once inside the safepoint, no threads remain in critical regions and garbage collection can always proceed to completion. As a result, the diagnostic flag GCLockerRetryAllocationCount has been removed, as it is no longer necessary.


tools/jlink

Issue Description
JDK-8345259

jlink --add-modules ALL-MODULE-PATH Requires Explicit --module-path Argument


Starting with JDK 24, the jlink --add-modules ALL-MODULE-PATH option will require users to set the module path via the --module-path option. Prior to JDK 24, using --add-modules ALL-MODULE-PATH without --module-path could be used to create an image with all JDK modules from $JAVA_HOME/jmods. In JDK 24, to create an image using ALL-MODULE-PATH, it is required to explicitly set --module-path. To create an image with all JDK modules, use jlink --add-modules ALL-MODULE-PATH --module-path $JAVA_HOME/jmods instead.


core-svc/java.lang.management

Issue Description
JDK-8350820

OperatingSystemMXBean CpuLoad() Methods Return -1.0 on Windows


On Windows, the OperatingSystemMXBean CPU load methods, such as getSystemCpuLoad, getCpuLoad, and getProcessCpuLoad, always return -1. This error affects CPU usage monitoring of Windows targets.

This issue was introduced during JDK 24 development. It does not affect earlier releases. It was found too late to be fixed in JDK 24, but will be resolved in an update release.


Resolved: OperatingSystemMXBean CpuLoad() Methods Return -1.0 on Windows


On Windows, the OperatingSystemMXBean CPU load methods, getSystemCpuLoad, getCpuLoad, and getProcessCpuLoad, were failing and always returning -1. This error affected CPU usage monitoring of Windows targets. This is resolved in this release.


xml/jaxb

Issue Description
JDK-8327378

Corrected Error Handling for XMLStreamReader


Fixed XMLStreamReader's error handling where its next() method incorrectly threw EOFException instead of the documented XMLStreamException when encountering a premature end of file.


FIXED ISSUES

client-libs

Priority Bug Summary
P4 JDK-8347122 Add missing @serial tags to module java.desktop
P4 JDK-8345888 Broken links in the JDK 24 JavaDoc API documentation, build 27
P4 JDK-8355515 Clarify the purpose of forcePass() and forceFail() methods
P4 JDK-8355077 Compiler error at splashscreen_gif.c due to unterminated string initialization
P4 JDK-8294155 Exception thrown before awaitAndCheck hangs PassFailJFrame
P4 JDK-8347375 Extra

tag in robot specification

P4 JDK-8357672 Extreme font sizes can cause font substitution
P4 JDK-8350260 Improve HTML instruction formatting in PassFailJFrame
P4 JDK-8355179 Reinstate javax/swing/JScrollBar/4865918/bug4865918.java headful and macos run
P4 JDK-8355441 Remove antipattern from PassFailJFrame.forcePass javadoc
P4 JDK-8340784 Remove PassFailJFrame constructor with screenshots
P4 JDK-8353138 Screen capture for test TaskbarPositionTest.java, failure case
P4 JDK-8345797 Update copyright year to 2024 for client-libs in files where it was missed
P4 JDK-8345876 Update nativeAddAtIndex comment to match the code
P5 JDK-8352624 Add missing {@code} to PassFailJFrame.Builder.splitUI
P5 JDK-8356605 JRSUIControl.hashCode and JRSUIState.hashCode can use Long.hashCode
P5 JDK-8346953 Remove unnecessary @SuppressWarnings annotations (client, #2)
P5 JDK-8357287 Unify usage of ICC profile "header size" constants in CMM-related code

client-libs/2d

Priority Bug Summary
P2 JDK-8349926 [BACKOUT] Support static JDK in libfontmanager/freetypeScaler.c
P3 JDK-8330936 [ubsan] exclude function BilinearInterp and ShapeSINextSpan in libawt java2d from ubsan checks
P3 JDK-8346465 Add a check in setData() to restrict the update of Built-In ICC_Profiles
P3 JDK-8347377 Add validation checks for ICC_Profile header fields
P3 JDK-8346394 Bundled freetype library needs to have JNI_OnLoad for static builds
P3 JDK-8353230 Emoji rendering regression after JDK-8208377
P3 JDK-8344637 Fix Page8 of manual test java/awt/print/PrinterJob/PrintTextTest.java on Linux and Windows
P3 JDK-8357299 Graphics copyArea doesn't copy any pixels when there is overflow
P3 JDK-8343224 print/Dialog/PaperSizeError.java fails with MediaSizeName is not A4: A4
P3 JDK-8358107 Rollback JDK-8357299 changeset
P3 JDK-8208377 Soft hyphens render if not using TextLayout
P3 JDK-8356803 Test TextLayout/TestControls fails on windows & linux: line and paragraph separator show non-zero advance
P3 JDK-8348596 Update FreeType to 2.13.3
P3 JDK-8348597 Update HarfBuzz to 10.4.0
P3 JDK-8355528 Update HarfBuzz to 11.2.0
P3 JDK-8348110 Update LCMS to 2.17
P4 JDK-8312198 [macos] metal pipeline - window rendering stops after display sleep
P4 JDK-8350203 [macos] Newlines and tabs are not ignored when drawing text to a Graphics2D object
P4 JDK-8349925 [REDO] Support static JDK in libfontmanager/freetypeScaler.c
P4 JDK-8347321 [ubsan] CGGlyphImages.m:553:30: runtime error: nan is outside the range of representable values of type 'unsigned long'
P4 JDK-8344119 CUPSPrinter does not respect PostScript printer definition specification in case of reading ImageableArea values from PPD files
P4 JDK-6562489 Font-Renderer should ignore invisible characters \u2062 and \u2063
P4 JDK-8354077 Get rid of offscreenSharingEnabled windows flag
P4 JDK-8352733 Improve RotFontBoundsTest test
P4 JDK-8356966 java/awt/Graphics2D/DrawString/IgnoredWhitespaceTest.java fails on Linux after JDK-8350203
P4 JDK-8270265 LineBreakMeasurer calculates incorrect line breaks with zero-width characters
P4 JDK-8356814 LineBreakMeasurer.nextLayout() slower than necessary when no break needed
P4 JDK-8356844 Missing @Serial annotation for sun.print.CustomOutputBin#serialVersionUID
P4 JDK-8315113 Print request Chromaticity.MONOCHROME attribute does not work on macOS
P4 JDK-8356571 Re-enable -Wtype-limits for GCC in LCMS
P4 JDK-8356208 Remove obsolete code in PSPrinterJob for plugin printing
P4 JDK-8344146 Remove temporary font file tracking code.
P4 JDK-8349859 Support static JDK in libfontmanager/freetypeScaler.c
P4 JDK-8353187 Test TextLayout/TestControls fails on macOS: width of 0x9, 0xa, 0xd isn't zero
P4 JDK-8349350 Unable to print using InputSlot and OutputBin print attributes at the same time
P4 JDK-8358057 Update validation of ICC_Profile header data
P5 JDK-8355611 Get rid of SurfaceManagerFactory
P5 JDK-8355078 java.awt.Color.createContext() uses unnecessary synchronization
P5 JDK-8349932 PSPrinterJob sometimes generates unnecessary PostScript commands
P5 JDK-8352890 Remove unnecessary Windows version check in FileFontStrike
P5 JDK-8344668 Unnecessary array allocations and copying in TextLine

client-libs/java.awt

Priority Bug Summary
P2 JDK-8351907 [XWayland] [OL10] Robot.mousePress() is delivered to wrong place
P2 JDK-8358526 Clarify behavior of java.awt.HeadlessException constructed with no-args
P2 JDK-8346195 Fix static initialization problem in GDIHashtable
P3 JDK-8280991 [XWayland] No displayChanged event after setDisplayMode call
P3 JDK-8282862 AwtWindow::SetIconData leaks old icon handles if an exception is detected
P3 JDK-8346388 Cannot use DllMain in libawt for static builds
P3 JDK-6899304 java.awt.Toolkit.getScreenInsets(GraphicsConfiguration) returns incorrect values
P3 JDK-8349099 java/awt/Headless/HeadlessMalfunctionTest.java fails on CI with Compilation error
P3 JDK-8344907 NullPointerException in Win32ShellFolder2.getSystemIcon when "icon" is null
P3 JDK-8342096 Popup menus that request focus are not shown on Linux with Wayland
P3 JDK-8332271 Reading data from the clipboard from multiple threads crashes the JVM
P3 JDK-8345538 Robot.mouseMove doesn't clamp bounds on macOS when trying to move mouse off screen
P3 JDK-8348675 TrayIcon tests fail in Ubuntu 24.10 Wayland
P3 JDK-8348598 Update Libpng to 1.6.47
P3 JDK-8348600 Update PipeWire to 1.3.81
P3 JDK-8340427 Windows L&F on scaled display uses tiny control font
P4 JDK-8346059 [ASAN] awt_LoadLibrary.c reported compile warning ignoring return value of function by clang17
P4 JDK-8332947 [macos] OpenURIHandler events not received when AWT is embedded in another toolkit
P4 JDK-8349751 AIX build failure after upgrade pipewire to 1.3.81
P4 JDK-8357675 Amend headless message
P4 JDK-8334644 Automate javax/print/attribute/PageRangesException.java
P4 JDK-8342782 AWTEventMulticaster throws StackOverflowError using AquaButtonUI
P4 JDK-8349378 Build splashscreen lib with SIZE optimization
P4 JDK-8348106 Catch C++ exception in Java_sun_awt_windows_WTaskbarPeer_setOverlayIcon
P4 JDK-8354316 clang/linux build fails with -Wunused-result warning at XToolkit.c:695:9
P4 JDK-8353950 Clipboard interaction on Windows is unstable
P4 JDK-8347836 Disabled PopupMenu shows shortcuts on Mac
P4 JDK-8346887 DrawFocusRect() may cause an assertion failure
P4 JDK-8336382 Fix error reporting in loading AWT
P4 JDK-8355366 Fix the wrong usage of PassFailJFrame.forcePass() in some manual tests
P4 JDK-8354191 GTK LaF should use pre-multiplied alpha same as cairo
P4 JDK-8357176 java.awt javadoc code examples still use Applet API
P4 JDK-8343170 java/awt/Cursor/JPanelCursorTest/JPanelCursorTest.java does not show the default cursor
P4 JDK-8323545 java/awt/GraphicsDevice/CheckDisplayModes.java fails with "exit code: 133"
P4 JDK-8359889 java/awt/MenuItem/SetLabelTest.java inadvertently triggers clicks on items pinned to the taskbar
P4 JDK-8348830 LIBFONTMANAGER optimization is always HIGHEST
P4 JDK-8334016 Make PrintNullString.java automatic
P4 JDK-8352922 Refactor client classes javadoc to use @throws instead of @exception
P4 JDK-8351277 Remove pipewire from AIX build
P4 JDK-8345144 Robot does not specify all causes of IllegalThreadStateException
P4 JDK-8343618 Stack smashing in awt_InputMethod.c on Linux s390x
P4 JDK-8343739 Test java/awt/event/KeyEvent/ExtendedKeyCode/ExtendedKeyCodeTest.java failed: Wrong extended key code
P4 JDK-8341370 Test java/awt/Frame/ShapeNotSetSometimes/ShapeNotSetSometimes.java fails intermittently on macOS-aarch64
P4 JDK-8356053 Test java/awt/Toolkit/Headless/HeadlessToolkit.java fails by timeout
P4 JDK-8339561 The test/jdk/java/awt/Paint/ListRepaint.java may fail after JDK-8327401
P4 JDK-8357598 Toolkit.removeAWTEventListener should handle null listener in AWTEventListenerProxy
P4 JDK-8348299 Update List/ItemEventTest/ItemEventTest.java
P5 JDK-8356843 Avoid redundant HashMap.get to obtain old value in Toolkit.setDesktopProperty
P5 JDK-8357224 Avoid redundant WeakHashMap.get in Toolkit.removeAWTEventListener
P5 JDK-8357696 Enhance code consistency: java.desktop/unix
P5 JDK-8355790 Enhance code consistency: java.desktop/unix:sun.awt
P5 JDK-8352638 Enhance code consistency: java.desktop/windows
P5 JDK-8356175 Remove unnecessary Map.get from XWM.getInsets
P5 JDK-8352970 Remove unnecessary Windows version check in Win32ShellFolderManager2
P5 JDK-8353002 Remove unnecessary Windows version check in WTaskbarPeer
P5 JDK-8354789 Unnecessary null check in sun.awt.windows.WToolkit.getFontPeer

client-libs/java.beans

Priority Bug Summary
P3 JDK-8347826 Introspector shows wrong method list after 8071693
P4 JDK-8347008 beancontext package spec does not clearly explain why the API is deprecated
P4 JDK-8344892 beans/finder/MethodFinder.findMethod incorrectly returns null

client-libs/javax.accessibility

Priority Bug Summary
P3 JDK-8345728 [Accessibility,macOS,Screen Magnifier]: JCheckbox unchecked state does not magnify but works for checked state
P3 JDK-8341311 [Accessibility,macOS,VoiceOver] VoiceOver announces incorrect number of items in submenu of JPopupMenu
P3 JDK-8348936 [Accessibility,macOS,VoiceOver] VoiceOver doesn't announce untick on toggling the checkbox with "space" key on macOS
P3 JDK-8286204 [Accessibility,macOS,VoiceOver] VoiceOver reads the spinner value 10 as 1 when user iterates to 10 for the first time on macOS
P3 JDK-8339728 [Accessibility,Windows,JAWS] Bug in the getKeyChar method of the AccessBridge class

client-libs/javax.imageio

Priority Bug Summary
P3 JDK-8347911 Limit the length of inflated text chunks
P4 JDK-5043343 FileImageInputStream and FileImageOutputStream do not properly track streamPos for RandomAccessFile
P4 JDK-8351110 ImageIO.write for JPEG can write corrupt JPEG for certain thumbnail dimensions
P4 JDK-8351108 ImageIO.write(..) fails with exception when writing JPEG with IndexColorModel
P4 JDK-8160327 Support for thumbnails present in APP1 marker for JPEG
P5 JDK-8356846 Remove unnecessary List.contains key from TIFFDirectory.removeTagSet
P5 JDK-8354944 Remove unnecessary PartiallyOrderedSet.nodes

client-libs/javax.sound

Priority Bug Summary
P3 JDK-8355561 [macos] Build failure with Xcode 16.3
P3 JDK-8336920 ArithmeticException in javax.sound.sampled.AudioInputStream
P3 JDK-8356049 Need a simple way to play back a sound clip
P3 JDK-8350813 Rendering of bulky sound bank from MIDI sequence can cause OutOfMemoryError
P4 JDK-8347576 Error output in libjsound has non matching format strings

client-libs/javax.swing

Priority Bug Summary
P1 JDK-8348760 RadioButton is not shown if JRadioButtonMenuItem is rendered with ImageIcon in WindowsLookAndFeel
P2 JDK-8347427 JTabbedPane/8134116/Bug8134116.java has no license header
P3 JDK-8357305 Compilation failure in javax/swing/JMenuItem/bug6197830.java
P3 JDK-8139228 JFileChooser renders file names as HTML document
P3 JDK-8334581 Remove no-arg constructor BasicSliderUI()
P3 JDK-8318577 Windows Look-and-Feel JProgressBarUI does not render correctly on 2x UI scale
P4 JDK-8355203 [macos] AquaButtonUI and AquaRootPaneUI repaint default button unnecessarily
P4 JDK-8356061 [macos] com/apple/laf/RootPane/RootPaneDefaultButtonTest.java test fails on macosx-aarch64 machine
P4 JDK-8268145 [macos] Rendering artifacts is seen when text inside the JTable with TableCellEditor having JTextfield
P4 JDK-8344981 [REDO] JDK-6672644 JComboBox still scrolling if switch to another window and return back
P4 JDK-8354219 Automate javax/swing/JComboBox/ComboPopupBug.java
P4 JDK-8353324 Clean up of comments and import after 8319192
P4 JDK-8280818 Expand bug8033699.java to iterate over all LaFs
P4 JDK-8350924 javax/swing/JMenu/4213634/bug4213634.java fails
P4 JDK-8346324 javax/swing/JScrollBar/4865918/bug4865918.java fails in CI
P4 JDK-8345767 javax/swing/JSplitPane/4164779/JSplitPaneKeyboardNavigationTest.java fails in ubuntu22.04
P4 JDK-8345618 javax/swing/text/Caret/8163124/CaretFloatingPointAPITest.java leaves Caret is not complete
P4 JDK-8348885 javax/swing/text/DefaultEditorKit/4278839/bug4278839.java still fails in CI
P4 JDK-8346055 javax/swing/text/StyledEditorKit/4506788/bug4506788.java fails in ubuntu22.04
P4 JDK-8348865 JButton/bug4796987.java never runs because Windows XP is unavailable
P4 JDK-8346581 JRadioButton/ButtonGroupFocusTest.java fails in CI on Linux
P4 JDK-8356594 JSplitPane loses divider location when reopened via JOptionPane.createDialog()
P4 JDK-4466930 JTable.selectAll boundary handling
P4 JDK-8354285 Open source Swing tests Batch 3
P4 JDK-8351884 Refactor bug8033699.java test code
P4 JDK-8319192 Remove javax.swing.plaf.synth.SynthLookAndFeel.load(URL url)
P4 JDK-8350224 Test javax/swing/JComboBox/TestComboBoxComponentRendering.java fails in ubuntu 23.x and later
P4 JDK-8347019 Test javax/swing/JRadioButton/8033699/bug8033699.java still fails: Focus is not on Radio Button Single as Expected
P5 JDK-8348308 Make fields of ListSelectionEvent final
P5 JDK-8348303 Remove repeated 'a' from ListSelectionEvent
P5 JDK-8347916 Simplify javax.swing.text.html.CSS.LengthUnit.getValue
P5 JDK-8348170 Unnecessary Hashtable usage in CSS.styleConstantToCssMap
P5 JDK-8348648 Unnecessary Hashtable usage in javax.swing.text.html.CSS.LengthUnit
P5 JDK-8347370 Unnecessary Hashtable usage in javax.swing.text.html.HTML
P5 JDK-8345616 Unnecessary Hashtable usage in javax.swing.text.html.parser.Element
P5 JDK-8346036 Unnecessary Hashtable usage in javax.swing.text.html.parser.Entity
P5 JDK-8354791 Use Hashtable.putIfAbsent in CSS constructor
P5 JDK-8342524 Use latch in AbstractButton/bug6298940.java instead of delay

core-libs

Priority Bug Summary
P2 JDK-8344611 Add missing classpath exception
P2 JDK-8348892 Properly fix compilation error for zip_util.c on Windows
P2 JDK-8348888 tier1 closed build failure on Windows after JDK-8348348
P3 JDK-8347121 Add missing @serial tags to module java.base
P3 JDK-8353641 Deprecate core library permission classes for removal
P3 JDK-8342486 Implement JEP 505: Structured Concurrency (Fifth Preview)
P3 JDK-8352695 JEP 506: Scoped Values
P3 JDK-8357637 Native resources cached in thread locals not released when FJP common pool threads clears thread locals
P3 JDK-8346834 Tests failing with -XX:+UseNUMA due to "NUMA support disabled" warning
P3 JDK-8346174 UMAX/UMIN are missing from XXXVector::reductionOperations
P3 JDK-8356443 Update open/test/jdk/TEST.groups manual test groups definitions with missing manual test
P3 JDK-8357268 Use JavaNioAccess.getBufferAddress rather than DirectBuffer.address()
P4 JDK-8346869 [AIX] Add regression test for handling 4 Byte aligned doubles in structures
P4 JDK-8345016 [ASAN] java.c reported ‘%s’ directive argument is null [-Werror=format-truncation=]
P4 JDK-8347038 [JMH] jdk.incubator.vector.SpiltReplicate fails NoClassDefFoundError
P4 JDK-8350682 [JMH] vector.IndexInRangeBenchmark failed with IndexOutOfBoundsException for size=1024
P4 JDK-8346101 [JVMCI] Export jdk.internal.misc to jdk.graal.compiler
P4 JDK-8310691 [REDO] [vectorapi] Refactor VectorShuffle implementation
P4 JDK-8345676 [ubsan] ProcessImpl_md.c:561:40: runtime error: applying zero offset to null pointer on macOS aarch64
P4 JDK-8339543 [vectorapi] laneHelper and withLaneHelper should be ForceInline
P4 JDK-8211673 Add @requires tags to reduce unnecessary testing
P4 JDK-8357808 Add a command line option for specifying a counter in TestRandomFloatingDecimal
P4 JDK-8345335 Add excluded jdk_foreign tests to tier4
P4 JDK-8349620 Add VMProps for static JDK
P4 JDK-8344168 Change Unsafe base offset from int to long
P4 JDK-8351290 Clarify integral only for vector operators
P4 JDK-8346667 Doccheck: warning about missing before

P4 JDK-8357063 Document preconditions for DecimalDigits methods
P4 JDK-8356632 Fix remaining {@link/@linkplain} tags with refer to private/protected types in java.base
P4 JDK-8340493 Fix some Asserts failure messages
P4 JDK-8355080 java.base/jdk.internal.foreign.SystemLookup.find() doesn't work on static JDK
P4 JDK-8358217 jdk/incubator/vector/PreferredSpeciesTest.java#id0 failures - expected [128] but found [256]
P4 JDK-8354898 jdk/internal/loader/NativeLibraries/Main.java fails on static JDK
P4 JDK-8340343 JEP 505: Structured Concurrency (Fifth Preview)
P4 JDK-8353296 JEP 508: Vector API (Tenth Incubator)
P4 JDK-8352015 LIBVERIFY_OPTIMIZATION remove special optimization settings
P4 JDK-8344943 Mark not subclassable classes final in java.base exported classes
P4 JDK-8350765 Need to pin when accessing thread container from virtual thread
P4 JDK-8353686 Optimize Math.cbrt for x86 64 bit platforms
P4 JDK-8346986 Remove ASM from java.base
P4 JDK-8355573 Remove kludge_c++11.h from jpackage code
P4 JDK-8346981 Remove obsolete java.base exports of jdk.internal.objectweb.asm packages
P4 JDK-8348348 Remove unnecessary #ifdef STATIC_BUILD around DEF_STATIC_JNI_OnLoad from zip_util.c
P4 JDK-8348301 Remove unused Reference.waitForReferenceProcessing break-ins in tests
P4 JDK-8357081 Removed unused methods of HexDigits
P4 JDK-8350041 Skip test/jdk/java/lang/String/nativeEncoding/StringPlatformChars.java on static JDK
P4 JDK-8346468 SM cleanup of common test library
P4 JDK-8346570 SM cleanup of tests for Beans and Serialization
P4 JDK-8356395 Spec needs to be clarified for InterfaceAddress class level API documentation and getBroadcast() method
P4 JDK-8351096 Typos in Vector API doc
P4 JDK-8345799 Update copyright year to 2024 for core-libs in files where it was missed
P4 JDK-8350748 VectorAPI: Method "checkMaskFromIndexSize" should be force inlined
P4 JDK-8356634 VectorShape#largestShapeFor should have public access
P4 JDK-8351993 VectorShuffle access to and from MemorySegments
P5 JDK-8343478 Remove unnecessary @SuppressWarnings annotations (core-libs)
P5 JDK-8346532 XXXVector::rearrangeTemplate misses null check

core-libs/java.io

Priority Bug Summary
P2 JDK-8361587 AssertionError in File.listFiles() when path is empty and -esa is enabled
P2 JDK-8362429 AssertionError in File.listFiles(FileFilter | FilenameFilter)
P3 JDK-8348052 java.io.Console in JDK >= 22 emits unexpected/unwanted escape sequences
P3 JDK-8347740 java/io/File/createTempFile/SpecialTempFile.java failing
P4 JDK-8355444 [java.io] Use @requires tag instead of exiting based on "os.name" property value
P4 JDK-8355443 [java.io] Use @requires tag instead of exiting based on File.separatorChar value
P4 JDK-8354450 A File should be invalid if an element of its name sequence ends with a space
P4 JDK-8351435 Change the default Console implementation back to the built-in one in `java.base` module
P4 JDK-8356221 Clarify Console.charset() method description
P4 JDK-8355954 File.delete removes read-only files (win)
P4 JDK-8349006 File.getCanonicalPath should remove "(on UNIX platforms)" from its specification
P4 JDK-8349092 File.getFreeSpace violates specification if quotas are in effect (win)
P4 JDK-8345368 java/io/File/createTempFile/SpecialTempFile.java fails on Windows Server 2025
P4 JDK-8343342 java/io/File/GetXSpace.java fails on Windows with CD-ROM drive
P4 JDK-8357052 java/io/File/GetXSpace.java prints wrong values in exception
P4 JDK-8346805 JLine update to System.console interferes with existing Java SignalHandler
P4 JDK-8354724 Methods in java.io.Reader to read all characters and all lines
P4 JDK-8024695 new File("").exists() returns false whereas it is the current working directory
P4 JDK-8354053 Remove unused JavaIOFilePermissionAccess
P4 JDK-8355558 SJIS.java test is always ignored
P4 JDK-8352906 stdout/err.encoding on Windows set by incorrect Win32 call
P4 JDK-8358158 test/jdk/java/io/Console/CharsetTest.java failing with NoClassDefFoundError: jtreg/SkippedException
P4 JDK-8356985 Use "stdin.encoding" in Console's read*() methods

core-libs/java.io:serialization

Priority Bug Summary
P4 JDK-8356694 Removed unused subclass audits in ObjectInput/OutputStream

core-libs/java.lang

Priority Bug Summary
P2 JDK-8349183 [BACKOUT] Optimization for StringBuilder append boolean & null
P2 JDK-8349239 [BACKOUT] Reuse StringLatin1::putCharsAt and StringUTF16::putCharsAt
P2 JDK-8354300 Mark String.hash field @Stable
P3 JDK-8357179 Deprecate VFORK launch mechanism from Process implementation (linux)
P3 JDK-8353197 Document preconditions for JavaLangAccess methods
P3 JDK-8359830 Incorrect os.version reported on macOS Tahoe 26 (Beta)
P3 JDK-8356695 java/lang/StringBuilder/HugeCapacity.java failing with OOME
P3 JDK-8355632 WhiteBox.waitForReferenceProcessing() fails assert for return type
P4 JDK-8357683 (process) SIGQUIT still blocked after JDK-8234262 with jdk.lang.Process.launchMechanism=FORK or VFORK
P4 JDK-8138614 (spec str) StringBuffer and StringBuilder methods improperly require "new" String to be returned
P4 JDK-8338140 (str) Add notes to String.trim and String.isEmpty pointing to newer APIs
P4 JDK-8346880 [aix] java/lang/ProcessHandle/InfoTest.java still fails: "reported cputime less than expected"
P4 JDK-8356107 [java.lang] Use @requires tag instead of exiting based on os.name or separatorChar property
P4 JDK-8349358 [JMH] Cannot access class jdk.internal.vm.ContinuationScope
P4 JDK-8350049 [JMH] Float16OperationsBenchmark fails java.lang.NoClassDefFoundError
P4 JDK-8350909 [JMH] test ThreadOnSpinWaitShared failed for 2 threads config
P4 JDK-8343962 [REDO] Move getChars to DecimalDigits
P4 JDK-8355215 Add @spec tags to Emoji related methods
P4 JDK-8357690 Add @Stable and final to java.lang.CharacterDataLatin1 and other CharacterData classes
P4 JDK-8343110 Add getChars(int, int, char[], int) to CharSequence and CharBuffer
P4 JDK-8350703 Add standard system property stdin.encoding
P4 JDK-8355992 Add unsignedMultiplyExact and *powExact methods to Math and StrictMath
P4 JDK-8354464 Additional cleanup setting up native.encoding
P4 JDK-8356080 Address post-integration comments for Stable Values
P4 JDK-8357561 BootstrapLoggerTest does not work on Ubuntu 24 with LANG de_DE.UTF-8
P4 JDK-8342283 CDS cannot handle a large number of classes
P4 JDK-8357436 Change jspawnhelper warning recommendation from VFORK to FORK
P4 JDK-8351927 Change VirtualThread implementation to use use FJP delayed task handling
P4 JDK-8354872 Clarify java.lang.Process resource cleanup
P4 JDK-8351740 Clean up some code around initialization of encoding properties
P4 JDK-8348870 Eliminate array bound checks in DecimalDigits
P4 JDK-8351565 Implement JEP 502: Stable Values (Preview)
P4 JDK-8355022 Implement JEP 506: Scoped Values
P4 JDK-8351374 Improve comment about queue.remove timeout in CleanerImpl.run
P4 JDK-8358809 Improve link to stdin.encoding from java.lang.IO
P4 JDK-8351462 Improve robustness of String concatenation
P4 JDK-8351443 Improve robustness of StringBuilder
P4 JDK-8353489 Increase timeout and improve Windows compatibility in test/jdk/java/lang/ProcessBuilder/Basic.java
P4 JDK-8298783 java/lang/ref/FinalizerHistogramTest.java failed with "RuntimeException: MyObject is not found in test output"
P4 JDK-8346063 java/lang/Thread/virtual/Starvation.java missing @requires vm.continuations
P4 JDK-8353124 java/lang/Thread/virtual/stress/Skynet.java#Z times out on macosx-x64-debug
P4 JDK-8349787 java/lang/Thread/virtual/ThreadPollOnYield.java#default passes unexpectedly without libVThreadPinner.so
P4 JDK-8312611 JEP 502: Stable Values (Preview)
P4 JDK-8349284 Make libExplicitAttach work on static JDK
P4 JDK-8349874 Missing comma in copyright from JDK-8349689
P4 JDK-8354335 No longer deprecate wrapper class constructors for removal
P4 JDK-8356420 Provide examples on wrapping System.in
P4 JDK-8354334 Remove @ValueBased from ProcessHandle
P4 JDK-8347270 Remove unix_getParentPidAndTimings, unix_getChildren and unix_getCmdlineAndUserInfo
P4 JDK-8355240 Remove unused Import in StringUTF16
P4 JDK-8352533 Report useful IOExceptions when jspawnhelper fails
P4 JDK-8351970 Retire JavaLangAccess::exit
P4 JDK-8357798 ReverseOrderListView uses Boolean boxes after JDK-8356080
P4 JDK-8349689 Several virtual thread tests missing /native keyword
P4 JDK-8350786 Some java/lang jtreg tests miss requires vm.hasJFR
P4 JDK-8356152 String.concat can throw StringIndexOutOfBoundsException
P4 JDK-8351000 StringBuilder getChar and putChar robustness
P4 JDK-8347817 Timeouts running test/jdk/java/lang/String/concat/HiddenClassUnloading.java with fastdebug builds
P4 JDK-8343829 Unify decimal and hexadecimal parsing in FloatingDecimal
P4 JDK-8347605 Use spec tag to refer to IEEE 754 standard
P4 JDK-8357000 Write overview documentation for start of release changes
P5 JDK-8357685 Change the type of Integer::digits from char[] to byte[]
P5 JDK-8357178 Simplify Class::componentType

core-libs/java.lang.classfile

Priority Bug Summary
P2 JDK-8347762 ClassFile attribute specification refers to non-SE modules
P3 JDK-8345773 Class-File API debug printing capability
P3 JDK-8357955 java.lang.classfile.Signature.ArrayTypeSig.of IAE not thrown for dims > 255
P3 JDK-8349624 Validation for slot missing in CodeBuilder local variable instructions
P4 JDK-8355335 Avoid pattern matching switches in core ClassFile API
P4 JDK-8361615 CodeBuilder::parameterSlot throws undocumented IOOBE
P4 JDK-8346128 Comparison build fails due to difference in LabelTarget.html
P4 JDK-8294957 Consolidate JDK class files parsing, generating, and transforming (umbrella)
P4 JDK-8342206 Convenience method to check if a constant pool entry matches nominal descriptors
P4 JDK-8347472 Correct Attribute traversal and writing for Code attributes
P4 JDK-8354877 DirectClassBuilder default flags should include ACC_SUPER
P4 JDK-8342465 Improve API documentation for java.lang.classfile
P4 JDK-8342466 Improve API documentation for java.lang.classfile.attribute
P4 JDK-8342468 Improve API documentation for java.lang.classfile.constantpool
P4 JDK-8342469 Improve API documentation for java.lang.classfile.instruction
P4 JDK-8355775 Improve symbolic sharing in dynamic constant pool entries
P4 JDK-8350548 java.lang.classfile package javadoc has errors
P4 JDK-8348283 java.lang.classfile.components.snippets.PackageSnippets shipped in java.base.jmod
P4 JDK-8347163 Javadoc error in ConstantPoolBuilder after JDK-8342468
P4 JDK-8354899 Reduce overhead associated with type switches
P4 JDK-8346984 Remove ASM-based benchmarks from Class-File API benchmarks
P4 JDK-8346983 Remove ASM-based transforms from Class-File API tests
P4 JDK-8334733 Remove obsolete @enablePreview from tests after JDK-8334714
P4 JDK-8342464 Umbrella - Improve API documentation for the ClassFile API

core-libs/java.lang.foreign

Priority Bug Summary
P2 JDK-8349238 Some more FFM benchmarks are broken
P3 JDK-8349146 [REDO] Implement a better allocator for downcalls
P3 JDK-8349343 Add missing copyright messages in FFM benchmarks
P3 JDK-8357462 Amend open/test/jdk//java/foreign/TestMatrix.java test scenario to run as manual
P3 JDK-8357919 Arena::allocate returns segments with address zero if the segment length is zero after JDK-8345687
P3 JDK-8347047 Cleanup action passed to MemorySegment::reinterpret keeps old segment alive
P3 JDK-8345465 Fix performance regression on x64 after JDK-8345120
P3 JDK-8287788 Implement a better allocator for downcalls
P3 JDK-8355962 RISCV64 cross build fails after 8354996
P3 JDK-8344370 RunThese: Mapped files are left lingering leading to memory mapping limit is reached
P4 JDK-8348909 [BACKOUT] Implement a better allocator for downcalls
P4 JDK-8350701 [JMH] test foreign.AllocFromSliceTest failed with Exception for size>1024
P4 JDK-8350811 [JMH] test foreign.StrLenTest failed with StringIndexOutOfBoundsException for size=451
P4 JDK-8345155 Add /native to native test in FFM
P4 JDK-8357106 Add missing classpath exception copyright headers
P4 JDK-8339527 Adjust threshold for MemorySegment::fill native invocation
P4 JDK-8349537 Bad copyright in TestArrayStructs.java
P4 JDK-8355971 Build warnings after the changes for JDK-8354996
P4 JDK-8349344 Clarify documentation of Arena.ofConfined
P4 JDK-8349653 Clarify the docs for MemorySegment::reinterpret
P4 JDK-8347408 Create an internal method handle adapter for system calls with errno
P4 JDK-8356126 Duplication handling and optimization of CaptureCallState
P4 JDK-8346132 fallbacklinker.c failed compilation due to unused variable
P4 JDK-8346609 Improve MemorySegment.toString
P4 JDK-8345687 Improve the implementation of SegmentFactories::allocateSegment
P4 JDK-8346432 java.lang.foreign.Linker comment typo
P4 JDK-8356658 java/foreign/TestBufferStackStress2.java failed again with junit action timed out
P4 JDK-8356114 java/foreign/TestBufferStackStress2.java failed with junit action timed out
P4 JDK-8348976 MemorySegment::reinretpret should be force inlined
P4 JDK-8348668 Prevent first resource cleanup in confined arena from escaping
P4 JDK-8354996 Reduce dynamic code generation for a single downcall
P4 JDK-8350118 Simplify the layout access VarHandle
P4 JDK-8351757 Test java/foreign/TestDeadlock.java#FileChannel_map timed out after passing
P4 JDK-8354121 Use a record class rather than a lambda in AbstractMemorySegmentImpl::cleanupAction
P5 JDK-8346610 Make all imports consistent in the FFM API

core-libs/java.lang.invoke

Priority Bug Summary
P3 JDK-8354890 AOT-initialize j.l.i.MethodHandleImpl and inner classes
P3 JDK-8351996 Behavioral updates for ClassValue::remove
P4 JDK-8315131 Clarify VarHandle set/get access on 32-bit platforms
P4 JDK-8351045 ClassValue::remove cannot ensure computation observes up-to-date state
P4 JDK-8350607 Consolidate MethodHandles::zero into MethodHandles::constant
P4 JDK-8297727 Forcing LF interpretation lead to StackOverflowError in reflection code
P4 JDK-8350549 MethodHandleProxies.WRAPPER_TYPES is not thread-safe
P4 JDK-8350462 MethodTypeForm.LF_INTERPRET can cache the MemberName instead
P4 JDK-8355442 Reference field lambda forms with type casts are not generated
P4 JDK-8357165 test java/lang/invoke/ClassValueTest.java fails intermittently
P4 JDK-8356119 Typo in bytecode behavior for Lookup.findGetter

core-libs/java.lang.module

Priority Bug Summary
P4 JDK-8299504 Resolve `uses` and `provides` at run time if the service is optional and missing

core-libs/java.lang:reflect

Priority Bug Summary
P3 JDK-8297271 AccessFlag.maskToAccessFlags should be specific to class file version
P4 JDK-8347063 Add comments in ClassFileFormatVersion for class file format evolution history
P4 JDK-8320255 Add method to java.lang.Class to find main method
P4 JDK-8347397 Cleanup of JDK-8169880
P4 JDK-8350704 Create tests to ensure the failure behavior of core reflection APIs
P4 JDK-8345614 Improve AnnotationFormatError message for duplicate annotation interfaces
P4 JDK-8347471 Provide valid flags and mask in AccessFlag.Location
P4 JDK-8357597 Proxy.getInvocationHandler throws NullPointerException instead of IllegalArgumentException for null
P4 JDK-8342979 Start of release updates for JDK 25

core-libs/java.math

Priority Bug Summary
P4 JDK-8355300 Add final to BitSieve
P4 JDK-8356709 Avoid redundant String formatting in BigDecimal.valueOf(double)
P4 JDK-8341402 BigDecimal's square root optimization
P4 JDK-8357401 BigDecimal: Constants ONE_TENTH and ONE_HALF are unused after JDK-8341402
P4 JDK-8356555 Incorrect use of {@link} in BigDecimal
P4 JDK-8355719 Reduce memory consumption of BigInteger.pow()
P4 JDK-8356891 Some code simplifications in BigInteger

core-libs/java.net

Priority Bug Summary
P2 JDK-8359709 java.net.HttpURLConnection sends unexpected "Host" request header in some cases after JDK-8344190
P2 JDK-8346017 Socket.connect specified to throw UHE for unresolved address is problematic for SOCKS V5 proxy
P3 JDK-8359268 3 JNI exception pending defect groups in 2 files
P3 JDK-8346378 Cannot use DllMain in libnet for static builds
P3 JDK-8351843 change test/jdk/com/sun/net/httpserver/simpleserver/RootDirPermissionsTest.java to a manual test
P3 JDK-8353642 Deprecate URL::getPermission method and networking permission classes for removal
P3 JDK-8348986 Improve coverage of enhanced exception messages
P3 JDK-8346705 SNI not sent with Java 22+ using java.net.http.HttpClient.Builder#sslParameters
P3 JDK-8228773 URLClassLoader constructors should include API note warning that the parent should not be null
P4 JDK-8355360 -d option of jwebserver command should accept relative paths
P4 JDK-8355578 [java.net] Use @requires tag instead of exiting based on "os.name" property value
P4 JDK-8354024 [JMH] Create ephemeral UnixDomainSocketAddress provider with thread-safe close semantics
P4 JDK-8350915 [JMH] test SocketChannelConnectionSetup failed for 2 threads config
P4 JDK-8351601 [JMH] test UnixSocketChannelReadWrite failed for 2 threads config
P4 JDK-8328919 Add BodyHandlers / BodySubscribers methods to handle excessive server input
P4 JDK-8353662 Add test for non-local file URL fallback to FTP
P4 JDK-8349135 Add tests for HttpRequest.Builder.copy()
P4 JDK-8345249 Apply some conservative cleanups in FileURLConnection
P4 JDK-8345794 Backout doc change introduced by JDK-8235786
P4 JDK-8347000 Bug in com/sun/net/httpserver/bugs/B6361557.java test
P4 JDK-8285888 Clarify that java.net.http.HttpClient do NOT support Digest authentication
P4 JDK-8347348 Clarify that the HTTP server in jdk.httpserver module is not a full featured server
P4 JDK-8358496 Concurrent reading from Socket with timeout executes sequentially
P4 JDK-8353278 Consolidate local file URL checks in jar: and file: URL schemes
P4 JDK-7046003 Default value of Authenticator.getRequestingURL() is not specified
P4 JDK-8344308 Deprecate java.net.URLConnection.getPermission for removal.
P4 JDK-8353440 Disable FTP fallback for non-local file URLs by default
P4 JDK-8347373 HTTP/2 flow control checks may count unprocessed data twice
P4 JDK-8352706 httpclient HeadTest does not run on HTTP2
P4 JDK-8351347 HttpClient Improve logging of response headers
P4 JDK-8350279 HttpClient: Add a new HttpResponse method to identify connections
P4 JDK-8350019 HttpClient: DelegatingExecutor should resort to the fallback executor only on RejectedExecutionException
P4 JDK-8347597 HttpClient: improve exception reporting when closing connection
P4 JDK-8353949 HttpHeaders.firstValueAsLong unnecessarily boxes to Long
P4 JDK-8304065 HttpServer.stop should terminate immediately if no exchanges are in progress
P4 JDK-8357013 HttpURLConnection#getResponseCode can avoid substring call when parsing to int
P4 JDK-8355370 Include server name in HTTP test server thread names to improve diagnostics
P4 JDK-8354576 InetAddress.getLocalHost() on macos may return address of an interface which is not UP - leading to "Network is down" error
P4 JDK-8351419 java.net.http: Cleanup links in HttpResponse and module-info API doc comments
P4 JDK-8353013 java.net.URI.create(String) may have low performance to scan the host/domain name from URI string when the hostname starts with number
P4 JDK-8349705 java.net.URI.scanIPv4Address throws unnecessary URISyntaxException
P4 JDK-8347173 java/net/DatagramSocket/InterruptibleDatagramSocket.java fails with virtual thread factory
P4 JDK-8217914 java/net/httpclient/ConnectTimeoutHandshakeSync.java failed on connection refused while doing POST
P4 JDK-8352431 java/net/httpclient/EmptyAuthenticate.java uses "localhost"
P4 JDK-8330598 java/net/httpclient/Http1ChunkedTest.java fails with java.util.MissingFormatArgumentException: Format specifier '%s'
P4 JDK-8348102 java/net/httpclient/HttpClientSNITest.java fails intermittently
P4 JDK-8358617 java/net/HttpURLConnection/HttpURLConnectionExpectContinueTest.java fails with 403 due to system proxies
P4 JDK-8281511 java/net/ipv6tests/UdpTest.java fails with checkTime failed
P4 JDK-8359364 java/net/URL/EarlyOrDelayedParsing test fails intermittently
P4 JDK-8349702 jdk.internal.net.http.Http2Connection::putStream needs to provide cause while cancelling stream
P4 JDK-8352858 Make java.net.JarURLConnection fields final
P4 JDK-8352623 MultiExchange should cancel exchange impl if responseFilters throws
P4 JDK-8353698 Output of Simple Web Server is garbled if the console's encoding is not UTF-8
P4 JDK-8348108 Race condition in AggregatePublisher.AggregateSubscription
P4 JDK-8347995 Race condition in jdk/java/net/httpclient/offline/FixedResponseHttpClient.java
P4 JDK-8346712 Remove com/sun/net/httpserver/TcpNoDelayNotRequired.java test
P4 JDK-8353847 Remove extra args to System.out.printf in open/test/jdk/java/net/httpclient tests
P4 JDK-8357406 Remove usages of jdk.tracePinnedThreads system property from httpclient tests
P4 JDK-8356154 Respecify java.net.Socket constructors that allow creating UDP sockets to throw IllegalArgumentException
P4 JDK-8350546 Several java/net/InetAddress tests fails UnknownHostException
P4 JDK-8349662 SSLTube SSLSubscriptionWrapper has potential races when switching subscriptions
P4 JDK-8354276 Strict HTTP header validation
P4 JDK-8349813 Test behavior of limiting() on RS operators throwing exceptions
P4 JDK-8359402 Test CloseDescriptors.java should throw SkippedException when there is no lsof/sctp
P4 JDK-8343074 test/jdk/com/sun/net/httpserver/docs/test1/largefile.txt could be generated
P4 JDK-8348107 test/jdk/java/net/httpclient/HttpsTunnelAuthTest.java fails intermittently
P4 JDK-8357539 TimeSource.now() is not monotonic
P4 JDK-8355475 UNCTest should use an existing UNC path
P4 JDK-8342807 Update links in java.base to use https://
P4 JDK-8353453 URLDecoder should use HexFormat
P4 JDK-8352895 UserCookie.java runs wrong test class
P4 JDK-8351339 WebSocket::sendBinary assume that user supplied buffers are BIG_ENDIAN
P5 JDK-8354826 Make ResolverConfigurationImpl.lock field final
P5 JDK-8336412 sun.net.www.MimeTable has a few unused methods

core-libs/java.nio

Priority Bug Summary
P2 JDK-8361299 (bf) CharBuffer.getChars(int,int,char[],int) violates pre-existing specification
P3 JDK-8360887 (fs) Files.getFileAttributeView returns unusable FileAttributeView if UserDefinedFileAttributeView unavailable (aix)
P3 JDK-8358764 (sc) SocketChannel.close when thread blocked in read causes connection to be reset (win)
P3 JDK-8347994 Add additional diagnostics to macOS failure handler to assist with diagnosing MCast test failures
P3 JDK-8346573 Can't use custom default file system provider with custom system class loader
P3 JDK-8346671 java/nio/file/Files/probeContentType/Basic.java fails on Windows 2025
P3 JDK-8361183 JDK-8360887 needs fixes to avoid cycles and better tests (aix)
P3 JDK-8351851 Update PmemTest to run on AMD64
P4 JDK-8345421 (bf) Create specific test for temporary direct buffers and the buffer size limit
P4 JDK-8357280 (bf) Remove @requires tags from java/nio/Buffer/LimitDirectMemory[NegativeTest].java
P4 JDK-8211851 (ch) java/nio/channels/AsynchronousSocketChannel/StressLoopback.java times out (aix)
P4 JDK-8351458 (ch) Move preClose to UnixDispatcher
P4 JDK-8345432 (ch, fs) Replace anonymous Thread with InnocuousThread
P4 JDK-8347171 (dc) java/nio/channels/DatagramChannel/InterruptibleOrNot.java fails with virtual thread factory
P4 JDK-8351086 (fc) Make java/nio/channels/FileChannel/BlockDeviceSize.java test manual
P4 JDK-8353053 (fs) Add support for UserDefinedFileAttributeView on AIX
P4 JDK-8350654 (fs) Files.createTempDirectory should say something about the default file permissions when no file attributes specified
P4 JDK-8349812 (fs) Files.newByteChannel with empty path name and CREATE_NEW throws unexpected exception
P4 JDK-8346722 (fs) Files.probeContentType throws ClassCastException with custom file system provider
P4 JDK-8356678 (fs) Files.readAttributes should map ENOTDIR to NoSuchFileException where possible (unix)
P4 JDK-8356888 (fs) FileSystems.newFileSystem that take an env must specify IllegalArgumentException
P4 JDK-8349383 (fs) FileTreeWalker.next() superfluous null check of visit() return value
P4 JDK-8321591 (fs) Improve String -> Path conversion performance (win)
P4 JDK-8351294 (fs) Minor verbiage correction for Files.createTemp{Directory,File}
P4 JDK-8351415 (fs) Path::toAbsolutePath should specify if an absolute path has a root component
P4 JDK-8356606 (fs) PosixFileAttributes.permissions() implementations should return an EnumSet
P4 JDK-8357912 (fs) Remove @since tag from java.nio.file.FileSystems.newFileSystem(Path,ClassLoader)
P4 JDK-8347286 (fs) Remove some extensions from java/nio/file/Files/probeContentType/Basic.java
P4 JDK-8357425 (fs) SecureDirectoryStream setPermissions should use fchmodat
P4 JDK-8351505 (fs) Typo in the documentation of java.nio.file.spi.FileSystemProvider.getFileSystem()
P4 JDK-8357303 (fs) UnixSecureDirectoryStream.implDelete has unused haveFlags parameter
P4 JDK-8350880 (zipfs) Add support for read-only zip file systems
P4 JDK-8358558 (zipfs) Reorder the listing of "accessMode" property in the ZIP file system's documentation
P4 JDK-8355445 [java.nio] Use @requires tag instead of exiting based on "os.name" property value
P4 JDK-8346463 Add test coverage for deploying the default provider as a module
P4 JDK-8354530 AIX: sporadic unexpected errno when calling setsockopt in Net.joinOrDrop
P4 JDK-8343157 Examine large files for character encoding/decoding
P4 JDK-8349868 Remove unneeded libjava shared library dependency from jtreg test libNewDirectByteBuffer, libDirectIO and libInheritedChannel
P4 JDK-8346972 Test java/nio/channels/FileChannel/LoopingTruncate.java fails sometimes with IOException: There is not enough space on the disk
P5 JDK-8356036 (fs) FileKey.hashCode and UnixFileStore.hashCode implementations can use Long.hashCode

core-libs/java.nio.charsets

Priority Bug Summary
P4 JDK-8346117 Add test annotation
P4 JDK-8356822 Refactor HTML anchor tags to javadoc in Charset
P4 JDK-8350442 Update copyright

core-libs/java.rmi

Priority Bug Summary
P2 JDK-8360157 Multiplex protocol not removed from RMI specification Index
P4 JDK-8359385 Java RMI specification still mentions applets
P4 JDK-8359729 Remove the multiplex protocol from the RMI specification

core-libs/java.sql

Priority Bug Summary
P4 JDK-8346202 Correct typo in SQLPermission
P4 JDK-8344575 Examine usage of ReflectUtil.forName() in java.sql.rowset - XmlReaderContentHandler
P4 JDK-8356629 Incorrect use of {@linkplain} in java.sql

core-libs/java.text

Priority Bug Summary
P4 JDK-8354522 Clones of DecimalFormat cause interferences when used concurrently
P4 JDK-8351074 Disallow null prefix and suffix in DecimalFormat
P4 JDK-8364370 java.text.DecimalFormat specification indentation correction
P4 JDK-4745837 Make grouping usage during parsing apparent in relevant NumberFormat methods
P4 JDK-8353585 Provide ChoiceFormat#parse(String, ParsePosition) tests
P4 JDK-5061061 SimpleDateFormat: unspecified behavior for reserved pattern letter
P4 JDK-8353322 Specification of ChoiceFormat#parse(String, ParsePosition) is inadequate
P5 JDK-8357681 Fixed the DigitList::toString method causing incorrect results during debugging

core-libs/java.time

Priority Bug Summary
P3 JDK-8347965 (tz) Update Timezone Data to 2025a
P3 JDK-8352716 (tz) Update Timezone Data to 2025b
P3 JDK-8175709 DateTimeFormatterBuilder.appendZoneId() has misleading JavaDoc
P3 JDK-8166983 Remove old/legacy unused tzdata files
P3 JDK-8345668 ZoneOffset.ofTotalSeconds performance regression
P4 JDK-8346300 Add @Test annotation to TCKZoneId.test_constant_OLD_IDS_POST_2024b test
P4 JDK-8334742 Change java.time month/day field types to 'byte'
P4 JDK-8351017 ChronoUnit.MONTHS.between() not giving correct result when date is in February
P4 JDK-8348880 Replace ConcurrentMap with AtomicReferenceArray for ZoneOffset.QUARTER_CACHE
P4 JDK-8337279 Share StringBuilder to format instant
P4 JDK-8342886 Update MET timezone in TimeZoneNames files
P4 JDK-8355391 Use Long::hashCode in java.time

core-libs/java.util

Priority Bug Summary
P3 JDK-8351233 [ASAN] avx2-emu-funcs.hpp:151:20: error: ‘D.82188’ is used uninitialized
P3 JDK-8345818 Fix SM cleanup of parsing of System property resource.bundle.debug
P3 JDK-8301875 java.util.TimeZone.getSystemTimeZoneID uses C library default file mode
P4 JDK-8353741 Eliminate table lookup in UUID.toString
P4 JDK-8351567 Jar Manifest test ValueUtf8Coding produces misleading diagnostic output
P4 JDK-8350542 Optional.orElseThrow(Supplier) does not specify behavior when supplier returns null
P4 JDK-8348898 Remove unused OctalDigits to clean up code
P5 JDK-8351593 [JMH] test PhoneCode.Bulk reports NPE exception
P5 JDK-8351897 Extra closing curly brace typos in Javadoc

core-libs/java.util.concurrent

Priority Bug Summary
P3 JDK-8357146 ForkJoinPool:schedule(*) does not throw RejectedExecutionException when pool is shutdown
P3 JDK-8353331 Test ForkJoinPool20Test::testFixedDelaySequence is failing
P3 JDK-8358633 Test ThreadPoolExecutorTest::testTimedInvokeAnyNullTimeUnit is broken by JDK-8347491
P3 JDK-8347039 ThreadPerTaskExecutor terminates if cancelled tasks still running
P3 JDK-8362882 Update SubmissionPublisher() specification to reflect use of ForkJoinPool.asyncCommonPool()
P4 JDK-8358151 Harden JSR166 Test case testShutdownNow_delayedTasks
P4 JDK-8347491 IllegalArgumentationException thrown by ThreadPoolExecutor doesn't have a useful message
P4 JDK-8319447 Improve performance of delayed task handling
P4 JDK-8351933 Inaccurate masking of TC subfield decrement in ForkJoinPool
P4 JDK-8356553 Incorrect uses of {@link} in AbstractQueuedLongSynchronizer and AbstractQueuedSynchronizer
P4 JDK-8352971 Increase maximum number of hold counts for ReentrantReadWriteLock
P4 JDK-8354111 JavaDoc states that Iterator.remove() is linear in the LinkedBlockingDeque
P4 JDK-8357285 JSR166 Test case testShutdownNow_delayedTasks failed
P4 JDK-8355369 Remove setAccessible usage for setting final fields in java.util.concurrent
P4 JDK-8353659 SubmissionPublisherTest::testCap1Submit times out
P4 JDK-8347842 ThreadPoolExecutor specification discusses RuntimePermission
P4 JDK-8354016 Update ReentrantReadWriteLock documentation to reflect its new max capacity
P4 JDK-8357797 Use StructuredTaskScopeImpl.ST_NEW for state init

core-libs/java.util.jar

Priority Bug Summary
P3 JDK-8347712 IllegalStateException on multithreaded ZipFile access with non-UTF8 charset
P3 JDK-8353787 Increased number of SHA-384-Digest java.util.jar.Attributes$Name instances leading to higher memory footprint
P3 JDK-8355975 ZipFile uses incorrect Charset if another instance for the same ZIP file was constructed with a different Charset
P4 JDK-8357145 CRC/Inflater/Deflater/Adler32 methods that take a ByteBuffer throw UOE if backed by shared memory segment
P4 JDK-8346871 Improve robustness of java/util/zip/EntryCount64k.java test
P4 JDK-8225763 Inflater and Deflater should implement AutoCloseable
P4 JDK-8204868 java/util/zip/ZipFile/TestCleaner.java still fails with "cleaner failed to clean zipfile."
P4 JDK-8358456 ZipFile.getInputStream(ZipEntry) throws unspecified IllegalArgumentException
P5 JDK-8066583 DeflaterInput/OutputStream and InflaterInput/OutputStream should explain responsibility for freeing resources

core-libs/java.util.logging

Priority Bug Summary
P3 JDK-8354424 java/util/logging/LoggingDeadlock5.java fails intermittently in tier6
P4 JDK-8353684 [BACKOUT] j.u.l.Handler classes create deadlock risk via synchronized publish() method
P4 JDK-8353683 [REDO] j.u.l.Handler classes create deadlock risk via synchronized publish() method
P4 JDK-8354513 Bug in j.u.l.Handler deadlock test allows null pointer during race condition
P4 JDK-8349206 j.u.l.Handler classes create deadlock risk via synchronized publish() method

core-libs/java.util.regex

Priority Bug Summary
P4 JDK-8352628 Refine Grapheme test

core-libs/java.util.stream

Priority Bug Summary
P3 JDK-8347274 Gatherers.mapConcurrent exhibits undesired behavior under variable delays, interruption, and finishing
P3 JDK-8357647 Stream gatherers forward upstream size information to downstream
P4 JDK-8352709 Remove bad timing annotations from WhileOpTest.java

core-libs/java.util:collections

Priority Bug Summary
P3 JDK-8351230 Collections.synchronizedList returns a list that is not thread-safe
P3 JDK-8356486 ReverseOrderListView should override reversed() to return `base`
P4 JDK-8358015 Fix SequencedMap sequenced view method specifications
P4 JDK-8327858 Improve spliterator and forEach for single-element immutable collections

core-libs/java.util:i18n

Priority Bug Summary
P3 JDK-8356096 ISO 4217 Amendment 179 Update
P3 JDK-8349873 StackOverflowError after JDK-8342550 if -Duser.timezone= is set to a deprecated zone id
P3 JDK-8346948 Update CLDR to Version 47.0
P4 JDK-8349200 [JMH] time.format.ZonedDateTimeFormatterBenchmark fails
P4 JDK-8348365 Bad format string in CLDRDisplayNamesTest
P4 JDK-8350646 Calendar.Builder.build() Throws ArrayIndexOutOfBoundsException
P4 JDK-8347949 Currency method to stream available Currencies
P4 JDK-8353118 Deprecate the use of `java.locale.useOldISOCodes` system property
P4 JDK-8354343 Hardening of Currency tests for not yet defined future ISO 4217 currency
P4 JDK-8353713 Improve Currency.getInstance exception handling
P4 JDK-8348205 Improve cutover time selection when building available currencies set
P4 JDK-8348351 Improve lazy initialization of the available currencies set
P4 JDK-8356040 java/util/PluggableLocale/LocaleNameProviderTest.java timed out
P4 JDK-8345213 JVM Prefers /etc/timezone Over /etc/localtime on Debian 12
P4 JDK-8357275 Locale.Builder.setLanguageTag should mention conversions made on language tag
P4 JDK-8358449 Locale.getISOCountries does not specify the returned set is unmodifiable
P4 JDK-8349883 Locale.LanguageRange.parse("-") throws ArrayIndexOutOfBoundsException
P4 JDK-8342550 Log warning for using JDK1.1 compatible time zone IDs for future removal
P4 JDK-8352755 Misconceptions about j.text.DecimalFormat digits during parsing
P4 JDK-8356450 NPE in CLDRTimeZoneNameProviderImpl for tzdata downgrades after JDK-8342550
P4 JDK-8349000 Performance improvement for Currency.isPastCutoverDate(String)
P4 JDK-8357075 Remove leftover COMPAT locale data tests
P4 JDK-8347613 Remove leftover doPrivileged call in Currency test: CheckDataVersion.java
P4 JDK-8358089 Remove the GenerateKeyList.java test tool
P4 JDK-8357886 Remove TimeZoneNames_* of the COMPAT locale data provider
P4 JDK-8349493 Replace sun.util.locale.ParseStatus usage with java.text.ParsePosition
P4 JDK-8358170 Repurpose testCompat in test/jdk/java/util/TimeZone/Bug8167143.java
P4 JDK-8291027 Some of TimeZone methods marked 'synchronized' unnecessarily
P4 JDK-8357281 sun.util.Locale.LanguageTag should be immutable
P4 JDK-8354344 Test behavior after cut-over for future ISO 4217 currency
P4 JDK-8347841 Test fixes that use deprecated time zone IDs
P4 JDK-8347955 TimeZone methods to stream the available timezone IDs
P4 JDK-8348328 Update IANA Language Subtag Registry to Version 2025-05-15
P4 JDK-8356021 Use Double::hashCode in java.util.Locale::hashCode
P4 JDK-8357882 Use UTF-8 encoded data in LocaleDataTest
P5 JDK-8358095 Cleanup tests with explicit locale provider set to only CLDR

core-libs/javax.lang.model

Priority Bug Summary
P4 JDK-8342982 Add SourceVersion.RELEASE_25
P4 JDK-8174840 Elements.overrides does not check the return type of the methods
P4 JDK-8354091 Update RELEASE_25 description for Flexible Constructor Bodies
P4 JDK-8356108 Update SourceVersion.RELEASE_25 description for JEPs 511 and 512

core-libs/javax.naming

Priority Bug Summary
P4 JDK-8355278 Improve debuggability of com/sun/jndi/ldap/LdapPoolTimeoutTest.java test
P4 JDK-8349107 Remove RMI finalizers

core-svc

Priority Bug Summary
P3 JDK-8356870 HotSpotDiagnosticMXBean.dumpThreads and jcmd Thread.dump_to_file updates
P4 JDK-8350524 Some hotspot/jtreg/serviceability/dcmd/vm tier1 tests fail on static JDK
P4 JDK-8358077 sun.tools.attach.VirtualMachineImpl::checkCatchesAndSendQuitTo on Linux leaks file handles after JDK-8327114
P4 JDK-8345800 Update copyright year to 2024 for serviceability in files where it was missed

core-svc/debugger

Priority Bug Summary
P3 JDK-8357193 [VS 2022 17.14] Warning C5287 in debugInit.c: enum type mismatch during build
P3 JDK-8346383 Cannot use DllMain in libdt_socket for static builds
P3 JDK-8353953 com/sun/jdi tests should be fixed to not always require includevirtualthreads=y
P3 JDK-8355071 Fix nsk/jdi test to not require lookup of main thread in order to set the breakpoint used for communication
P3 JDK-8353955 nsk/jdi tests should be fixed to not always require includevirtualthreads=y
P3 JDK-8229012 When single stepping, the debug agent can cause the thread to remain in interpreter mode after single stepping completes
P4 JDK-8352088 Call of com.sun.jdi.ThreadReference.threadGroups() can lock up target VM
P4 JDK-8346985 Convert test/jdk/com/sun/jdi/ClassUnloadEventTest.java to Class-File API
P4 JDK-8351310 Deprecate com.sun.jdi.JDIPermission for removal
P4 JDK-8357172 Extend try block in nsk/jdi tests to capture exceptions thrown by Debuggee.classByName()
P4 JDK-8355221 Get rid of unnecessary override of JDIBase.breakpointForCommunication in nsk/jdi tests
P4 JDK-8355453 nsk.share.jdi.Debugee.waitingEvent() does not timeout properly
P4 JDK-8355211 nsk/jdi/EventRequest/disable/disable001.java should use JDIBase superclass
P4 JDK-8355214 nsk/jdi/ThreadStartRequest/addThreadFilter/addthreadfilter001.java should use JDIBase superclass
P4 JDK-8355773 Some nsk/jdi tests can fetch ThreadReference from static field in the debuggee
P4 JDK-8356023 Some nsk/jdi tests can fetch ThreadReference from static field in the debuggee: part 2
P4 JDK-8356588 Some nsk/jdi tests can fetch ThreadReference from static field in the debuggee: part 3
P4 JDK-8356811 Some nsk/jdi tests can fetch ThreadReference from static field in the debuggee: part 4
P4 JDK-8355569 Some nsk/jdi tests can glean the "main" thread by using the ClassPrepareEvent for the debuggee main class
P4 JDK-8358178 Some nsk/jdi tests should be run with includevirtualthreads=y even though they pass without
P4 JDK-8356641 Test com/sun/jdi/EarlyThreadGroupChildrenTest.java fails sometimes on macOS
P4 JDK-8357184 Test vmTestbase/nsk/jdi/ExceptionEvent/_itself_/exevent008/TestDescription.java fails with unreported exception
P4 JDK-8338714 vmTestbase/nsk/jdb/kill/kill001/kill001.java fails with JTREG_TEST_THREAD_FACTORY=Virtual

core-svc/java.lang.instrument

Priority Bug Summary
P4 JDK-8346151 Add transformer error logging to VerifyLocalVariableTableOnRetransformTest

core-svc/java.lang.management

Priority Bug Summary
P2 JDK-8350820 OperatingSystemMXBean CpuLoad() methods return -1.0 on Windows
P4 JDK-8347267 [macOS]: UnixOperatingSystem.c:67:40: runtime error: division by zero
P4 JDK-8351002 com/sun/management/OperatingSystemMXBean cpuLoad tests fail intermittently
P4 JDK-8350818 Improve OperatingSystemMXBean cpu load tests to not accept -1.0 by default
P4 JDK-8346255 java/lang/management/ThreadMXBean/VirtualThreadDeadlocks.java finds no deadlock
P4 JDK-8351542 LIBMANAGEMENT_OPTIMIZATION remove special optimization settings
P4 JDK-8345684 OperatingSystemMXBean.getSystemCpuLoad() throws NPE
P4 JDK-8351359 OperatingSystemMXBean: values from getCpuLoad and getProcessCpuLoad are stale after 24.8 days (Windows)
P4 JDK-8353231 Test com/sun/management/OperatingSystemMXBean/GetProcessCpuLoad still fails intermittently
P4 JDK-8354407 Test com/sun/management/OperatingSystemMXBean/GetProcessCpuLoad.java still fails on Windows
P4 JDK-8351821 VMManagementImpl.c avoid switching off warnings

core-svc/javax.management

Priority Bug Summary
P3 JDK-8358701 Remove misleading javax.management.remote API doc wording about JMX spec, and historic link to JMXMP
P4 JDK-8346261 Cleanup in JDP tests
P4 JDK-8347985 Deprecate java.management Permission classes for removal
P4 JDK-8347433 Deprecate XML interchange in java.management/javax/management/modelmbean/DescriptorSupport for removal
P4 JDK-8345987 java.management has two Util.newObjectName methods (remove one)
P4 JDK-8350571 Remove mention of Tonga test suite from JMX tests
P4 JDK-8345984 Remove redundant checkXXX methods from java.management Util class
P4 JDK-8347345 Remove redundant test policy file from ModelMBeanInfoSupport directory
P4 JDK-8344966 Remove the allowNonPublic MBean compatibility property
P4 JDK-8345048 Remove the jmx.extend.open.types compatibility property
P4 JDK-8344976 Remove the jmx.invoke.getters compatibility property
P4 JDK-8344969 Remove the jmx.mxbean.multiname compatibility property
P4 JDK-8345045 Remove the jmx.remote.x.buffer.size JMX notification property
P4 JDK-8345049 Remove the jmx.tabular.data.hash.map compatibility property
P4 JDK-8350939 Revisit Windows PDH buffer size calculation for OperatingSystemMXBean
P4 JDK-8348265 RMIConnectionImpl: Remove Subject.callAs on MarshalledObject
P4 JDK-8345079 Simplify/cleanup Exception handling in RMIConnectionImpl

core-svc/tools

Priority Bug Summary
P3 JDK-8340401 DcmdMBeanPermissionsTest.java and SystemDumpMapTest.java fail with assert(_stack_base != nullptr) failed: Sanity check
P3 JDK-8219896 Enhance Attach API to support arbitrary length arguments
P3 JDK-8342995 Enhance Attach API to support arbitrary length arguments - Linux
P3 JDK-8342996 Enhance Attach API to support arbitrary length arguments - OSX
P3 JDK-8346927 serviceability/dcmd/vm/[SystemMapTest.java|SystemDumpMapTest.java] fail at jmx
P3 JDK-8346717 serviceability/dcmd/vm/SystemDumpMapTest.java failing on Windows with "Stack base not yet set for thread id"
P3 JDK-8346248 serviceability/dcmd/vm/{SystemMapTest.java,SystemMapTest.java} failing on macos-aarch64
P4 JDK-8351224 Deprecate com.sun.tools.attach.AttachPermission for removal
P4 JDK-8318730 MonitorVmStartTerminate.java still times out after JDK-8209595
P4 JDK-8354460 Streaming output for attach API should be turned on by default
P4 JDK-8361869 Tests which call ThreadController should mark as /native
P4 JDK-8356222 Thread.print command reports waiting on the Class initialization monitor for both carrier and virtual threads
P4 JDK-8357650 ThreadSnapshot to take snapshot of thread for thread dumps
P4 JDK-8358588 ThreadSnapshot.ThreadLock should be static nested class
P4 JDK-8345745 Update mode of the Attach API communication pipe.
P4 JDK-8354461 Update tests to disable streaming output for attach tools

docs

Priority Bug Summary
P4 JDK-8366197 Update JDK 25 documentation for Text Blocks

docs/guides

Priority Bug Summary
P3 JDK-8349395 Add removed text to JDK Providers Guide
P3 JDK-8362421 Virtual Threads / Viewing Virtual Threads in jcmd Thread Dumps section isn't correct
P4 JDK-8350384 Add a link to the new security related properties html file in the security troubleshooting guide
P4 JDK-8344547 Add an example of FFM memory mapping to the guides
P4 JDK-8355991 Doc change for JDK-8354305: In The SUN Provider (a part of the Security Guide), add "SHAKE128-256" and "SHAKE256-512"
P4 JDK-8347934 Document Compatible OCSP readtimeout property with OCSP timeout
P4 JDK-8361311 Extra spaces in Monitoring and Management Properties table
P4 JDK-8360195 The collapsed MVC diagram is missing in the "Swing Architecture Overview" document
P4 JDK-8356217 Update JDK Providers Doc and PKCS11 Reference Guide for JDK-8348732
P4 JDK-8356015 Update JSSE docs for the TLS Exporters
P4 JDK-8349605 Update PKCS11 guide for the new HKDF support
P4 JDK-8361537 Update the JAXP section of the Guide

docs/hotspot

Priority Bug Summary
P4 JDK-8356396 G1EnableStringDeduplication wrong flag name in gc tuning docs

globalization

Priority Bug Summary
P2 JDK-8364089 JDK 25 RDP2 L10n resource files update

globalization/translation

Priority Bug Summary
P2 JDK-8347498 JDK 24 RDP2 L10n resource files update
P3 JDK-8345327 JDK 24 RDP1 L10n resource files update
P3 JDK-8359761 JDK 25 RDP1 L10n resource files update
P4 JDK-8351223 Update localized resources in keytool and jarsigner

hotspot/compiler

Priority Bug Summary
P1 JDK-8346039 [BACKOUT] - [C1] LIR Operations with one input should be implemented as LIR_Op1
P1 JDK-8356266 Fix non-Shenandoah build after JDK-8356075
P1 JDK-8349070 Fix riscv and ppc build errors caused by JDK-8343767
P2 JDK-8353237 [AArch64] Incorrect result of VectorizedHashCode intrinsic on Cortex-A53
P2 JDK-8358236 [AOT] Graal crashes when trying to use persisted MDOs
P2 JDK-8357468 [asan] heap buffer overflow reported in PcDesc::pc_offset() pcDesc.hpp:57
P2 JDK-8352965 [BACKOUT] 8302459: Missing late inline cleanup causes compiler/vectorapi/VectorLogicalOpIdentityTest.java IR failure
P2 JDK-8355363 [BACKOUT] 8354668: Missing REX2 prefix accounting in ZGC barriers leads to incorrect encoding
P2 JDK-8348687 [BACKOUT] C2: Non-fluid StringBuilder pattern bails out in OptoStringConcat
P2 JDK-8352110 [BACKOUT] C2: Print compilation bailouts with PrintCompilation compile command
P2 JDK-8364409 [BACKOUT] Consolidate Identity of self-inverse operations
P2 JDK-8347987 Bad ifdef in 8330851
P2 JDK-8362171 C2 fails with unexpected node in SuperWord truncation: ModI
P2 JDK-8350835 C2 SuperWord: assert/wrong result when using Float.float16ToFloat with byte instead of short input
P2 JDK-8358334 C2/Shenandoah: incorrect execution with Unsafe
P2 JDK-8356708 C2: loop strip mining expansion doesn't take sunk stores into account
P2 JDK-8351660 C2: SIGFPE in unsigned_mod_value
P2 JDK-8356122 Client build fails after JDK-8350209
P2 JDK-8357402 Crash in AdapterHandlerLibrary::lookup
P2 JDK-8348631 Crash in PredictedCallGenerator::generate after JDK-8347006
P2 JDK-8357514 Disable AOT caching for runtime stubs
P2 JDK-8356281 Fix for TestFPComparison failure due to incorrect result
P2 JDK-8348853 Fold layout helper check for objects implementing non-array interfaces
P2 JDK-8362564 hotspot/jtreg/compiler/c2/TestLWLockingCodeGen.java fails on static JDK on x86_64 with AVX instruction extensions
P2 JDK-8348388 Incorrect copyright header in TestFluidAndNonFluid.java
P2 JDK-8348327 Incorrect march flag when building libsleef/vector_math_neon.c
P2 JDK-8361952 Installation of MethodData::extra_data_lock() misses synchronization on reader side
P2 JDK-8349637 Integer.numberOfLeadingZeros outputs incorrectly in certain cases
P2 JDK-8357166 Many AOT tests failed with VM crash
P2 JDK-8359200 Memory corruption in MStack::push
P2 JDK-8356989 Unexpected null in C2 compiled code
P2 JDK-8348562 ZGC: segmentation fault due to missing node type check in barrier elision analysis
P3 JDK-8347407 [BACKOUT] C1/C2 don't handle allocation failure properly during initialization (RuntimeStub::new_runtime_stub fatal crash)
P3 JDK-8347554 [BACKOUT] C2: implement optimization for series of Add of unique value
P3 JDK-8354443 [Graal] crash after deopt in TestG1BarrierGeneration.java
P3 JDK-8353841 [jittester] Fix JITTester build after asm removal
P3 JDK-8355034 [JVMCI] assert(static_cast(_jvmci_data_size) == align_up(compiler->is_jvmci() ? jvmci_data->size() : 0, oopSize)) failed: failed: 104 != 16777320
P3 JDK-8358183 [JVMCI] crash accessing nmethod::jvmci_name in CodeCache::aggregate
P3 JDK-8348203 [JVMCI] Make eager JVMCI initialization observable in the debugger
P3 JDK-8343158 [JVMCI] ZGC should deoptimize on old gen allocation
P3 JDK-8353274 [PPC64] Bug related to -XX:+UseCompactObjectHeaders -XX:-UseSIGTRAP in JDK-8305895
P3 JDK-8351666 [PPC64] Make non-volatile VectorRegisters available for C2 register allocation
P3 JDK-8358013 [PPC64] VSX has poor performance on Power8
P3 JDK-8332827 [REDO] C2: crash in compiled code because of dependency on removed range check CastIIs
P3 JDK-8355364 [REDO] Missing REX2 prefix accounting in ZGC barriers leads to incorrect encoding
P3 JDK-8360942 [ubsan] aotCache tests trigger runtime error: applying non-zero offset 16 to null pointer in CodeBlob::relocation_end()
P3 JDK-8288981 [Umbrella] C2: Fix issues with Skeleton/Assertion Predicates
P3 JDK-8350258 AArch64: Client build fails after JDK-8347917
P3 JDK-8356085 AArch64: compiler stub buffer size wrongly depends on ZGC
P3 JDK-8356774 AArch64: StubGen final stubs buffer too small for ZGC on Cavium CPU
P3 JDK-8348561 Add aarch64 intrinsics for ML-DSA
P3 JDK-8349721 Add aarch64 intrinsics for ML-KEM
P3 JDK-8351034 Add AVX-512 intrinsics for ML-DSA
P3 JDK-8351412 Add AVX-512 intrinsics for ML-KEM
P3 JDK-8352585 Add special case handling for Float16.max/min x86 backend
P3 JDK-8361101 AOTCodeAddressTable::_stubs_addr not initialized/freed properly
P3 JDK-8359436 AOTCompileEagerly should not be diagnostic
P3 JDK-8362250 ARM32: forward_exception_entry missing return address
P3 JDK-8347997 assert(false) failed: EA: missing memory path
P3 JDK-8348261 assert(n->is_Mem()) failed: memory node required
P3 JDK-8357250 assert(shift >= 0 && shift < 4) failed: unexpected compressd klass shift!
P3 JDK-8354471 Assertion failure with -XX:-EnableX86ECoreOpts
P3 JDK-8358534 Bailout in Conv2B::Ideal when type of cmp input is not supported
P3 JDK-8356182 Build fails on aarch64 without ZGC
P3 JDK-8354941 Build failure with glibc 2.42 due to uabs() name collision
P3 JDK-8353217 Build libsleef on macos-aarch64
P3 JDK-8359646 C1 crash in AOTCodeAddressTable::add_C_string
P3 JDK-8351627 C2 AArch64 ROR/ROL: assert((1 << ((T>>1)+3)) > shift) failed: Invalid Shift value
P3 JDK-8353345 C2 asserts because maskShiftAmount modifies node without deleting the hash
P3 JDK-8348572 C2 compilation asserts due to unexpected irreducible loop
P3 JDK-8350563 C2 compilation fails because PhaseCCP does not reach a fixpoint
P3 JDK-8352681 C2 compilation hits asserts "must set the initial type just once"
P3 JDK-8351392 C2 crash: failed: Expected Bool, but got OpaqueMultiversioning
P3 JDK-8351515 C2 incorrectly removes double negation for double and float
P3 JDK-8351635 C2 ROR/ROL: assert failed: Long constant expected
P3 JDK-8350177 C2 SuperWord: Integer.numberOfLeadingZeros, numberOfTrailingZeros, reverse and bitCount have input types wrongly truncated for byte and short
P3 JDK-8352587 C2 SuperWord: we must avoid Multiversioning for PeelMainPost loops
P3 JDK-8351468 C2: array fill optimization assigns wrong type to intrinsic call
P3 JDK-8347040 C2: assert(!loop->_body.contains(in)) failed
P3 JDK-8347515 C2: assert(!success || (C->macro_count() == (old_macro_count - 1))) failed: elimination must have deleted one node from macro list
P3 JDK-8356453 C2: assert(!vbox->is_Phi()) during vector box expansion
P3 JDK-8346184 C2: assert(has_node(i)) failed during split thru phi
P3 JDK-8359678 C2: assert(static_cast(result) == thing) caused by ReverseBytesNode::Value()
P3 JDK-8351950 C2: AVX512 vector assembler routines causing SIGFPE / no valid evex tuple_table entry
P3 JDK-8356246 C2: Compilation fails with "assert(bol->is_Bool()) failed: unexpected if shape" in StringConcat::eliminate_unneeded_control
P3 JDK-8357105 C2: compilation fails with "assert(false) failed: empty program detected during loop optimization"
P3 JDK-8331717 C2: Crash with SIGFPE Because Loop Predication Wrongly Hoists Division Requiring Zero Check
P3 JDK-8356084 C2: Data is wrongly rewired to Initialized Assertion Predicates instead of Template Assertion Predicates
P3 JDK-8349139 C2: Div looses dependency on condition that guarantees divisor not zero in counted loop
P3 JDK-8350329 C2: Div looses dependency on condition that guarantees divisor not zero in counted loop after peeling
P3 JDK-8335747 C2: fix overflow case for LoopLimit with constant inputs
P3 JDK-8333697 C2: Hit MemLimit in PhaseCFG::global_code_motion
P3 JDK-8347018 C2: Insertion of Assertion Predicates ignores the effects of PhaseIdealLoop::clone_up_backedge_goo()
P3 JDK-8349032 C2: Parse Predicate refactoring in Loop Unswitching broke fix for JDK-8290850
P3 JDK-8355674 C2: Partial Peeling should not introduce Phi nodes above OpaqueInitializedAssertionPredicate nodes
P3 JDK-8353341 C2: removal of a Mod[DF]Node crashes when the node is already dead
P3 JDK-8344251 C2: remove blackholes with dead control input
P3 JDK-8343747 C2: TestReplicateAtConv.java crashes with -XX:MaxVectorSize=8
P3 JDK-8341976 C2: use_mem_state != load->find_exact_control(load->in(0)) assert failure
P3 JDK-8349479 C2: when a Type node becomes dead, make CFG path that uses it unreachable
P3 JDK-8353266 C2: Wrong execution with Integer.bitCount(int) intrinsic on AArch64
P3 JDK-8350840 C2: x64 Assembler::vpcmpeqq assert: failed: XMM register should be 0-15
P3 JDK-8336042 Caller/callee param size mismatch in deoptimization causes crash
P3 JDK-8350609 Cleanup unknown unwind opcode (0xB) for windows
P3 JDK-8356310 compiler/print/TestPrintAssemblyDeoptRace.java fails with Improperly specified VM option 'DeoptimizeALot'
P3 JDK-8350159 compiler/tiered/Level2RecompilationTest.java fails after JDK-8349915
P3 JDK-8347422 Crash during safepoint handler execution with -XX:+UseAPX
P3 JDK-8349921 Crash in codeBuffer.cpp:1004: guarantee(sect->end() <= tend) failed: sanity
P3 JDK-8355230 Crash in fuzzer tests: assert(n != nullptr) failed: must not be null
P3 JDK-8350344 Cross-build failure: _vptr name conflict
P3 JDK-8360776 Disable Intel APX by default and enable it with -XX:+UnlockExperimentalVMOptions -XX:+UseAPX in all builds
P3 JDK-8345826 Do not automatically resolve jdk.internal.vm.ci when libgraal is used
P3 JDK-8356192 Enable AOT code caching only on supported platforms
P3 JDK-8354544 Fix bugs in increment and xor APX codegen
P3 JDK-8359386 Fix incorrect value for max_size of C2CodeStub when APX is used
P3 JDK-8350577 Fix missing Assertion Predicates when splitting loops
P3 JDK-8357982 Fix several failing BMI tests with -XX:+UseAPX
P3 JDK-8351158 Incorrect APX EGPR register save ordering
P3 JDK-8359327 Incorrect AVX3Threshold results into code buffer overflows on APX targets
P3 JDK-8354473 Incorrect results for compress/expand tests with -XX:+EnableX86ECoreOpts
P3 JDK-8359788 Internal Error: assert(get_instanceKlass()->is_loaded()) failed: must be at least loaded
P3 JDK-8361259 JDK25: Backout JDK-8258229
P3 JDK-8352696 JFR: assert(false): EA: missing memory path
P3 JDK-8357782 JVM JIT Causes Static Initialization Order Issue
P3 JDK-8358003 KlassTrainingData initializer reads garbage holder
P3 JDK-8347006 LoadRangeNode floats above array guard in arraycopy intrinsic
P3 JDK-8355896 Lossy narrowing cast of JVMCINMethodData::size
P3 JDK-8353786 Migrate Vector API math library support to FFM API
P3 JDK-8354668 Missing REX2 prefix accounting in ZGC barriers leads to incorrect encoding
P3 JDK-8353041 NeverBranchNode causes incorrect block frequency calculation
P3 JDK-8355094 Performance drop in auto-vectorized kernel due to split store
P3 JDK-8358179 Performance regression in Math.cbrt
P3 JDK-8348638 Performance regression in Math.tanh
P3 JDK-8333393 PhaseCFG::insert_anti_dependences can fail to raise LCAs and to add necessary anti-dependence edges
P3 JDK-8325030 PhaseMacroExpand::value_from_mem_phi assert with "unknown node on this path"
P3 JDK-8350209 Preserve adapters in AOT cache
P3 JDK-8352595 Regression of JDK-8314999 in IR matching
P3 JDK-8354926 Remove remnants of debugging in the fix for JDK-8348561 and JDK-8349721
P3 JDK-8350579 Remove Template Assertion Predicates belonging to a loop once it is folded away
P3 JDK-8346831 Remove the extra closing parenthesis in CTW Makefile
P3 JDK-8358892 RISC-V: jvm crash when running dacapo sunflow after JDK-8352504
P3 JDK-8349102 Test compiler/arguments/TestCodeEntryAlignment.java failed: assert(allocates2(pc)) failed: not in CodeBuffer memory
P3 JDK-8356275 TestCodeEntryAlignment fails with "Alignment must be <= CodeEntryAlignment"
P3 JDK-8343938 TestStressBailout triggers "Should not be locked when freed" assert
P3 JDK-8347718 Unexpected NullPointerException in C2 compiled code due to ReduceAllocationMerges
P3 JDK-8357084 Zero build fails after JDK-8354887
P4 JDK-8346264 "Total compile time" counter should include time spent in failing/bailout compiles
P4 JDK-8348658 [AArch64] The node limit in compiler/codegen/TestMatcherClone.java is too strict
P4 JDK-8358632 [asan] reports heap-buffer-overflow in AOTCodeCache::copy_bytes
P4 JDK-8354181 [Backout] 8334046: Set different values for CompLevel_any and CompLevel_all
P4 JDK-8345609 [C1] LIR Operations with one input should be implemented as LIR_Op1
P4 JDK-8352020 [CompileFramework] enable compilation for VectorAPI
P4 JDK-8342775 [Graal] java/util/concurrent/locks/Lock/OOMEInAQS.java fails OOME thrown from the UncaughtExceptionHandler
P4 JDK-8332980 [IR Framework] Add option to measure IR rule processing time
P4 JDK-8351345 [IR Framework] Improve reported disabled IR verification messages
P4 JDK-8325647 [IR framework] Only prints stdout if exitCode is 134
P4 JDK-8348401 [IR Framework] PrintTimes should not require verbose
P4 JDK-8352597 [IR Framework] test bug: TestNotCompilable.java fails on product build
P4 JDK-8351952 [IR Framework]: allow ignoring methods that are not compilable
P4 JDK-8355387 [jittester] Disable downcasts by default
P4 JDK-8354255 [jittester] Remove TempDir debug output
P4 JDK-8349142 [JMH] compiler.MergeLoadBench.getCharBV fails
P4 JDK-8346954 [JMH] jdk.incubator.vector.MaskedLogicOpts fails due to IndexOutOfBoundsException
P4 JDK-8350614 [JMH] jdk.incubator.vector.VectorCommutativeOperSharingBenchmark fails
P4 JDK-8336760 [JVMCI] -XX:+PrintCompilation should also print "hosted" JVMCI compilations
P4 JDK-8346282 [JVMCI] Add failure reason support to UnresolvedJava/Type/Method/Field
P4 JDK-8357581 [JVMCI] Add HotSpotProfilingInfo
P4 JDK-8357660 [JVMCI] Add support for retrieving all BootstrapMethodInvocations directly from ConstantPool
P4 JDK-8357987 [JVMCI] Add support for retrieving all methods of a ResolvedJavaType
P4 JDK-8350892 [JVMCI] Align ResolvedJavaType.getInstanceFields with Class.getDeclaredFields
P4 JDK-8353735 [JVMCI] Allow specifying storage kind of the callee save register
P4 JDK-8349374 [JVMCI] concurrent use of HotSpotSpeculationLog can crash
P4 JDK-8357506 [JVMCI] Consolidate eager JVMCI initialization code
P4 JDK-8356971 [JVMCI] Export VM_Version::supports_avx512_simd_sort to JVMCI compiler
P4 JDK-8346781 [JVMCI] Limit ServiceLoader to class initializers
P4 JDK-8346825 [JVMCI] Remove NativeImageReinitialize annotation
P4 JDK-8357619 [JVMCI] Revisit phantom_ref parameter in JVMCINMethodData::get_nmethod_mirror
P4 JDK-8351036 [JVMCI] value not an s2: -32776
P4 JDK-8357304 [PPC64] C2: Implement MinV, MaxV and Reduction nodes
P4 JDK-8352065 [PPC64] C2: Implement PopCountVL, CountLeadingZerosV and CountTrailingZerosV nodes
P4 JDK-8348678 [PPC64] C2: unaligned vector load/store is ok
P4 JDK-8350325 [PPC64] ConvF2HFIdealizationTests timeouts on Power8
P4 JDK-8357981 [PPC64] Remove old instructions from VM_Version::determine_features()
P4 JDK-8331859 [PPC64] Remove support for Power7 and older
P4 JDK-8353058 [PPC64] Some IR framework tests are failing after JDK-8352595
P4 JDK-8349727 [PPC] C1: Improve Class.isInstance intrinsic
P4 JDK-8346038 [REDO] - [C1] LIR Operations with one input should be implemented as LIR_Op1
P4 JDK-8347406 [REDO] C1/C2 don't handle allocation failure properly during initialization (RuntimeStub::new_runtime_stub fatal crash)
P4 JDK-8352131 [REDO] C2: Print compilation bailouts with PrintCompilation compile command
P4 JDK-8352963 [REDO] Missing late inline cleanup causes compiler/vectorapi/VectorLogicalOpIdentityTest.java IR failure
P4 JDK-8349686 [s390x] C1: Improve Class.isInstance intrinsic
P4 JDK-8353500 [s390x] Intrinsify Unsafe::setMemory
P4 JDK-8351662 [Test] RISC-V: enable bunch of IR test
P4 JDK-8355293 [TEST] RISC-V: enable more ir tests
P4 JDK-8352615 [Test] RISC-V: TestVectorizationMultiInvar.java fails on riscv64 without rvv support
P4 JDK-8357047 [ubsan] AdapterFingerPrint::AdapterFingerPrint runtime error: index 3 out of bounds
P4 JDK-8346888 [ubsan] block.cpp:1617:30: runtime error: 9.97582e+36 is outside the range of representable values of type 'int'
P4 JDK-8352420 [ubsan] codeBuffer.cpp:984:27: runtime error: applying non-zero offset 18446744073709486080 to null pointer
P4 JDK-8352486 [ubsan] compilationMemoryStatistic.cpp:659:21: runtime error: index 64 out of bounds for type const struct unnamed struct
P4 JDK-8352112 [ubsan] hotspot/share/code/relocInfo.cpp:130:37: runtime error: applying non-zero offset 18446744073709551614 to null pointer
P4 JDK-8352422 [ubsan] Out-of-range reported in ciMethod.cpp:917:20: runtime error: 2.68435e+09 is outside the range of representable values of type 'int'
P4 JDK-8354507 [ubsan] subnode.cpp:406:36: runtime error: negation of -9223372036854775808 cannot be represented in type 'long int'
P4 JDK-8350866 [x86] Add C1 intrinsics for CRC32-C
P4 JDK-8345125 Aarch64: Add aarch64 backend for Float16 scalar operations
P4 JDK-8355585 Aarch64: Add aarch64 backend for Float16 vector operations
P4 JDK-8349522 AArch64: Add backend implementation for new unsigned and saturating vector operations
P4 JDK-8350463 AArch64: Add vector rearrange support for small lane count vectors
P4 JDK-8347917 AArch64: Enable upper GPR registers in C1
P4 JDK-8350663 AArch64: Enable UseSignumIntrinsic by default
P4 JDK-8354674 AArch64: Intrinsify Unsafe::setMemory
P4 JDK-8348659 AArch64: IR rule failure with compiler/loopopts/superword/TestSplitPacks.java
P4 JDK-8356095 AArch64: Obsolete -XX:+NearCPool option
P4 JDK-8337666 AArch64: SHA3 GPR intrinsic
P4 JDK-8350483 AArch64: turn on signum intrinsics by default on Ampere CPUs
P4 JDK-8346890 AArch64: Type profile counters generate suboptimal code
P4 JDK-8345225 AARCH64: VM crashes with -NearCpool +UseShenandoahGC options
P4 JDK-8355233 Add a DMB related benchmark
P4 JDK-8334717 Add JVMCI support for APX EGPRs
P4 JDK-8346777 Add missing const declarations and rename variables
P4 JDK-8354284 Add more compiler test folders to tier1 runs
P4 JDK-8355488 Add stress mode for C2 loop peeling
P4 JDK-8352418 Add verification code to check that the associated loop nodes of useless Template Assertion Predicates are dead
P4 JDK-8349582 APX NDD code generation for OpenJDK
P4 JDK-8358330 AsmRemarks and DbgStrings clear() method may not get called before their destructor
P4 JDK-8352317 Assertion failure during size estimation of BoxLockNode with -XX:+UseAPX
P4 JDK-8355739 AssertionError: Invalid CPU feature name after 8353786
P4 JDK-8346236 Auto vectorization support for various Float16 operations
P4 JDK-8356000 C1/C2-only modes use 2 compiler threads on low CPU count machines
P4 JDK-8351155 C1/C2: Remove 32-bit x86 specific FP rounding support
P4 JDK-8353188 C1: Clean up x86 backend after 32-bit x86 removal
P4 JDK-8337251 C1: Improve Class.isInstance intrinsic
P4 JDK-8348186 C1: Purge fpu_stack_size infrastructure
P4 JDK-8351156 C1: Remove FPU stack support after 32-bit x86 removal
P4 JDK-8353176 C1: x86 patching stub always calls Thread::current()
P4 JDK-8342103 C2 compiler support for Float16 type and associated scalar operations
P4 JDK-8345766 C2 should emit macro nodes for ModF/ModD instead of calls during parsing
P4 JDK-8323582 C2 SuperWord AlignVector: misaligned vector memory access with unaligned native memory
P4 JDK-8350756 C2 SuperWord Multiversioning: remove useless slow loop when the fast loop disappears
P4 JDK-8357530 C2 SuperWord: Diagnostic flag AutoVectorizationOverrideProfitability
P4 JDK-8354477 C2 SuperWord: make use of memory edges more explicit
P4 JDK-8346993 C2 SuperWord: refactor to make more vector nodes available in VectorNode::make
P4 JDK-8343685 C2 SuperWord: refactor VPointer with MemPointer
P4 JDK-8348263 C2 SuperWord: TestMemorySegment.java has failing IR rules with AlignVector after JDK-8343685
P4 JDK-8320909 C2: Adapt IGVN's enqueuing logic to match idealization of AndNode with LShift operand
P4 JDK-8345156 C2: Add bailouts next to a few asserts
P4 JDK-8355970 C2: Add command line option to print the compile phases
P4 JDK-8353842 C2: Add graph dumps before and after loop opts phase
P4 JDK-8346552 C2: Add IR tests to check that Predicate cloning in Loop Unswitching works as expected
P4 JDK-8332268 C2: Add missing optimizations for UDivI/L and UModI/L and unify the shared logic with the signed nodes
P4 JDK-8336906 C2: assert(bb->is_reachable()) failed: getting result from unreachable basicblock
P4 JDK-8344130 C2: Avoid excessive hoisting in scheduler due to minuscule differences in block frequency
P4 JDK-8345801 C2: Clean up include statements to speed up compilation when touching type.hpp
P4 JDK-8347563 C2: clean up ModRefBarrierSetC2
P4 JDK-8353192 C2: Clean up x86 backend after 32-bit x86 removal
P4 JDK-8335708 C2: Compile::verify_graph_edges must start at root and safepoints, just like CCP traversal
P4 JDK-8353551 C2: Constant folding for ReverseBytes nodes
P4 JDK-8346989 C2: deoptimization and re-execution cycle with Math.*Exact in case of frequent overflow
P4 JDK-8353638 C2: deoptimization and re-execution cycle with StringBuilder
P4 JDK-8356647 C2: Excessively strict assert in PhaseIdealLoop::do_unroll
P4 JDK-8350485 C2: factor out common code in Node::grow() and Node::out_grow()
P4 JDK-8346280 C2: implement late barrier elision for G1
P4 JDK-8307513 C2: intrinsify Math.max(long,long) and Math.min(long,long)
P4 JDK-8345287 C2: live in computation is broken
P4 JDK-8351414 C2: MergeStores must happen after RangeCheck smearing
P4 JDK-8347459 C2: missing transformation for chain of shifts/multiplications by constants
P4 JDK-8330851 C2: More efficient TypeFunc creation
P4 JDK-8341696 C2: Non-fluid StringBuilder pattern bails out in OptoStringConcat
P4 JDK-8346664 C2: Optimize mask check with constant offset
P4 JDK-8353359 C2: Or(I|L)Node::Ideal is missing AddNode::Ideal call
P4 JDK-8352893 C2: OrL/INode::add_ring optimize (x | -1) to -1
P4 JDK-8351938 C2: Print compilation bailouts with PrintCompilation compile command
P4 JDK-8343148 C2: Refactor uses of "PhaseValue::*con*() + PhaseIdealLoop::set_ctrl()" into separate method
P4 JDK-8330469 C2: Remove or change "PrintOpto && VerifyLoopOptimizations" as printing code condition
P4 JDK-8348411 C2: Remove the control input of LoadKlassNode and LoadNKlassNode
P4 JDK-8347481 C2: Remove the control input of some nodes
P4 JDK-8348172 C2: Remove unused local variables in filter_helper() methods
P4 JDK-8352620 C2: rename MemNode::memory_type() to MemNode::value_basic_type()
P4 JDK-8349361 C2: RShiftL should support all applicable transformations that RShiftI does
P4 JDK-8343607 C2: Shenandoah crashes during barrier expansion in Continuation::enter
P4 JDK-8345299 C2: some nodes can still have incorrect control after do_range_check()
P4 JDK-8347449 C2: UseLoopPredicate off should also turn UseProfiledLoopPredicate off
P4 JDK-8346836 C2: Verify CastII/CastLL bounds at runtime
P4 JDK-8347645 C2: XOR bounded value handling blocks constant folding
P4 JDK-8356447 Change default for EagerJVMCI to true
P4 JDK-8352248 Check if CMoveX is supported
P4 JDK-8345471 Clean up compiler/intrinsics/sha/cli tests
P4 JDK-8351162 Clean up x86 (Macro)Assembler after 32-bit x86 removal
P4 JDK-8355473 Clean up x86 globals/VM_Version after 32-bit x86 removal
P4 JDK-8355472 Clean up x86 nativeInst after 32-bit x86 removal
P4 JDK-8354542 Clean up x86 stubs after 32-bit x86 removal
P4 JDK-8344171 Clone and initialize Assertion Predicates in order instead of in reverse-order
P4 JDK-8354625 Compile::igv_print_graph_to_network doesn't use its second parameter
P4 JDK-8356778 Compiler add event logging in case of failures
P4 JDK-8349559 Compiler interface doesn't need to store protection domain
P4 JDK-8349193 compiler/intrinsics/TestContinuationPinningAndEA.java missing @requires vm.continuations
P4 JDK-8348657 compiler/loopopts/superword/TestEquivalentInvariants.java timed out
P4 JDK-8358129 compiler/startup/StartupOutput.java runs into out of memory on Windows after JDK-8347406
P4 JDK-8356783 CompilerTask hot_method is redundant
P4 JDK-8346289 Confusing phrasing in IR Framework README / User-defined Regexes
P4 JDK-8350988 Consolidate Identity of self-inverse operations
P4 JDK-8258229 Crash in nmethod::reloc_string_for
P4 JDK-8344802 Crash in StubRoutines::verify_mxcsr with -XX:+EnableX86ECoreOpts and -Xcheck:jni
P4 JDK-8348887 Create IR framework test for JDK-8347997
P4 JDK-8350211 CTW: Attempt to preload all classes in constant pool
P4 JDK-8348570 CTW: Expose the code hidden by uncommon traps
P4 JDK-8344833 CTW: Make failing on zero classes optional
P4 JDK-8356702 CTW: Update modules
P4 JDK-8350210 CTW: Use stackless exceptions
P4 JDK-8349088 De-virtualize Codeblob and nmethod
P4 JDK-8357781 Deep recursion in PhaseCFG::set_next_call leads to stack overflow
P4 JDK-8355635 Do not collect C strings in C2 scratch buffer
P4 JDK-8356885 Don't emit C1 profiling for casts if TypeProfileCasts is off
P4 JDK-8345435 Eliminate tier1_compiler_not_xcomp group
P4 JDK-8351994 Enable Extended EVEX to REX2/REX demotion when src and dst are the same
P4 JDK-8357481 Excessive CompileTask wait/notify monitor creation
P4 JDK-8357370 Export supported GCs in JVMCI
P4 JDK-8357175 Failure to generate or load AOT code should be handled gracefully
P4 JDK-8352490 Fatal error message for unhandled bytecode needs more detail
P4 JDK-8345492 Fix -Wzero-as-null-pointer-constant warnings in adlc code
P4 JDK-8345269 Fix -Wzero-as-null-pointer-constant warnings in ppc code
P4 JDK-8345273 Fix -Wzero-as-null-pointer-constant warnings in s390 code
P4 JDK-8350956 Fix repetitions of the word "the" in compiler component comments
P4 JDK-8346787 Fix two C2 IR matching tests for RISC-V
P4 JDK-8346107 Generators: testing utility for random value generation
P4 JDK-8343468 GenShen: Enable relocation of remembered set card tables
P4 JDK-8358339 Handle MethodCounters::_method backlinks after JDK-8355003
P4 JDK-8356172 IdealGraphPrinter doesn't need ThreadCritical
P4 JDK-8357649 IGV: add block index to the supplemental node properties
P4 JDK-8354930 IGV: dump C2 graph before and after live range stretching
P4 JDK-8354520 IGV: dump contextual information
P4 JDK-8353669 IGV: dump OOP maps for MachSafePoint nodes
P4 JDK-8345041 IGV: Free Placement Mode in IGV Layout
P4 JDK-8282053 IGV: refine schedule approximation
P4 JDK-8350006 IGV: show memory slices as type information
P4 JDK-8357568 IGV: Show NULL and numbers up to 4 characters in "Condense graph" filter
P4 JDK-8346607 IGV: Support drag-and-drop for opening graph files
P4 JDK-8348645 IGV: visualize live ranges
P4 JDK-8355003 Implement JEP 515: Ahead-of-Time Method Profiling
P4 JDK-8350852 Implement JMH benchmark for sparse CodeCache
P4 JDK-8344009 Improve compiler memory statistics
P4 JDK-8346194 Improve G1 pre-barrier C2 cost estimate
P4 JDK-8341781 Improve Min/Max node identities
P4 JDK-8351256 Improve printing of runtime call stub names in disassember output
P4 JDK-8351568 Improve source code documentation for PhaseCFG::insert_anti_dependences
P4 JDK-8353216 Improve VerifyMethodHandles for method handle linkers
P4 JDK-8346007 Incorrect copyright header in UModLNodeIdealizationTests.java
P4 JDK-8355616 Incorrect ifdef in compilationMemoryStatistic.cpp
P4 JDK-8349753 Incorrect use of CodeBlob::is_buffer_blob() in few places
P4 JDK-8350086 Inline hot Method accessors for faster task selection
P4 JDK-8350585 InlineSecondarySupersTest must be guarded on ppc64 by COMPILER2
P4 JDK-8347426 Invalid value used for enum Cell in iTypeFlow::StateVector::meet_exception
P4 JDK-8314999 IR framework fails to detect allocation
P4 JDK-8352617 IR framework test TestCompileCommandFileWriter.java runs TestCompilePhaseCollector instead of itself
P4 JDK-8357135 java.lang.OutOfMemoryError: Error creating or attaching to libjvmci after JDK-8356447
P4 JDK-8325147 JEP 515: Ahead-of-Time Method Profiling
P4 JDK-8349579 jsvml.dll incorrect RDATA SEGMENT specification
P4 JDK-8347706 jvmciEnv.cpp has jvmci includes out of order
P4 JDK-8350263 JvmciNotifyBootstrapFinishedEventTest intermittently times out
P4 JDK-8349977 JVMCIRuntime::_shared_library_javavm_id should be jlong
P4 JDK-8350194 Last 2 parameters of ReturnNode::ReturnNode are swapped in the declaration
P4 JDK-8356259 Lift basic -Xlog:jit* logging to "info" level
P4 JDK-8346567 Make Class.getModifiers() non-native
P4 JDK-8351280 Mark Assertion Predicates useless instead of replacing them by a constant directly
P4 JDK-8347405 MergeStores with reverse bytes order value
P4 JDK-8353593 MethodData "mileage_*" methods and fields aren't used and can be removed
P4 JDK-8354119 Missing C2 proper allocation failure handling during initialization (during generate_uncommon_trap_blob)
P4 JDK-8302459 Missing late inline cleanup causes compiler/vectorapi/VectorLogicalOpIdentityTest.java IR failure
P4 JDK-8352591 Missing UnlockDiagnosticVMOptions in VerifyGraphEdgesWithDeadCodeCheckFromSafepoints test
P4 JDK-8350459 MontgomeryIntegerPolynomialP256 multiply intrinsic with AVX2 on x86_64
P4 JDK-8343629 More MergeStore benchmark
P4 JDK-8343789 Move mutable nmethod data out of CodeCache
P4 JDK-8346965 Multiple compiler/ciReplay test fails with -XX:+SegmentedCodeCache
P4 JDK-8357143 New test AOTCodeCompressedOopsTest.java fails on platforms without AOT Code Cache support
P4 JDK-8350683 Non-C2 / minimal JVM crashes in the build on ppc64 platforms
P4 JDK-8323497 On x64, use 32-bit immediate moves for narrow klass base if possible
P4 JDK-8355769 Optimize nmethod dependency recording
P4 JDK-8317976 Optimize SIMD sort for AMD Zen 4
P4 JDK-8357600 Patch nmethod flushing message to include more details
P4 JDK-8216437 PPC64: Add intrinsic for GHASH algorithm
P4 JDK-8352972 PPC64: Intrinsify Unsafe::setMemory
P4 JDK-8354887 Preserve runtime blobs in AOT code cache
P4 JDK-8349858 Print compilation task before blocking compiler thread for shutdown
P4 JDK-8351640 Print reason for making method not entrant
P4 JDK-8342393 Promote commutative vector IR node sharing
P4 JDK-8342651 Refactor array constant to use an array of jbyte
P4 JDK-8350578 Refactor useless Parse and Template Assertion Predicate elimination code by using a PredicateVisitor
P4 JDK-8349937 Regression ~10% on Renaissance-ScalaKmeans in 25-b2
P4 JDK-8352426 RelocIterator should correctly handle nullptr address of relocation data
P4 JDK-8345746 Remove :resourcehogs/compiler from :hotspot_slow_compiler
P4 JDK-8351700 Remove code conditional on BarrierSetNMethod being null
P4 JDK-8345580 Remove const from Node::_idx which is modified
P4 JDK-8348367 Remove hotspot_not_fast_compiler and hotspot_slow_compiler test groups
P4 JDK-8349180 Remove redundant initialization in ciField constructor
P4 JDK-8354254 Remove the linux ppc64 -minsert-sched-nops=regroup_exact compile flag
P4 JDK-8346931 Replace divisions by zero in sharedRuntimeTrans.cpp
P4 JDK-8344035 Replace predicate walking code in Loop Unswitching with a predicate visitor
P4 JDK-8347721 Replace SIZE_FORMAT in compiler directories
P4 JDK-8349428 RISC-V: "bad alignment" with -XX:-AvoidUnalignedAccesses after JDK-8347489
P4 JDK-8355667 RISC-V: Add backend implementation for unsigned vector Min / Max operations
P4 JDK-8352159 RISC-V: add more zfa support
P4 JDK-8345298 RISC-V: Add riscv backend for Float16 operations - scalar
P4 JDK-8350960 RISC-V: Add riscv backend for Float16 operations - vectorization
P4 JDK-8351861 RISC-V: add simple assert at arrays_equals_v
P4 JDK-8347981 RISC-V: Add Zfa zli imm loads
P4 JDK-8349632 RISC-V: Add Zfa fminm/fmaxm
P4 JDK-8349764 RISC-V: C1: Improve Class.isInstance intrinsic
P4 JDK-8321003 RISC-V: C2 MulReductionVI
P4 JDK-8321004 RISC-V: C2 MulReductionVL
P4 JDK-8318220 RISC-V: C2 ReverseI
P4 JDK-8318221 RISC-V: C2 ReverseL
P4 JDK-8320997 RISC-V: C2 ReverseV
P4 JDK-8349908 RISC-V: C2 SelectFromTwoVector
P4 JDK-8351101 RISC-V: C2: Small improvement to MacroAssembler::revb
P4 JDK-8355074 RISC-V: C2: Support Vector-Scalar version of Zvbb Vector And-Not instruction
P4 JDK-8329887 RISC-V: C2: Support Zvbb Vector And-Not instruction
P4 JDK-8354815 RISC-V: Change type of bitwise rotation shift to iRegIorL2I
P4 JDK-8356924 RISC-V: Clean up cost for vector instructions
P4 JDK-8351949 RISC-V: Cleanup and enable store-load peephole for membars
P4 JDK-8347352 RISC-V: Cleanup bitwise AND assembler routines
P4 JDK-8356188 RISC-V: Cleanup effect of vmaskcmp_fp
P4 JDK-8355562 RISC-V: Cleanup names of vector-scalar instructions in riscv_v.ad
P4 JDK-8346868 RISC-V: compiler/sharedstubs tests fail after JDK-8332689
P4 JDK-8355796 RISC-V: compiler/vectorapi/AllBitsSetVectorMatchRuleTest.java fails after JDK-8355657
P4 JDK-8353600 RISC-V: compiler/vectorization/TestRotateByteAndShortVector.java is failing with Zvbb
P4 JDK-8359045 RISC-V: construct test to verify invocation of C2_MacroAssembler::enc_cmove_cmp_fp => BoolTest::ge/gt
P4 JDK-8339910 RISC-V: crc32 intrinsic with carry-less multiplication
P4 JDK-8356700 RISC-V: Declare incompressible scope in fill_words / zero_memory assembler routines
P4 JDK-8355239 RISC-V: Do not support subword scatter store
P4 JDK-8356030 RISC-V: enable (part of) BasicDoubleOpTest.java
P4 JDK-8351876 RISC-V: enable and fix some float round tests
P4 JDK-8356642 RISC-V: enable hotspot/jtreg/compiler/vectorapi/VectorFusedMultiplyAddSubTest.java
P4 JDK-8352529 RISC-V: enable loopopts tests
P4 JDK-8349666 RISC-V: enable superwords tests for vector reductions
P4 JDK-8355704 RISC-V: enable TestIRFma.java
P4 JDK-8356875 RISC-V: extension flag UseZvfh should depends on UseZfh
P4 JDK-8351839 RISC-V: Fix base offset calculation introduced in JDK-8347489
P4 JDK-8353219 RISC-V: Fix client builds after JDK-8345298
P4 JDK-8352504 RISC-V: implement and enable CMoveI/L
P4 JDK-8355913 RISC-V: improve hotspot/jtreg/compiler/vectorization/runner/BasicFloatOpTest.java
P4 JDK-8355657 RISC-V: Improve PrintOptoAssembly output of vector-scalar instructions
P4 JDK-8356869 RISC-V: Improve tail handling of array fill stub
P4 JDK-8349556 RISC-V: improve the performance when -COH and -AvoidUnalignedAccesses for UL and LU string comparison
P4 JDK-8351140 RISC-V: Intrinsify Unsafe::setMemory
P4 JDK-8353665 RISC-V: IR verification fails in TestSubNodeFloatDoubleNegation.java
P4 JDK-8350093 RISC-V: java/math/BigInteger/LargeValueExceptions.java timeout with COH
P4 JDK-8355878 RISC-V: jdk/incubator/vector/DoubleMaxVectorTests.java fails when using RVV
P4 JDK-8355668 RISC-V: jdk/incubator/vector/Int256VectorTests.java fails when using RVV
P4 JDK-8347489 RISC-V: Misaligned memory access with COH
P4 JDK-8351145 RISC-V: only enable some crypto intrinsic when AvoidUnalignedAccess == false
P4 JDK-8357460 RISC-V: Optimize array fill stub for small size
P4 JDK-8346235 RISC-V: Optimize bitwise AND with mask values
P4 JDK-8350855 RISC-V: print offset by assert of patch_offset_in_conditional_branch
P4 JDK-8352477 RISC-V: Print warnings when unsupported intrinsics are enabled
P4 JDK-8346786 RISC-V: Reconsider ConditionalMoveLimit when adding conditional move
P4 JDK-8346478 RISC-V: Refactor add/sub assembler routines
P4 JDK-8350095 RISC-V: Refactor string_compare
P4 JDK-8350480 RISC-V: Relax assertion about registers in C2_MacroAssembler::minmax_fp
P4 JDK-8355654 RISC-V: Relax register constraint for some vector-scalar instructions
P4 JDK-8350940 RISC-V: remove unnecessary assert_different_registers in minmax_fp
P4 JDK-8350931 RISC-V: remove unnecessary src register for fp_sqrt_d/f
P4 JDK-8355980 RISC-V: remove vmclr_m before vmsXX and vmfXX
P4 JDK-8342881 RISC-V: secondary_super_cache does not scale well: C1 and interpreter
P4 JDK-8351902 RISC-V: Several tests fail after JDK-8351145
P4 JDK-8352423 RISC-V: simplify DivI/L ModI/L
P4 JDK-8346475 RISC-V: Small improvement for MacroAssembler::ctzc_bit
P4 JDK-8356593 RISC-V: Small improvement to array fill stub
P4 JDK-8355699 RISC-V: support SUADD/SADD/SUSUB/SSUB
P4 JDK-8352022 RISC-V: Support Zfa fminm_h/fmaxm_h for float16
P4 JDK-8351033 RISC-V: TestFloat16ScalarOperations asserts with offset (4210) is too large to be patched in one beq/bge/bgeu/blt/bltu/bne instruction!
P4 JDK-8352607 RISC-V: use cmove in min/max when Zicond is supported
P4 JDK-8355476 RISC-V: using zext_w directly in vector_update_crc32 could trigger assert
P4 JDK-8345159 RISCV: Fix -Wzero-as-null-pointer-constant warning in emit_static_call_stub
P4 JDK-8334046 Set different values for CompLevel_any and CompLevel_all
P4 JDK-8339889 Several compiler tests ignore vm flags and not marked as flagless
P4 JDK-8356153 Shenandoah stubs are missing in AOT Code Cache addresses table
P4 JDK-8358169 Shenandoah/JVMCI: Export GC state constants
P4 JDK-8345661 Simplify page size alignment in code heap reservation
P4 JDK-8356328 Some C2 IR nodes miss size_of() function
P4 JDK-8351958 Some compile commands should be made diagnostic
P4 JDK-8344951 Stabilize write barrier micro-benchmarks
P4 JDK-8352675 Support Intel AVX10 converged vector ISA feature detection
P4 JDK-8356075 Support Shenandoah GC in JVMCI
P4 JDK-8344942 Template-Based Testing Framework
P4 JDK-8349820 Temporarily increase MemLimit for tests until JDK-8349772 and JDK-8337821 are fixed
P4 JDK-8349040 Test compiler/inlining/LateInlinePrinting.java fails after JDK-8319850
P4 JDK-8355512 Test compiler/vectorization/TestVectorZeroCount.java times out with -XX:TieredStopAtLevel=3
P4 JDK-8354767 Test crashed: assert(increase < max_live_nodes_increase_per_iteration) failed: excessive live node increase in single iteration of IGVN: 4470 (should be at most 4000)
P4 JDK-8350386 Test TestCodeCacheFull.java fails with option -XX:-UseCodeCacheFlushing
P4 JDK-8343906 test2 of compiler/c2/TestCastX2NotProcessedIGVN.java fails on some platforms
P4 JDK-8350383 Test: add more test case for string compare (UL case)
P4 JDK-8353730 TestSubNodeFloatDoubleNegation.java fails with native Float16 support
P4 JDK-8352512 TestVectorZeroCount: counter not reset between iterations
P4 JDK-8345700 tier{1,2,3}_compiler don't cover all compiler tests
P4 JDK-8354572 Turn off AlwaysMergeDMB for Ampere CPU by default
P4 JDK-8355708 Two Float16 IR tests fail after JDK-8345125
P4 JDK-8332368 ubsan aarch64: immediate_aarch64.cpp:298:31: runtime error: shift exponent 32 is too large for 32-bit type 'int'
P4 JDK-8338194 ubsan: mulnode.cpp:862:59: runtime error: shift exponent 64 is too large for 64-bit type 'long unsigned int'
P4 JDK-8344026 Ubsan: prevent potential integer overflow in c1_LIRGenerator_.cpp file
P4 JDK-8351833 Unexpected increase in live nodes when splitting Phis through MergeMems in PhiNode::Ideal
P4 JDK-8350471 Unhandled compilation bailout in GraphKit::builtin_throw
P4 JDK-8342676 Unsigned Vector Min / Max transforms
P4 JDK-8349523 Unused runtime calls to drem/frem should be removed
P4 JDK-8350516 Update model numbers for ECore-based cpus
P4 JDK-8343978 Update the default value of CodeEntryAlignment for Ampere-1A and 1B
P4 JDK-8346774 Use Predicate classes instead of Node classes
P4 JDK-8358333 Use VEX2 prefix in Assembler::psllq
P4 JDK-8352724 Verify bounds for primitive array reads in JVMCI
P4 JDK-8352869 Verify.checkEQ: extension for NaN, VectorAPI and arbitrary Objects
P4 JDK-8346106 Verify.checkEQ: testing utility for recursive value verification
P4 JDK-8349927 Waiting for compiler termination delays shutdown for 10+ ms
P4 JDK-8355689 Wrong native entry name for FloatMaxVector vector math stubs with -XX:MaxVectorSize=8
P4 JDK-8353572 x86: AMD platforms miss the check for CLWB feature flag
P4 JDK-8354231 x86: Purge FPU support from (Macro)Assembler after 32-bit x86 removal
P4 JDK-8353558 x86: Use better instructions for ICache sync when available
P4 JDK-8357267 ZGC: Handle APX EGPRs spilling in ZRuntimeCallSpill
P5 JDK-8350197 [UBSAN] Node::dump_idx reported float-cast-overflow
P5 JDK-8350178 Incorrect comment after JDK-8345580
P5 JDK-8358230 Incorrect location for the assert for blob != nullptr in CodeBlob::create
P5 JDK-8355492 MissedOptCastII is missing UnlockDiagnosticVMOptions flag
P5 JDK-8319850 PrintInlining should print which methods are late inlines
P5 JDK-8356648 runtime/Thread/AsyncExceptionTest.java fails with +StressCompiledExceptionHandlers
P5 JDK-8352866 TestLogJIT.java runs wrong test class
P5 JDK-8346288 WB_IsIntrinsicAvailable fails if called with wrong compilation level

hotspot/gc

Priority Bug Summary
P2 JDK-8352584 [Backout] G1: Pinned regions with pinned objects only reachable by native code crash VM
P2 JDK-8352508 [Redo] G1: Pinned regions with pinned objects only reachable by native code crash VM
P2 JDK-8351456 Build failure with --disable-jvm-feature-shenandoahgc after 8343468
P2 JDK-8352116 Deadlock with GCLocker and JVMTI after JDK-8192647
P2 JDK-8351921 G1: Pinned regions with pinned objects only reachable by native code crash VM
P2 JDK-8349688 G1: Wrong initial optional region index when selecting candidates from retained regions
P2 JDK-8334513 New test gc/TestAlwaysPreTouchBehavior.java is failing on MacOS aarch64
P2 JDK-8354517 Parallel: JDK-8339668 causes up to 3.7x slowdown in openjdk.bench.vm.gc.systemgc
P2 JDK-8345970 pthread_getcpuclockid related crashes in shenandoah tests
P2 JDK-8360679 Shenandoah: AOT saved adapter calls into broken GC barrier stub
P2 JDK-8347564 ZGC: Crash in DependencyContext::clean_unloading_dependents
P2 JDK-8353637 ZGC: Discontiguous memory reservation is broken on Windows
P3 JDK-8346971 [ubsan] psCardTable.cpp:131:24: runtime error: large index is out of bounds
P3 JDK-8360775 Fix Shenandoah GC test failures when APX is enabled
P3 JDK-8351405 G1: Collection set early pruning causes suboptimal region selection
P3 JDK-8351500 G1: NUMA migrations cause crashes in region allocation
P3 JDK-8334759 gc/g1/TestMixedGCLiveThreshold.java fails on Windows with JTREG_TEST_THREAD_FACTORY=Virtual due to extra memory allocation
P3 JDK-8192647 GClocker induced GCs can starve threads requiring memory leading to OOME
P3 JDK-8357976 GenShen crash in swap_card_tables: Should be clean
P3 JDK-8357550 GenShen crashes during freeze: assert(!chunk->requires_barriers()) failed
P3 JDK-8348400 GenShen: assert(ShenandoahHeap::heap()->is_full_gc_in_progress() || (used_regions_size() <= _max_capacity)) failed: Cannot use more than capacity #
P3 JDK-8345399 GenShen: Error: Verify init-mark remembered set violation; clean card should be dirty
P3 JDK-8361529 GenShen: Fix bad assert in swap card tables
P3 JDK-8346737 GenShen: Generational memory pools should not report zero for maximum capacity
P3 JDK-8355336 GenShen: Resume Old GC even with back-to-back Young GC triggers
P3 JDK-8345323 Parallel GC does not handle UseLargePages and UseNUMA gracefully
P3 JDK-8360288 Shenandoah crash at size_given_klass in op_degenerated
P3 JDK-8348092 Shenandoah: assert(nk >= _lowest_valid_narrow_klass_id && nk <= _highest_valid_narrow_klass_id) failed: narrowKlass ID out of range (3131947710)
P3 JDK-8351464 Shenandoah: Hang on ShenandoahController::handle_alloc_failure when run test TestAllocHumongousFragment#generational
P3 JDK-8352185 Shenandoah: Invalid logic for remembered set verification
P3 JDK-8345750 Shenandoah: Test TestJcmdHeapDump.java#aggressive intermittent assert(gc_cause() == GCCause::_no_gc) failed: Over-writing cause
P3 JDK-8348268 Test gc/shenandoah/TestResizeTLAB.java#compact: fatal error: Before Updating References: Thread C2 CompilerThread1: expected gc-state 9, actual 21
P3 JDK-8353184 ZGC: Simplify and correct tlab_used() tracking
P3 JDK-8347337 ZGC: String dedups short-lived strings
P4 JDK-8314840 3 gc/epsilon tests ignore external vm options
P4 JDK-8357155 [asan] ZGC does not work (x86_64 and ppc64)
P4 JDK-8346713 [testsuite] NeverActAsServerClassMachine breaks TestPLABAdaptToMinTLABSize.java TestPinnedHumongousFragmentation.java TestPinnedObjectContents.java
P4 JDK-8354428 [ubsan] g1BiasedArray.hpp: pointer overflow in address calculation
P4 JDK-8350605 assert(!heap->is_uncommit_in_progress()) failed: Cannot uncommit bitmaps while resetting them
P4 JDK-8276995 Bug in jdk.jfr.event.gc.collection.TestSystemGC
P4 JDK-8346572 Check is_reserved() before using ReservedSpace instances
P4 JDK-8351157 Clean up x86 GC barriers after 32-bit x86 removal
P4 JDK-8347256 Epsilon: Demote heap size and AlwaysPreTouch warnings to info level
P4 JDK-8345659 Fix broken alignment after ReservedSpace splitting in GC code
P4 JDK-8346008 Fix recent NULL usage backsliding in Shenandoah
P4 JDK-8350954 Fix repetitions of the word "the" in gc component comments
P4 JDK-8333578 Fix uses of overaligned types induced by ZCACHE_ALIGNED
P4 JDK-8358104 Fix ZGC compilation error on GCC 10.2
P4 JDK-8308854 G1 archive region allocation may expand/shrink the heap above/below -Xms
P4 JDK-8271871 G1 does not try to deduplicate objects that failed evacuation
P4 JDK-8271870 G1: Add objArray splitting when scanning object with evacuation failure
P4 JDK-8357621 G1: Clean up G1BiasedArray
P4 JDK-8349213 G1: Clearing bitmaps during collection set merging not claimed by region
P4 JDK-8355743 G1: Collection set clearing is not recorded as part of "Free Collection Set Time"
P4 JDK-8349906 G1: Improve initial survivor rate for newly used young regions
P4 JDK-8350643 G1: Make loop iteration variable type correspond to limit in G1SurvRateGroup
P4 JDK-8357954 G1: No SATB barriers applied for runtime IN_NATIVE atomics
P4 JDK-8346568 G1: Other time can be negative
P4 JDK-8358313 G1: Refactor G1CollectedHeap::is_maximal_no_gc
P4 JDK-8357306 G1: Remove _gc_succeeded from VM_G1CollectForAllocation because it is always true
P4 JDK-8352138 G1: Remove G1AddMetaspaceDependency.java test
P4 JDK-8357218 G1: Remove loop in G1CollectedHeap::try_collect_fullgc
P4 JDK-8352147 G1: TestEagerReclaimHumongousRegionsClearMarkBits test takes very long
P4 JDK-8350758 G1: Use actual last prediction in accumulated survivor rate prediction too
P4 JDK-8343782 G1: Use one G1CardSet instance for multiple old gen regions
P4 JDK-8354145 G1: UseCompressedOops boundary is calculated on maximum heap region size instead of maxiumum ergonomic heap region size
P4 JDK-8352765 G1CollectedHeap::expand_and_allocate() may fail to allocate even after heap expansion succeeds
P4 JDK-8355681 G1HeapRegionManager::find_contiguous_allow_expand ignores free regions when checking regions available for allocation
P4 JDK-8355756 G1HeapSizingPolicy::full_collection_resize_amount should consider allocation size
P4 JDK-8349783 g1RemSetSummary.cpp:344:68: runtime error: member call on null pointer of type 'struct G1HeapRegion'
P4 JDK-8354559 gc/g1/TestAllocationFailure.java doesn't need WB API
P4 JDK-8354431 gc/logging/TestGCId fails on Shenandoah
P4 JDK-8357503 gcbasher fails with java.lang.IllegalArgumentException: Unknown constant pool type
P4 JDK-8358102 GenShen: Age tables could be seeded with cumulative values
P4 JDK-8352091 GenShen: assert(!(request.generation->is_old() && _heap->old_generation()->is_doing_mixed_evacuations())) failed: Old heuristic should not request cycles while it waits for mixed evacuation
P4 JDK-8355789 GenShen: assert(_degen_point == ShenandoahGC::_degenerated_unset) failed: Should not be set yet: Outside of Cycle
P4 JDK-8349766 GenShen: Bad progress after degen does not always need full gc
P4 JDK-8350889 GenShen: Break out of infinite loop of old GC cycles
P4 JDK-8347804 GenShen: Crash with small GCCardSizeInBytes and small Java heap
P4 JDK-8349002 GenShen: Deadlock during shutdown
P4 JDK-8356667 GenShen: Eliminate races with ShenandoahFreeSet::available()
P4 JDK-8352588 GenShen: Enabling JFR asserts when getting GCId
P4 JDK-8348595 GenShen: Fix generational free-memory no-progress check
P4 JDK-8346688 GenShen: Missing metadata trigger log message
P4 JDK-8352428 GenShen: Old-gen cycles are still looping
P4 JDK-8349094 GenShen: Race between control and regulator threads may violate assertions
P4 JDK-8355340 GenShen: Remove unneeded log messages related to remembered set write table
P4 JDK-8344593 GenShen: Review of ReduceInitialCardMarks
P4 JDK-8355372 GenShen: Test gc/shenandoah/generational/TestOldGrowthTriggers.java fails with UseCompactObjectHeaders enabled
P4 JDK-8353596 GenShen: Test TestClone.java#generational-no-coops intermittent timed out
P4 JDK-8348610 GenShen: TestShenandoahEvacuationInformationEvent failed with setRegions >= regionsFreed: expected 1 >= 57
P4 JDK-8352299 GenShen: Young cycles that interrupt old cycles cannot be cancelled
P4 JDK-8357018 Guidance for ParallelRefProcEnabled is wrong in the man pages
P4 JDK-8354078 Implement JEP 521: Generational Shenandoah
P4 JDK-8346470 Improve WriteBarrier JMH to have old-to-young refs
P4 JDK-8347094 Inline CollectedHeap::increment_total_full_collections
P4 JDK-8356990 JEP 521: Generational Shenandoah
P4 JDK-8354310 JFR: Inconsistent metadata in ZPageAllocation
P4 JDK-8346051 MemoryTest fails when Shenandoah's generational mode is enabled
P4 JDK-8345656 Move os alignment functions out of ReservedSpace
P4 JDK-8351081 Off-by-one error in ShenandoahCardCluster
P4 JDK-8339668 Parallel: Adopt PartialArrayState to consolidate marking stack in Full GC
P4 JDK-8357109 Parallel: Fix typo in YoungedGeneration
P4 JDK-8357854 Parallel: Inline args of PSOldGen::initialize_performance_counters
P4 JDK-8345217 Parallel: Refactor PSParallelCompact::next_src_region
P4 JDK-8357801 Parallel: Remove deprecated PSVirtualSpace methods
P4 JDK-8353263 Parallel: Remove locking in PSOldGen::resize
P4 JDK-8354228 Parallel: Set correct minimum of InitialSurvivorRatio
P4 JDK-8347923 Parallel: Simplify compute_survivor_space_size_and_threshold
P4 JDK-8205051 Poor Performance with UseNUMA when cpu and memory nodes are misaligned
P4 JDK-8345732 Provide helpers for using PartialArrayState
P4 JDK-8348171 Refactor GenerationCounters and its subclasses
P4 JDK-8344665 Refactor PartialArrayState allocation for reuse
P4 JDK-8305186 Reference.waitForReferenceProcessing should be more accessible to tests
P4 JDK-8356157 Remove retry loop in collect of SerialHeap and ParallelScavengeHeap
P4 JDK-8354541 Remove Shenandoah post barrier expand loop opts
P4 JDK-8357944 Remove unused CollectedHeap::is_maximal_no_gc
P4 JDK-8355401 Remove unused HWperKB
P4 JDK-8347730 Replace SIZE_FORMAT in g1
P4 JDK-8347729 Replace SIZE_FORMAT in parallel and serial gc
P4 JDK-8347727 Replace SIZE_FORMAT in shared gc
P4 JDK-8347732 Replace SIZE_FORMAT in shenandoah
P4 JDK-8347731 Replace SIZE_FORMAT in zgc
P4 JDK-8353559 Restructure CollectedHeap error printing
P4 JDK-8349652 Rewire nmethod oop load barriers
P4 JDK-8356848 Separate Metaspace and GC printing
P4 JDK-8348089 Serial: Remove virtual specifier in SerialHeap
P4 JDK-8346920 Serial: Support allocation in old generation when heap is almost full
P4 JDK-8357563 Shenandoah headers leak un-prefixed defines
P4 JDK-8350314 Shenandoah: Capture thread state sync times in GC timings
P4 JDK-8348420 Shenandoah: Check is_reserved before using ReservedSpace instances
P4 JDK-8351444 Shenandoah: Class Unloading may encounter recycled oops
P4 JDK-8348594 Shenandoah: Do not penalize for degeneration when not the fault of triggering heuristic
P4 JDK-8350898 Shenandoah: Eliminate final roots safepoint
P4 JDK-8344049 Shenandoah: Eliminate init-update-refs safepoint
P4 JDK-8354452 Shenandoah: Enforce range checks on parameters controlling heuristic sleep times
P4 JDK-8346690 Shenandoah: Fix log message for end of GC usage report
P4 JDK-8351091 Shenandoah: global marking context completeness is not accurately maintained
P4 JDK-8344055 Shenandoah: Make all threads use local gc state
P4 JDK-8353218 Shenandoah: Out of date comment references Brooks pointers
P4 JDK-8345423 Shenandoah: Parallelize concurrent cleanup
P4 JDK-8350285 Shenandoah: Regression caused by ShenandoahLock under extreme contention
P4 JDK-8350905 Shenandoah: Releasing a WeakHandle's referent may extend its lifetime
P4 JDK-8338737 Shenandoah: Reset marking bitmaps after the cycle
P4 JDK-8344050 Shenandoah: Retire GC LABs concurrently
P4 JDK-8342444 Shenandoah: Uncommit regions from a separate, STS aware thread
P4 JDK-8351077 Shenandoah: Update comments in ShenandoahConcurrentGC::op_reset_after_collect
P4 JDK-8347620 Shenandoah: Use 'free' tag for free set related logging
P4 JDK-8347617 Shenandoah: Use consistent name for update references phase
P4 JDK-8352918 Shenandoah: Verifier does not deactivate barriers as intended
P4 JDK-8346569 Shenandoah: Worker initializes ShenandoahThreadLocalData twice results in memory leak
P4 JDK-8354309 Sort GC includes
P4 JDK-8346139 test_memset_with_concurrent_readers.cpp should not use
P4 JDK-8333386 TestAbortOnVMOperationTimeout test fails for client VM
P4 JDK-8345374 Ubsan: runtime error: division by zero
P4 JDK-8347052 Update java man page documentation to reflect current state of the UseNUMA flag
P4 JDK-8354362 Use automatic indentation in CollectedHeap printing
P4 JDK-8352762 Use EXACTFMT instead of expanded version where applicable
P4 JDK-8357307 VM GC operations should have a public gc_succeeded()
P4 JDK-8356880 ZGC: Backoff in ZLiveMap::reset spin-loop
P4 JDK-8356716 ZGC: Cleanup Uncommit Logic
P4 JDK-8354938 ZGC: Disable UseNUMA when ZFakeNUMA is used
P4 JDK-8356083 ZGC: Duplicate ZTestEntry symbols in gtests
P4 JDK-8350572 ZGC: Enhance z_verify_safepoints_are_blocked interactions with VMError
P4 JDK-8352994 ZGC: Fix regression introduced in JDK-8350572
P4 JDK-8351167 ZGC: Lazily initialize livemap
P4 JDK-8357449 ZGC: Multiple medium page sizes
P4 JDK-8357443 ZGC: Optimize old page iteration in remap remembered phase
P4 JDK-8350441 ZGC: Overhaul Page Allocation
P4 JDK-8350851 ZGC: Reduce size of ZAddressOffsetMax scaling data structures
P4 JDK-8353471 ZGC: Redundant generation id in ZGeneration
P4 JDK-8356455 ZGC: Replace ZIntrusiveRBTree with IntrusiveRBTree
P4 JDK-8358310 ZGC: riscv, ppc ZPlatformAddressOffsetBits may return a too large value
P4 JDK-8351216 ZGC: Store NUMA node count
P4 JDK-8348241 ZGC: Unnecessarily reinitialize ZFragmentationLimit's default value
P4 JDK-8354929 ZGC: Update collection stats while holding page allocator lock
P4 JDK-8347335 ZGC: Use limitless mark stack memory
P4 JDK-8354922 ZGC: Use MAP_FIXED_NOREPLACE when reserving memory
P4 JDK-8355394 ZGC: Windows compile error in ZUtils
P4 JDK-8353264 ZGC: Windows heap unreserving is broken
P4 JDK-8354358 ZGC: ZPartition::prime handle discontiguous reservations correctly
P4 JDK-8337995 ZUtils::fill uses std::fill_n
P5 JDK-8349836 G1: Improve group prediction log message
P5 JDK-8357559 G1HeapRegionManager refactor rename functions related to the number of regions in different states
P5 JDK-8331723 Serial: Remove the unused parameter of the method SerialHeap::gc_prologue

hotspot/jfr

Priority Bug Summary
P2 JDK-8358628 [BACKOUT] 8342818: Implement JEP 509: JFR CPU-Time Profiling
P2 JDK-8352251 Implement JEP 518: JFR Cooperative Sampling
P2 JDK-8352738 Implement JEP 520: JFR Method Timing and Tracing
P2 JDK-8350338 JEP 518: JFR Cooperative Sampling
P2 JDK-8352648 JFR: 'jfr query' should not be available in product builds
P2 JDK-8362097 JFR: Active Settings view broken
P2 JDK-8359593 JFR: Instrumentation of java.lang.String corrupts recording
P2 JDK-8359895 JFR: method-timing view doesn't work
P2 JDK-8352066 JVM.commit() and JVM.flush() exhibit race conditions against JFR epochs
P2 JDK-8356587 Missing object ID X in pool jdk.types.Method
P2 JDK-8358689 test/micro/org/openjdk/bench/java/net/SocketEventOverhead.java does not build after JDK-8351594
P2 JDK-8364258 ThreadGroup constant pool serialization is not normalized
P3 JDK-8351976 assert(vthread_epoch == current_epoch) failed: invariant
P3 JDK-8357829 Commented out sample limit in JfrSamplerThread::task_stacktrace
P3 JDK-8353856 Deprecate FlighRecorderPermission class for removal
P3 JDK-8360403 Disable constant pool ID assert during troubleshooting
P3 JDK-8358619 Fix interval recomputation in CPU Time Profiler
P3 JDK-8358536 jdk/jfr/api/consumer/TestRecordingFileWrite.java times out
P3 JDK-8337789 JEP 509: JFR CPU-Time Profiling (Experimental)
P3 JDK-8328610 JEP 520: JFR Method Timing & Tracing
P3 JDK-8295651 JFR: 'jfr scrub' should summarize what was removed
P3 JDK-8351266 JFR: -XX:StartFlightRecording:report-on-exit
P3 JDK-8356698 JFR: @Contextual
P3 JDK-8351967 JFR: AnnotationIterator should handle num_annotations = 0
P3 JDK-8351064 JFR: Consistent timestamps
P3 JDK-8356224 JFR: Default value of @Registered is ignored
P3 JDK-8361175 JFR: Document differences between method sample events
P3 JDK-8353226 JFR: emit old object samples must be transitive closure complete for segment
P3 JDK-8358750 JFR: EventInstrumentation MASK_THROTTLE* constants should be computed in longs
P3 JDK-8357911 JFR: Fix subtle xor method tagging bug
P3 JDK-8359248 JFR: Help text for-XX:StartFlightRecording:report-on-exit should explain option can be repeated
P3 JDK-8351992 JFR: Improve robustness of the SettingControl examples
P3 JDK-8358590 JFR: Include min and max in MethodTiming event
P3 JDK-8346052 JFR: Incorrect average value in 'jfr view'
P3 JDK-8346047 JFR: Incorrect percentile value in 'jfr view'
P3 JDK-8351999 JFR: Incorrect scaling of throttled values
P3 JDK-8361639 JFR: Incorrect top frame for I/O events
P3 JDK-8360201 JFR: Initialize JfrThreadLocal::_sampling_critical_section
P3 JDK-8353614 JFR: jfr print --exact
P3 JDK-8345337 JFR: jfr view should display all direct subfields for an event type
P3 JDK-8345493 JFR: JVM.flush hangs intermittently
P3 JDK-8351995 JFR: Leftovers from removal of Security Manager
P3 JDK-8361338 JFR: Min and max time in MethodTime event is confusing
P3 JDK-8358429 JFR: minimize the time the Threads_lock is held for sampling
P3 JDK-8359242 JFR: Missing help text for method trace and timing
P3 JDK-8356816 JFR: Move printing of metadata into separate class
P3 JDK-8360287 JFR: PlatformTracer class should be loaded lazily
P3 JDK-8361640 JFR: RandomAccessFile::readLine emits events for each character
P3 JDK-8351594 JFR: Rate-limited sampling of Java events
P3 JDK-8343510 JFR: Remove AccessControlContext from FlightRecorder::addListener specification
P3 JDK-8347287 JFR: Remove use of Security Manager
P3 JDK-8353484 JFR: Simplify EventConfiguration
P3 JDK-8354949 JFR: Split up the EventInstrumentation class
P3 JDK-8357187 JFR: User-defined defaults should be respected when an incorrect setting is set
P3 JDK-8359135 New test TestCPUTimeSampleThrottling fails intermittently
P3 JDK-8358621 Reduce busy waiting in worse case at the synchronization point returning from native in CPU Time Profiler
P3 JDK-8348907 Stress times out when is executed with ZGC
P3 JDK-8345130 Test jdk/jfr/api/consumer/streaming/TestLatestEvent.java failed: Recording file is stuck in locked stream state.
P3 JDK-8347496 Test jdk/jfr/jvm/TestModularImage.java fails after JDK-8347124: No javac
P4 JDK-8358666 [REDO] Implement JEP 509: JFR CPU-Time Profiling
P4 JDK-8351142 Add JFR monitor deflation and statistics events
P4 JDK-8351187 Add JFR monitor notification event
P4 JDK-8342818 Implement JEP 509: JFR CPU-Time Profiling
P4 JDK-8356945 jdk/jfr/event/os/TestProcessStart failed on Windows Subsystem for Linux
P4 JDK-8352942 jdk/jfr/startupargs/TestMemoryOptions.java fails with 32-bit build
P4 JDK-8358448 JFR: Incorrect time unit for MethodTiming event
P4 JDK-8352414 JFR: JavaMonitorDeflateEvent crashes when deflated monitor object is dead
P4 JDK-8351146 JFR: JavaMonitorInflate event should default to no threshold and be disabled
P4 JDK-8353227 JFR: Prepare tests for strong parser validation
P4 JDK-8346099 JFR: Query for 'jfr view' can't handle wildcard with multiple event types
P4 JDK-8357671 JFR: Remove JfrTraceIdEpoch synchronizing
P4 JDK-8353431 JFR: Sets to use hashmap instead of binary search as backend
P4 JDK-8354508 JFR: Strengthen metadata checks for labels
P4 JDK-8358318 JFR: Tighten up PlatformTracer initialization
P4 JDK-8357830 JfrVframeStream::_cont_entry shadows super-class field
P4 JDK-8347042 Remove an extra parenthesis in macro definition in `jfrTraceIdMacros.hpp`
P4 JDK-8358205 Remove unused JFR array allocation code
P4 JDK-8347724 Replace SIZE_FORMAT in jfr directory
P4 JDK-8346875 Test jdk/jdk/jfr/event/os/TestCPULoad.java fails on macOS
P4 JDK-8353235 Test jdk/jfr/api/metadata/annotations/TestPeriod.java fails with IllegalArgumentException
P4 JDK-8344453 Test jdk/jfr/event/oldobject/TestSanityDefault.java timed out
P4 JDK-8352096 Test jdk/jfr/event/profiling/TestFullStackTrace.java shouldn't be executed with -XX:+DeoptimizeALot
P4 JDK-8352879 TestPeriod.java and TestGetContentType.java run wrong test class
P4 JDK-8348430 Update jfr tests to allow execution with different vm flags
P4 JDK-8318098 Update jfr tests to replace keyword jfr with vm.flagless

hotspot/jvmti

Priority Bug Summary
P3 JDK-8352652 [BACKOUT] nsk/jvmti/ tests should fail when nsk_jvmti_setFailStatus() is called
P3 JDK-8310340 assert(_thread->is_interp_only_mode() || stub_caller) failed: expected a stub-caller
P3 JDK-8356372 JVMTI heap sampling not working properly with outside TLAB allocations
P3 JDK-8352773 JVMTI should disable events during java upcalls
P3 JDK-8346727 JvmtiVTMSTransitionDisabler deadlock
P3 JDK-8353496 SuspendResume1.java and SuspendResume2.java timeout after JDK-8319447
P3 JDK-8320189 vmTestbase/nsk/jvmti/scenarios/bcinstr/BI02/bi02t001 memory corruption when using -Xcheck:jni
P4 JDK-8352098 -Xrunjdwp fails on static JDK
P4 JDK-8346143 add ClearAllFramePops function to speedup debugger single stepping in some cases
P4 JDK-8353938 hotspot/jtreg/serviceability/dcmd/jvmti/LoadAgentDcmdTest.java fails on static JDK
P4 JDK-8357800 Initialize JvmtiThreadState bool fields with bool literals
P4 JDK-8356251 Need minor cleanup for interp_only_mode
P4 JDK-8346460 NotifyFramePop should return JVMTI_ERROR_DUPLICATE
P4 JDK-8351375 nsk/jvmti/ tests should fail when nsk_jvmti_setFailStatus() is called
P4 JDK-8346082 Output JVMTI agent information in hserr files
P4 JDK-8350903 Remove explicit libjvm.so dependency for libVThreadEventTest
P4 JDK-8357673 remove test serviceability/jvmti/vthread/TestPinCaseWithCFLH
P4 JDK-8352812 remove useless class and function parameter in SuspendThread impl
P4 JDK-8337016 serviceability/jvmti/RedefineClasses/RedefineLeakThrowable.java gets Metaspace OOM
P4 JDK-8346792 serviceability/jvmti/vthread/GetThreadState/GetThreadState.java testObjectWaitMillis failed
P4 JDK-8316682 serviceability/jvmti/vthread/SelfSuspendDisablerTest timed out
P4 JDK-8300708 Some nsk jvmti tests fail with virtual thread wrapper due to jvmti missing some virtual thread support
P4 JDK-8316397 StackTrace/Suspended/GetStackTraceSuspendedStressTest.java failed with: SingleStep event is NOT expected
P4 JDK-8346998 Test nsk/jvmti/ResourceExhausted/resexhausted003 fails with java.lang.OutOfMemoryError when CDS is off
P4 JDK-8345543 Test serviceability/jvmti/vthread/StopThreadTest/StopThreadTest.java failed: expected JVMTI_ERROR_OPAQUE_FRAME instead of: 0
P4 JDK-8357282 Test vmTestbase/nsk/jvmti/AttachOnDemand/attach045/TestDescription.java fails after ClassNotFoundException
P4 JDK-8332857 Test vmTestbase/nsk/jvmti/GetThreadCpuTime/thrcputime002/TestDescription.java failed
P4 JDK-8305010 Test vmTestbase/nsk/jvmti/scenarios/sampling/SP05/sp05t003/TestDescription.java timed out: thread not suspended

hotspot/other

Priority Bug Summary
P3 JDK-8349140 Size optimization (opt-size) build fails after recent PCH changes
P4 JDK-8355498 [AIX] Adapt code for C++ VLA rule
P4 JDK-8323158 HotSpot Style Guide should specify more include ordering
P4 JDK-8345169 Implement JEP 503: Remove the 32-bit x86 Port
P4 JDK-8345168 JEP 503: Remove the 32-bit x86 Port
P4 JDK-8356689 Make HotSpot Style Guide change process more prominent
P4 JDK-8348180 Remove mention of include of precompiled.hpp from the HotSpot Style Guide
P4 JDK-8354543 Set more meaningful names for "get_vm_result" and "get_vm_result_2"
P4 JDK-8345795 Update copyright year to 2024 for hotspot in files where it was missed
P4 JDK-8345975 Update SAP SE copyright year to 2024 where it was missed

hotspot/runtime

Priority Bug Summary
P1 JDK-8358231 Template interpreter generator crashes with ShouldNotReachHere on some platforms after 8353686
P2 JDK-8349122 -XX:+AOTClassLinking is not compatible with jdwp
P2 JDK-8352092 -XX:AOTMode=record crashes with InstanceKlass in allocated state
P2 JDK-8353584 [BACKOUT] DaCapo xalan performance with -XX:+UseObjectMonitorTable
P2 JDK-8354535 [BACKOUT] Force clients to explicitly pass mem_tag value, even if it is mtNone
P2 JDK-8351997 AArch64: Interpreter volatile reference stores with G1 are not sequentially consistent
P2 JDK-8346457 AOT cache creation crashes with "assert(pair_at(i).match() < pair_at(i+1).match()) failed: unsorted table entries"
P2 JDK-8351319 AOT cache support for custom class loaders broken since JDK-8348426
P2 JDK-8357917 Assert in MetaspaceShared::preload_and_dump() when printing exception
P2 JDK-8347627 Compiler replay tests are failing after JDK-8346990
P2 JDK-8348752 Enable -XX:+AOTClassLinking by default when -XX:AOTMode is specified
P2 JDK-8356020 Failed assert in virtualMemoryTracker.cpp
P2 JDK-8349009 JVM fails to start when AOTClassLinking is used with unverifiable old classes
P2 JDK-8361754 New test runtime/jni/checked/TestCharArrayReleasing.java can cause disk full errors
P2 JDK-8349752 Tier1 build failure caused by JDK-8349178
P2 JDK-8351313 VM crashes when AOTMode/AOTCache/AOTConfiguration are empty
P2 JDK-8344068 Windows x86-64: Out of CodeBuffer space when generating final stubs
P3 JDK-8340212 -Xshare:off -XX:CompressedClassSpaceBaseAddress=0x40001000000 crashes on macos-aarch64
P3 JDK-8354558 -XX:AOTMode=record crashes with boot loader package-info class
P3 JDK-8351327 -XX:AOTMode=record interferes with application execution
P3 JDK-8346714 [ASAN] compressedKlass.cpp reported applying non-zero offset to null pointer
P3 JDK-8353189 [ASAN] memory leak after 8352184
P3 JDK-8358289 [asan] runtime/cds/appcds/aotCode/AOTCodeFlags.java reports heap-buffer-overflow in ArchiveBuilder
P3 JDK-8360405 [PPC64] some environments don't support mfdscr instruction
P3 JDK-8357793 [PPC64] VM crashes with -XX:-UseSIGTRAP -XX:-ImplicitNullChecks
P3 JDK-8361447 [REDO] Checked version of JNI ReleaseArrayElements needs to filter out known wrapped arrays
P3 JDK-8346847 [s390x] minimal build failure
P3 JDK-8345569 [ubsan] adjustments to filemap.cpp and virtualspace.cpp for macOS aarch64
P3 JDK-8358645 Access violation in ThreadsSMRSupport::print_info_on during thread dump
P3 JDK-8346605 AIX fastdebug build fails in memoryReserver.cpp after JDK-8345655
P3 JDK-8353298 AOT cache creation asserts with _array_klasses in an unregistered InstanceKlass
P3 JDK-8360164 AOT cache creation crashes in ~ThreadTotalCPUTimeClosure()
P3 JDK-8348322 AOT cache creation crashes with "All cached hidden classes must be aot-linkable" when AOTInvokeDynamicLinking is disabled
P3 JDK-8352001 AOT cache should not contain classes injected into built-in class loaders
P3 JDK-8357448 AOT crashes on linux musl with AddReads.java
P3 JDK-8349888 AOTMode=create crashes with EpsilonGC
P3 JDK-8356308 Assert with -Xlog:class+path when classpath has an empty element
P3 JDK-8348040 Bad use of ifdef with INCLUDE_xxx GC macros
P3 JDK-8356016 Build fails by clang(XCode 16.3) on macOS after JDK-8347719
P3 JDK-8346433 Cannot use DllMain in hotspot for static builds
P3 JDK-8353129 CDS ArchiveRelocation tests fail after JDK-8325132
P3 JDK-8352768 CDS test MethodHandleTest.java failed in -Xcomp mode
P3 JDK-8343191 Cgroup v1 subsystem fails to set subsystem path
P3 JDK-8349988 Change cgroup version detection logic to not depend on /proc/cgroups
P3 JDK-8350649 Class unloading accesses/resurrects dead Java mirror after JDK-8346567
P3 JDK-8323100 com/sun/tools/attach/StartManagementAgent.java failed with "WaitForSingleObject failed"
P3 JDK-8347811 Container detection code for cgroups v2 should use cgroup.controllers
P3 JDK-8347129 cpuset cgroups controller is required for no good reason
P3 JDK-8352187 Don't start management agent during AOT cache creation
P3 JDK-8353175 Eliminate double iteration of stream in FieldDescriptor reinitialization
P3 JDK-8353014 Exclude AOT tooling classes from AOT cache
P3 JDK-8344671 Few JFR streaming tests fail with application not alive error on MacOS 15
P3 JDK-8357576 FieldInfo::_index is not initialized by the constructor
P3 JDK-8354878 File Leak in CgroupSubsystemFactory::determine_type of cgroupSubsystem_linux.cpp:300
P3 JDK-8355353 File Leak in os::read_image_release_file of os.cpp:1552
P3 JDK-8350457 Implement JEP 519: Compact Object Headers
P3 JDK-8266329 Improve CDS module graph support for command-line options
P3 JDK-8353946 Incorrect WINDOWS ifdef in os::build_agent_function_name
P3 JDK-8356125 Interned strings are omitted from AOT cache
P3 JDK-8356942 invokeinterface Throws AbstractMethodError Instead of IncompatibleClassChangeError
P3 JDK-8345266 java/util/concurrent/locks/StampedLock/OOMEInStampedLock.java JTREG_TEST_THREAD_FACTORY=Virtual fails with OOME
P3 JDK-8357962 JFR Cooperative Sampling reveals inconsistent interpreter frames as part of JVMTI PopFrame
P3 JDK-8351778 JIT compiler fails when running -XX:AOTMode=create
P3 JDK-8355556 JVM crash because archived method handle intrinsics are not restored
P3 JDK-8352775 JVM crashes with -XX:AOTMode=create -XX:+UseZGC
P3 JDK-8350148 Native stack overflow when writing Java heap objects into AOT cache
P3 JDK-8350824 New async logging gtest StallingModePreventsDroppedMessages fails
P3 JDK-8350201 Out of bounds access on Linux aarch64 in os::print_register_info
P3 JDK-8356407 Part of class verification is skipped in AOT training run
P3 JDK-8352075 Perf regression accessing fields
P3 JDK-8345532 Provide option to indicate to the JDK that it will be crashing
P3 JDK-8353597 Refactor handling VM options for AOT cache input and output
P3 JDK-8345629 Remove expired flags in JDK 25
P3 JDK-8346838 RISC-V: runtime/CommandLine/OptionsValidation/TestOptionsWithRanges.java crash with debug VMs
P3 JDK-8356212 runtime/cds/appcds/LotsOfSyntheticClasses.java timed out with -XX:+AOTClassLinking
P3 JDK-8343890 SEGV crash in RunTimeClassInfo::klass
P3 JDK-8290043 serviceability/attach/ConcAttachTest.java failed "guarantee(!CheckJNICalls) failed: Attached JNI thread exited without being detached"
P3 JDK-8332506 SIGFPE In ObjectSynchronizer::is_async_deflation_needed()
P3 JDK-8354484 SIGSEGV when supertype of an AOT-cached class is excluded
P3 JDK-8354897 Support Soft/Weak Reference in AOT cache
P3 JDK-8351115 Test AOTClassLinkingVMOptions.java fails after JDK-8348322
P3 JDK-8352568 Test gtest/AsyncLogGtest.java failed at droppingMessage_vm
P3 JDK-8350214 Test gtest/AsyncLogGtest.java fails after JDK-8349755
P3 JDK-8353330 Test runtime/cds/appcds/SignedJar.java fails in CDSHeapVerifier
P3 JDK-8347531 The signal tests are failing after JDK-8345782 due to an unrelated warning
P3 JDK-8347959 ThreadDumper leaks memory
P3 JDK-8331201 UBSAN enabled build reports on Linux x86_64 runtime error: shift exponent 65 is too large for 64-bit type 'long unsigned int'
P3 JDK-8340110 Ubsan: verifier.cpp:2043:19: runtime error: shift exponent 100 is too large for 32-bit type 'int'
P3 JDK-8346040 Zero interpreter build on Linux Aarch64 is broken
P4 JDK-8351689 -Xshare:dump with default classlist fails on static JDK
P4 JDK-8339313 32-bit build broken
P4 JDK-8347143 [aix] Fix strdup use in os::dll_load
P4 JDK-8358254 [AOT] runtime/cds/appcds/applications/JavacBench.java#aot crashes with SEGV in ClassLoaderData::holder
P4 JDK-8349623 [ASAN] Gtest os_linux.glibc_mallinfo_wrapper_vm fails
P4 JDK-8348567 [ASAN] Memory access partially overflows by NativeCallStack
P4 JDK-8345632 [ASAN] memory leak in get_numbered_property_as_sorted_string function
P4 JDK-8346866 [ASAN] memoryReserver.cpp reported applying non-zero offset to non-null pointer produced null pointer
P4 JDK-8347148 [BACKOUT] AccessFlags can be u2 in metadata
P4 JDK-8347720 [BACKOUT] Portable implementation of FORBID_C_FUNCTION and ALLOW_C_FUNCTION
P4 JDK-8350770 [BACKOUT] Protection zone for easier detection of accidental zero-nKlass use
P4 JDK-8354446 [BACKOUT] Remove friends for ObjectMonitor
P4 JDK-8347763 [doc] Add documentation of module options for JEP 483
P4 JDK-8348013 [doc] fix typo in java.md caused by JDK-8347763
P4 JDK-8349184 [JMH] jdk.incubator.vector.ColumnFilterBenchmark.filterDoubleColumn fails on linux-aarch64
P4 JDK-8341481 [perf] vframeStreamCommon constructor may be optimized
P4 JDK-8350266 [PPC64] Interpreter: intrinsify Thread.currentThread()
P4 JDK-8344232 [PPC64] secondary_super_cache does not scale well: C1 and interpreter
P4 JDK-8347147 [REDO] AccessFlags can be u2 in metadata
P4 JDK-8346916 [REDO] align_up has potential overflow
P4 JDK-8353588 [REDO] DaCapo xalan performance with -XX:+UseObjectMonitorTable
P4 JDK-8346123 [REDO] NMT should not use ThreadCritical
P4 JDK-8347719 [REDO] Portable implementation of FORBID_C_FUNCTION and ALLOW_C_FUNCTION
P4 JDK-8351040 [REDO] Protection zone for easier detection of accidental zero-nKlass use
P4 JDK-8354448 [REDO] Remove friends for ObjectMonitor
P4 JDK-8335367 [s390] Add support for load immediate on condition instructions.
P4 JDK-8350716 [s390] intrinsify Thread.currentThread()
P4 JDK-8336356 [s390x] preserve Vector Register before using for string compress / expand
P4 JDK-8350482 [s390x] Relativize esp in interpreter frames
P4 JDK-8350398 [s390x] Relativize initial_sp/monitors in interpreter frames
P4 JDK-8350308 [s390x] Relativize last_sp (and top_frame_sp) in interpreter frames
P4 JDK-8350182 [s390x] Relativize locals in interpreter frames
P4 JDK-8345285 [s390x] test failures: foreign/normalize/TestNormalize.java with C2
P4 JDK-8354426 [ubsan] applying non-zero offset 34359738368 to null pointer in CompressedKlassPointers::encoding_range_end
P4 JDK-8351333 [ubsan] CDSMapLogger::log_region applying non-zero offset to null pointer
P4 JDK-8347268 [ubsan] logOutput.cpp:357:21: runtime error: applying non-zero offset 1 to null pointer
P4 JDK-8346881 [ubsan] logSelection.cpp:154:24 / logSelectionList.cpp:72:94 : runtime error: applying non-zero offset 1 to null pointer
P4 JDK-8349554 [UBSAN] os::attempt_reserve_memory_between reported applying non-zero offset to non-null pointer produced null pointer
P4 JDK-8345390 [ubsan] systemDictionaryShared.cpp:964: member call on null pointer
P4 JDK-8349465 [UBSAN] test_os_reserve_between.cpp reported applying non-zero offset to null pointer
P4 JDK-8346157 [Ubsan]: runtime error: pointer index expression with base 0x000000001000 overflowed to 0xfffffffffffffff0
P4 JDK-8357223 AArch64: Optimize interpreter profile updates
P4 JDK-8356949 AArch64: Tighten up template interpreter method entry code
P4 JDK-8339113 AccessFlags can be u2 in metadata
P4 JDK-8315719 Adapt AOTClassLinking test case for dynamic CDS archive
P4 JDK-8345314 Add a red–black tree as a utility data structure
P4 JDK-8351748 Add class init barrier to AOT-cached Method/Var Handles
P4 JDK-8348515 Add docs for -XX:AOT* options in java man pages
P4 JDK-8351491 Add info from release file to hserr file
P4 JDK-8345405 Add JMH showing the regression in 8341649
P4 JDK-8319875 Add macOS implementation for jcmd System.map
P4 JDK-8352084 Add more test code in TestSetupAOT.java
P4 JDK-8352178 Add precondition in VMThread::execute to prevent deadlock
P4 JDK-8354969 Add strdup function for ResourceArea
P4 JDK-8349211 Add support for intrusive trees to the utilities red-black tree
P4 JDK-8351654 Agent transformer bytecodes should be verified
P4 JDK-8349780 AIX os::get_summary_cpu_info support Power 11
P4 JDK-8354803 ALL_64_BITS is the same across platforms
P4 JDK-8355069 Allocation::check_out_of_memory() should support CheckUnhandledOops mode
P4 JDK-8355236 AOT Assembly crash with unregistered class and -Xlog:cds+resolve=trace
P4 JDK-8356693 AOT assembly phase fails with -javaagent
P4 JDK-8356597 AOT cache and CDS archive should not be created in read-only mode
P4 JDK-8358680 AOT cache creation fails: no strings should have been added
P4 JDK-8356838 AOT incorrectly sets a cached class's loader type to boot
P4 JDK-8357693 AOTCodeCompressedOopsTest.java failed with -XX:+UseLargePages
P4 JDK-8350303 ARM32: StubCodeGenerator::verify_stub(StubGenStubId) failed after JDK-8343767
P4 JDK-8354433 Assert in AbstractRBTree::visit_range_in_order(const K& from, const K& to, F f) is wrong
P4 JDK-8326236 assert(ce != nullptr) failed in Continuation::continuation_bottom_sender
P4 JDK-8340631 assert(reserved_rgn->contain_region(base_addr, size)) failed: Reserved CDS region should contain this mapping region
P4 JDK-8355608 Async UL should take the file lock of stream when outputting
P4 JDK-8323807 Async UL: Add a stalling mode to async UL
P4 JDK-8355979 ATTRIBUTE_NO_UBSAN needs to be extended to handle float divisions by zero on AIX
P4 JDK-8345936 Call ClassLoader.getResourceAsByteArray only for multi-release jar
P4 JDK-8353504 CDS archives are not found when JVM is in non-variant location
P4 JDK-8348647 CDS dumping commits 3GB when large pages are used
P4 JDK-8361328 cds/appcds/dynamicArchive/TestAutoCreateSharedArchive.java archive timestamps comparison failed
P4 JDK-8325132 CDS: Make sure the ArchiveRelocationMode is always printed in the log
P4 JDK-8350444 Check for verifer error in StackMapReader::check_offset()
P4 JDK-8350584 Check the usage of LOG_PLEASE
P4 JDK-8336147 Clarify CDS documentation about static vs dynamic archive
P4 JDK-8346477 Clarify the Java manpage in relation to the JVM's OnOutOfMemoryError flags
P4 JDK-8354180 Clean up uses of ObjectMonitor caches
P4 JDK-8351673 Clean up a case of if (LockingMode == LM_LIGHTWEIGHT) in a legacy-only locking mode function
P4 JDK-8354215 Clean up Loom support after 32-bit x86 removal
P4 JDK-8355481 Clean up MHN_copyOutBootstrapArguments
P4 JDK-8353174 Clean up thread register handling after 32-bit x86 removal
P4 JDK-8345040 Clean up unused variables and code in `generate_native_wrapper`
P4 JDK-8351151 Clean up x86 template interpreter after 32-bit x86 removal
P4 JDK-8354811 clock_tics_per_sec code duplication between os_linux and os_posix
P4 JDK-8356229 cmp-baseline build fail due to lib/modules difference
P4 JDK-8350666 cmp-baseline builds fail after JDK-8280682
P4 JDK-8351087 Combine scratch object tables in heapShared.cpp
P4 JDK-8352920 Compilation failure: comparison of unsigned expression >= 0 is always true
P4 JDK-8345678 compute_modifiers should not be in create_mirror
P4 JDK-8311542 Consolidate the native stack printing code
P4 JDK-8356998 Convert -Xlog:cds to -Xlog:aot (step 2)
P4 JDK-8356595 Convert -Xlog:cds to -Xlog:aot (step1)
P4 JDK-8348323 Corrupted timezone string in JVM crash log
P4 JDK-8353117 Crash: assert(id >= ThreadIdentifier::initial() && id < ThreadIdentifier::current()) failed: must be reasonable)
P4 JDK-8346193 CrashGCForDumpingJavaThread do not trigger expected crash build with clang17
P4 JDK-8339114 DaCapo xalan performance with -XX:+UseObjectMonitorTable
P4 JDK-8357525 Default CDS archive becomes non-deterministic after JDK-8305895
P4 JDK-8345955 Deprecate the UseOprofile flag with a view to removing the legacy oprofile support in the VM
P4 JDK-8350753 Deprecate UseCompressedClassPointers
P4 JDK-8348169 Destruct values on free in Treap
P4 JDK-8346159 Disable CDS AOTClassLinking tests for JVMCI due to JDK-8345635
P4 JDK-8351891 Disable TestBreakSignalThreadDump.java#with_jsig and XCheckJSig.java on static JDK
P4 JDK-8349580 Do not use address in MemTracker top level functions
P4 JDK-8354453 Don't strcpy in os::strdup, use memcpy instead
P4 JDK-8355627 Don't use ThreadCritical for EventLog list
P4 JDK-8346310 Duplicate !HAS_PENDING_EXCEPTION check in DynamicArchive::dump_at_exit
P4 JDK-8345911 Enhance error message when IncompatibleClassChangeError is thrown for sealed class loading failures
P4 JDK-8348554 Enhance Linux kernel version checks
P4 JDK-8343767 Enumerate StubGen blobs, stubs and entries and generate code from declarations
P4 JDK-8354560 Exponentially delay subsequent native thread creation in case of EAGAIN
P4 JDK-8330022 Failure test/hotspot/jtreg/vmTestbase/nsk/sysdict/share/BTreeTest.java: Could not initialize class java.util.concurrent.ThreadLocalRandom
P4 JDK-8304674 File java.c compile error with -fsanitize=address -O0
P4 JDK-8346160 Fix -Wzero-as-null-pointer-constant warnings from explicit casts
P4 JDK-8350767 Fix -Wzero-as-null-pointer-constant warnings in nsk jni stress tests
P4 JDK-8350623 Fix -Wzero-as-null-pointer-constant warnings in nsk native test utilities
P4 JDK-8345505 Fix -Wzero-as-null-pointer-constant warnings in zero code
P4 JDK-8349755 Fix corner case issues in async UL
P4 JDK-8348890 Fix docs for -XX:AOT* options in java man page
P4 JDK-8349417 Fix NULL usage from JDK-8346433
P4 JDK-8350955 Fix repetitions of the word "the" in runtime component comments
P4 JDK-8293123 Fix various include file ordering
P4 JDK-8344883 Force clients to explicitly pass mem_tag value, even if it is mtNone
P4 JDK-8339331 GCC fortify error in vm_version_linux_aarch64.cpp
P4 JDK-8348426 Generate binary file for -XX:AOTMode=record -XX:AOTConfiguration=file
P4 JDK-8350668 has_extra_module_paths in filemap.cpp may be uninitialized
P4 JDK-8350029 Illegal invokespecial interface not caught by verification
P4 JDK-8355798 Implement JEP 514: Ahead-of-Time Command Line Ergonomics
P4 JDK-8355228 Improve runtime/CompressedOops/CompressedClassPointersEncodingScheme.java to support JDK build with -XX:+UseCompactObjectHeaders
P4 JDK-8350854 Include thread counts in safepoint logging
P4 JDK-8350313 Include timings for leaving safepoint in safepoint logging
P4 JDK-8358283 Inconsistent failure mode for MetaspaceObj::operator new(size_t, MemTag)
P4 JDK-8354347 Increase the default padding size for aarch64 in JDK code.
P4 JDK-8350642 Interpreter: Upgrade CountBytecodes to 64 bit on 64 bit platforms
P4 JDK-8315130 java.lang.IllegalAccessError when processing classlist to create CDS archive
P4 JDK-8350022 JEP 514: Ahead-of-Time Command-Line Ergonomics
P4 JDK-8354672 JEP 519: Compact Object Headers
P4 JDK-8352191 JNI Specification: Clarify how to correctly size the buffer for GetStringUTFRegion
P4 JDK-8352184 Jtreg tests using CommandLineOptionTest.getVMTypeOption() and optionsvalidation.JVMOptionsUtils fail on static JDK
P4 JDK-8338303 Linux ppc64le with toolchain clang - detection failure in early JVM startup
P4 JDK-8357910 LoaderConstraintsTest.java fails when run with TEST_THREAD_FACTORY=Virtual
P4 JDK-8349145 Make Class.getProtectionDomain() non-native
P4 JDK-8349860 Make Class.isArray(), Class.isInterface() and Class.isPrimitive() non-native
P4 JDK-8348029 Make gtest death tests work with real crash signals
P4 JDK-8345959 Make JVM_IsStaticallyLinked JVM_LEAF
P4 JDK-8355490 Make VM_RedefineClasses::merge_constant_pools only take reference arguments
P4 JDK-8337997 MallocHeader description refers to non-existent NMT state "minimal"
P4 JDK-8354802 MAX_SECS definition is unused in os_linux
P4 JDK-8346923 MetaspaceShared base calculation may cause overflow in align_up
P4 JDK-8356577 Migrate ClassFileVersionTest to be feature-agnostic
P4 JDK-8350499 Minimal build fails with slowdebug builds
P4 JDK-8355649 Missing ResourceMark in ExceptionMark::check_no_pending_exception
P4 JDK-8347758 modules.cpp leaks string returned from get_numbered_property_as_sorted_string()
P4 JDK-8348195 More u2 conversion warnings after JDK-8347147
P4 JDK-8345655 Move reservation code out of ReservedSpace
P4 JDK-8349003 NativeCallStack::print_on() output is unreadable
P4 JDK-8351382 New test containers/docker/TestMemoryWithSubgroups.java is failing
P4 JDK-8352114 New test runtime/interpreter/CountBytecodesTest.java is failing
P4 JDK-8350566 NMT: add size parameter to MemTracker::record_virtual_memory_tag
P4 JDK-8350565 NMT: remaining memory flag/type to be replaced with memory tag
P4 JDK-8356233 NMT: tty->print_cr should not be used in VirtualMemoryTracker::add_reserved_region()
P4 JDK-8350567 NMT: update VMATree::register_mapping to copy the existing tag of the region
P4 JDK-8352256 ObjectSynchronizer::quick_notify misses JFR event notification path
P4 JDK-8339019 Obsolete the UseLinuxPosixThreadCPUClocks flag
P4 JDK-8354057 Odd debug output in -Xlog:os+container=debug on certain systems
P4 JDK-8356631 OopHandle replacement methods should not be called on empty handles
P4 JDK-8355646 Optimize ObjectMonitor::exit
P4 JDK-8351655 Optimize ObjectMonitor::unlink_after_acquire()
P4 JDK-8350497 os::create_thread unify init thread attributes part across UNIX platforms
P4 JDK-8350869 os::stat doesn't follow symlinks on Windows
P4 JDK-8337548 Parallel class loading can pass is_superclass true for interfaces
P4 JDK-8348402 PerfDataManager stalls shutdown for 1ms
P4 JDK-8313396 Portable implementation of FORBID_C_FUNCTION and ALLOW_C_FUNCTION
P4 JDK-8341095 Possible overflow in os::Posix::print_uptime_info
P4 JDK-8350636 Potential null-pointer dereference in MallocSiteTable::new_entry
P4 JDK-8327495 Print more warning with -Xshare:auto when CDS fails to use archive
P4 JDK-8330174 Protection zone for easier detection of accidental zero-nKlass use
P4 JDK-8356025 Provide a PrintVMInfoAtExit diagnostic switch
P4 JDK-8352980 Purge infrastructure for FP-to-bits interpreter intrinsics after 32-bit x86 removal
P4 JDK-8351484 Race condition in max stats in MonitorList::add
P4 JDK-8349525 RBTree: provide leftmost, rightmost, and a simple way to print trees
P4 JDK-8298733 Reconsider monitors_on_stack assert
P4 JDK-8354547 REDO: Force clients to explicitly pass mem_tag value, even if it is mtNone
P4 JDK-8353273 Reduce number of oop map entries in instances
P4 JDK-8349405 Redundant and confusing null checks on data from CP::resolved_klasses
P4 JDK-8280682 Refactor AOT code source validation checks
P4 JDK-8352579 Refactor CDS legacy optimization for lambda proxy classes
P4 JDK-8352435 Refactor CDS test library for execution and module packaging
P4 JDK-8348349 Refactor CDSConfig::is_dumping_heap()
P4 JDK-8349923 Refactor StackMapTable constructor and StackMapReader
P4 JDK-8355692 Refactor stream indentation
P4 JDK-8357504 Refactor the assignment of loader bits in InstanceKlassFlags
P4 JDK-8344140 Refactor the discovery of AOT cache artifacts
P4 JDK-8345782 Refining the cases that libjsig deprecation warning is issued
P4 JDK-8353692 Relax memory constraint on updating ObjectMonitorTable's item count
P4 JDK-8356394 Remove USE_LIBRARY_BASED_TLS_ONLY macro
P4 JDK-8171508 Remove -Dsun.java.launcher.is_altjvm option
P4 JDK-8340416 Remove ArchiveBuilder::estimate_archive_size()
P4 JDK-8351082 Remove dead code for estimating CDS archive size
P4 JDK-8337458 Remove debugging code print_cpool_bytes
P4 JDK-8329549 Remove FORMAT64_MODIFIER
P4 JDK-8354234 Remove friends for ObjectMonitor
P4 JDK-8355617 Remove historical debug_only macro in favor of DEBUG_ONLY
P4 JDK-8355711 Remove incorrect overflow check in RawBytecodeStream::raw_next
P4 JDK-8346990 Remove INTX_FORMAT and UINTX_FORMAT macros
P4 JDK-8352948 Remove leftover runtime_x86_32.cpp after 32-bit x86 removal
P4 JDK-8350916 Remove misleading warning "Cannot dump shared archive while using shared archive"
P4 JDK-8348829 Remove ObjectMonitor perf counters
P4 JDK-8241678 Remove PerfData sampling via StatSampler
P4 JDK-8324686 Remove redefinition of NULL for MSVC
P4 JDK-8347346 Remove redundant ClassForName.java and test.policy from runtime/Dictionary
P4 JDK-8347990 Remove SIZE_FORMAT macros and replace remaining uses
P4 JDK-8350952 Remove some non present files from OPT_SPEED_SRC list
P4 JDK-8350667 Remove startThread_lock() and _startThread_lock on AIX
P4 JDK-8294954 Remove superfluous ResourceMarks when using LogStream
P4 JDK-8348240 Remove SystemDictionaryShared::lookup_super_for_unregistered_class()
P4 JDK-8345838 Remove the appcds/javaldr/AnonVmClassesDuringDump.java test
P4 JDK-8356173 Remove ThreadCritical
P4 JDK-8353753 Remove unnecessary forward declaration in oop.hpp
P4 JDK-8358035 Remove unused `compute_fingerprint` declaration in `ClassFileStream`
P4 JDK-8346921 Remove unused arg in markWord::must_be_preserved
P4 JDK-8347482 Remove unused field in ParkEvent
P4 JDK-8355650 Remove unused fields in ParkEvent
P4 JDK-8351165 Remove unused includes from vmStructs
P4 JDK-8346602 Remove unused macro parameters in `jni.cpp`
P4 JDK-8354292 Remove unused PRAGMA_FORMAT_IGNORED
P4 JDK-8351665 Remove unused UseNUMA in os_aix.cpp
P4 JDK-8351046 Rename ObjectMonitor functions
P4 JDK-8356390 Rename ResolvedIndyEntry::set_flags to set_has_appendix
P4 JDK-8347924 Replace SIZE_FORMAT in memory and metaspace
P4 JDK-8347609 Replace SIZE_FORMAT in os/os_cpu/cpu directories
P4 JDK-8347733 Replace SIZE_FORMAT in runtime code
P4 JDK-8347566 Replace SSIZE_FORMAT with 'z' length modifier
P4 JDK-8349771 Replace usages of -mx and -ms in some monitor tests
P4 JDK-8334320 Replace vmTestbase/metaspace/share/TriggerUnloadingWithWhiteBox.java with ClassUnloadCommon from testlibrary
P4 JDK-8356329 Report compact object headers in hs_err
P4 JDK-8341491 Reserve and commit memory operations should be protected by NMT lock
P4 JDK-8353694 Resolved Class/Field/Method CP entries missing from AOT Configuration
P4 JDK-8341544 Restore fence() in Mutex
P4 JDK-8353325 Rewrite appcds/methodHandles test cases to use CDSAppTester
P4 JDK-8354329 Rewrite runtime/ClassFile/JsrRewriting.java and OomWhileParsingRepeatedJsr.java tests
P4 JDK-8354327 Rewrite runtime/LoadClass/LoadClassNegative.java
P4 JDK-8343840 Rewrite the ObjectMonitor lists
P4 JDK-8347434 Richer VM operations events logging
P4 JDK-8346706 RISC-V: Add available registers to hs_err
P4 JDK-8345322 RISC-V: Add concurrent gtests for cmpxchg variants
P4 JDK-8356159 RISC-V: Add Zabha
P4 JDK-8347794 RISC-V: Add Zfhmin - Float cleanup
P4 JDK-8353829 RISC-V: Auto-enable several more extensions for debug builds
P4 JDK-8349851 RISC-V: Call VM leaf can use movptr2
P4 JDK-8352897 RISC-V: Change default value for UseConservativeFence
P4 JDK-8353344 RISC-V: Detect and enable several extensions for debug builds
P4 JDK-8348384 RISC-V: Disable auto-enable Vector on buggy kernels
P4 JDK-8345669 RISC-V: fix client build failure due to AlignVector after JDK-8343827
P4 JDK-8346231 RISC-V: Fix incorrect assertion in SharedRuntime::generate_handler_blob
P4 JDK-8357968 RISC-V: Interpreter volatile reference stores with G1 are not sequentially consistent
P4 JDK-8357695 RISC-V: Move vector intrinsic condition checks into match_rule_supported_vector
P4 JDK-8358105 RISC-V: Optimize interpreter profile updates
P4 JDK-8357626 RISC-V: Tighten up template interpreter method entry code
P4 JDK-8347343 RISC-V: Unchecked zicntr csr reads
P4 JDK-8352218 RISC-V: Zvfh requires RVV
P4 JDK-8349508 runtime/cds/appcds/TestParallelGCWithCDS.java should not check for specific output
P4 JDK-8346929 runtime/ClassUnload/DictionaryDependsTest.java fails with "Test failed: should be unloaded"
P4 JDK-8346832 runtime/CompressedOops/CompressedCPUSpecificClassSpaceReservation.java fails on RISC-V
P4 JDK-8357408 runtime/interpreter/CountBytecodesTest.java should be flagless
P4 JDK-8349178 runtime/jni/atExit/TestAtExit.java should be supported on static JDK
P4 JDK-8356892 runtime/jni/CalleeSavedRegisters/FPRegs.java fails on static-jdk
P4 JDK-8354523 runtime/Monitor/SyncOnValueBasedClassTest.java triggers SIGSEGV
P4 JDK-8350429 runtime/NMT/CheckForProperDetailStackTrace.java should only run for debug JVM
P4 JDK-8352946 SEGV_BND signal code of SIGSEGV missing from our signal-code table
P4 JDK-8353568 SEGV_BNDERR signal code adjust definition
P4 JDK-8345589 Simplify Windows definition of strtok_r
P4 JDK-8350665 SIZE_FORMAT_HEX macro undefined in gtest
P4 JDK-8352276 Skip jtreg tests using native executable with libjvm.so/libjli.so dependencies on static JDK
P4 JDK-8350616 Skip ValidateHazardPtrsClosure in non-debug builds
P4 JDK-8353329 Small memory leak when create GrowableArray with initial size 0
P4 JDK-8348575 SpinLockT is typedef'ed but unused
P4 JDK-8328473 StringTable and SymbolTable statistics delay time to safepoint
P4 JDK-8352437 Support --add-exports with -XX:+AOTClassLinking
P4 JDK-8352003 Support --add-opens with -XX:+AOTClassLinking
P4 JDK-8354083 Support --add-reads with -XX:+AOTClassLinking
P4 JDK-8333470 Support disabling usage of dbghelp.dll-based symbol parsing
P4 JDK-8350103 Test containers/systemd/SystemdMemoryAwarenessTest.java fails on Linux ppc64le SLES15 SP6
P4 JDK-8357149 Test runtime/cds/appcds/aotCode/AOTCodeFlags.java is broken after JDK-8354887
P4 JDK-8345347 Test runtime/cds/TestDefaultArchiveLoading.java should accept VM flags or be marked as flagless
P4 JDK-8351309 test/hotspot/jtreg/runtime/posixSig/TestPosixSig.java fails on static-jdk
P4 JDK-8357914 TestEmptyBootstrapMethodsAttr.java fails when run with TEST_THREAD_FACTORY=Virtual
P4 JDK-8356102 TestJcmdOutput, JcmdWithNMTDisabled and DumpSharedDictionary hs/tier1 tests fail on static-jdk
P4 JDK-8350081 The behavior of the -Xrs flag is the opposite of what is documented
P4 JDK-8350464 The flags to set the native priority for the VMThread and Java threads need a broader range
P4 JDK-8349007 The jtreg test ResolvedMethodTableHash takes excessive time
P4 JDK-8350974 The os_cpu VM_STRUCTS, VM_TYPES, etc have no declarations and should be removed
P4 JDK-8348117 The two-argument overload of SignatureHandlerLibrary::add is not used
P4 JDK-8355648 Thread.SpinAcquire()'s lock name parameter is not used
P4 JDK-8340465 Timezone printed in hs_err file is corrupt on Windows
P4 JDK-8353365 TOUCH_ASSERT_POISON clears GetLastError()
P4 JDK-8347734 Turning off PerfData logging doesn't work
P4 JDK-8354954 Typed static memory for late initialization of static class members in Hotspot
P4 JDK-8348028 Unable to run gtests with CDS enabled
P4 JDK-8346306 Unattached thread can cause crash during VM exit if it calls wait_if_vm_exited
P4 JDK-8356318 Unexpected VerifyError in AOT training run
P4 JDK-8355319 Update Manpage for Compact Object Headers (Production)
P4 JDK-8347431 Update ObjectMonitor comments
P4 JDK-8355237 Upstream AOT test cases from Leyden repo to mainline
P4 JDK-8350893 Use generated names for hand generated opto runtime blobs
P4 JDK-8337978 Verify OopHandles oops on access
P4 JDK-8346120 VirtualThreadPinned event recorded for Object.wait may have wrong duration or may record second event
P4 JDK-8347004 vmTestbase/metaspace/shrink_grow/ShrinkGrowTest/ShrinkGrowTest.java fails with CDS disabled
P4 JDK-8321818 vmTestbase/nsk/stress/strace/strace015.java failed with 'Cannot read the array length because "" is null'
P4 JDK-8345658 WB_NMTCommitMemory redundantly records an NMT tag
P4 JDK-8356946 x86: Optimize interpreter profile updates
P4 JDK-8351152 x86: Remove code blocks that handle UseSSE < 2
P4 JDK-8357434 x86: Simplify Interpreter::profile_taken_branch
P4 JDK-8352415 x86: Tighten up template interpreter method entry code
P5 JDK-8354636 [PPC64] Clean up comments regarding frame manager
P5 JDK-8344983 [PPC64] Rename ConditionRegisters
P5 JDK-8347366 RISC-V: Add extension asserts for CMO instructions
P5 JDK-8357056 RISC-V: Asm fixes - load/store width
P5 JDK-8352673 RISC-V: Vector can't be turned on with -XX:+UseRVV

hotspot/svc

Priority Bug Summary
P2 JDK-8352163 [AIX] SIGILL in AttachOperation::ReplyWriter::write_fully after 8319055
P2 JDK-8352180 AttachListenerThread causes many tests to timeout on Windows
P2 JDK-8359870 JVM crashes in AccessInternal::PostRuntimeDispatch
P4 JDK-8350111 [PPC] AsyncGetCallTrace crashes when called while handling SIGTRAP
P4 JDK-8350106 [PPC] Avoid ticks_unknown_not_Java AsyncGetCallTrace() if JavaFrameAnchor::_last_Java_pc not set
P4 JDK-8352800 [PPC] OpenJDK fails to build on PPC after JDK-8350106
P4 JDK-8352392 AIX: implement attach API v2 and streaming output
P4 JDK-8350771 Fix -Wzero-as-null-pointer-constant warning in nsk/monitoring ThreadController utility
P4 JDK-8353727 HeapDumpPath doesn't expand %p
P4 JDK-8319055 JCMD should not buffer the whole output of commands
P4 JDK-8353479 jcmd with streaming output breaks intendation
P4 JDK-8356177 Regression after JDK-8352180
P4 JDK-8350723 RISC-V: debug.cpp help() is missing riscv line for pns
P4 JDK-8355439 Some hotspot/jtreg/serviceability/sa/* tests fail on static JDK due to explicit checks for shared libraries in process memory map

hotspot/svc-agent

Priority Bug Summary
P2 JDK-8348800 Many serviceability/sa tests failing after JDK-8348239
P3 JDK-8360312 Serviceability Agent tests fail with JFR enabled due to unknown thread type JfrRecorderThread
P4 JDK-8349039 Adjust exception No type named in database
P4 JDK-8350287 Cleanup SA's support for CodeBlob subclasses
P4 JDK-8355432 Remove CompileTask from SA
P4 JDK-8315488 Remove outdated and unused ciReplay support from SA
P4 JDK-8354920 SA core file support on Linux only prints error messages when debug logging is enabled
P4 JDK-8348239 SA does not know about DeoptimizeObjectsALotThread
P4 JDK-8346304 SA doesn't need a copy of getModifierFlags
P4 JDK-8357999 SA: FileMapInfo.metadataTypeArray initialization issue after JDK-8355003
P4 JDK-8347779 sun/tools/jhsdb/HeapDumpTestWithActiveProcess.java fails with Unable to deduce type of thread from address
P5 JDK-8348347 Cleanup JavaThread subclass support in SA
P5 JDK-8349571 Remove JavaThreadFactory interface from SA

hotspot/test

Priority Bug Summary
P1 JDK-8350280 The JDK-8346050 testlibrary changes break the build
P3 JDK-8347127 CTW fails to build after JDK-8334733
P3 JDK-8352926 New test TestDockerMemoryMetricsSubgroup.java fails
P3 JDK-8354475 TestDockerMemoryMetricsSubgroup.java fails with exitValue = 1
P4 JDK-8350858 [IR Framework] Some tests failed on Cascade Lake
P4 JDK-8354080 Add JCK testing with JFR enabled
P4 JDK-8338428 Add logging of final VM flags while setting properties
P4 JDK-8353214 Add testing with --enable-preview
P4 JDK-8353307 Create template for standard PIT task for hotspot testing
P4 JDK-8358004 Delete applications/scimark/Scimark.java test
P4 JDK-8347840 Fix testlibrary compilation warnings
P4 JDK-8347083 Incomplete logging in nsk/jvmti/ResourceExhausted/resexhausted00* tests
P4 JDK-8356089 java/lang/IO/IO.java fails with -XX:+AOTClassLinking
P4 JDK-8343802 Prevent NULL usage backsliding
P4 JDK-8348536 Remove remain SIZE_FORMAT usage after JDK-8347990
P4 JDK-8345698 Remove tier1_compiler_not_xcomp from github actions
P4 JDK-8353695 RISC-V: compiler/cpuflags/TestAESIntrinsicsOnUnsupportedConfig.java is failing with Zvkn
P4 JDK-8352730 RISC-V: Disable tests in qemu-user
P4 JDK-8352011 RISC-V: Two IR tests fail after JDK-8351662
P4 JDK-8351138 Running subset of gtests gets error printing result information
P4 JDK-8359272 Several vmTestbase/compact tests timed out on large memory machine
P4 JDK-8357271 Simplify hs-jck-pit job
P4 JDK-8356904 Skip jdk/test/lib/process/TestNativeProcessBuilder on static-jdk
P4 JDK-8354510 Skipped gtest cause test failure
P4 JDK-8350151 Support requires property to filter tests incompatible with --enable-preview
P4 JDK-8346048 test/lib/containers/docker/DockerRunOptions.java uses addJavaOpts() from ctor
P4 JDK-8356187 TestJcmd.java may incorrectly parse podman version
P4 JDK-8346924 TestVectorizationNegativeScale.java fails without the rvv extension on RISCV fastdebug VM
P4 JDK-8346922 TestVectorReinterpret.java fails without the rvv extension on RISCV fastdebug VM
P4 JDK-8348324 The failure handler cannot be build by JDK 24 due to restricted warning
P4 JDK-8346050 Update BuildTestLib.gmk to build whole testlibrary
P4 JDK-8356649 Update JCStress test suite
P4 JDK-8353190 Use "/native" Run Option for TestAvailableProcessors Execution
P4 JDK-8322983 Virtual Threads: exclude 2 tests

infrastructure

Priority Bug Summary
P1 JDK-8364038 Remove EA from the JDK 25 version string with first RC promotion
P2 JDK-8345693 Update JCov for class file version 69
P4 JDK-8350982 -server|-client causes fatal exception on static JDK
P4 JDK-8354686 [AIX] now ubsan is possible
P4 JDK-8355669 Add static-jdk-bundles make target
P4 JDK-8348905 Add support to specify the JDK for compiling Jtreg tests
P4 JDK-8351399 AIX: clang pollutes the burned-in library search paths of the generated executables / Second try with a better solution than JDK8348663
P4 JDK-8352064 AIX: now also able to build static-jdk image with a statically linked launcher
P4 JDK-8346046 Enable copyright header format check
P4 JDK-8356269 Fix broken web-links after JDK-8295470
P4 JDK-8355452 GHA: Test jtreg tier1 on linux-x64 static-jdk
P4 JDK-8349513 Remove unused BUILD_JDK_JTREG_LIBRARIES_JDK_LIBS_libTracePinnedThreads
P4 JDK-8358634 RISC-V: Fix several broken documentation web-links
P4 JDK-8349934 Wrong file regex for copyright header format check in .jcheck/conf
P4 JDK-8354257 xctracenorm profiler not working with JDK JMH benchmarks

infrastructure/build

Priority Bug Summary
P1 JDK-8357991 make bootcycle-images is broken after JDK-8349665
P2 JDK-8357511 [BACKOUT] 8357048: RunTest variables should always be assigned
P2 JDK-8349511 [BACKOUT] Framework for tracing makefile inclusion and parsing
P2 JDK-8345628 [BACKOUT] JDK-8287122 Use gcc12 -ftrivial-auto-var-init=pattern in debug builds
P2 JDK-8353449 [BACKOUT] One instance of STATIC_LIB_CFLAGS was missed in JDK-8345683
P2 JDK-8353005 AIX build broken after 8352481
P2 JDK-8348207 Linux PPC64 PCH build broken after JDK-8347909
P2 JDK-8347501 Make static-launcher fails after JDK-8346669
P3 JDK-8354088 [BACKOUT] Run jtreg in the work dir
P3 JDK-8349515 [REDO] Framework for tracing makefile inclusion and parsing
P3 JDK-8352692 Add support for extra jlink options
P3 JDK-8348975 Broken links in the JDK 24 JavaDoc API documentation, build 33
P3 JDK-8244533 Configure should abort on missing short names in Windows
P3 JDK-8353709 Debug symbols bundle should contain full debug files when building --with-external-symbols-in-bundles=public
P3 JDK-8338973 Document need to have UTF-8 locale available to build the JDK
P3 JDK-8353458 Don't pass -Wno-format-nonliteral to CFLAGS
P3 JDK-8348190 Framework for tracing makefile inclusion and parsing
P3 JDK-8350774 Generated test- targets broken after JDK-8348998
P3 JDK-8360042 GHA: Bump MSVC to 14.44
P3 JDK-8351029 IncludeCustomExtension does not work on cygwin with source code below /home
P3 JDK-8346669 Increase abstraction in SetupBuildLauncher and remove extra args
P3 JDK-8349467 INIT_TARGETS tab completions on "make" lost with JDK-8348998
P3 JDK-8347996 JavaCompilation.gmk should not include ZipArchive.gmk
P3 JDK-8356226 JCov Grabber server didn't respond
P3 JDK-8346150 Jib dependency on autoconf missing for 'docs' profile
P3 JDK-8349665 Make clean removes module-deps.gmk
P3 JDK-8347825 Make IDEA ide support use proper build system mechanisms
P3 JDK-8349933 Mixing of includes and snippets stack causes the wrong -post snippet to be included
P3 JDK-8345424 Move FindDebuginfoFiles out of FileUtils.gmk
P3 JDK-8346377 Properly support static builds for Windows
P3 JDK-8354278 Revert use of non-POSIX echo -n introduced in JDK-8301197
P3 JDK-8348429 Update cross-compilation devkits to Fedora 41/gcc 13.2
P3 JDK-8339238 Update to use jtreg 7.5.1
P3 JDK-8351154 Use -ftrivial-auto-var-init=pattern for clang too
P4 JDK-8315844 $LSB_RELEASE is not defined before use
P4 JDK-8348286 [AIX] clang 17 introduces new warning Wtentative-Definitions which produces Build errors
P4 JDK-8348663 [AIX] clang pollutes the burned-in library search paths of the generated executables
P4 JDK-8357510 [REDO] RunTest variables should always be assigned
P4 JDK-8345627 [REDO] Use gcc12 -ftrivial-auto-var-init=pattern in debug builds
P4 JDK-8340341 Abort in configure when using Xcode 16.0 or 16.1
P4 JDK-8187520 Add --disable-java-warnings-as-errors configure option
P4 JDK-8282493 Add --with-jcov-modules convenience option
P4 JDK-8357920 Add .rej and .orig to .gitignore
P4 JDK-8350801 Add a code signing hook to the JDK build system
P4 JDK-8348387 Add fixpath if needed for user-supplied tools
P4 JDK-8352645 Add tool support to check order of includes
P4 JDK-8350137 After JDK-8348975, Linux builds contain man pages for windows only tools
P4 JDK-8345590 AIX 'make all' fails after JDK-8339480
P4 JDK-8349143 All make control variables need special propagation
P4 JDK-8347909 Automatic precompiled.hpp inclusion
P4 JDK-8349953 Avoid editing AOTConfiguration file in "make test JTREG=AOT_JDK=true"
P4 JDK-8347347 Build fails undefined symbol: __asan_init by clang17
P4 JDK-8342984 Bump minimum boot jdk to JDK 24
P4 JDK-8351603 Change to GCC 14.2.0 for building on Linux at Oracle
P4 JDK-8354902 Change to Visual Studio 17.13.2 for building on Windows at Oracle
P4 JDK-8355446 Change to Xcode 15.4 for building on macOS at Oracle
P4 JDK-8355235 Clean out old versions from Tools.gmk
P4 JDK-8346278 Clean up some flag handing in flags-cflags.m4
P4 JDK-8349375 Cleanup AIX special file build settings
P4 JDK-8347570 Configure fails on macOS if directory name do not have correct case
P4 JDK-8355697 Create windows devkit on wsl and msys2
P4 JDK-8327466 ct.sym zip not reproducible across build environment timezones
P4 JDK-8357376 Disable syntax highlighting for JDK API docs
P4 JDK-8356686 doc/building.html is not up to date after JDK-8301971
P4 JDK-8356656 Drop unused DEVKIT_HOME from jib-profiles.js
P4 JDK-8285692 Enable _FORTIFY_SOURCE=2 when building with Clang
P4 JDK-8352481 Enforce the use of lld with clang
P4 JDK-8343832 Enhance test summary with number of skipped tests
P4 JDK-8359181 Error messages generated by configure --help after 8301197
P4 JDK-8352284 EXTRA_CFLAGS incorrectly applied to BUILD_LIBJVM src/hotspot C++ source files
P4 JDK-8356820 fixpath should allow + in paths on Windows
P4 JDK-8344272 gcc devkit doesn't have lto-plugin where needed
P4 JDK-8349399 GHA: Add static-jdk build on linux-x64
P4 JDK-8341097 GHA: Demote Mac x86 jobs to build only
P4 JDK-8350443 GHA: Split static-libs-bundles into a separate job
P4 JDK-8347500 hsdis cannot be built with Capstone.next
P4 JDK-8350819 Ignore core files
P4 JDK-8349214 Improve size optimization flags for MSVC builds
P4 JDK-8334391 JDK build should exclude *-files directories for Java source
P4 JDK-8358337 JDK-8357991 was committed with incorrect indentation
P4 JDK-8354565 jtreg failure handler GatherProcessInfoTimeoutHandler has a leftover call to System.loadLibrary
P4 JDK-8348391 Keep case if possible for TOPDIR
P4 JDK-8347120 Launchers should not have java headers on include path
P4 JDK-8353580 libjpeg is not found if not installed in system directories
P4 JDK-8351440 Link with -reproducible on macOS
P4 JDK-8350094 Linux gcc 13.2.0 build fails when ubsan is enabled
P4 JDK-8344559 Log is spammed by missing pandoc warnings when building man pages
P4 JDK-8348392 Make claims "other matches are possible" even when that is not true
P4 JDK-8358515 make cmp-baseline is broken after JDK-8349665
P4 JDK-8301197 Make sure use of printf is correct and actually needed
P4 JDK-8349781 make test TEST=gtest fails on WSL
P4 JDK-8356379 Need a proper way to test existence of binary from configure
P4 JDK-8292944 Noisy output when running make help the first time
P4 JDK-8349075 Once again allow -compilejdk in JAVA_OPTIONS
P4 JDK-8353272 One instance of STATIC_LIB_CFLAGS was missed in JDK-8345683
P4 JDK-8348586 Optionally silence make warnings about non-control variables
P4 JDK-8357842 PandocFilter misses copyright header
P4 JDK-8351323 Parameterize compiler and linker flags for iconv
P4 JDK-8351322 Parameterize link option for pthreads
P4 JDK-8353066 Properly detect Windows/aarch64 as build platform
P4 JDK-8339622 Regression in make open-hotspot-xcode-project
P4 JDK-8348182 Remove DONT_USE_PRECOMPILED_HEADER
P4 JDK-8356335 Remove linux-x86 from jib profiles
P4 JDK-8352618 Remove old deprecated functionality in the build system
P4 JDK-8345683 Remove special flags for files compiled for static libraries
P4 JDK-8355249 Remove the use of WMIC from the entire source code
P4 JDK-8300339 Run jtreg in the work dir
P4 JDK-8357048 RunTest variables should always be assigned
P4 JDK-8345942 Separate source output from class output when building microbenchmarks
P4 JDK-8348582 Set -fstack-protector when building with clang
P4 JDK-8350267 Set mtune and mcpu settings in JDK native lib compilation on Linux ppc64(le)
P4 JDK-8346830 Simplify adlc build config for aix
P4 JDK-8352506 Simplify make/test/JtregNativeHotspot.gmk
P4 JDK-8355725 SPEC_FILTER stopped working
P4 JDK-8348998 Split out PreInit.gmk from Init.gmk
P4 JDK-8349150 Support precompiled headers on AIX
P4 JDK-8353573 System giflib not found by configure if it's not in system directories
P4 JDK-8348039 testmake fails at IDEA after JDK-8347825
P4 JDK-8350202 Tune for Power10 CPUs on Linux ppc64le
P4 JDK-8342987 Update --release 24 symbol information for JDK 24 build 27
P4 JDK-8346295 Update --release 24 symbol information for JDK 24 build 29
P4 JDK-8345793 Update copyright year to 2024 for the build system in files where it was missed
P4 JDK-8358538 Update GHA Windows runner to 2025
P4 JDK-8345726 Update mx in RunTestPrebuiltSpec to reflect change in JDK-8345302
P4 JDK-8351606 Use build_platform for graphviz dependency
P4 JDK-8345744 Use C++ LINK_TYPE with SetupBuildLauncher in StaticLibs.gmk
P4 JDK-8287122 Use gcc12 -ftrivial-auto-var-init=pattern in debug builds
P4 JDK-8340185 Use make -k on GHA to catch more build errors
P4 JDK-8356657 Use stable source-date for cmp-baseline jib profiles
P4 JDK-8355594 Warnings occur when building with clang and enabling ubsan
P4 JDK-8354230 Wrong boot jdk for alpine-linux-x64 in GHA
P5 JDK-8355400 Better git detection in update_copyright_year.sh
P5 JDK-8356032 createAutoconfBundle.sh downloads to local directory
P5 JDK-8317012 Explicitly check for 32-bit word size for using libatomic with zero
P5 JDK-8329173 LCMS_CFLAGS from configure are lost
P5 JDK-8354919 Move HotSpot .editorconfig into the global .editorconfig
P5 JDK-8196896 Use SYSROOT_CFLAGS in dtrace gensrc

infrastructure/docs

Priority Bug Summary
P3 JDK-8349095 A link is missing from the JDK 24 Tool Specifications to the jnativescan tool documentation
P4 JDK-8358284 doc/testing.html is not up to date after JDK-8355003
P4 JDK-8353009 Improve documentation for Windows AArch64 builds

infrastructure/other

Priority Bug Summary
P3 JDK-8301971 Make JDK source code UTF-8
P4 JDK-8311227 Add .editorconfig
P4 JDK-8306579 Consider building with /Zc:throwingNew
P4 JDK-8354266 Fix non-UTF-8 text encoding
P4 JDK-8346773 Fix unmatched brackets in some misc files
P4 JDK-8358543 Remove CommentChecker.java and DirDiff.java
P4 JDK-8354273 Replace even more Unicode characters with ASCII
P4 JDK-8354968 Replace unicode sequences in comment text with UTF-8 characters
P4 JDK-8354213 Restore pointless unicode characters to ASCII
P4 JDK-8345805 Update copyright year to 2024 for other files where it was missed
P4 JDK-8356644 Update encoding declaration to UTF-8
P4 JDK-8356977 UTF-8 cleanups
P5 JDK-8353063 make/ide/vscode: Invalid Configuration Values

other-libs

Priority Bug Summary
P4 JDK-8347123 Add missing @serial tags to other modules

performance

Priority Bug Summary
P4 JDK-8350518 org.openjdk.bench.java.util.TreeMapUpdate.compute fails with "java.lang.IllegalArgumentException: key out of range"
P4 JDK-8350460 org.openjdk.bench.vm.floatingpoint.DremFrem JMH fails with -ea

performance/libraries

Priority Bug Summary
P4 JDK-8349943 [JMH] Use jvmArgs consistently
P4 JDK-8346230 [perf] scalability issue for the specjvm2008::xml.transform workload
P4 JDK-8346142 [perf] scalability issue for the specjvm2008::xml.validation workload
P4 JDK-8355559 Benchmark modification/extension shouldn't affect the behavior of other benchmarks
P4 JDK-8353478 Update crypto microbenchmarks to cover ML-DSA, ML-KEM, and HSS algorithms

security-libs

Priority Bug Summary
P2 JDK-8356051 Update SignatureUtil.java with the new KnownOIDs
P3 JDK-8350661 PKCS11 HKDF throws ProviderException when requesting a 31-byte AES key
P4 JDK-8350964 Add an ArtifactResolver.fetch(clazz) method
P4 JDK-8347065 Add missing @spec tags for Java Security Standard Algorithm Names
P4 JDK-8346045 Cleanup of security library tests calling Security Manager APIs
P4 JDK-8349532 Refactor ./util/Pem/encoding.sh to run in java
P4 JDK-8349533 Refactor validator tests shell files to java
P4 JDK-8345803 Update copyright year to 2024 for security in files where it was missed

security-libs/java.security

Priority Bug Summary
P2 JDK-8359170 Add 2 TLS and 2 CS Sectigo roots
P2 JDK-8298420 Implement JEP 470: PEM Encodings of Cryptographic Objects (Preview)
P3 JDK-8347946 Add API note that caller should validate/trust signers to the getCertificates and getCodeSigners methods of JarEntry and JarURLConnection
P3 JDK-8283795 Add TLSv1.3 and CNSA 1.0 algorithms to implementation requirements
P3 JDK-8358171 Additional code coverage for PEM API
P3 JDK-8347506 Compatible OCSP readtimeout property with OCSP timeout
P3 JDK-8348967 Deprecate security permission classes for removal
P3 JDK-8346736 Java Security Standard Algorithm Names spec should include key algorithm names
P3 JDK-8358076 KeyFactory.getInstance("EdDSA").generatePublic(null) throws NPE
P3 JDK-8358099 PEM spec updates
P3 JDK-8342062 Reformat keytool and jarsigner output for keys with a named parameter set
P3 JDK-8303770 Remove Baltimore root certificate expiring in May 2025
P3 JDK-8184352 Remove Sun provider information from KeyPairGenerator javadoc
P3 JDK-8344361 Restore null return for invalid services from legacy providers
P3 JDK-8354305 SHAKE128 and SHAKE256 MessageDigest algorithms
P3 JDK-8346129 Simplify EdDSA & XDH curve name usage
P3 JDK-8347596 Update HSS/LMS public key encoding
P3 JDK-8357062 Update Public Suffix List to 823beb1
P3 JDK-8350830 Values converted incorrectly when reading TLS session tickets
P4 JDK-8349759 Add unit test for CertificateBuilder and SimpleOCSPServer test utilities
P4 JDK-8183348 Better cleanup for jdk/test/sun/security/pkcs12/P12SecretKey.java
P4 JDK-8328914 Document the java.security.debug property in javadoc
P4 JDK-8341775 Duplicate manifest files are removed by jarsigner after signing
P4 JDK-8346094 Harden X509CertImpl.getExtensionValue for NPE cases
P4 JDK-8349664 HEX dump should always use ASCII or ISO_8859_1
P4 JDK-8349400 Improve startup speed via eliminating nested classes
P4 JDK-8360416 Incorrect l10n test case in sun/security/tools/keytool/i18n.java
P4 JDK-8352277 java.security documentation: incorrect regex syntax describing "usage" algorithm constraint
P4 JDK-8346049 jdk/test/lib/security/timestamp/TsaServer.java warnings
P4 JDK-8300911 JEP 470: PEM Encodings of Cryptographic Objects (Preview)
P4 JDK-8345940 Migrate security-related resources from Java classes to properties files
P4 JDK-8347606 Optimize Java implementation of ML-DSA
P4 JDK-8349890 option -Djava.security.debug=x509,ava breaks special chars
P4 JDK-8358319 Pem.decode should cache the Pattern
P4 JDK-8358316 PKCS8Key.getEncoded() can throw NPE after JDK-8298420
P4 JDK-8349348 Refactor ClassLoaderDeadlock.sh and Deadlock.sh to run fully in java
P4 JDK-8349151 Refactor test/java/security/cert/CertificateFactory/slowstream.sh to java test
P4 JDK-8353001 Remove leftover Security Manager parsing code in sun.security.util.Debug
P4 JDK-8351366 Remove the java.security.debug=scl option
P4 JDK-8350498 Remove two Camerfirma root CA certificates
P4 JDK-8344316 security/auth/callback/TextCallbackHandler/Password.java make runnable with JTReg and add the UI
P4 JDK-8302111 Serialization considerations
P4 JDK-8339891 Several sun/security/ssl/SSLSessionImpl/* tests override test.java.opts
P4 JDK-8353945 Test javax/security/auth/x500/X500Principal/NameFormat.java fails after JDK-8349890
P4 JDK-8345134 Test sun/security/tools/jarsigner/ConciseJarsigner.java failed: unable to find valid certification path to requested target
P4 JDK-8352302 Test sun/security/tools/jarsigner/TimestampCheck.java is failing
P4 JDK-8345133 Test sun/security/tools/jarsigner/TsacertOptionTest.java failed: Warning found in stdout
P4 JDK-8350689 Turn on timestamp and thread metadata by default for java.security.debug
P4 JDK-8354061 Update copyright in NameFormat.java fix after JDK-8349890
P4 JDK-8357592 Update output parsing in test/jdk/sun/security/tools/jarsigner/compatibility/Compatibility.java
P4 JDK-8349492 Update sun/security/pkcs12/KeytoolOpensslInteropTest.java to use a recent Openssl version
P5 JDK-8343467 Remove unnecessary @SuppressWarnings annotations (security)
P5 JDK-8352509 Update jdk.test.lib.SecurityTools jar method to accept List parameter

security-libs/javax.crypto

Priority Bug Summary
P3 JDK-8347289 HKDF delayed provider selection failed with non-extractable PRK
P3 JDK-8353888 Implement JEP 510: Key Derivation Function API
P3 JDK-8353275 JEP 510: Key Derivation Function API
P3 JDK-8351113 RC2ParameterSpec throws IllegalArgumentException when offset is negative
P3 JDK-8353578 Refactor existing usage of internal HKDF impl to use the KDF API
P3 JDK-8350456 Test javax/crypto/CryptoPermissions/InconsistentEntries.java crashed: EXCEPTION_ACCESS_VIOLATION
P3 JDK-8342238 Test javax/crypto/CryptoPermissions/InconsistentEntries.java writes files in tested JDK dir
P4 JDK-8345757 [ASAN] clang17 report 'dprintf' macro redefined
P4 JDK-8348405 Add PBES2 as a standard AlgorithmParameters algorithm
P4 JDK-8347428 Avoid using secret-key in specifications
P4 JDK-8349106 Change ChaCha20 intrinsic to use quarter-round parallel implementation on aarch64
P4 JDK-8189441 Define algorithm names for keys derived from KeyAgreement
P4 JDK-8347819 ECDH standard algorithm incorrectly refers to RFC 3278
P4 JDK-8350476 Fix typo introduced in JDK-8350147
P4 JDK-8267068 Incomplete @throws javadoc for various javax.crypto.spec classes
P4 JDK-8350589 Investigate cleaner implementation of AArch64 ML-DSA intrinsic introduced in JDK-8348561
P4 JDK-8347608 Optimize Java implementation of ML-KEM
P4 JDK-8350126 Regression ~3% on Crypto-ChaCha20Poly1305.encrypt for MacOSX aarch64
P4 JDK-8353671 Remove dead code missed in JDK-8350459
P4 JDK-8350147 Replace example in KEM class with the one from JEP 452
P4 JDK-8249831 Test sun/security/mscapi/nonUniqueAliases/NonUniqueAliases.java is marked with @ignore
P4 JDK-8345598 Upgrade NSS binaries for interop tests

security-libs/javax.crypto:pkcs11

Priority Bug Summary
P3 JDK-8356087 Problematic KeyInfo check using key algorithm in P11SecretKeyFactory class
P3 JDK-8348732 SunJCE and SunPKCS11 have different PBE key encodings
P4 JDK-8349849 PKCS11 SunTlsKeyMaterial crashes when used with TLS1.2 TlsKeyMaterialParameterSpec
P4 JDK-8230016 re-visit test sun/security/pkcs11/Serialize/SerializeProvider.java
P4 JDK-8346720 Support Generic keys in SunPKCS11 SecretKeyFactory
P4 JDK-8328119 Support HKDF in SunPKCS11

security-libs/javax.net.ssl

Priority Bug Summary
P2 JDK-8349583 Add mechanism to disable signature schemes based on their TLS scope
P2 JDK-8340321 Disable SHA-1 in TLS/DTLS 1.2 handshake signatures
P2 JDK-8355779 When no "signature_algorithms_cert" extension is present we do not apply certificate scope constraints to algorithms in "signature_algorithms" extension
P3 JDK-8341346 Add support for exporting TLS Keying Material
P3 JDK-8350807 Certificates using MD5 algorithm that are disabled by default are incorrectly allowed in TLSv1.3 when re-enabled
P3 JDK-8350582 Correct the parsing of the ssl value in javax.net.debug
P3 JDK-8344924 Default CA certificates loaded despite request to use custom keystore
P3 JDK-8346587 Distrust TLS server certificates anchored by Camerfirma Root CAs
P4 JDK-8350705 [JMH] test security.SSLHandshake failed for 2 threads configuration
P4 JDK-8345840 Add missing TLS handshake messages to SSLHandshake.java
P4 JDK-8310003 Improve logging when default truststore is inaccessible
P4 JDK-8277424 javax/net/ssl/TLSCommon/TLSTest.java fails with connection refused
P4 JDK-8348309 MultiNST tests need more debugging and timing
P4 JDK-8357033 Reduce stateless session ticket size
P4 JDK-8349121 SSLParameters.setApplicationProtocols() ALPN example could be clarified
P4 JDK-8355637 SSLSessionImpl's "serialization" list documentation is incorrectly ordered
P4 JDK-8344629 SSLSocketNoServerHelloClientShutdown test timeout
P4 JDK-8354235 Test javax/net/ssl/SSLSocket/Tls13PacketSize.java failed with java.net.SocketException: An established connection was aborted by the software in your host machine
P4 JDK-8355262 Test sun/security/ssl/SSLSessionImpl/NoInvalidateSocketException.java failed: accept timed out
P4 JDK-8249825 Tests sun/security/ssl/SSLSocketImpl/SetClientMode.java and NonAutoClose.java marked with @ignore

security-libs/javax.xml.crypto

Priority Bug Summary
P3 JDK-8354449 Remove com/sun/org/apache/xml/internal/security/resource/xmlsecurity_de.properties
P3 JDK-8344137 Update XML Security for Java to 3.0.5

security-libs/jdk.security

Priority Bug Summary
P3 JDK-8353299 VerifyJarEntryName.java test fails
P4 JDK-8339280 jarsigner -verify performs cross-checking between CEN and LOC
P4 JDK-8349501 Relocate supporting classes in security/testlibrary to test/lib/jdk tree
P4 JDK-8346285 Update jarsigner compatibility test for change in default digest algorithm
P5 JDK-8337723 Remove redundant tests from com/sun/security/sasl/gsskerb

security-libs/org.ietf.jgss

Priority Bug Summary
P4 JDK-8351349 GSSUtil.createSubject has outdated access control context and policy related text

security-libs/org.ietf.jgss:krb5

Priority Bug Summary
P3 JDK-8297531 sun/security/krb5/MicroTime.java fails with "Exception: What? only 100 musec precision?"
P4 JDK-8352719 Add an equals sign to the modules statement
P4 JDK-8349534 Refactor jdk/sun/security/krb5/runNameEquals.sh to java test

specification/language

Priority Bug Summary
P4 JDK-8348901 14.11.1: Allow 'null' case label for 'switch (null)'
P4 JDK-8346100 15.9.2: Assertion regarding local class creation and static contexts should refer to direct superclass of the anonymous class, not the anonymous class itself
P4 JDK-8346380 15.9.2: Fix the assertion regarding instantiation of an anonymous class
P4 JDK-8362424 Hyphenate “null” followed by “matching” in the definition
P4 JDK-8349215 JEP 507: Primitive Types in Patterns, instanceof, and switch (Third Preview)
P4 JDK-8344700 JEP 511: Module Import Declarations
P4 JDK-8344699 JEP 512: Compact Source Files and Instance Main Methods
P4 JDK-8344702 JEP 513: Flexible Constructor Bodies
P4 JDK-8344707 JLS Changes for Compact Source Files and Instance Main Methods
P4 JDK-8344704 JLS changes for Flexible Constructor Bodies
P4 JDK-8344709 JLS changes for Module Import Declarations
P4 JDK-8354325 JLS Changes for Primitive Types in Patterns, instanceof, and switch (Third Preview)
P4 JDK-8351401 Remove Uses of Boxed Primitive Constructors in JLS

specification/vm

Priority Bug Summary
P4 JDK-8323626 4.10.1.2: improve verification typing rules
P4 JDK-8349179 4.10.1.9 invokespecial: rewrittenUninitializedType has wrong result type
P4 JDK-8323611 4.10.1.9 multianewarray: revise classDimension predicate
P4 JDK-8323557 4.10.1: clarify distinction between types and classes
P4 JDK-8258138 4.10: Eliminate redundant 'final' checks in verification
P4 JDK-8342985 4.1: Allow v69.0 class files for Java SE 25
P4 JDK-8358016 Address versions and preview features in JVMS Chapter 1
P5 JDK-8342613 6.5: Opcode description issues

tools

Priority Bug Summary
P3 JDK-8341608 jdeps in JDK 23 crashes when parsing signatures while jdeps in JDK 22 works fine
P4 JDK-8349984 (jdeps) jdeps can use String.repeat instead of String.replaceAll
P4 JDK-8357654 [BACKOUT] JDK-8343580: Type error with inner classes of generic classes in functions generic by outer
P4 JDK-8353840 JNativeScan should not abort for missing classes
P4 JDK-8353917 jnativescan: Simplify ClassResolver
P4 JDK-8352748 Remove com.sun.tools.classfile from the JDK
P4 JDK-8345804 Update copyright year to 2024 for langtools in files where it was missed

tools/jar

Priority Bug Summary
P4 JDK-8345431 Improve jar --validate to detect duplicate or invalid entries
P4 JDK-8302293 jar --create fails with IllegalArgumentException if archive name is shorter than 3 characters
P4 JDK-8345506 jar --validate may lead to java.nio.file.FileAlreadyExistsException
P4 JDK-8268611 jar --validate should check targeted classes in MR-JAR files
P4 JDK-8346232 Remove leftovers of the jar --normalize feature

tools/javac

Priority Bug Summary
P1 JDK-8348038 Docs build failing in Options.notifyListeners with AssertionError
P2 JDK-8359596 Behavior change when both -Xlint:options and -Xlint:-options flags are given
P2 JDK-8355065 ConcurrentModificationException in RichDiagnosticFormatter
P2 JDK-8356441 IllegalStateException in RichDiagnosticFormatter after JDK-8355065
P2 JDK-8361570 Incorrect 'sealed is not allowed here' compile-time error
P2 JDK-8352621 MatchException from backwards incompatible change to switch expressions
P3 JDK-8349058 'internal proprietary API' warnings make javac warnings unusable
P3 JDK-8356894 Adjust CreateSymbols to properly handle the newly added @jdk.internal.RequiresIdentity
P3 JDK-8361214 An anonymous class is erroneously being classify as an abstract class
P3 JDK-8322706 AnnotationTypeMismatchException in javac with annotation processing
P3 JDK-8357016 Candidate main methods not computed properly
P3 JDK-8348928 Check for case label validity are misbehaving when binding patterns with unnamed bindings are present
P3 JDK-8320220 Compilation of cyclic hierarchy causes infinite recursion
P3 JDK-8361445 javac crashes on unresolvable constant in @SuppressWarnings
P3 JDK-8353565 Javac throws "inconsistent stack types at join point" exception
P3 JDK-8345944 JEP 492: extending local class in a different static context should not be allowed
P3 JDK-8345953 JEP 492: instantiating local classes in a different static context should not be allowed
P3 JDK-8322810 Lambda expression types can't be classes
P3 JDK-8344647 Make java.se participate in the preview language feature `requires transitive java.base`
P3 JDK-8347646 module-info classfile missing the preview flag
P3 JDK-8348212 Need to add warn() step to JavacTaskImpl after JDK-8344148
P3 JDK-8358066 Non-ascii package names gives compilation error "import requires canonical name"
P3 JDK-8351232 NPE: Cannot invoke "getDeclarationAttributes" because "sym" is null
P3 JDK-8325859 Potential information loss during type inference
P3 JDK-8336470 Source launcher should work with service loader SPI in unnamed module
P3 JDK-8349475 Test tools/javac/api/TestJavacTaskWithWarning.java writes files in src dir
P4 JDK-8355753 @SuppressWarnings("this-escape") not respected for indirect leak via field
P4 JDK-8329951 `var` emits deprecation warnings that do not point to the file or position
P4 JDK-8354071 Add LintCategory property indicating whether @SuppressWarnings is supported
P4 JDK-8342983 Add source 25 and target 25 to javac
P4 JDK-8355004 Apply java.io.Serial annotations in java.compiler
P4 JDK-8326485 Assertion due to Type.addMetadata adding annotations to already-annotated type
P4 JDK-8343882 BasicAnnoTests doesn't handle multiple annotations at the same position
P4 JDK-8344703 Compiler Implementation for Flexible Constructor Bodies
P4 JDK-8164714 Constructor.newInstance creates instance of inner class with null outer class
P4 JDK-8348427 DeferredLintHandler API should use JCTree instead of DiagnosticPosition
P4 JDK-8332934 Do loop with continue with subsequent switch leads to incorrect stack maps
P4 JDK-8349512 Duplicate PermittedSubclasses entries with doclint enabled
P4 JDK-8357361 Exception when compiling switch expression with inferred type
P4 JDK-8354556 Expand value-based class warnings to java.lang.ref API
P4 JDK-8349991 GraphUtils.java can use String.replace() instead of String.replaceAll()
P4 JDK-8344708 Implement JEP 511: Module Import Declarations
P4 JDK-8344706 Implement JEP 512: Compact Source Files and Instance Main Methods
P4 JDK-8347530 Improve error message with invalid permits clauses
P4 JDK-8348906 InstanceOfTree#getType doesn't specify when it returns null
P4 JDK-8346751 Internal java compiler error with type annotations in constants expression in constant fields
P4 JDK-8349754 Invalid "early reference" error when class extends an outer class
P4 JDK-8346294 Invalid lint category specified in compiler.properties
P4 JDK-8315447 Invalid Type Annotation attached to a method instead of a lambda
P4 JDK-8349132 javac Analyzers should handle non-deferrable errors
P4 JDK-8347562 javac crash due to type vars in permits clause
P4 JDK-8334756 javac crashed on call to non-existent generic method with explicit annotated type arg
P4 JDK-8354908 javac mishandles supplementary character in character literal
P4 JDK-8356551 Javac rejects receiver parameter in constructor of local class in early construction context
P4 JDK-8338675 javac shouldn't silently change .jar files on the classpath
P4 JDK-8352896 LambdaExpr02.java runs wrong test class
P4 JDK-8345263 Make sure that lint categories are used correctly when logging lint warnings
P4 JDK-8310310 Migrate CreateSymbols tool in make/langtools to Classfile API
P4 JDK-8352612 No way to add back lint categories after "none"
P4 JDK-8351556 Optimize Location.locationFor/isModuleOrientedLocation
P4 JDK-8347474 Options singleton is used before options are parsed
P4 JDK-8348410 Preview flag not checked during compilation resulting in runtime crash
P4 JDK-8356057 PrintingProcessor (-Xprint) does not print type variable bounds and type annotations for Object supertypes
P4 JDK-8354090 Refactor import warning suppression in Check.java
P4 JDK-8354323 Safeguard SwitchBootstraps.typeSwitch when used outside the compiler
P4 JDK-8352642 Set zipinfo-time=false when constructing zipfs FileSystem in com.sun.tools.javac.file.JavacFileManager$ArchiveContainer for better performance
P4 JDK-8354216 Small cleanups relating to Log.DiagnosticHandler
P4 JDK-8354766 Test TestUnexported.java javac build fails
P4 JDK-8345622 test/langtools/tools/javac/annotations/parameter/ParameterAnnotations.java should set processorpath to work correctly in the agentvm mode
P4 JDK-8347989 Trees.getScope may crash for not-yet attributed source
P4 JDK-8351431 Type annotations on new class creation expressions can't be retrieved
P4 JDK-8343580 Type error with inner classes of generic classes in functions generic by outer
P5 JDK-8344148 Add an explicit compiler phase for warning generation
P5 JDK-8352731 Compiler workaround to forcibly set "-Xlint:-options" can be removed
P5 JDK-8353757 Log class should have a proper clear() method
P5 JDK-8347958 Minor compiler cleanups relating to MandatoryWarningHandler
P5 JDK-8344079 Minor fixes and cleanups to compiler lint-related code
P5 JDK-8343477 Remove unnecessary @SuppressWarnings annotations (compiler)
P5 JDK-8347141 Several javac tests compile with an unnecessary -Xlint:-path flag
P5 JDK-8349155 The "log" parameter to Lint.logIfEnabled() is not needed

tools/javadoc(tool)

Priority Bug Summary
P3 JDK-8359024 Accessibility bugs in API documentation
P3 JDK-8286931 Add missing @serial tags to re-enable -serialwarn option
P3 JDK-8348282 Add option for syntax highlighting in javadoc snippets
P3 JDK-8346109 Create JDK taglet for additional preview notes
P3 JDK-8356276 JavaScript error in script.js after JDK-8348282
P3 JDK-8351332 Line breaks in search tag descriptions corrupt JSON search index
P3 JDK-8350638 Make keyboard navigation more usable in API docs
P3 JDK-8357458 Missing Highlight.js license file
P3 JDK-8346785 Potential infinite loop in JavadocTokenizer.ensures
P3 JDK-8287749 Re-enable javadoc -serialwarn option
P3 JDK-8352389 Remove incidental whitespace in pre/code content
P3 JDK-8352249 Remove incidental whitespace in traditional doc comments
P3 JDK-8346659 SnippetTaglet should report an error if provided ambiguous links
P3 JDK-8347058 When automatically translating the page to pt-br, all CSS styling disappears
P4 JDK-8337112 Accessibility checker for generated documentation
P4 JDK-8337109 Add system wide checks to the generated documentation
P4 JDK-8350007 Add usage message to the javadoc executable
P4 JDK-8337113 Bad character checker for generated documentation
P4 JDK-8337111 Bad HTML checker for generated documentation
P4 JDK-8332746 Broken links in JDK-24+14
P4 JDK-8345908 Class links should be properly spaced
P4 JDK-8337114 DocType checker for generated documentation
P4 JDK-8338833 Error on reference not found for a snippet target
P4 JDK-8337117 External links checker for generated documentation
P4 JDK-8352151 Fix display issues in javadoc-generated docs
P4 JDK-8338554 Fix inconsistencies in javadoc/doclet/testLinkOption/TestRedirectLinks.java
P4 JDK-8351555 Help section added in JDK-8350638 uses invalid HTML
P4 JDK-8254622 Hide superclasses from conditionally exported packages
P4 JDK-8345555 Improve layout of search results
P4 JDK-8345777 Improve sections for inherited members
P4 JDK-8331873 Improve/expand info in `New API In` on Help page
P4 JDK-8328848 Inaccuracy in the documentation of the -group option
P4 JDK-8337116 Internal links checker for generated documentation
P4 JDK-8352740 Introduce new factory method HtmlTree.IMG
P4 JDK-8322151 Javadoc documentation corrupted
P4 JDK-8345770 javadoc: API documentation builds are not always reproducible
P4 JDK-8358136 Make langtools/jdk/javadoc/doclet/testLinkOption/TestRedirectLinks.java intermittent
P4 JDK-8344301 Refine stylesheet for API docs
P4 JDK-8357452 Remove code span highlight in JavaDoc default stylesheet
P4 JDK-8357869 Remove PreviewNote taglet in its current form
P4 JDK-8352511 Show additional level of headings in table of contents
P4 JDK-8345212 Since checker should better handle non numeric values
P4 JDK-8357796 Stylesheet adjustments after JDK-8357452
P4 JDK-8349369 test/docs/jdk/javadoc/doccheck/checks/jdkCheckLinks.java did not report on missing man page files
P4 JDK-8351881 Tidy complains about missing "alt" attribute
P4 JDK-8351626 Update remaining icons to SVG format
P4 JDK-8347381 Upgrade jQuery UI to version 1.14.1
P4 JDK-8345664 Use simple parameter type names in @link and @see tags

tools/javap

Priority Bug Summary
P3 JDK-8358078 javap crashes with NPE on preview class file
P4 JDK-8355956 Prepare javap for class file format aware access flag parsing

tools/jlink

Priority Bug Summary
P2 JDK-8347376 tools/jlink/runtimeImage/JavaSEReproducibleTest.java and PackagedModulesVsRuntimeImageLinkTest.java failed after JDK-8321413
P3 JDK-8345259 Disallow ALL-MODULE-PATH without explicit --module-path
P3 JDK-8321413 IllegalArgumentException: Code length outside the allowed range while creating a jlink image
P3 JDK-8353185 Introduce the concept of upgradeable files in context of JEP 493
P3 JDK-8303884 jlink --add-options plugin does not allow GNU style options to be provided
P3 JDK-8345573 Module dependencies not resolved from run-time image when --limit-module is being used
P3 JDK-8355524 Only every second line in upgradeable files is being used
P3 JDK-8354629 Test tools/jlink/ClassFileInMetaInfo.java fails on builds with configure option --enable-linkable-runtime
P4 JDK-8347146 Convert IncludeLocalesPluginTest to use JUnit
P4 JDK-8331467 FileSystems.getDefault fails with ClassNotFoundException if custom default provider is in run-time image
P4 JDK-8346239 Improve memory efficiency of JimageDiffGenerator
P4 JDK-8349909 jdk.internal.jimage.decompressor.ZipDecompressor does not close the Inflater in exceptional cases
P4 JDK-8349907 jdk.tools.jlink.internal.plugins.ZipPlugin does not close the Deflater in exceptional cases
P4 JDK-8347334 JimageDiffGenerator code clean-ups
P4 JDK-8349989 jlink can use String.replace instead of String.replaceAll
P4 JDK-8353267 jmod create finds the wrong set of packages when class file are in non-package location
P4 JDK-8347302 Mark test tools/jimage/JImageToolTest.java as flagless
P4 JDK-8347761 Test tools/jimage/JImageExtractTest.java fails after JDK-8303884

tools/jpackage

Priority Bug Summary
P2 JDK-8346069 Add missing Classpath exception statements
P2 JDK-8357478 Fix copyright header in src/jdk.jpackage/share/classes/jdk/jpackage/internal/AppImageDesc.java
P2 JDK-8352293 jpackage tests build rpm packages on Ubuntu test machines after JDK-8351372
P3 JDK-8352289 [macos] Review skipped tests in tools/jpackage/macosx/SigningPackage*
P3 JDK-8354320 Changes to jpackage.md cause pandoc warning
P3 JDK-8333664 Decouple command line parsing and package building in jpackage
P3 JDK-8356309 Fix issues uncovered after running jpackage tests locally with installing test packages
P3 JDK-8351372 Improve negative tests coverage of jpackage
P3 JDK-8355651 Issues with post-image hook
P3 JDK-8326447 jpackage creates Windows installers that cannot be signed
P3 JDK-8356562 SigningAppImageTwoStepsTest test fails
P3 JDK-8349504 Support platform-specific JUnit tests in jpackage
P3 JDK-8345185 Update jpackage to not include service bindings by default
P4 JDK-8356664 [macos] AppContentTest fails after JDK-8352480
P4 JDK-8349509 [macos] Clean up macOS dead code in jpackage
P4 JDK-8353196 [macos] Contents of ".jpackage.xml" file are wrong when building .pkg from unsigned app image
P4 JDK-8353321 [macos] ErrorTest.testAppContentWarning test case requires signing environment
P4 JDK-8356819 [macos] MacSign should use "openssl" and "faketime" from Homebrew by default
P4 JDK-8347139 [macos] Test tools/jpackage/share/InOutPathTest.java failed: "execution error: Finder got an error: AppleEvent timed out."
P4 JDK-8351369 [macos] Use --install-dir option with DMG packaging
P4 JDK-8347272 [ubsan] JvmLauncher.cpp:262:52: runtime error: applying non-zero offset 40 to null pointer
P4 JDK-8350013 Add a test for JDK-8150442
P4 JDK-8357644 Add missing CPE statements
P4 JDK-8346434 Add test for non-automatic service binding
P4 JDK-8354985 Add unit tests for Executor class from jpackage test lib
P4 JDK-8357930 Amendment for JDK-8333664
P4 JDK-8352176 Automate setting up environment for mac signing tests
P4 JDK-8354989 Bug in MacCertificate class
P4 JDK-8352275 Clean up dead code in jpackage revealed with improved negative test coverage
P4 JDK-8349564 Clean warnings found in jpackage tests when building them with -Xlint:all
P4 JDK-8350011 Convert jpackage test lib tests in JUnit format
P4 JDK-8356128 Correct documentation for --linux-package-deps
P4 JDK-8350102 Decouple jpackage test-lib Executor.Result and Executor classes
P4 JDK-8352480 Don't follow symlinks in additional content for app images
P4 JDK-8150442 Enforce Supported Platforms in Packager for MSI bundles
P4 JDK-8355328 Improve negative tests coverage for jpackage signing
P4 JDK-8285624 jpackage fails to create exe, msi when Windows OS is in FIPS mode
P4 JDK-8356219 jpackage places libapplauncher.so in incorrect location in the app image
P4 JDK-8353681 jpackage suppresses errors when executed with --verbose option
P4 JDK-8333569 jpackage tests must run app launchers with retries on Linux only
P4 JDK-8341641 Make %APPDATA% and %LOCALAPPDATA% env variables available in *.cfg files
P4 JDK-8350601 Miscellaneous updates to jpackage test lib
P4 JDK-8334322 Misleading values of keys in jpackage resource bundle
P4 JDK-8350594 Misleading warning about install dir for DMG packaging
P4 JDK-8353679 Restructure classes in jdk.jpackage.internal package
P4 JDK-8354988 Separate stderr and stdout in Executor class from jpackage test lib
P4 JDK-8352419 Test tools/jpackage/share/ErrorTest.java#id0 and #id1 fail
P4 JDK-8333568 Test that jpackage doesn't modify R/O files/directories
P4 JDK-8349648 Test tools/jpackage/share/JLinkOptionsTest.java fails with --enable-linkable-runtime set after JDK-8346434
P4 JDK-8358017 Various enhancements of jpackage test helpers

tools/jshell

Priority Bug Summary
P3 JDK-8347050 Console.readLine() drops '\' when reading through JLine
P3 JDK-8341833 incomplete snippet from loaded files from command line is ignored
P3 JDK-8356245 stdin.encoding and stdout.encoding in jshell don't respect console code pages
P3 JDK-8353581 Support for `import module` in JShell's code completion
P3 JDK-8356165 System.in in jshell replace supplementary characters with ??
P3 JDK-8353332 Test jdk/jshell/ToolProviderTest.java failed in relation to enable-preview
P4 JDK-8353545 Improve debug info for StartOptionTest
P4 JDK-8351639 Improve debuggability of test/langtools/jdk/jshell/JdiHangingListenExecutionControlTest.java test
P4 JDK-8356633 Incorrect use of {@link} in jdk.jshell
P4 JDK-8350595 jshell completion on arrays does not work for clone()
P4 JDK-8350983 JShell LocalExecutionControl only needs stopCheck() on backward branches
P4 JDK-8355323 JShell LocalExecutionControl should add stopCheck() at method entry
P4 JDK-8299934 LocalExecutionControl replaces default uncaught exception handler
P4 JDK-8355371 NegativeArraySizeException in print methods in IO or System.console() in JShell
P4 JDK-8354910 Output by java.io.IO or System.console() corrupted for some non-ASCII characters
P4 JDK-8333262 Regression 3-4% in SpringBoot startup bmk
P4 JDK-8350808 Small typos in JShell method SnippetEvent.toString()
P4 JDK-8347629 Test FailOverDirectExecutionControlTest.java fails with -Xcomp
P4 JDK-8350749 Upgrade JLine to 3.29.0

tools/launcher

Priority Bug Summary
P4 JDK-8349254 Disable "best-fit" mapping on Windows environment variables
P4 JDK-8346778 Enable native access should work with the source launcher
P4 JDK-8351188 java launcher's implementation of (instance) main method selection can cause unexpected classloading failures
P4 JDK-8354260 Launcher help text is wrong for -Xms
P4 JDK-8352935 Launcher should not add $JDK/../lib to LD_LIBRARY_PATH
P4 JDK-8354189 Remove JLI_ReportErrorMessageSys on Windows
P4 JDK-8352046 Test testEcoFriendly() in jdk tools launcher ExecutionEnvironment.java for AIX and Linux/musl is brittle
P4 JDK-8293910 tools/launcher/FXLauncherTest.java fail with jfx

xml

Priority Bug Summary
P4 JDK-8344925 translet-name ignored when package-name is also set

xml/javax.xml.parsers

Priority Bug Summary
P4 JDK-8350051 [JMH] Several tests fails NPE

xml/javax.xml.validation

Priority Bug Summary
P4 JDK-8349516 StAXStream2SAX.handleCharacters() fails on empty CDATA

xml/jaxb

Priority Bug Summary
P4 JDK-8327378 XMLStreamReader throws EOFException instead of XMLStreamException

xml/jaxp

Priority Bug Summary
P4 JDK-8351969 Add Public Identifiers to the JDK built-in Catalog
P4 JDK-8343609 Broken links in java.xml
P4 JDK-8354774 DocumentBuilderFactory getAttribute throws NPE
P4 JDK-8323740 java.lang.ExceptionInInitializerError when trying to load XML classes in wrong order
P4 JDK-8259540 MissingResourceException for key cvc-complex-type.2.4.d.1
P4 JDK-8353234 Refactor XMLSecurityPropertyManager
P4 JDK-8353232 Standardizing and Unifying XML Component Configurations
P4 JDK-8354084 Streamline XPath API's extension function control
P4 JDK-8349959 Test CR6740048.java passes unexpectedly missing CR6740048.xsd
P4 JDK-8359337 XML/JAXP tests that make network connections should ensure that no proxy is selected

xml/org.xml.sax

Priority Bug Summary
P4 JDK-8349699 XSL transform fails with certain UTF-8 characters on 1024 byte boundaries