RELEASE NOTES FOR: 22 ==================================================================================================== Notes generated: Thu Apr 25 07:58:59 CEST 2024 Hint: Prefix bug IDs with https://bugs.openjdk.org/browse/ to reach the relevant JIRA entry. JAVA ENHANCEMENT PROPOSALS (JEP): JEP 423: Region Pinning for G1 Reduce latency by implementing region pinning in G1, so that garbage collection need not be disabled during Java Native Interface (JNI) critical regions. JEP 447: Statements before super(...) (Preview) In constructors in the Java programming language, allow statements that do not reference the instance being created to appear before an explicit constructor invocation. This is a [preview language feature](https://openjdk.org/jeps/12). JEP 454: Foreign Function & Memory API Introduce an API by which Java programs can interoperate with code and data outside of the Java runtime. By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI. JEP 456: Unnamed Variables & Patterns Enhance the Java programming language with unnamed variables and unnamed patterns, which can be used when variable declarations or nested patterns are required but never used. Both are denoted by the underscore character, `_`. JEP 457: Class-File API (Preview) Provide a standard API for parsing, generating, and transforming Java class files. This is a [preview API](https://openjdk.org/jeps/12). JEP 458: Launch Multi-File Source-Code Programs Enhance the `java` application launcher to be able to run a program supplied as multiple files of Java source code. This will make the transition from small programs to larger ones more gradual, enabling developers to choose whether and when to go to the trouble of configuring a build tool. JEP 459: String Templates (Second Preview) Enhance the Java programming language with _string templates_. String templates complement Java's existing string literals and text blocks by coupling literal text with embedded expressions and _template processors_ to produce specialized results. This is a [preview language feature and API](https://openjdk.org/jeps/12). JEP 460: Vector API (Seventh Incubator) Introduce an API to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPU architectures, thus achieving performance superior to equivalent scalar computations. JEP 461: Stream Gatherers (Preview) Enhance the [Stream API](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/stream/package-summary.html) to support custom intermediate operations. This will allow stream pipelines to transform data in ways that are not easily achievable with the existing built-in intermediate operations. This is a [preview API](https://openjdk.org/jeps/12). JEP 462: Structured Concurrency (Second Preview) Simplify concurrent programming by introducing an API for *structured concurrency*. Structured concurrency treats groups of related tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability. This is a [preview API](https://openjdk.org/jeps/12). JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview) Evolve the Java programming language so that students can write their first programs without needing to understand language features designed for large programs. Far from using a separate dialect of the language, students can write streamlined declarations for single-class programs and then seamlessly expand their programs to use more advanced features as their skills grow. This is a [preview language feature](https://openjdk.org/jeps/12). JEP 464: Scoped Values (Second Preview) Introduce _scoped values_, which enable managed sharing of immutable data both with child frames in the same thread, and with child threads. Scoped values are easier to reason about than thread-local variables and have lower space and time costs, especially when used in combination with [Virtual Threads](https://openjdk.org/jeps/444) and [Structured Concurrency](https://openjdk.org/jeps/462). This is a [preview API](https://openjdk.org/jeps/12). RELEASE NOTES: tools/javac: JDK-8319196: `ExecutableElement.getReceiverType` and `ExecutableType.getReceiverType()` Changed to Return Annotated Receiver Types for Methods Loaded from Bytecode The implementation of `ExecutableElement.getReceiverType` and `ExecutableType.getReceiverType` now returns a receiver type for methods loaded from bytecode if the type has associated type annotations. Previously it returned `NOTYPE` for all methods loaded from bytecode, which prevented associated type annotations from being retrieved. JDK-8318160: The `javac` Compiler Should Not Accept Private Method References with a Type Variable Receiver Prior to JDK 22, the `javac` compiler was accepting private method references with a type variable receiver. This implies that the `javac` compiler was accepting code like: ``` import java.util.function.*; class Test { private String asString() { return "bar"; } static Function foo() { return T::asString; } } ``` Starting from JDK 22 private method references with type variable receiver will be rejected by the `javac` compiler. JDK-8317300: Align `javac` with the Java Language Specification by Rejecting `final` in Record Patterns JDK 21 introduced pattern matching in the Java language. However, `javac` allowed `final` in front of a record pattern, such as (`case final R(...) ->`), something which is not allowed by the Java Language Specification. Programs that could be compiled erroneously in JDK21 with `final` will now fail to compile. This change fixes the issue in the compiler. Impacted users will need to remove the `final` keyword. JDK-8225377: `TypeMirror` Changed to Provide Annotations for Types Loaded from Bytecode The implementation of `TypeMirror` now provides access to annotations for types loaded from bytecode. Previously type annotations were not associated with types loaded from bytecode. Annotation processors can access type annotations for elements using `AnnotationMirror#getAnnotationMirrors`, and the annotations will be included in the output of `AnnotationMirror#toString`. Any programs that relied on annotations being omitted for elements loaded from the classpath should be updated to handle type annotations. JDK-8318913: When Using `--release N`, the System Module Descriptors Will Contain `N` As the Module Version For release builds of the JDK, when `javac` is used with `--release N`, the module descriptors for system modules will always contain `N` as their module version, regardless of the current JDK release and update release versions. For pre-release builds of JDK, the version will contain the pre-release identifiers in addition to `N`. Previously, the module version encoded in the module descriptors was either missing, for JDK release N, and `--release M`, where M < N, or the full module version, including update versions for JDK release N and `--release N`. JDK-8316971: Add `lint` Warning for Restricted Method Calls Some methods in the Foreign Function & Memory API are unsafe. When used improperly, these methods can lead to loss of memory safety which can result in a JVM crash or silent memory corruption. Accordingly, the unsafe methods in the FFM API are *restricted*. This means that their use is permitted, but by default causes a warning to be issued at run time. To indicate where run time warnings may occur, a new javac lint option, `-Xlint:restricted`, causes warnings to be issued at compile time if restricted methods are called in source code. These compile-time warnings can be suppressed using `@SuppressWarnings("restricted")`. JDK-8310061: `javac` Message If Implicit Annotation Processors Are Being Used Annotation processing by `javac` is enabled by default, including when no annotation processing configuration options are present. Implicit annotation processing by default may be disabled in a future release, possibly as early as JDK 22. To alert `javac` users of this possibility, in JDK 21 `javac` prints a note if implicit annotation processing is being used. The text of the note is: ``` Annotation processing is enabled because one or more processors were found on the class path. A future release of javac may disable annotation processing unless at least one processor is specified by name (-processor), or a search path is specified (--processor-path, --processor-module-path), or annotation processing is enabled explicitly (-proc:only, -proc:full). Use -Xlint:-options to suppress this message. Use -proc:none to disable annotation processing. ``` Good build hygiene includes explicitly configuring annotation processing. To ease the transition to a different default policy in the future, the new-in-JDK-21 `-proc:full javac` option requests the current default behavior of looking for annotation processors on the class path. core-libs/java.util: JDK-8302987: Add `equiDoubles()` Method to `java.util.random.RandomGenerator`. A new method, `equiDoubles()`, has been added to `java.util.random.RandomGenerator`. `equiDoubles()` guarantees a uniform distribution, provided the underlying `nextLong(long)` method returns uniformly distributed values, that is as dense as possible. It returns a `DoubleStream` rather than individual `double`s because of slightly expensive initial computations. They are better absorbed as setup costs for the stream rather than being repeated for each new computed value. The aim is to overcome some numerical limitations in the families of `doubles()` and `nextDouble()` methods. In these, an affine transform is applied to a uniformly distributed pseudo-random value in the half-open interval [0.0, 1.0) to obtain a pseudo-random value in the half-open interval [origin, bound). However, due to the nature of floating-point arithmetic, the affine transform ends up in a slightly distorted distribution, which is not necessarily uniform. core-libs/java.net: JDK-8308593: `TCP_KEEPxxxx` Extended Socket Options Are Now Supported on the Windows Platform The `java.net.ExtendedSocketOptions` `TCP_KEEPIDLE` and `TCP_KEEPINTERVAL` are supported on Windows platforms starting from Windows 10 version 1709 and onwards. `TCP_KEEPCOUNT` is supported starting from Windows 10 version 1703 and onwards. JDK-8318150: Corrected `ProxySelector` Parameter Validation The `java.net.ProxySelector` methods `select` and `connectFailure` now throw `IllegalArgumentException` in all `ProxySelector` implementations when called with invalid parameters. Previously, the `select` method of the `ProxySelector` returned by `ProxySelector.of(InetSocketAddress)` was incorrectly throwing a `NullPointerException` when its `uri` parameter was `null` or if the protocol could not be determined. The `connectFailed` method of the same `ProxySelector` instance returned without checking its parameters for validity. core-libs/java.util:i18n: JDK-8306116: Gregorian Era Names with `java.time.format` APIs Names for Gregorian eras returned from `java.time.format` APIs are now correctly retrieved from the CLDR locale data. Prior to this change, these APIs incorrectly used names from the legacy COMPAT locale data. For example, the Gregorian era names "BCE"/"CE" are now returned for the ROOT locale, instead of "BC"/"AD" that are in the COMPAT locale data. For possible compatibility issues and workarounds, refer to JDK-8320431 for more details. JDK-8306116: Support for CLDR Version 44 The locale data based on the Unicode Consortium's CLDR has been upgraded to version 44. Besides the usual addition of new locale data and translation changes, there are two notable date/time format changes from the upstream CLDR: - Mexico and Latin American countries changed their time formats from 24 hours to 12 hours ([CLDR-16358](https://unicode-org.atlassian.net/browse/CLDR-16358)) - The `FULL` date format for Australia and the United Kingdom no longer has a comma after weekday ([CLDR-16974](https://unicode-org.atlassian.net/browse/CLDR-16974)) Note that those locale data are subject to change in a future release of the CLDR, so users should not assume stability across releases. For more detailed locale data changes, please refer to the [Unicode Consortium's CLDR release notes](https://cldr.unicode.org/index/downloads/cldr-44). core-libs/java.lang: JDK-8311906: `Files.readString` May Return Incorrect String When Using UTF-16 or Other Charsets Strings read with `java.nio.files.Files.readString` may return incorrect strings when decoding with a charset other than US-ASCII, ISO08859-1, or UTF-8. Reading strings with other multi-byte charsets, such as UTF_16, may produce incorrect results. As a work-around, disable compact strings by setting `-XX:-CompactStrings` on the command line. This issue will be fixed in a future update. JDK-8309196: `Thread.countStackFrames` Has Been Removed The method `java.lang.Thread.countStackFrames()` has been removed in this release. This method dates from JDK 1.0 as an API for counting the stack frames of a suspended thread. The method was deprecated in JDK 1.2 (1998), deprecated for removal in Java 9, and re-specified/degraded in Java 14 to throw `UnsupportedOperationException` unconditionally. `java.lang.StackWalker` was added in Java 9 as a modern API for walking the current thread's stack. JDK-8296246: Support Unicode 15.1 This release upgrades the Unicode version to 15.1, which includes updated versions of the Unicode Character Database and Unicode Standard Annexes #9, #15, and #29: - The `java.lang.Character` class supports the Unicode Character Database, which adds 627 characters, for a total of 149,813 characters. The addition includes one new `UnicodeBlock`, which consists of urgently needed CJK ideographs, synchronized with planned additions to the Chinese national standard, GB 18030. - The `java.text.Bidi` and `java.text.Normalizer` classes support Unicode Standard Annexes, #9 and #15, respectively. - The `java.util.regex` package supports Extended Grapheme Clusters based on the Unicode Standard Annex #29. For more details about Unicode 15.1, refer to the [Unicode Consortium’s release note](https://unicode.org/versions/Unicode15.1.0/). core-libs/java.lang.foreign: JDK-8310626: JEP 454: Foreign Function & Memory API The Foreign Function & Memory API allows Java programs to interoperate with code and data outside of the Java runtime. Access to foreign memory is realized via the `MemorySegment` class. A memory segment is backed by a contiguous region of memory, located either off-heap or on-heap. Safe and deterministic deallocation of off-heap memory segments is provided via the `Arena` class. Structured access to memory segments is realized via the `MemoryLayout` class. A memory layout can be used to compute the size and offsets of struct fields, and to obtain var handles that read and write the data in memory segments. Access to foreign functions is realized via the `Linker` class. The native linker can be used to obtain method handles that provide a fast way for Java code to invoke native code. Native code is invoked using the calling convention for the OS and processor where the Java runtime is executing, so Java code is not polluted with platform-specific details. Native code can also call back into Java code. Native code is generally unsafe; if used incorrectly, it might crash the JVM or result in memory corruption. Some of the methods in the Foreign Function & Memory API are considered unsafe because they provide access to native code. These unsafe methods are *restricted*, which means their use is permitted but causes warnings at run time. Developers can compile their code with `-Xlint:restricted` to learn if it will produce warnings at run time due to use of unsafe methods. If the risks associated with native code are understood, then unsafe methods can be used without warnings at run time by passing `--enable-native-access=...` on the `java` command line. For example, `java --enable-native-access=com.example.myapp,ALL-UNNAMED ...` enables warning-free use of unsafe methods by code in the `com.example.myapp` module and code on the class path (denoted by `ALL-UNNAMED`). Additionally, in an executable JAR, the manifest attribute `Enable-Native-Access: ALL-UNNAMED` enables warning-free use of unsafe methods by code on the class path; no other module can be specified. When the `--enable-native-access` option or JAR manifest attribute is present, any use of unsafe methods by code outside the list of specified modules causes an `IllegalCallerException` to be thrown, rather than a warning to be issued. hotspot/svc: JDK-8306441: Two Phase Segmented Heap Dump During a heap dump, the application must pause execution and wait for the VM to complete the heap dump before resuming. This enhancement aims to minimize application pause time as much as possible by dividing the heap dump into two phases: - Phase one: Concurrent threads directly write data to segmented heap files (application is paused). - Phase two: Multiple heap files are merged into a complete heap dump file (application is resumed). This approach significantly reduces application pause time, but it is important to note that the total time required for the heap dump itself remains unchanged. This optimization solely focuses on minimizing the impact on the application's pause time. When executing `jmap` or `jcmd GC.heap_dump`, the VM automatically selects an appropriate number of parallel threads based on the type of garbage collector, number of processors, heap size, and degree of fragmentation. It will attempt to perform a parallel heap dump whenever possible, falling back to using a single thread when a parallel heap dump is not possible. In this case, the heap dump behavior is the same as before, and the details of the heap dump can be observed using the `-Xlog:heapdump` option. tools/launcher: JDK-8311653: `-XshowSettings` Launcher Behavior Changes The `-XshowSettings:all` and `-XshowSettings` launch options now differ in behavior. `-XshowSettings` will print a summary view for the `locale` and `security` categories and all information for the other categories. `-XshowSettings:all` will continue to print all settings information available. The `-XshowSettings` launcher option will now reject bad values passed to it. In such cases, an error message is printed and the JVM launch is aborted. See `java -X` for valid options that can be used with the `-XshowSettings` option. JDK-8310201: Available Locales Information Now Listed with `-XshowSettings:locale` Option The showSettings launcher option no longer prints available locales information by default, when `-XshowSettings` is used. The `-XshowSettings:locale` option will continue to print all settings related to available locales. JDK-8227229: `-Xdebug` and `-debug` Options Are Deprecated for Removal The `-Xdebug` and `-debug` options of the `java` command have been deprecated for removal. These options have been ignored for several releases and don't provide any functionality. Using either of these options while launching `java` will now log a deprecation warning. Existing applications which use either of these options should be updated to remove references to these options. core-libs/java.nio.charsets: JDK-8310047: New Constants for 32-bit UTF Charsets The following three new constants in `java.nio.charset.StandardCharsets` class have been introduced: ``` UTF_32 UTF_32BE UTF_32LE ``` These are 32-bit based UTF charsets that are in parallel with the existing 8-bit and 16-bit equivalents. hotspot/runtime: JDK-8305753: Allow JIT Compilation for `-Xshare:dump` It is now possible to enable JIT compilation when creating a CDS archive with the `-Xshare:dump` JVM option. By default, when `-Xshare:dump` is specified, the JIT compiler is disabled, as if the `-Xint` option were specified. This is necessary for creating CDS archives with deterministic content (see JDK-8241071). However, when creating a CDS archive with a very large class list, and when deterministic content is not required, you can add the `-Xmixed` option along with `-Xshare:dump` to enable the JIT compiler, which will speed up the archive creation. JDK-8312072: `-Xnoagent` Option Is Deprecated for Removal The `-Xnoagent` option of the `java` command has been deprecated for removal. This option has been ignored for many releases and doesn't provide any functionality. It will now generate a deprecation warning when used while launching `java`. Any existing code which uses this option should be updated to remove reference to this option. JDK-8261894: The Linux Specific Options `UseSHM` and `UseHugeTLBFS` Are Now Obsolete On Linux, if `UseLargePages` is enabled and `UseTransparentHugePages` is disabled, *static* or *explicit* large page mode, the options `UseSHM` and `UseHugeTLBFS` existed to switch between the two different implementations: - `UseHugeTLBFS` would cause the JVM to use POSIX APIs for allocating large pages. - `UseSHM` would let the JVM would use System V APIs. `UseHugeTLBFS` had been the default if both options were omitted. The `UseSHM` mode offered no advantage over `UseHugeTLBFS` and has therefore been removed. The switch `UseSHM` has been obsoleted. The JVM will now always use POSIX APIs for managing large pages. The switch `UseHugeTLBFS` has also been obsoleted; `UseHugeTLBFS` is now unconditionally enabled and cannot be switched off. JDK-8317772: NMT: Make Peak Values Available in Release Builds NMT reports will now show peak values for all categories. Peak values contain the highest value for committed memory in a given NMT category over the lifetime of the JVM process. If the committed memory for an NMT category is currently at peak, NMT prints "at peak"; otherwise, it prints the peak value. For example: ``` - Compiler (reserved=230KB, committed=230KB) (malloc=34KB #64) (peak=49KB #71) (arena=196KB #4) (peak=6126KB #16) ``` This shows Compiler arena memory peaked at a bit more than 6MB, whereas it now hovers around 200 KB. JDK-8311981: JVM May Hang When Using Generational ZGC if a VM Handshake Stalls on Memory The JVM can hang under an uncommon condition that involves the JVM running out of heap memory, the GC just starting a relocation phase to reclaim memory, and a JVM thread-local Handshake asking to relocate an object. JDK-8315880: Print LockStack in hs_err files We have seen bugs related to the new locking which is used by default since JDK-8315880. It would be helpful to see the LockStack of a crashing JavaThread in hs_err files. JDK-8314243: Add `-XX:UserThreadWaitAttemptsAtExit=` A new flag, `-XX:UserThreadWaitAttemptsAtExit=`, has been introduced. This flag is to specify the number of times the JVM waits for user threads to stop executing native code during a JVM exit. Each wait lasts 10 milliseconds. The maximum number of waits is 1000, to wait at most 10 seconds. By default, `UserThreadWaitAttemptsAtExit` is 30, thus the JVM may wait up to 300 milliseconds for user threads to stop executing native code when the JVM is exiting. That is the same as the existing behavior. JDK-8313782: Add User Facing Warning If THPs Are Enabled but Cannot Be Used On Linux, if the JVM is started with `+UseTransparentHugePages` but the system does not support Transparent Huge Pages, a warning will now be printed to stdout: `UseTransparentHugePages disabled; transparent huge pages are not supported by the operating system.` security-libs/java.security: JDK-8317374: Added ISRG Root X2 CA Certificate from Let's Encrypt The following root certificate has been added to the cacerts truststore: ``` + Let's Encrypt + letsencryptisrgx2 DN: CN=ISRG Root X2, O=Internet Security Research Group, C=US ``` JDK-8281658: New Security Category for `-XshowSettings` Launcher Option The `-XshowSettings` launcher has a new `security` category. Settings from security properties, security providers and TLS related settings are displayed with this option. A security sub-category can be passed as an argument to the security category option. See the output from `java -X`: ``` -XshowSettings:security show all security settings and continue -XshowSettings:security:*sub-category* show settings for the specified security sub-category and continue. Possible *sub-category* arguments for this option include: all: show all security settings and continue properties: show security properties and continue providers: show static security provider settings and continue tls: show TLS related security settings and continue ``` Third party security provider details will be reported if they are included in the application class path or module path and such providers are configured in the `java.security` file. JDK-8312489: Increase Default Value of the System Property `jdk.jar.maxSignatureFileSize` The system property, `jdk.jar.maxSignatureFileSize`, allows applications to control the maximum size of signature files in a signed JAR. Its default value has been increased from 8000000 bytes (8 MB) to 16000000 bytes (16 MB). JDK-8318759: Added Four Root Certificates from DigiCert, Inc. The following root certificates have been added to the cacerts truststore: ``` + DigiCert, Inc. + digicertcseccrootg5 DN: CN=DigiCert CS ECC P384 Root G5, O="DigiCert, Inc.", C=US + DigiCert, Inc. + digicertcsrsarootg5 DN: CN=DigiCert CS RSA4096 Root G5, O="DigiCert, Inc.", C=US + DigiCert, Inc. + digicerttlseccrootg5 DN: CN=DigiCert TLS ECC P384 Root G5, O="DigiCert, Inc.", C=US + DigiCert, Inc. + digicerttlsrsarootg5 DN: CN=DigiCert TLS RSA4096 Root G5, O="DigiCert, Inc.", C=US ``` JDK-8308398: Deprecation of the `jdk.crypto.ec` Module The `jdk.crypto.ec` module is being deprecated with the intent to remove it. An empty module exists as a transition for developers to fix applications or `jlink` commands with hard-coded dependencies before removal. The SunEC JCE Provider, which provides Elliptic Curve Cryptography, is now in the `java.base` module. There should be no difference in cryptographic functionality with this deprecation. JDK-8317373: Added Telia Root CA v2 Certificate The following root certificate has been added to the cacerts truststore: ``` + Telia Root CA v2 + teliarootcav2 DN: CN=Telia Root CA v2, O=Telia Finland Oyj, C=FI ``` JDK-8295894: Removed SECOM Trust System's RootCA1 Root Certificate The following root certificate from SECOM Trust System has been removed from the `cacerts` keystore: ``` + alias name "secomscrootca1 [jdk]" Distinguished Name: OU=Security Communication RootCA1, O=SECOM Trust.net, C=JP ``` JDK-8319187: Added Three Root Certificates from eMudhra Technologies Limited The following root certificates have been added to the cacerts truststore: ``` + eMudhra Technologies Limited + emsignrootcag1 DN: CN=emSign Root CA - G1, O=eMudhra Technologies Limited, OU=emSign PKI, C=IN + eMudhra Technologies Limited + emsigneccrootcag3 DN: CN=emSign ECC Root CA - G3, O=eMudhra Technologies Limited, OU=emSign PKI, C=IN + eMudhra Technologies Limited + emsignrootcag2 DN: CN=emSign Root CA - G2, O=eMudhra Technologies Limited, OU=emSign PKI, C=IN ``` JDK-8302233: HSS/LMS: `keytool` and `jarsigner` Changes The `jarsigner` and `keytool` tools have been updated to support the Hierarchical Signature System/Leighton-Micali Signature (HSS/LMS) signature algorithm. `jarsigner` supports signing JAR files with HSS/LMS and verifying JAR files signed with HSS/LMS while `keytool` supports generating HSS/LMS key pairs. The JDK includes a security provider that supports HSS/LMS signature verification only. In order to use the key pair generation and signing features of `keytool` and `jarsigner`, a third-party provider that supports HSS/LMS key pair and signature generation and a keystore implementation that can store HSS/LMS keys is required. Even though there’s no specific Java SE API to initialize an HSS/LMS key pair generator, `keytool` can function with a third-party `KeyPairGenerator` implementation that supports initialization via an integer keysize or a `NamedParameterSpec` object. In such cases, users are able to provide the parameters using the existing `-keysize` or `-groupname` options of `keytool`. As part of this change, the JAR specification was modified to repurpose the existing “.DSA” extension for JAR files signed with HSS/LMS and other forthcoming signature algorithms. JDK-8314960: Added Certigna Root CA Certificate The following root certificate has been added to the cacerts truststore: ``` + Certigna (Dhimyotis) + certignarootca DN: CN=Certigna Root CA, OU=0002 48146308100036, O=Dhimyotis, C=FR ``` core-libs/java.lang:reflect: JDK-8305104: The Old Core Reflection Implementation Has Been Removed The new core reflection implementation has been the default since JDK 18 and the old implementation is now removed. The `-Djdk.reflect.useDirectMethodHandle=false` introduced by JEP 416 to enable the old core reflection implementation becomes a no-op. JDK-8315810: Reimplement `sun.reflect.ReflectionFactory::newConstructorForSerialization` with Method Handles `sun.reflect.ReflectionFactory::newConstructorForSerialization` is reimplemented with method handles. When `newConstructorForSerialization(C.class, ctor)` is called with a constructor whose declaring class is not a superclass of `C`, the old implementation returned an ill-formed constructor such that if `newInstance` is invoked, the behavior is unspecified. The new implementation will throw an `UnsupportedOperationException` instead, to fail fast. xml/jaxp: JDK-8306055: Add a Built-in Catalog to JDK XML Module A JDK built-in catalog is introduced to host DTDs defined by the Java Platform. The JDK creates a CatalogResolver based on the built-in catalog when needed to function as the default external resource resolver. When no user-defined resolvers are registered, a JDK XML processor will fall back to the default CatalogResolver and will attempt to resolve an external reference before making a connection to fetch it. The fall-back also takes place if a user-defined resolver exists but allows the process to continue when unable to resolve the resource. If the default CatalogResolver is unable to locate a resource, it will signal the XML processors to continue processing, or skip the resource, or throw a CatalogException. The action it takes is configured with the `jdk.xml.jdkcatalog.resolve` property. The new property can be set on factory APIs, as a Java system property, or in the JAXP Configuration File. The new property affects all XML processors uniformly. For further information, see the JDK built-in Catalog section of the `java.xml` module summary. JDK-8306632: Add a JDK Property for Specifying DTD Support A new property `jdk.xml.dtd.support` is introduced that determines how XML processors handle DTDs. The new property can be set on factory APIs, as a Java system property, or in the JAXP Configuration File. The new property affects all XML processors uniformly. The new property complements the two existing DTD properties: `disallow-doctype-decl` (fully qualified name: `http://apache.org/xml/features/disallow-doctype-decl`), which is applicable only to the DOM and SAX processors, and `supportDTD` (`javax.xml.stream.supportDTD`), which is applicable only to the StAX processor. When one of these existing properties is set on the respective processor factory, its value will take precedence over any value specified for the `jdk.xml.dtd.support` property. For further information, see the Configuration section of the `java.xml` module summary. core-libs/java.util.concurrent: JDK-8288899: Changes to `java.util.concurrent.ForkJoinPool` and `ForkJoinTask` A new method, `invokeAllUninterruptibly(Collection)`, is added to `java.util.concurrent.ForkJoinPool` as an uninterruptible version of `invokeAll(Collection)`. The pre-existing `invokeAll(Collection)` method is defined by `ExecutorService` to throw `InterruptedException`. The override of this method in `ForkJoinPool` did not declare `InterruptedException`. As part of the changes, the override of this method has been removed from `ForkJoinPool`. Existing code that is compiled to use `ForkJoinPool.invokeAll` will no longer compile without change. Code that does not wish to handle interruption can be changed to use `invokeAllUninterruptibly`. New methods `adaptInterruptible(Runnable)` and `adaptInterruptible(Runnable, Object)` are added to `java.util.concurrent.ForkJoinTask` to support adaptation of runnable tasks that may handle interruption. As part of the changes in this release, the `Future` objects returned by the `ForkJoinPool.submit(Runnable)` and `ForkJoinPool.submit(Callable)` are changed to align with other implementations of `ExecutorService`. More specifically: - `Future.cancel(true)` will interrupt the thread running the task if cancelled before the task has completed. - `Future.get` will throw `ExecutionException` with the exception as the cause if the task fails. Previous behavior was to throw `ExecutionException` with a `RuntimeException` as the cause. security-libs/org.ietf.jgss:krb5: JDK-8309356: Read Files in `includedir` in Alphanumeric Order JDK 10 added support for the `includedir DIRNAME` directive in `krb5.conf`. With this code change, files in this directory are read in alphanumeric order. Prior to this change, the files were read in no specific order. This is to be consistent with MIT krb5 1.17 (released on 2019-01-08). tools: JDK-8310460: `Jdeps -profile` and `-P` Option Have Been Removed Compact profiles became obsolete in Java SE 9 when modules were introduced. The `jdeps` `-profile` and `-P` options were deprecated for removal in JDK 21 and now removed in JDK 22. Customers can use `jdeps` to find the set of modules required by their applications instead. core-libs/java.lang.invoke: JDK-8291065: `MethodHandles.Lookup::findStaticVarHandle` Does Not Eagerly Initialize the Field's Declaring Class In the previous releases, `MethodHandles.Lookup::findStaticVarHandle` eagerly initializes the declaring class of the static field when the `VarHandle` is created. As specified in the specification, the declaring class should be initialized when the `VarHandle` is operated on if it has not already been initialized. This issue is fixed in this release. The declaring class is no longer eagerly initialized when `MethodHandles.Lookup::findStaticVarHandle` is called. Existing code that relies on the previous behavior may observe a change of the order of the classes being initialized. JDK-6983726: Reimplement `MethodHandleProxies::asInterfaceInstance` In previous releases, `MethodHandleProxies::asInterfaceInstance` returns a `Proxy` instance. In JDK 22, `MethodHandleProxies::asInterfaceInstance` has been reimplemented to return instances of a hidden class that can be unloaded when all instances returned for the same interface becomes unreachable. Once unloaded, subsequent calls to `MethodHandleProxies::asInterfaceInstance` will spin and define a new hidden class that may incur performance overhead. security-libs/javax.xml.crypto: JDK-8319124: Update XML Security for Java to 3.0.3 The XML Signature implementation has been updated to Santuario 3.0.3. Support for four new SHA-3 based RSA-MGF1 `SignatureMethod` algorithms have been added: `SignatureMethod.SHA3_224_RSA_MGF1`, `SignatureMethod.SHA3_256_RSA_MGF1`, `SignatureMethod.SHA3_384_RSA_MGF1`, and `SignatureMethod.SHA3_512_RSA_MGF1`. JDK-8319124: Update XML Security for Java to 3.0.3 The XML Signature implementation has been updated to Santuario 3.0.3. Support for four new SHA-3 based RSA-MGF1 signature methods have been added: `SHA3_224_RSA_MGF1`, `SHA3_256_RSA_MGF1`, `SHA3_384_RSA_MGF1`, and `SHA3_512_RSA_MGF1`. While these new algorithm URIs are not defined in `javax.xml.crypto.dsig.SignatureMethod` in the JDK update releases, they may be represented as string literals in order to be functionally equivalent. SHA-3 hash algorithm support was delivered to JDK 9 via [JEP 287](https://openjdk.org/jeps/287). Releases earlier than that may use third party security providers. core-libs: JDK-8315938: `sun.misc.Unsafe park`, `unpark`, `getLoadAverage`, and `xxxFence` Methods Are Deprecated for Removal The `park`, `unpark`, `getLoadAverage`, `loadFence`, `storeFence`, and `fullFence` methods defined by `sun.misc.Unsafe` have been deprecated for removal. Code using these methods should move to `java.util.concurrent.locks.LockSupport.park/unpark` (Java 5), `java.lang.management.OperatingSystemMXBean.getSystemLoadAverage` (Java 6), and `java.lang.invoke.VarHandle.xxxFence` (Java 9). JDK-8316160: `sun.misc.Unsafe.shouldBeInitialized` and `ensureClassInitialized` Are Removed The `shouldBeInitialized(Class)` and `ensureClassInitialized(Class)` methods have been removed from `sun.misc.Unsafe`. These methods have been deprecated for removal since JDK 15. `java.lang.invoke.MethodHandles.Lookup.ensureInitialized(Class)` was added in Java 15 as a standard API to ensure that an accessible class is initialized. core-libs/java.text: JDK-8041488: Locale-Dependent List Patterns A new class, `ListFormat`, which processes the locale-dependent list patterns has been introduced, based on [Unicode Consortium's LDML specification](https://www.unicode.org/reports/tr35/tr35-general.html#ListPatterns). For example, a list of three `String`s: "Foo", "Bar", "Baz" is typically formatted as "Foo, Bar, and Baz" in US English, while in French it is "Foo, Bar et Baz." The following code snippet does such formatting: ``` ListFormat.getInstance().format(List.of("Foo", "Bar", "Baz")) ``` Besides the default concatenation type `STANDARD` (= and), the class provides two additional types, `OR` for "or" concatenation, and `UNIT` for concatenation suitable for units for the locale. core-libs/java.util.jar: JDK-8313765: Validations on ZIP64 Extra Fields A (JDK enhancement)[https://bugs.openjdk.org/browse/JDK-8311940] has improved validation of the ZIP64 Extra Fields contained within zip files and jar files. Files which do not satisfy these new validation checks may result in `ZipException : Invalid CEN header (invalid zip64 extra data field size)`. The following third party tools have released patches to better adhere to the ZIP File Format Specification: - Apache Commons Compress fix for Empty CEN Zip64 Extra Headers fixed in Commons Compress release 1.11 - Apache Ant fix for Empty CEN Zip64 Extra Headers fixed in Ant 1.10.14 - BND issue with writing invalid Extra Headers fixed in BND 5.3 - The maven-bundle-plugin 5.1.5 includes the BND 5.3 patch. If these improved validation checks cause issues for deployed zip or jar files, check how the file was created and whether patches are available from the generating software to resolve the issue. The new validation checks can be disabled by adding `-Djdk.util.zip.disableZip64ExtraFieldValidation=true` to the runtime launcher arguments. Further modification of validations on ZIP64 Extra Fields contained within zip and jar files will be made in the upcoming JDK release. See JDK-8313765. hotspot/compiler: JDK-8312749: JVM May Crash or Malfunction When Using ZGC and Non-Default ObjectAlignmentInBytes Running the JVM with `-XX:+UseZGC` and non-default value of `-XX:ObjectAlignmentInBytes` may lead to JVM crashes or incorrect execution. The issue is caused by an incorrect JIT compiler optimization of the `java.lang.Object.clone()` method for this configuration. If using ZGC with a non-default value of `ObjectAlignmentInBytes` is desired, JIT compilation of `java.lang.Object.clone()` can be disabled using the command-line options `-XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_clone`. JDK-8027711: Unify Syntax of `CompileOnly` and `CompileCommand` `-XX:CompileOnly=pattern1,[...],patternN` is now an alias for `-XX:CompileCommand=compileonly,pattern1 [...] -XX:CompileCommand=compileonly,patternN` JDK-8318027: `jdk.internal.vm.compiler` Renamed to `jdk.graal.compiler` In preparation for Project Galahad, the `jdk.internal.vm.compiler` module was renamed to `jdk.graal.compiler`. Being a JDK internal module, this should be transparent for most Java users. However, scripts that run `jlink` to create a run-time image containing the Graal compiler module will need to be updated to use the new module name. JDK-8282797: Exit VM for `CompileCommand` Parsing Errors `-XX:CompileCommand=...` will now exit the VM with a non-zero exit code after a parsing error occurs. JDK-8315082: ZGC: Reintroduced Support for Non-Default ObjectAlignmentInBytes The JDK 21 issue that could potentially lead to JVM crashes or incorrect execution when running the JVM with `-XX:+UseZGC` and non-default value of `-XX:ObjectAlignmentInBytes` has been resolved, and it is possible again to use this combination of JVM options. security-libs/javax.net.ssl: JDK-8311596: Add Separate System Properties for TLS Server and Client for Maximum Chain Length Two new system properties, `jdk.tls.server.maxInboundCertificateChainLength` and `jdk.tls.client.maxInboundCertificateChainLength`, have been added to set the maximum allowed length of the certificate chain accepted from the client or server during TLS/DTLS handshaking. A service can function as both a TLS/DTLS server and client. When the service acts as a server, it enforces a maximum certificate chain length accepted from clients. When the service acts as a client, it enforces a maximum certificate chain length accepted from servers. These properties, if set, override the existing `jdk.tls.maxCertificateChainLength` system property. The properties work together as follows: If the `jdk.tls.server.maxInboundCertificateChainLength` system property is set and its value is greater than or equal to 0, this value will be used to enforce the maximum length of a client certificate chain accepted by a server. Otherwise, if the `jdk.tls.maxCertificateChainLength` system property is set and its value is greater than or equal to 0, this value will be used to enforce it. If neither property is set, a default value of 8 will be used for enforcement. If the `jdk.tls.client.maxInboundCertificateChainLength` system property is set and its value is greater than or equal to 0, this value will be used to enforce the maximum length of a server certificate chain accepted by a client. Otherwise, if the `jdk.tls.maxCertificateChainLength` system property is set and its value is greater than or equal to 0, this value will be used to enforce it. If neither property is set, a default value of 10 will be used for enforcement. In this release, the default maximum chain length accepted from clients has been changed from 10 to 8 for client certificate chains. security-libs/javax.crypto: JDK-8322971: `KEM.getInstance()` Should Check If a Third-Party Security Provider Is Signed When instantiating a third-party security provider's implementation (class) of a `KEM` algorithm, the framework will determine the provider's codebase (JAR file) and verify its signature. In this way, JCA authenticates the provider and ensures that only providers signed by a trusted entity can be plugged into the JCA. This is consistent with other JCE service classes, such as `Cipher`, `Mac`, `KeyAgreement`, and others. hotspot/jfr: JDK-8211238: JFR Event for @Deprecated Methods A new JFR event, `jdk.DeprecatedInvocation`, has been added to JDK 22 to help users detect their use of deprecated methods located in the JDK. To record these events in JFR, a user must specify a recording on the command line, like `-XX:StartFlightRecording`. Starting a recording during runtime, for example, using `jcmd` or the JFR Java API, will not have these events reported unless `-XX:StartFlightRecording` is specified on the command line. An example event would be rendered like this using the JFR tool: ``` bin/jfr print jdk.DeprecatedInvocation { startTime = 23:31:28.431 (2023-12-04) method = jdk.jfr.internal.test.DeprecatedThing.foo() invocationTime = 23:31:25.954 (2023-12-04) forRemoval = true stackTrace = [ jdk.jfr.event.runtime.TestDeprecatedEvent.testLevelAll() line: 96 ... ] } ``` The current design will only report direct method invocations where the caller resides outside the JDK. Intra-JDK invocations will not be reported. Additionally, invoking methods declared deprecated but located outside of the JDK, for example in a third-party library, will not be reported, at least not during this first implementation. This might change in the future. There exists a small restriction in the reporting of invocations from the Interpreter. In the situation where two caller methods are members of the same class, and they invoke the same deprecated method, for example: ``` public class InterpreterRestriction { public static void main(String[] args) { invoke1(); invoke2(); } private static void invoke1() { System.getSecurityManager(); } private static void invoke2() { System.getSecurityManager(); } } ``` In this situation, only `` will be reported because the Interpreter implementation will consider `System.getSecurityManager()` to be resolved and linked after the first call. When `invoke2()` is called, no slow path will be taken for the resolution of the `System.getSecurityManager()` method because it is already resolved as part of the cpCache. This restriction does not exist in C1 or C2, only in the Interpreter. When analyzing the reported events, checking all methods in the reported class is recommended. This slight restriction can be resolved using an iterative process; if one call site is fixed, the other will be reported in the next run. client-libs/java.awt: JDK-8322750: AWT SystemTray API Is Not Supported on Most Linux Desktops The `java.awt.SystemTray` API is used for notifications in a desktop taskbar and may include an icon representing an application. On Linux, the Gnome desktop's own icon support in the taskbar has not worked properly for several years due to a platform bug. This, in turn, has affected the JDK's API, which relies upon that. Therefore, in accordance with the existing Java SE specification, `java.awt.SystemTray.isSupported()` will return false where ever the JDK determines the platform bug is likely to be present. The impact of this is likely to be limited since applications always must check for that support anyway. Additionally, some distros have not supported the SystemTray for several years unless the end-user chooses to install non-bundled desktop extensions. core-libs/java.util.regex: JDK-8312976: `java.util.regex.MatchResult` Might Throw `StringIndexOutOfBoundsException` on Regex Patterns Containing Lookaheads and Lookbehinds JDK-8132995 introduced an unintended regression when using instances returned by `java.util.regex.Matcher.toMatchResult()`. This happens on `java.util.regex.Pattern`s containing lookaheads and lookbehinds that, in turn, contain groups. If these are located outside the match, it results in throwing `StringIndexOutOfBoundsException` when accessing these groups. See JDK-8312976 for an example. tools/javadoc(tool): JDK-8285368: The `inheritDoc` Tag and Method Comments Algorithm Have Been Changed An optional parameter has been added to the `inheritDoc` tag so that an author can specify the supertype from which to search for inherited documentation. Additionally, the algorithm to search for inherited documentation has been modified to better align with the method inheriting and overriding rules in Java Language Specification. For more details, see the following sections of the Documentation Comment Specification for the Standard Doclet: - [Method Documentation](https://docs.oracle.com/en/java/javase/22/docs/specs/javadoc/doc-comment-spec.html#method-documentation) - [`{@inheritDoc}`](https://docs.oracle.com/en/java/javase/22/docs/specs/javadoc/doc-comment-spec.html#inheritdoc) core-libs/java.io: JDK-8308591: JLine As The Default Console Provider `System.console()` has changed in this release to return a `Console` with enhanced editing features that improve the experience of programs that use the `Console` API. In addition, `System.console()` now returns a `Console` object when the standard streams are redirected or connected to a virtual terminal. In prior releases, `System.console()` returned `null` for these cases. This change may impact code that uses the return from `System.console()` to test if the VM is connected to a terminal. If needed, running with `-Djdk.console=java.base` will restore older behavior where the console is only returned when it is connected to a terminal. A new method `Console.isTerminal()` has been added to test if console is connected to a terminal. JDK-8287843: `java.io.File` Drops the Windows Long Path Prefix from Path Strings On Windows, `java.io.File` has changed in this release such that creating a `File` from a path string with a long path prefix (`\\\\?\\` or `\\\\?\\UNC`) will now strip the prefix. This change fixes several anomalies with file path parsing, helps with interoperability with native code when the file path comes from a native program that includes the long path prefix, and also allows methods such as `File::getCanonicalFile` to return the canonical file from input that initially contained a long path prefix. The change to `java.io.File` aligns the behavior with the newer API `java.nio.file.Path`. The change may be observable to code that depends on `File::toString` returning a String that has the long path prefix. This change has no impact to file access, the JDK will continue to use the long path prefix when accessing files that need the prefix. hotspot/gc: JDK-8314573: G1: More Deterministic Heap Resize at Remark During the Remark pause G1 adjusts the Java heap size to keep a minimum and maximum amount of free regions as set via the `-XX:MinHeapFreeRatio` and `-XX:MaxHeapFreeRatio` options. Before this change, G1 considered Eden regions as occupied (full) for this calculation. This makes heap sizing very dependent on current Eden occupancy, although after the next garbage collection these regions will be empty. With this change, Eden regions are considered as empty (free) for matters of Java heap sizing. This new policy also aligns Java heap sizing to full GC heap sizing. The effect is that G1 now expands the Java heap less aggressively and more deterministically, with corresponding memory savings but potentially executing more garbage collections. JDK-8315503: G1: Balance Code Root Scan Phase during Garbage Collection The Code Root Scan Phase during garbage collection finds references to Java objects in compiled code. To speed up this process, G1 maintains a remembered set for compiled code that contains references into the Java heap. That is, every region contains a set of compiled code that contains references into it. Assuming that such references are few, previous code used a single thread per region to iterate over a particular region's references, which poses a scalability bottleneck if the distribution of these references is very unbalanced. G1 now distributes this code root scan work across multiple threads within regions, removing this bottleneck. JDK-8321013: Parallel: Better GC Throughput with Large Object Arrays During a young collection, Parallel GC searches for dirty cards in the card table to locate old-to-young pointers. After finding dirty cards, Parallel GC uses the internal bookkeeping data structures to locate object starts for heap-parsing to be able to walk the heap within these dirty cards object-by-object. This change modifies the internal bookkeeping data structure to the one used by Serial and G1. As a result, the object start lookup time is improved and one can observe about a 20% reduction of Young-GC pause in some benchmarks using large object arrays. JDK-8310031: Parallel: Precise Parallel Scanning of Large Object Arrays for Young Collection Roots During a young collection, ParallelGC partitions the old generation into 64kB stripes when scanning it for references into the young generation. These stripes are assigned to worker threads that do the scanning in parallel as work units. Before this change, Parallel GC always scanned these stripes completely even if only a small part had been known to contain interesting references. Additionally, every worker thread processed the objects that start in that stripe by itself, including parts of objects that extend into other stripes. This behavior limited parallelism when processing large objects. A single large object, potentially containing thousands of references, had been scanned by a single thread only and in full. This would cause bad scaling due to memory sharing and cache misses in the subsequent long, work stealing phase. With this change, Parallel GC workers limit work to their stripe and only process interesting parts of large object arrays. This reduces the work done by a single thread for a stripe, improves parallelism, and reduces the amount of work stealing. Parallel GC pauses are now on par with G1 in presence of large object arrays, reducing pause times by 4-5 times in some cases. JDK-8276094: JEP 423: Region Pinning for G1 This [JEP] reduces latency by implementing region pinning in G1, so that garbage collection need not be disabled during Java Native Interface (JNI) critical regions. Java threads that use native code do not stall garbage collections any more. Garbage collections will execute regardless of native code keeping references to Java objects. The garbage collection will keep objects that may be accessed by native code in place, collecting garbage only in surrounding heap areas but will be otherwise unaffected. [JEP]: https://openjdk.org/jeps/423 "JEP 423: Region Pinning for G1" JDK-8140326: G1: Fast Collection of Evacuation Failed Regions G1 now reclaims regions that failed evacuation in the next garbage collection. When there is not enough space to move Java objects from the collection set, young generation regions for example, to some destination area, or that region has been pinned and contains non-movable Java objects (see [JEP 423]), G1 considers that region to have failed evacuation. Previously, such regions were moved into the old generation as completely full regions, and left lingering for re-examination until the next complete heap analysis, marking, found them to be reclaimable in the next space reclamation phase. Very often, such regions are sparsely populated because only a very few objects were not relocatable or very few objects were actually pinned. With this change, G1 considers evacuation failed regions as reclaimable beginning with any subsequent garbage collection. If the pause time permits, G1 will evacuate them in addition to the existing collection set. This can substantially reduce the time to reclaim these mostly empty regions, decreasing heap pressure and the need for garbage collection activity in the presence of evacuation failed regions. JDK-8319373: Serial: Better GC Throughput with Scarce Dirty Cards During a young collection, Serial GC searches for dirty cards in the card table to locate old-to-young pointers. After finding dirty cards, Serial GC uses the block offset table to locate object starts for heap-parsing to be able to walk the heap within these dirty cards object-by-object. This change improves the object start lookup and search for dirty cards resulting in a large (~40%) reduction in Young-GC pause in some benchmarks using large object arrays. ALL FIXED ISSUES, BY COMPONENT AND PRIORITY: client-libs: (P3) JDK-8305593: Add @spec tags in java.desktop (P3) JDK-8312612: Handle WideCharToMultiByte return values (P3) JDK-8307145: windowsaccessbridge.dll erroneously includes private methods in its C API (P4) JDK-8320303: Allow PassFailJFrame to accept single window creator (P4) JDK-8294156: Allow PassFailJFrame.Builder to create test UI (P4) JDK-8311606: Change read_icc_profile() to static function in java.desktop/share/native/libjavajpeg/imageioJPEG.c (P4) JDK-8308286: Fix clang warnings in linux code (P4) JDK-8294158: HTML formatting for PassFailJFrame instructions (P4) JDK-8320365: IPPPrintService.getAttributes() causes blanket re-initialisation (P4) JDK-8311881: jdk/javax/swing/ProgressMonitor/ProgressTest.java does not show the ProgressMonitorInputStream all the time (P4) JDK-8321226: JDK22 update task definition for client (P4) JDK-8315071: Modify TrayIconScalingTest.java, PrintLatinCJKTest.java to use new PassFailJFrame's builder pattern usage (P4) JDK-8312592: New parentheses warnings after HarfBuzz 7.2.0 update (P4) JDK-8311380: Prepare java.desktop for C++17 (P4) JDK-8316017: Refactor timeout handler in PassFailJFrame (P4) JDK-8314738: Remove all occurrences of and support for @revised (P5) JDK-8316556: Fix typos in java.desktop (P5) JDK-8312165: Fix typos in java.desktop Swing client-libs/2d: (P3) JDK-8318364: Add an FFM-based implementation of harfbuzz OpenType layout (P3) JDK-8318951: Additional negative value check in JPEG decoding (P3) JDK-8316741: BasicStroke.createStrokedShape miter-limits failing on small shapes (P3) JDK-8312191: ColorConvertOp.filter for the default destination is too slow (P3) JDK-8311666: Disabled tests in test/jdk/sun/java2d/marlin (P3) JDK-8312555: Ideographic characters aren't stretched by AffineTransform.scale(2, 1) (P3) JDK-8316975: Memory leak in MTLSurfaceData (P3) JDK-8316028: Update FreeType to 2.13.2 (P3) JDK-8313643: Update HarfBuzz to 8.2.2 (P4) JDK-8311033: [macos] PrinterJob does not take into account Sides attribute (P4) JDK-8320443: [macos] Test java/awt/print/PrinterJob/PrinterDevice.java fails on macOS (P4) JDK-8319268: Build failure with GCC8.3.1 after 8313643 (P4) JDK-6211202: ColorSpace.getInstance(int): IAE is not specified (P4) JDK-8316710: Exclude java/awt/font/Rotate/RotatedTextTest.java (P4) JDK-8317706: Exclude java/awt/Graphics2D/DrawString/RotTransText.java on linux (P4) JDK-8313576: GCC 7 reports compiler warning in bundled freetype 2.13.0 (P4) JDK-8314076: ICC_ColorSpace#minVal/maxVal have the opposite description (P4) JDK-6211126: ICC_ColorSpace.toCIEXYZ(float[]): NPE is not specified (P4) JDK-6211139: ICC_ColorSpace.toRGB(float[]): NPE is not specified (P4) JDK-8320608: Many jtreg printing tests are missing the @printer keyword (P4) JDK-8311917: MAP_FAILED definition seems to be obsolete in src/java.desktop/unix/native/common/awt/fontpath.c (P4) JDK-8318100: Remove redundant check for Metal support (P4) JDK-8316206: Test StretchedFontTest.java fails for Baekmuk font (P5) JDK-8318850: Duplicate code in the LCMSImageLayout (P5) JDK-8313220: Remove Windows specific workaround in LCMS.c for _snprintf client-libs/demo: (P4) JDK-8304503: Modernize debugging jvm args in demo netbeans projects client-libs/java.awt: (P1) JDK-8322750: Test "api/java_awt/interactive/SystemTrayTests.html" failed because A blue ball icon is added outside of the system tray (P2) JDK-8318854: [macos14] Running any AWT app prints Secure coding warning (P2) JDK-8309703: AIX build fails after JDK-8280982 (P2) JDK-8317964: java/awt/Mouse/MouseModifiersUnitTest/MouseModifiersUnitTest_Standard.java fails on macosx-all after JDK-8317751 (P2) JDK-8311689: Wrong visible amount in Adjustable of ScrollPane (P3) JDK-8317288: [macos] java/awt/Window/Grab/GrabTest.java: Press on the outside area didn't cause ungrab (P3) JDK-8315701: [macos] Regression: KeyEvent has different keycode on different keyboard layouts (P3) JDK-8311922: [macOS] right-Option key fails to generate release event (P3) JDK-8313697: [XWayland][Screencast] consequent getPixelColor calls are slow (P3) JDK-8309621: [XWayland][Screencast] screen capture failure with sun.java2d.uiScale other than 1 (P3) JDK-8305825: getBounds API returns wrong value resulting in multiple Regression Test Failures on Ubuntu 23.04 (P3) JDK-8006421: GraphicsConfiguration of a frame is changed when the frame is moved to another screen (P3) JDK-8309756: Occasional crashes with pipewire screen capture on Wayland (P3) JDK-8310054: ScrollPane insets are incorrect (P3) JDK-8313164: src/java.desktop/windows/native/libawt/windows/awt_Robot.cpp GetRGBPixels adjust releasing of resources (P3) JDK-8316030: Update Libpng to 1.6.40 (P4) JDK-8296972: [macos13] java/awt/Frame/MaximizedToIconified/MaximizedToIconified.java: getExtendedState() != 6 as expected. (P4) JDK-8317290: [macos14] java/awt/event/MouseEvent/SpuriousExitEnter/SpuriousExitEnter_3.java: incorrect event number (P4) JDK-8313633: [macOS] java/awt/dnd/NextDropActionTest/NextDropActionTest.java fails with java.lang.RuntimeException: wrong next drop action! (P4) JDK-8319665: [macOS] Obsolete imports of in java.desktop (P4) JDK-8302618: [macOS] Problem typing uppercase letters with java.awt.Robot when moving mouse (P4) JDK-8314498: [macos] Transferring File objects to Finder fails (P4) JDK-8310334: [XWayland][Screencast] screen capture error message in debug (P4) JDK-8318955: Add ReleaseIntArrayElements in Java_sun_awt_X11_XlibWrapper_SetBitmapShape XlbWrapper.c to early return (P4) JDK-8317112: Add screenshot for Frame/DefaultSizeTest.java (P4) JDK-8320655: awt screencast robot spin and sync issues with native libpipewire api (P4) JDK-8311805: Clean up ScrollPane: drop redundant initialiser, mark scroller final (P4) JDK-8319985: Delete sun.awt.windows.WToolkit.embedded*() API (P4) JDK-8312147: Dynamic Exception Specification warnings are no longer required after JDK-8311380 (P4) JDK-8312591: GCC 6 build failure after JDK-8280982 (P4) JDK-8318154: Improve stability of WheelModifier.java test (P4) JDK-8315484: java/awt/dnd/RejectDragDropActionTest.java timed out (P4) JDK-8266242: java/awt/GraphicsDevice/CheckDisplayModes.java failing on macOS 11 ARM (P4) JDK-8313252: Java_sun_awt_windows_ThemeReader_paintBackground release resources in early returns (P4) JDK-8318448: Link PopupMenu/PopupMenuLocation.java failure to JDK-8259913 (P4) JDK-8318102: macos10.14 check in CSystemColors can be removed. (P4) JDK-8316389: Open source few AWT applet tests (P4) JDK-8315663: Open source misc awt tests (P4) JDK-8316240: Open source several add/remove MenuBar manual tests (P4) JDK-8315726: Open source several AWT applet tests (P4) JDK-8316211: Open source several manual applet tests (P4) JDK-8315965: Open source various AWT applet tests (P4) JDK-8318091: Remove empty initIDs functions (P4) JDK-8311113: Remove invalid pointer cast and clean up setLabel() in awt_MenuItem.cpp (P4) JDK-8305321: Remove unused exports in java.desktop (P4) JDK-8321325: Remove unused Java_java_awt_MenuComponent_initIDs function (P4) JDK-8312626: Resolve multiple definition of 'start_timer' when statically linking JDK native libraries with user code (P4) JDK-8305667: Some fonts installed in user directory are not detected on Windows (P4) JDK-8305645: System Tray icons get corrupted when Windows primary monitor changes (P4) JDK-8311109: tautological-compare warning in awt_Win32GraphicsDevice.cpp (P4) JDK-8299052: ViewportOverlapping test fails intermittently on Win10 & Win11 (P4) JDK-8280482: Window transparency bug on Linux (P5) JDK-8309958: Incorrect @since tag format in Container.java (P5) JDK-8318028: Remove unused class="centered" from FocusCycle.svg client-libs/javax.accessibility: (P2) JDK-8309733: [macOS, Accessibility] VoiceOver: Incorrect announcements of JRadioButton (P3) JDK-8311160: [macOS, Accessibility] VoiceOver: No announcements on JRadioButtonMenuItem and JCheckBoxMenuItem (P3) JDK-8283214: [macos] Screen magnifier does not show the magnified text for JComboBox (P4) JDK-8318104: macOS 10.13 check in TabButtonAccessibility.m can be removed (P4) JDK-8310908: Non-standard `@since` tag in `com.sun.java.accessibility.util.package-info` client-libs/javax.imageio: (P4) JDK-6355567: AdobeMarkerSegment causes failure to read valid JPEG client-libs/javax.sound: (P3) JDK-8301846: Invalid TargetDataLine after screen lock when using JFileChooser or COM library (P3) JDK-8312535: MidiSystem.getSoundbank() throws unexpected SecurityException (P3) JDK-8301310: The SendRawSysexMessage test may cause a JVM crash (P4) JDK-8074211: javax.sound.midi: Error with send System Exclusive messages of different length (P4) JDK-8250667: MIDI sysex over USB scrambled when reply length matches previous message client-libs/javax.swing: (P2) JDK-8316627: JViewport Test headless failure (P3) JDK-6928542: Chinese characters in RTF are not decoded (P3) JDK-8312075: FileChooser.win32.newFolder is not updated when changing Locale (P3) JDK-8318590: JButton ignores margin when painting HTML text (P3) JDK-8301606: JFileChooser file chooser details view "size" label cut off in Metal Look&Feel (P3) JDK-8140527: JInternalFrame has incorrect title button width (P3) JDK-8224261: JProgressBar always with border painted around it (P3) JDK-8319103: Popups that request focus are not shown on Linux with Wayland (P3) JDK-8210807: Printing a JTable with a JScrollPane prints table without rows populated (P3) JDK-8313902: Test javax/swing/JFileChooser/FileSystemView/SystemIconTest.java fails with NullPointerException (P3) JDK-8225220: When the Tab Policy is checked,the scroll button direction displayed incorrectly. (P3) JDK-6875229: Wrong placement of icons in JTabbedPane in Nimbus (P4) JDK-8318580: "javax/swing/MultiMonitor/MultimonVImage.java failing with Error. Can't find library: /open/test/jdk/java/awt/regtesthelpers" after JDK-8316053 (P4) JDK-8315986: [macos14] javax/swing/JMenuItem/4654927/bug4654927.java: component must be showing on the screen to determine its location (P4) JDK-8139208: [macosx] Issue with setExtendedState of JFrame (P4) JDK-8310238: [test bug] javax/swing/JTableHeader/6889007/bug6889007.java fails (P4) JDK-8311585: Add JRadioButtonMenuItem to bug8031573.java (P4) JDK-8294535: Add screen capture functionality to PassFailJFrame (P4) JDK-4346610: Adding JSeparator to JToolBar "pushes" buttons added after separator to edge (P4) JDK-8318101: Additional test cases for CSSAttributeEqualityBug (P4) JDK-6450193: After the first Serialization, JTableHeader does not uninstall its UI (P4) JDK-8313810: BoxLayout uses
instead of list for layout options (P4) JDK-4365952: Cannot disable JFileChooser (P4) JDK-7083187: Class CSS.CssValue is missing implementations of equals() and hashCode() (P4) JDK-8318113: CSS.BackgroundImage doesn't implement equals (P4) JDK-8319925: CSS.BackgroundImage incorrectly uses double-checked locking (P4) JDK-8258970: Disabled JPasswordField foreground color is wrong with GTK LAF (P4) JDK-6664309: Docking point of a floating toolbar changes after closing (P4) JDK-8313348: Fix typo in JFormattedTextField: 'it self' (P4) JDK-8166900: If you wrap a JTable in a JLayer, the cursor is moved to the last row of table by you press the page down key. (P4) JDK-4622866: javax.swing.text.Document.remove(int, int) has a misleading picture (P4) JDK-8314246: javax/swing/JToolBar/4529206/bug4529206.java fails intermittently on Linux (P4) JDK-6442919: JFilechooser popup still left-to-right when JFilechooser is set to right-to-left (P4) JDK-8139392: JInternalFrame has incorrect padding (P4) JDK-8307934: JRobot.moveMouseTo must access component on EDT (P4) JDK-5108458: JTable does not properly layout its content (P4) JDK-8311031: JTable header border vertical lines are not aligned with data grid lines (P4) JDK-4516654: Metalworks Demo: Window title not displayed fully in Low Vision Theme (P4) JDK-8315825: Open some swing tests (P4) JDK-8315882: Open some swing tests 2 (P4) JDK-8316053: Open some swing tests 3 (P4) JDK-8316146: Open some swing tests 4 (P4) JDK-8316218: Open some swing tests 5 (P4) JDK-8316371: Open some swing tests 6 (P4) JDK-8316306: Open source and convert manual Swing test (P4) JDK-8315594: Open source few headless Swing misc tests (P4) JDK-8315600: Open source few more headless Swing misc tests (P4) JDK-8315609: Open source few more swing text/html tests (P4) JDK-8315677: Open source few swing JFileChooser and other tests (P4) JDK-8315741: Open source few swing JFormattedTextField and JPopupMenu tests (P4) JDK-8316106: Open source few swing JInternalFrame and JMenuBar tests (P4) JDK-8315761: Open source few swing JList and JMenuBar tests (P4) JDK-8315606: Open source few swing text/html tests (P4) JDK-8315876: Open source several Swing CSS related tests (P4) JDK-8315889: Open source several Swing HTMLDocument related tests (P4) JDK-8315951: Open source several Swing HTMLEditorKit related tests (P4) JDK-8315834: Open source several Swing JSpinner related tests (P4) JDK-8315804: Open source several Swing JTabbedPane JTextArea JTextField tests (P4) JDK-8315952: Open source several Swing JToolbar JTooltip JTree tests (P4) JDK-8315883: Open source several Swing JToolbar tests (P4) JDK-8316149: Open source several Swing JTree JViewport KeyboardManager tests (P4) JDK-8316056: Open source several Swing JTree tests (P4) JDK-8315669: Open source several Swing PopupMenu related tests (P4) JDK-8316061: Open source several Swing RootPane and Slider related tests (P4) JDK-8315742: Open source several Swing Scroll related tests (P4) JDK-8316104: Open source several Swing SplitPane and RadioButton related tests (P4) JDK-8315731: Open source several Swing Text related tests (P4) JDK-8315824: Open source several Swing Text/HTML related tests (P4) JDK-8315898: Open source swing JMenu tests (P4) JDK-8315602: Open source swing security manager test (P4) JDK-8315611: Open source swing text/html and tree test (P4) JDK-8315981: Opensource five more random Swing tests (P4) JDK-8315871: Opensource five more Swing regression tests (P4) JDK-8316285: Opensource JButton manual tests (P4) JDK-8316164: Opensource JMenuBar manual test (P4) JDK-8316154: Opensource JTextArea manual tests (P4) JDK-8316242: Opensource SwingGraphics manual test (P4) JDK-8313403: Remove unused 'mask' field from JFormattedTextField (P4) JDK-8320349: Simplify FileChooserSymLinkTest.java by using single-window testUI (P4) JDK-6415065: Submenu is shown on wrong screen in multiple monitor environment (P4) JDK-4893524: Swing drop targets should call close() on transferred readers and streams (P4) JDK-8154846: SwingNode does not resize when content size constraints are changed (P4) JDK-8309070: Test javax/swing/JTabbedPane/6355537/bug6355537.java failed: Disabled tabs should not have prelight (P4) JDK-8319938: TestFileChooserSingleDirectorySelection.java fails with "getSelectedFiles returned empty array" (P4) JDK-8317847: Typo in API documentation of class JPopupMenu (P4) JDK-8316159: Update BoxLayout sample image for crisper edges (P4) JDK-8316003: Update FileChooserSymLinkTest.java to HTML instructions (P4) JDK-8313408: Use SVG for BoxLayout example (P4) JDK-8316025: Use testUI() method of PassFailJFrame.Builder in FileChooserSymLinkTest.java (P5) JDK-8313811: Improve description of how BoxLayout lays out components core-libs: (P2) JDK-8324858: [vectorapi] Bounds checking issues when accessing memory segments (P2) JDK-8312195: Changes in JDK-8284493 use wrong copyright syntax (P2) JDK-8317302: JEP 462: Structured Concurrency (Second Preview) (P3) JDK-8309727: Assert privileges while reading the jdk.incubator.vector.VECTOR_ACCESS_OOB_CHECK system property (P3) JDK-8321641: ClassFile ModuleAttribute.ModuleAttributeBuilder::moduleVersion spec contains a copy-paste error (P3) JDK-8319613: Complier error in benchmark TestLoadSegmentVarious (P3) JDK-8312522: Implementation of Foreign Function & Memory API (P3) JDK-8315886: SBR execution and failure analysis for JDK22 b14 (P3) JDK-8314615: VarHandle::get() throws unexpected IllegalArgumentException (P3) JDK-8318678: Vector access on heap MemorySegments only works for byte[] (P4) JDK-8310550: Adjust references to rt.jar (P4) JDK-8311822: AIX : test/jdk/java/foreign/TestLayouts.java fails because of different output - expected [[i4](struct)] but found [[I4](struct)] (P4) JDK-8296240: Augment discussion of test tiers in doc/testing.md (P4) JDK-8317959: Check return values of malloc in native java.base coding (P4) JDK-8311207: Cleanup for Optimization for UUID.toString (P4) JDK-8311943: Cleanup usages of toLowerCase() and toUpperCase() in java.base (P4) JDK-8315938: Deprecate for removal Unsafe methods that have standard APIs for many releases (P4) JDK-8317696: Fix compilation with clang-16 (P4) JDK-8316038: Fix doc typos in java.io.Console and java.util.Scanner (P4) JDK-8311122: Fix typos in java.base (P4) JDK-8314085: Fixing scope from benchmark to thread for JMH tests having shared state (P4) JDK-8320440: Implementation of Structured Concurrency (Second Preview) (P4) JDK-8284493: Improve computeNextExponential tail performance and accuracy (P4) JDK-8316190: Improve MemorySegment::toString (P4) JDK-8309303: jdk/internal/misc/VM/RuntimeArguments test ignores jdk/internal/vm/options (P4) JDK-8315945: JEP 460: Vector API (Seventh Incubator) (P4) JDK-8318898: JEP 464: Scoped Values (Second Preview) (P4) JDK-8311178: JMH tests don't scale well when sharing output buffers (P4) JDK-8316421: libjava should load shell32.dll eagerly (P4) JDK-8310995: missing @since tags in 36 jdk.dynalink classes (P4) JDK-8319195: Move most tier 1 vector API regression tests to tier 3 (P4) JDK-8310890: Normalize identifier names (P4) JDK-8312164: Refactor Arrays.hashCode for long, boolean, double, float, and Object arrays (P4) JDK-8315413: Remove special filtering of Continuation.yield0 in StackWalker (P4) JDK-8316160: Remove sun.misc.Unsafe.{shouldBeInitialized,ensureClassInitialized} (P4) JDK-8314753: Remove support for @beaninfo, @ToDo, @since.unbundled, and @Note (P4) JDK-8317532: SBR execution and failure analysis for JDK22 b18 (P4) JDK-8306584: Start of release updates for JDK 22 (P4) JDK-8320665: update jdk_core at open/test/jdk/TEST.groups (P4) JDK-8311961: Update Manual Test Groups for ATR JDK22 (P4) JDK-8320586: update manual test/jdk/TEST.groups core-libs/java.io: (P3) JDK-8321409: Console read line with zero out should zero out underlying buffer in JLine (redux) (P3) JDK-8274122: java/io/File/createTempFile/SpecialTempFile.java fails in Windows 11 (P4) JDK-8314120: Add tests for FileDescriptor.sync (P4) JDK-8316156: ByteArrayInputStream.transferTo causes MaxDirectMemorySize overflow (P4) JDK-8320798: Console read line with zero out should zero out underlying buffer (P4) JDK-8321131: Console read line with zero out should zero out underlying buffer in JLine (P4) JDK-8155902: DataOuputStream should clarify that it might write primitive types as multiple byte groups (P4) JDK-8315034: File.mkdirs() occasionally fails to create folders on Windows shared folder (P4) JDK-8316000: File.setExecutable silently fails if file does not exist (P4) JDK-8287843: File::getCanonicalFile doesn't work for \\?\C:\ style paths DOS device paths (P4) JDK-8312127: FileDescriptor.sync should temporarily increase parallelism (P4) JDK-8310909: java.io.InvalidObjectException has redundant `@since` tag (P4) JDK-8308591: JLine as the default Console provider (P4) JDK-8310530: PipedOutputStream.flush() accesses sink racily (P4) JDK-8311489: Remove unused dirent_md files (P4) JDK-8320348: test/jdk/java/io/File/GetAbsolutePath.windowsDriveRelative fails if working directory is not on drive C (P4) JDK-8319958: test/jdk/java/io/File/libGetXSpace.c does not compile on Windows 32-bit (P4) JDK-8315960: test/jdk/java/io/File/TempDirDoesNotExist.java leaves test files behind (P4) JDK-8321053: Use ByteArrayInputStream.buf directly when parameter of transferTo() is trusted (P4) JDK-8136895: Writer not closed with disk full error, file resource leaked (P5) JDK-8316207: Fix typos in java.io.StreamTokenizer (P5) JDK-8219567: Name of first parameter of RandomAccessFile(String,String) is inconsistent core-libs/java.io:serialization: (P4) JDK-8309688: Data race on java.io.ClassCache$CacheRef.strongReferent core-libs/java.lang: (P1) JDK-8315970: Big-endian issues after JDK-8310929 (P2) JDK-8310922: java/lang/Class/forName/ForNameNames.java fails after being added by JDK-8310242 (P2) JDK-8310982: jdk/internal/util/ArchTest.java fails after JDK-8308452 failed with Method isARM() (P2) JDK-8316879: RegionMatches1Tests fails if CompactStrings are disabled after JDK-8302163 (P2) JDK-8321514: UTF16 string gets constructed incorrectly from codepoints if CompactStrings is not enabled (P3) JDK-8310265: (process) jspawnhelper should not use argv[0] (P3) JDK-8308609: java/lang/ScopedValue/StressStackOverflow.java fails with "-XX:-VMContinuations" (P3) JDK-8311645: Memory leak in jspawnhelper spawnChild after JDK-8307990 (P3) JDK-8320570: NegativeArraySizeException decoding >1G UTF8 bytes with non-ascii characters (P3) JDK-8222329: Readable read(CharBuffer) does not specify that 0 is returned when there is no remaining space in buffer (P3) JDK-8322846: Running with -Djdk.tracePinnedThreads set can hang (P3) JDK-8310892: ScopedValue throwing StructureViolationException should be clearer (P3) JDK-8210375: StackWalker::getCallerClass throws UnsupportedOperationException (P3) JDK-8322512: StringBuffer.repeat does not work correctly after toString() was called (P3) JDK-8309545: Thread.interrupted from virtual thread needlessly resets interrupt status (P3) JDK-8322818: Thread::getStackTrace can fail with InternalError if virtual thread is timed-parked when pinned (P3) JDK-8312498: Thread::getState and JVM TI GetThreadState should return TIMED_WAITING virtual thread is timed parked (P3) JDK-8296246: Update Unicode Data Files to 15.1.0 (P3) JDK-8321270: Virtual Thread.yield consumes parking permit (P4) JDK-8317868: Add @sealedGraph to MethodHandleDesc and descendants (P4) JDK-8317874: Add @sealedGraph to StringTemplate.Processor.Linkage (P4) JDK-8295391: Add discussion of binary <-> decimal conversion issues (P4) JDK-8314489: Add javadoc index entries for java.lang.Math terms (P4) JDK-8318415: Adjust describing comment of os_getChildren after 8315026 (P4) JDK-8315373: Change VirtualThread to unmount after freezing, re-mount before thawing (P4) JDK-8314449: Clarify the name of the declaring class of StackTraceElement (P4) JDK-8310242: Clarify the name parameter to Class::forName (P4) JDK-8315721: CloseRace.java#id0 fails transiently on libgraal (P4) JDK-8310848: Convert ClassDesc and MethodTypeDesc to be stored in static final fields (P4) JDK-8310838: Correct range notations in MethodTypeDesc specification (P4) JDK-8309702: Exclude java/lang/ScopedValue/StressStackOverflow.java from JTREG_TEST_THREAD_FACTORY=Virtual runs (P4) JDK-8319574: Exec/process tests should be marked as flagless (P4) JDK-8308452: Extend internal Architecture enum with byte order and address size (P4) JDK-8320940: Fix typo in java.lang.Double (P4) JDK-8320781: Fix whitespace in j.l.Double and j.u.z.ZipInputStream @snippets (P4) JDK-8321223: Implementation of Scoped Values (Second Preview) (P4) JDK-8311290: Improve java.lang.ref.Cleaner rendered documentation (P4) JDK-8311906: Improve robustness of String constructors with mutable array inputs (P4) JDK-8316305: Initial buffer size of StackWalker is too small caused by JDK-8285447 (P4) JDK-8318646: Integer#parseInt("") throws empty NumberFormatException message (P4) JDK-8315921: Invalid CSS declarations in java.lang class documentation (P4) JDK-8314094: java/lang/ProcessHandle/InfoTest.java fails on Windows when run as user with Administrator privileges (P4) JDK-8315213: java/lang/ProcessHandle/TreeTest.java test enhance output of children (P4) JDK-8311926: java/lang/ScopedValue/StressStackOverflow.java takes 9mins in tier1 (P4) JDK-8323296: java/lang/Thread/virtual/stress/GetStackTraceALotWhenPinned.java#id1 timed out (P4) JDK-8316924: java/lang/Thread/virtual/stress/ParkALot.java times out (P4) JDK-8317956: Make jdk.internal.util.Architecture current architecture final (P4) JDK-8316582: Minor startup regression in 22-b15 due JDK-8310929 (P4) JDK-8310929: Optimization for Integer.toString (P4) JDK-8310502: Optimization for j.l.Long.fastUUID() (P4) JDK-8311220: Optimization for StringLatin UpperLower (P4) JDK-8310849: Pattern matching for instanceof and arrayType cleanup in j.l.invoke and j.l.reflect (P4) JDK-8315026: ProcessHandle implementation listing processes on AIX should use getprocs64 (P4) JDK-8268829: Provide an optimized way to walk the stack with Class object only (P4) JDK-8309196: Remove Thread.countStackFrames (P4) JDK-8316456: StackWalker may skip Continuation::yield0 frame mistakenly (P4) JDK-8285447: StackWalker minimal batch size should be optimized for getCallerClass (P4) JDK-8311992: Test java/lang/Thread/virtual/JfrEvents::testVirtualThreadPinned failed (P4) JDK-8311989: Test java/lang/Thread/virtual/Reflection.java timed out (P4) JDK-8319677: Test jdk/internal/misc/VM/RuntimeArguments.java should be marked as flagless (P4) JDK-8323002: test/jdk/java/lang/Thread/virtual/stress/GetStackTraceALotWhenPinned.java times out on macosx-x64 (P4) JDK-8320788: The system properties page is missing some properties (P4) JDK-8310868: Thread.interrupt() method's javadoc has an incorrect {@link} (P4) JDK-8309408: Thread.sleep cleanup (P4) JDK-8321470: ThreadLocal.nextHashCode can be static final (P4) JDK-8310830: typo in the parameter name in @throws of ClassDesc::ofDescriptor (P4) JDK-8319120: Unbound ScopedValue.get() throws the wrong exception (P4) JDK-8317515: Unify the code of the parse*() families of methods in j.l.Integer and j.l.Long (P4) JDK-8310453: Update javadoc of java.lang.Object (P4) JDK-8318457: Use prefix-less prepend methods directly to reduce branches in String concat expressions (P4) JDK-8314759: VirtualThread.parkNanos timeout adjustment when pinned should be replaced (P4) JDK-8316688: Widen allowable error bound of Math.hypot (P5) JDK-8313621: test/jdk/jdk/internal/math/FloatingDecimal/TestFloatingDecimal should use RandomFactory (P5) JDK-8313875: Use literals instead of static fields in java.util.Math: twoToTheDoubleScaleUp, twoToTheDoubleScaleDown core-libs/java.lang.classfile: (P2) JDK-8280389: JEP 457: Class-File API (Preview) (P3) JDK-8321248: ClassFile API ClassModel::verify is inconsistent with the rest of the API (P3) JDK-8317609: Classfile API fails to verify /jdk.jcmd/sun/tools/jstat/Alignment.class (P3) JDK-8320618: NPE: Cannot invoke "java.lang.constant.ClassDesc.isArray()" because "this.sym" is null (P4) JDK-8311084: Add typeSymbol() API for applicable constant pool entries (P4) JDK-8308753: Class-File API transition to Preview (P4) JDK-8315678: Classfile API ConstantPool::entryCount and ConstantPool::entryByIndex methods are confusing (P4) JDK-8315541: Classfile API TypeAnnotation.TargetInfo factory methods accept null labels (P4) JDK-8309838: Classfile API Util.toBinaryName and other cleanup (P4) JDK-8311172: Classfile.PREVIEW_MINOR_VERSION doesn't match that read from class files (P4) JDK-8313452: Improve Classfile API attributes handling safety (P4) JDK-8306650: Improve control of stack maps generation in Classfile API (P4) JDK-8308899: Introduce Classfile context and improve Classfile options (P4) JDK-8313258: RuntimeInvisibleTypeAnnotationsAttribute.annotations() API Index out of Bound error (P4) JDK-8319462: Signature.ClassTypeSig::classDesc() incorrect for inner class types (P4) JDK-8311020: Typo cleanup in Classfile API (P4) JDK-8312491: Update Classfile API snippets and examples (P4) JDK-8316587: Use ArraysSupport.vectorizedHashCode in Utf8EntryImpl (P4) JDK-8320222: Wrong bytecode accepted, and StackMap table generated core-libs/java.lang.foreign: (P1) JDK-8323745: Missing comma in copyright header in TestScope (P2) JDK-8254693: Add Panama feature to pass heap segments to native code (P2) JDK-8322324: java/foreign/TestStubAllocFailure.java times out while waiting for forked process (P2) JDK-8310626: JEP 454: Foreign Function & Memory API (P2) JDK-8298095: Refine implSpec for SegmentAllocator (P2) JDK-8319211: Regression in LoopOverNonConstantFP (P2) JDK-8313023: Return value corrupted when using CCS + isTrivial (mainline) (P2) JDK-8317819: Scope should reflect lifetime of underying resource (mainline) (P2) JDK-8319882: SequenceLayout::toString throws ArithmeticException (P2) JDK-8311932: Suboptimal compiled code of nested loop over memory segment (P3) JDK-8311630: [s390] Implementation of Foreign Function & Memory API (Preview) (P3) JDK-8318538: Add a way to obtain a strided var handle from a layout (P3) JDK-8316970: Add internal annotation to mark restricted methods (P3) JDK-8317799: AIX PPC64: FFI symbol lookup doesn't find symbols (P3) JDK-8318175: AIX PPC64: Handle alignment of double in structs (P3) JDK-8317545: AIX PPC64: Implementation of Foreign Function & Memory API (P3) JDK-8310011: Arena with try-with-resources is slower than it should be (P3) JDK-8317824: Beef up javadoc for base offset in var handles derived from layouts (mainline) (P3) JDK-8319316: Clarify text around which layouts a linker supports (P3) JDK-8318072: DowncallLinker does not acquire/release segments in interpreter (P3) JDK-8318324: Drop redundant default methods from FFM API (P3) JDK-8317514: Ensure MemorySegment is initialized before touching NativeMemorySegmentImpl (P3) JDK-8319928: Exceptions thrown by cleanup actions should be handled correctly (P3) JDK-8318586: Explicitly handle upcall stub allocation failure (P3) JDK-8308858: FFM API and strings (P3) JDK-8310646: Javadoc around prototype-less functions might be incorrect (P3) JDK-8293511: Javadoc style issues in the foreign API (P3) JDK-8317837: Leftover FFM implementation-only changes (P3) JDK-8310405: Linker.Option.firstVariadicArg should specify which index values are valid (P3) JDK-8321467: MemorySegment.setString(long, String, Charset) throws IAE(Misaligned access) (P3) JDK-8318601: Remove javadoc text about restricted methods (P3) JDK-8321387: SegmentAllocator:allocateFrom(AddressLayout, MemorySegment) does not throw stated UnsupportedOperationException (P3) JDK-8321786: SegmentAllocator:allocateFrom(ValueLayout, MemorySegment,ValueLayout,long,long) spec mismatch in exception scenario (P3) JDK-8325001: Typo in the javadocs for the Arena::ofShared method (P3) JDK-8319166: Typos in the JavaDocs for MemorySegment (P3) JDK-8314260: Unable to load system libraries on Windows when using a SecurityManager (P3) JDK-8318653: UpcallTestHelper::runInNewProcess waits for forked process without timeout (P3) JDK-8310053: VarHandle and slice handle derived from layout are lacking alignment check (P3) JDK-8316046: x64 platforms unecessarily save xmm16-31 when UseAVX >= 3 (P4) JDK-8309937: Add @sealedGraph for some Panama FFM interfaces (P4) JDK-8319966: AIX: expected [[0:i4]] but found [[0:I4]] after JDK-8319882 (P4) JDK-8320309: AIX: pthreads created by foreign test library don't work as expected (P4) JDK-8321300: Cleanup TestHFA (P4) JDK-8323159: Consider adding some text re. memory zeroing in Arena::allocate (P4) JDK-8318737: Fallback linker passes bad JNI handle (P4) JDK-8318598: FFM stylistic cleanups (P4) JDK-8319323: FFM: Harmonize the @throws tags in the javadocs (P4) JDK-8319324: FFM: Reformat javadocs (P4) JDK-8319607: FFM: Review the language in the FFM documentation (P4) JDK-8313889: Fix -Wconversion warnings in foreign benchmarks (P4) JDK-8318363: Foreign benchmarks fail to build on some platforms (P4) JDK-8313880: Incorrect copyright header in jdk/java/foreign/TestFree.java after JDK-8310643 (P4) JDK-8321938: java/foreign/critical/TestCriticalUpcall.java does not need a core file (P4) JDK-8322637: java/foreign/critical/TestCriticalUpcall.java timed out (P4) JDK-8315891: java/foreign/TestLinker.java failed with "error occurred while instantiating class TestLinker: null" (P4) JDK-8321400: java/foreign/TestStubAllocFailure.java fails with code cache exhaustion (P4) JDK-8314949: linux PPC64 Big Endian: Implementation of Foreign Function & Memory API (P4) JDK-8318180: Memory model reference from foreign package-info is broken (P4) JDK-8321130: Microbenchmarks do not build any more after 8254693 on 32 bit platforms (P4) JDK-8311593: Minor doc issue in MemorySegment::copy (P4) JDK-8310591: Missing `@since` tags in java.lang.foreign (P4) JDK-8313406: nep_invoker_blob can be simplified more (P4) JDK-8321159: SymbolLookup.libraryLookup(Path, Arena) Assumes default Filesystem (P4) JDK-8314071: Test java/foreign/TestByteBuffer.java timed out (P4) JDK-8318454: TestLayoutPaths broken on Big Endian platforms after JDK-8317837 (P4) JDK-8316050: Use hexadecimal encoding in MemorySegment::toString (P4) JDK-8320131: Zero build fails on macOS after JDK-8254693 (P5) JDK-8319556: Harmonize interface formatting in the FFM API (P5) JDK-8310643: Misformatted copyright messages in FFM (P5) JDK-8319563: Reformat code in the FFM API (P5) JDK-8319560: Reformat method parameters in the FFM API (P5) JDK-8319820: Use unnamed variables in the FFM implementation core-libs/java.lang.invoke: (P2) JDK-8313809: String template fails with java.lang.StringIndexOutOfBoundsException if last fragment is UTF16 (P3) JDK-8199149: Improve the exception message thrown by VarHandle of unsupported operation (P3) JDK-8307508: IndirectVarHandle.isAccessModeSupported throws NPE (P4) JDK-8310157: Allow void-returning filters for MethodHandles::collectCoordinates (P4) JDK-8309819: Clarify API note in Class::getName and MethodType::toMethodDescriptorString (P4) JDK-8310814: Clarify the targetName parameter of Lookup::findClass (P4) JDK-8291065: Creating a VarHandle for a static field triggers class initialization (P4) JDK-8267509: Improve IllegalAccessException message to include the cause of the exception (P4) JDK-6983726: Reimplement MethodHandleProxies.asInterfaceInstance (P4) JDK-8294980: test/jdk/java/lang/invoke 15 test classes use experimental bytecode library (P4) JDK-8319567: Update java/lang/invoke tests to support vm flags core-libs/java.lang.module: (P4) JDK-8319676: A couple of jdk/modules/incubator/ tests ignore VM flags (P4) JDK-8310815: Clarify the name of the main class, services and provider classes in module descriptor (P4) JDK-8320716: ResolvedModule::reads includes self when configuration contains two or more automatic modules core-libs/java.lang:class_loading: (P2) JDK-8319265: TestLoadLibraryDeadlock.java fails on windows-x64 "Unable to load b.jar" (P4) JDK-8254566: Clarify the spec of ClassLoader::getClassLoadingLock for non-parallel capable loader (P4) JDK-8309763: Move tests in test/jdk/sun/misc/URLClassPath directory to test/jdk/jdk/internal/loader (P4) JDK-8319672: Several classloader tests ignore VM flags (P4) JDK-8317965: TestLoadLibraryDeadlock.java fails with "Unable to load native library.: expected true, was false" core-libs/java.lang:reflect: (P3) JDK-8319436: Proxy.newProxyInstance throws NPE if loader is null and interface not visible from class loader (P3) JDK-8315810: Reimplement sun.reflect.ReflectionFactory::newConstructorForSerialization with method handles (P4) JDK-6361826: (reflect) provide method for mapping strings to class object for primitive types (P4) JDK-8316851: Add @sealedGraph to Executable (P4) JDK-8312203: Improve specification of Array.newInstance (P4) JDK-8310267: Javadoc for Class#isPrimitive() is incorrect regarding Class objects for primitives (P4) JDK-8305104: Remove the old core reflection implementation (P4) JDK-8311115: Type in java.lang.reflect.AccessFlag.METHOD_PARAMETER (P4) JDK-8319568: Update java/lang/reflect/exeCallerAccessTest/CallerAccessTest.java to accept vm flags (P5) JDK-8314734: Remove unused field TypeVariableImpl.EMPTY_ANNOTATION_ARRAY core-libs/java.math: (P3) JDK-8318915: Enhance checks in BigDecimal.toPlainString() (P4) JDK-8318476: Add resource consumption note to BigInteger and BigDecimal (P4) JDK-8319174: Enhance robustness of some j.m.BigInteger constructors (P4) JDK-8320199: Fix HTML 5 errors in java.math.BigInteger core-libs/java.net: (P3) JDK-8299058: AssertionError in sun.net.httpserver.ServerImpl when connection is idle (P3) JDK-8306040: HttpResponseInputStream.available() returns 1 on empty stream (P3) JDK-8318599: HttpURLConnection cache issues leading to crashes in JGSS w/ native GSS introduced by 8303809 (P3) JDK-8313239: InetAddress.getCanonicalHostName may return ip address if reverse lookup fails (P3) JDK-8304701: Request with timeout aborts later in-flight request on HTTP/1.1 cxn (P3) JDK-8304885: Reuse stale data to improve DNS resolver resiliency (P3) JDK-8309591: Socket.setOption(TCP_QUICKACK) uses wrong level (P3) JDK-8316031: SSLFlowDelegate should not log from synchronized block (P3) JDK-8317736: Stream::handleReset locks twice (P3) JDK-8263256: Test java/net/Inet6Address/serialize/Inet6AddressSerializationTest.java fails due to dynamic reconfigurations of network interface during test (P4) JDK-8272215: Add InetAddress methods for parsing IP address literals (P4) JDK-8308593: Add KEEPALIVE Extended Socket Options Support for Windows (P4) JDK-8310645: CancelledResponse.java does not use HTTP/2 when testing the HttpClient (P4) JDK-8317246: Cleanup java.net.URLEncoder and URLDecoder use of file.encoding property (P4) JDK-8301457: Code in SendPortZero.java is uncommented even after JDK-8236852 was fixed (P4) JDK-8310731: Configure a javax.net.ssl.SNIMatcher for the HTTP/1.1 test servers in java/net/httpclient tests (P4) JDK-8311032: Empty value for java.protocol.handler.pkgs system property can lead to unnecessary classloading attempts of protocol handlers (P4) JDK-8313256: Exclude failing multicast tests on AIX (P4) JDK-8316399: Exclude java/net/MulticastSocket/Promiscuous.java on AIX (P4) JDK-8317803: Exclude java/net/Socket/asyncClose/Race.java on AIX (P4) JDK-8316387: Exclude more failing multicast tests on AIX after JDK-8315651 (P4) JDK-8319531: FileServerHandler::discardRequestBody could be improved (P4) JDK-8320168: handle setsocktopt return values (P4) JDK-8317808: HTTP/2 stream cancelImpl may leave subscriber registered (P4) JDK-8318492: Http2ClientImpl should attempt to close and remove connection in stop() (P4) JDK-8312433: HttpClient request fails due to connection being considered idle and closed (P4) JDK-8309939: HttpClient should not use Instant.now() as Instant source for deadlines (P4) JDK-8316580: HttpClient with StructuredTaskScope does not close when a task fails (P4) JDK-8309118: HttpClient: Add more tests for 100 ExpectContinue with HTTP/2 (P4) JDK-8310330: HttpClient: debugging interestOps/readyOps could cause exceptions and smaller cleanup (P4) JDK-8315436: HttpsServer does not send TLS alerts (P4) JDK-8320577: Improve MessageHeader's toString() function to make HttpURLConnection's debug log readable (P4) JDK-8315098: Improve URLEncodeDecode microbenchmark (P4) JDK-8312818: Incorrect format specifier in a HttpClient log message (P4) JDK-8309910: Introduce jdk.internal.net.http.HttpConnection.getSNIServerNames() method (P4) JDK-8293713: java/net/httpclient/BufferingSubscriberTest.java fails in timeout, blocked in submission publisher (P4) JDK-8316738: java/net/httpclient/HttpClientLocalAddrTest.java failed in timeout (P4) JDK-8311792: java/net/httpclient/ResponsePublisher.java fails intermittently with AssertionError: Found some outstanding operations (P4) JDK-8282726: java/net/vthread/BlockingSocketOps.java timeout/hang intermittently on Windows (P4) JDK-8319825: jdk.net/jdk.net.ExtendedSocketOptions::IP_DONTFRAGMENT is missing @since 19 (P4) JDK-8308184: Launching java with large number of jars in classpath with java.protocol.handler.pkgs system property set can lead to StackOverflowError (P4) JDK-8311001: missing @since info in jdk.net (P4) JDK-8310997: missing @since tags in jdk.httpserver (P4) JDK-8314978: Multiple server call from connection failing with expect100 in getOutputStream (P4) JDK-8316433: net.dll should delay load winhttp.dll (P4) JDK-8319450: New methods java.net.InetXAddress.ofLiteral() miss @since tag (P4) JDK-8314774: Optimize URLEncoder (P4) JDK-8318006: remove unused net related coding (P4) JDK-8317866: replace NET_SocketAvailable (P4) JDK-8317295: ResponseSubscribers.SubscriberAdapter should call the finisher function asynchronously (P4) JDK-8316681: Rewrite URLEncoder.encode to use small reusable buffers (P4) JDK-8311162: Simplify and modernize equals and hashCode for java.net (P4) JDK-8318130: SocksSocketImpl needlessly encodes hostname for IPv6 addresses (P4) JDK-8314517: some tests fail in case ipv6 is disabled on the machine (P4) JDK-8318150: StaticProxySelector.select should not throw NullPointerExceptions (P4) JDK-8315651: Stop hiding AIX specific multicast socket errors via NetworkConfiguration (aix) (P4) JDK-8314136: Test java/net/httpclient/CancelRequestTest.java failed: WARNING: tracker for HttpClientImpl(42) has outstanding operations (P4) JDK-8308336: Test java/net/HttpURLConnection/HttpURLConnectionExpectContinueTest.java failed: java.net.BindException: Address already in use (P4) JDK-8317522: Test logic for BODY_CF in AbstractThrowingSubscribers.java is wrong (P4) JDK-8308144: Uncontrolled memory consumption in SSLFlowDelegate.Reader (P4) JDK-8308995: Update Network IO JFR events to be static mirror events (P4) JDK-6956385: URLConnection.getLastModified() leaks file handles for jar:file and file: URLs (P4) JDK-8316734: URLEncoder should specify that replacement bytes will be used in case of coding error (P5) JDK-8314877: Make fields final in 'java.net' package (P5) JDK-8314261: Make fields final in sun.net.www (P5) JDK-8313948: Remove unnecessary static fields defaultUpper/defaultLower in sun.net.PortConfig core-libs/java.nio: (P2) JDK-8316337: (bf) Concurrency issue in DirectByteBuffer.Deallocator (P3) JDK-8312180: (bf) MappedMemoryUtils passes incorrect arguments to msync (aix) (P3) JDK-8312166: (dc) DatagramChannel's socket adaptor does not release carrier thread when blocking in receive (P3) JDK-8310902: (fc) FileChannel.transferXXX async close and interrupt issues (P3) JDK-8316304: (fs) Add support for BasicFileAttributes.creationTime() for Linux (P3) JDK-8214248: (fs) Files:mismatch spec clarifications (P3) JDK-8318422: Allow poller threads be virtual threads (P3) JDK-8241800: Disable IPV6_MULTICAST_ALL to prevent interference from all multicast groups (P3) JDK-8313873: java/nio/channels/DatagramChannel/SendReceiveMaxSize.java fails on AIX due to small default RCVBUF size and different IPv6 Header interpretation (P3) JDK-8317128: java/nio/file/Files/CopyAndMove.java failed with AccessDeniedException (P4) JDK-4800398: (ch spec) Clarify Channels.newChannel(InputStream) spec (P4) JDK-8318677: (ch) Add implNote about minBufferCap to main variant of Channels.newWriter (P4) JDK-8306308: (ch) Writer created by Channels::newWriter may lose data (P4) JDK-8319417: (dc) DatagramChannel.connect undocumented behavior (P4) JDK-8313368: (fc) FileChannel.size returns 0 on block special files (P4) JDK-8262742: (fs) Add Path::resolve with varargs string (P4) JDK-8038244: (fs) Check return value of malloc in Java_sun_nio_fs_AixNativeDispatcher_getmntctl() (P4) JDK-8114830: (fs) Files.copy fails due to interference from something else changing the file system (P4) JDK-8073061: (fs) Files.copy(foo, bar, REPLACE_EXISTING) deletes bar even if foo is not readable (P4) JDK-8062795: (fs) Files.setPermissions requires read access when NOFOLLOW_LINKS specified (P4) JDK-8317687: (fs) FileStore.supportsFileAttributeView("posix") incorrectly returns 'true' for FAT32 volume on macOS (P4) JDK-8314569: (fs) Improve normalization of UnixPath for input with trailing slashes (P4) JDK-8314810: (fs) java/nio/file/Files/CopyInterference.java should use TestUtil::supportsLinks (P4) JDK-8315485: (fs) Move java/nio/file/Path/Misc.java tests into java/nio/file/Path/PathOps.java (P4) JDK-8315241: (fs) Move toRealPath tests in java/nio/file/Path/Misc.java to separate JUnit 5 test (P4) JDK-8306882: (fs) Path.toRealPath(LinkOption.NOFOLLOW_LINKS) fails when "../../" follows a link (P4) JDK-8316391: (zipfs) ZipFileSystem.readFullyAt does not tolerate short reads (P4) JDK-8317886: Add @sealedGraph to ByteBuffer (P4) JDK-8312013: avoid UnixConstants.java.template warning: '__linux__' is not defined on AIX (P4) JDK-8313250: Exclude java/foreign/TestByteBuffer.java on AIX (P4) JDK-8317839: Exclude java/nio/channels/Channels/SocketChannelStreams.java on AIX (P4) JDK-8320943: Files/probeContentType/Basic.java fails on latest Windows 11 - content type mismatch (P4) JDK-8317603: Improve exception messages thrown by sun.nio.ch.Net native methods (win) (P4) JDK-8310807: java/nio/channels/DatagramChannel/Connect.java timed out (P4) JDK-8319757: java/nio/channels/DatagramChannel/InterruptibleOrNot.java failed: wrong exception thrown (P4) JDK-8309778: java/nio/file/Files/CopyAndMove.java fails when using second test directory (P4) JDK-8310978: JFR events SocketReadEvent/SocketWriteEvent for Socket adaptor ops (P4) JDK-8310682: No package-info (and @since) for package jdk.nio.mapmode (P4) JDK-8312089: Simplify and modernize equals, hashCode, and compareTo in java.nio and implementation code (P4) JDK-8309475: Test java/foreign/TestByteBuffer.java fails: a problem with msync (aix) (P4) JDK-8321519: Typo in exception message (P5) JDK-8312527: (ch) Re-examine use of sun.nio.ch.Invoker.myGroupAndInvokeCount (P5) JDK-8313743: Make fields final in sun.nio.ch (P5) JDK-8314746: Remove unused private put* methods from DirectByteBufferR (P5) JDK-8315318: Typo in comment on sun.nio.ch.Net.unblock4 core-libs/java.nio.charsets: (P3) JDK-8310631: test/jdk/sun/nio/cs/TestCharsetMapping.java is spuriously passing (P4) JDK-8310047: Add UTF-32 based Charsets into StandardCharsets (P4) JDK-8319817: Charset constructor should make defensive copy of aliases (P4) JDK-8310458: Fix build failure caused by JDK-8310049 (P4) JDK-8310049: Refactor Charset tests to use JUnit (P4) JDK-8310683: Refactor StandardCharset/standard.java to use JUnit (P4) JDK-8311183: Remove unused mapping test files (P4) JDK-8167252: Some of Charset.availableCharsets() does not contain itself (P5) JDK-8313865: Always true condition in sun.nio.cs.CharsetMapping#readINDEXC2B core-libs/java.rmi: (P4) JDK-8316923: Add DEF_STATIC_JNI_OnLoad for librmi (P4) JDK-8303525: Refactor/cleanup open/test/jdk/javax/rmi/ssl/SSLSocketParametersTest.java core-libs/java.sql: (P4) JDK-8310828: java.sql java.sql.rowset packages have no `@since` info core-libs/java.text: (P3) JDK-8319986: Invalid/inconsistent description and example for DateFormat (P3) JDK-8316974: ListFormat creation is unsuccessful for some of the supported Locales (P3) JDK-8317265: ListFormat::format specification could be made clearer regarding handling IllegalArgumentException. (P3) JDK-8317471: ListFormat::parseObject() spec can be improved on parsePosition valid values (P3) JDK-8318487: Specification of the ListFormat.equals() method can be improved (P3) JDK-8317443: StackOverflowError on calling ListFormat::getInstance() for Norwegian locales (P4) JDK-6333341: [BI] Doc: java.text.BreakIterator class specification is unclear (P4) JDK-7061097: [Doc] Inconsistenency between the spec and the implementation for DateFormat.Field (P4) JDK-8039165: [Doc] MessageFormat null locale generates NullPointerException (P4) JDK-6960866: [Fmt-Ch] ChoiceFormat claims impossible and unimplemented functionality (P4) JDK-8318569: Add getter methods for Locale and Patterns in ListFormat (P4) JDK-8317612: ChoiceFormat and MessageFormat constructors call non-final public method (P4) JDK-8314925: ChoiceFormat does not specify IllegalArgumentExceptions (P4) JDK-8318186: ChoiceFormat inconsistency between applyPattern() and setChoices() (P4) JDK-8318613: ChoiceFormat patterns are not well tested (P4) JDK-8318189: ChoiceFormat::format throws undocumented AIOOBE (P4) JDK-8314169: Combine related RoundingMode logic in j.text.DigitList (P4) JDK-8319628: DateFormat does not mention IllegalArgumentException for invalid style args (P4) JDK-8315946: DecimalFormat and CompactNumberFormat do allow U+FFFE and U+FFFF in the pattern (P4) JDK-8318466: Improve spec of NumberFormat's methods with unsupported operations (P4) JDK-8309686: inconsistent URL for https://www.unicode.org/reports/tr35 (P4) JDK-8315064: j.text.ChoiceFormat provides no specification on quoting behavior (P4) JDK-8316629: j.text.DateFormatSymbols setZoneStrings() exception is unhelpful (P4) JDK-8314604: j.text.DecimalFormat behavior regarding patterns is not clear (P4) JDK-6228794: java.text.ChoiceFormat pattern behavior is not well documented. (P4) JDK-8041488: Locale-Dependent List Patterns (P4) JDK-8312411: MessageFormat.formatToCharacterIterator() can be improved (P4) JDK-8317633: Modernize text.testlib.HexDumpReader (P4) JDK-8317631: Refactor ChoiceFormat tests to use JUnit (P4) JDK-8317372: Refactor some NumberFormat tests to use JUnit (P4) JDK-5066247: Refine the spec of equals() and hashCode() for j.text.Format classes (P4) JDK-8316696: Remove the testing base classes: IntlTest and CollatorTest (P4) JDK-8311188: Simplify and modernize equals and hashCode in java.text (P4) JDK-8315410: Undocumented exceptions in java.text.StringCharacterIterator (P4) JDK-8321059: Unneeded array assignments in MergeCollation and CompactByteArray core-libs/java.time: (P3) JDK-8322725: (tz) Update Timezone Data to 2023d (P4) JDK-8321958: @param/@return descriptions of ZoneRules#isDaylightSavings() are incorrect (P4) JDK-8310033: Clarify return value of Java Time compareTo methods (P4) JDK-8319640: ClassicFormat::parseObject (from DateTimeFormatter) does not conform to the javadoc and may leak DateTimeException (P4) JDK-8310182: DateTimeFormatter date formats (ISO_LOCAL_DATE) separated with hyphen, not dash (P4) JDK-8319753: Duration javadoc has "period" instead of "duration" in several places (P4) JDK-8318051: Duration.between uses exceptions for control flow (P4) JDK-8319423: Improve Year.isLeap by checking divisibility by 16 (P4) JDK-8310232: java.time.Clock$TickClock.millis() fails in runtime when tick is 1 microsecond (P4) JDK-8310241: OffsetDateTime compareTo redundant computation core-libs/java.util: (P3) JDK-8279031: Add API note to ToolProvider about being reusable/reentrant (P3) JDK-8306785: fix deficient spliterators for Sequenced Collections (P3) JDK-8310975: java.util.FormatItemModifier should not be protected (P3) JDK-8310913: Move ReferencedKeyMap to jdk.internal so it may be shared (P4) JDK-8317873: Add @sealedGraph to IllegalFormatException (P4) JDK-8315454: Add a way to create an immutable snapshot of a BitSet (P4) JDK-8317795: Add an ImmutableBitSetPredicate variant for bitsets <= 128 elements (P4) JDK-8302987: Add uniform and spatially equidistributed bounded double streams to RandomGenerator (P4) JDK-8317763: Follow-up to AVX512 intrinsics for Arrays.sort() PR (P4) JDK-8315850: Improve AbstractMap anonymous Iterator classes (P4) JDK-8317742: ISO Standard Date Format implementation consistency on DateTimeFormatter and String.format (P4) JDK-8314883: Java_java_util_prefs_FileSystemPreferences_lockFile0 write result errno in missing case (P4) JDK-8315789: Minor HexFormat performance improvements (P4) JDK-8301492: Modernize equals() method of ResourceBundle.CacheKey and Bundles.CacheKey (P4) JDK-8315968: Move java.util.Digits to jdk.internal.util and refactor to reduce duplication (P4) JDK-8320538: Obsolete CSS styles in collection framework doc-file (P4) JDK-8316426: Optimization for HexFormat.formatHex (P4) JDK-8315751: RandomTestBsi1999 fails often with timeouts on Linux ppc64le (P4) JDK-8319569: Several java/util tests should be updated to accept VM flags (P4) JDK-8312019: Simplify and modernize java.util.BitSet.equals (P4) JDK-8309665: Simplify Arrays.copyOf/-Range methods (P4) JDK-8319378: Spec for j.util.Timer::purge and j.util.Timer::cancel could be improved (P4) JDK-8316540: StoreReproducibilityTest fails on some locales (P4) JDK-8310571: Use inline @return tag on java.util.Objects (P4) JDK-8314209: Wrong @since tag for RandomGenerator::equiDoubles (P5) JDK-8314129: Make fields final in java.util.Scanner (P5) JDK-8312414: Make java.util.ServiceLoader.LANG_ACCESS final (P5) JDK-8316187: Modernize examples in StringTokenizer and {Date,Number}Format (P5) JDK-8314321: Remove unused field jdk.internal.util.xml.impl.Attrs.mAttrIdx (P5) JDK-8316144: Remove unused field jdk.internal.util.xml.impl.XMLStreamWriterImpl.Element._Depth core-libs/java.util.concurrent: (P2) JDK-8323659: LinkedTransferQueue add and put methods call overridable offer (P3) JDK-8288899: java/util/concurrent/ExecutorService/CloseTest.java failed with "InterruptedException: sleep interrupted" (P3) JDK-8300663: java/util/concurrent/SynchronousQueue/Fairness.java failed with "Error: fair=true i=0 j=1" (P3) JDK-8267502: JDK-8246677 caused 16x performance regression in SynchronousQueue (P3) JDK-8309853: StructuredTaskScope.join description improvements (P3) JDK-8311867: StructuredTaskScope.shutdown does not interrupt newly started threads (P4) JDK-8318467: [jmh] tests concurrent.Queues and concurrent.ProducerConsumer hang with 101+ threads (P4) JDK-8319662: ForkJoinPool trims worker threads too slowly (P4) JDK-8319498: ForkJoinPool.invoke(ForkJoinTask) does not specify behavior when task throws checked exception (P4) JDK-8308047: java/util/concurrent/ScheduledThreadPoolExecutor/BasicCancelTest.java timed out and also had jcmd pipe errors (P4) JDK-8301341: LinkedTransferQueue does not respect timeout for poll() (P4) JDK-8313290: Misleading exception message from STS.Subtask::get when task forked after shutdown (P4) JDK-8314280: StructuredTaskScope.shutdown should document that the state of completing subtasks is not defined (P5) JDK-8315973: Remove unused fields from ThreadLocalRandom core-libs/java.util.jar: (P2) JDK-8313765: Invalid CEN header (invalid zip64 extra data field size) (P3) JDK-8317678: Fix up hashCode() for ZipFile.Source.Key (P4) JDK-8314891: Additional Zip64 extra header validation (P4) JDK-8303920: Avoid calling out to python in DataDescriptorSignatureMissing test (P4) JDK-8249832: java/util/zip/DataDescriptorSignatureMissing.java uses @ignore w/o bug-id (P4) JDK-8317141: Remove unused validIndex method from URLClassPath$JarLoader (P4) JDK-8304020: Speed up test/jdk/java/util/zip/ZipFile/TestTooManyEntries.java and clarify its purpose (P4) JDK-8315117: Update Zlib Data Compression Library to Version 1.3 core-libs/java.util.logging: (P2) JDK-8314263: Signed jars triggering Logger finder recursion and StackOverflowError (P3) JDK-8315696: SignedLoggerFinderTest.java test failed (P4) JDK-8310987: Missing @since tag(s) in java/util/logging/ErrorManager.java (P4) JDK-8313768: Reduce interaction with volatile field in j.u.l.StreamHandler (P4) JDK-8316087: Test SignedLoggerFinderTest.java is still failing core-libs/java.util.regex: (P2) JDK-8312976: MatchResult produces StringIndexOutOfBoundsException for groups outside match (P4) JDK-8311939: Excessive allocation of Matcher.groups array (P4) JDK-8309955: Matcher uses @since {@inheritDoc} (P4) JDK-8317264: Pattern.Bound has `static` fields that should be `static final`. core-libs/java.util.stream: (P2) JDK-8317955: JEP 461: Stream Gatherers (Preview) (P3) JDK-8321124: java/util/stream/GatherersTest.java times out (P4) JDK-8318421: AbstractPipeline.sourceStageSpliterator() chases pointers needlessly (P4) JDK-8271268: Fix Javadoc links for Stream.mapMulti (P4) JDK-8319123: Implement JEP 461: Stream Gatherers (Preview) (P4) JDK-8316998: Remove redundant type arguments in the java.util.stream package (P4) JDK-8317034: Remove redundant type cast in the java.util.stream package (P4) JDK-8317119: Remove unused imports in the java.util.stream package (P5) JDK-8318420: AbstractPipeline invokes overridden method in constructor core-libs/java.util:collections: (P3) JDK-8308694: Clarify reversed() default methods' implementation requirements (P3) JDK-8159527: Collections mutator methods should all be marked as optional operations (P3) JDK-8309882: LinkedHashMap adds an errant serializable field (P4) JDK-8311517: Add performance information to ArrayList javadoc (P4) JDK-8314896: additional clarifications to reversed() default methods' implementation requirements (P4) JDK-8314236: Overflow in Collections.rotate core-libs/java.util:i18n: (P3) JDK-8321480: ISO 4217 Amendment 176 Update (P3) JDK-8322647: Short name for the `Europe/Lisbon` time zone is incorrect (P3) JDK-8306116: Update CLDR to Version 44.0 (P4) JDK-8311663: Additional refactoring of Locale tests to JUnit (P4) JDK-8320919: Clarify Locale related system properties (P4) JDK-8311968: Clarify Three-letter time zone IDs in java.util.TimeZone (P4) JDK-8320714: java/util/Locale/LocaleProvidersRun.java and java/util/ResourceBundle/modules/visibility/VisibilityTest.java timeout after passing (P4) JDK-8314611: Provide more explicative error message parsing Currencies (P4) JDK-8317126: Redundant entries in Windows `tzmappings` file (P4) JDK-8313231: Redundant if statement in ZoneInfoFile (P4) JDK-8310923: Refactor Currency tests to use JUnit (P4) JDK-8310234: Refactor Locale tests to use JUnit (P4) JDK-8310818: Refactor more Locale tests to use JUnit (P4) JDK-8316559: Refactor some util/Calendar tests to JUnit (P4) JDK-8311528: Remove IDE specific SuppressWarnings (P4) JDK-8322235: Split up and improve LocaleProvidersRun (P4) JDK-8316435: sun.util.calendar.CalendarSystem subclassing should be restricted (P4) JDK-8312416: Tests in Locale should have more descriptive names (P4) JDK-8313702: Update IANA Language Subtag Registry to Version 2023-08-02 (P4) JDK-8318322: Update IANA Language Subtag Registry to Version 2023-10-16 (P4) JDK-8296250: Update ICU4J to Version 74.1 (P4) JDK-8317979: Use TZ database style abbreviations in the CLDR locale provider (P5) JDK-8313813: Field sun.util.calendar.CalendarDate#forceStandardTime is never set (P5) JDK-8316557: Make fields final in 'sun.util' package (P5) JDK-8312521: Unused field LocaleProviderAdapter#defaultLocaleProviderAdapter could be removed core-libs/javax.lang.model: (P3) JDK-8319133: Implement JEP 463: Changes to annotation processing related to dropping unnamed classes (P3) JDK-8307184: Incorrect/inconsistent specification and implementation for Elements.getDocComment (P4) JDK-8312418: Add Elements.getEnumConstantBody (P4) JDK-8315137: Add explicit override RecordComponentElement.asType() (P4) JDK-8310676: add note about unnamed module to Elements.getAllModuleElements (P4) JDK-8306585: Add SourceVersion.RELEASE_22 (P4) JDK-8320941: Discuss receiver type handling (P4) JDK-8281169: Expand discussion of elements and types (P4) JDK-8317221: Implementation for javax.lang.model for Unnamed Variables & Patterns (P4) JDK-8314477: Improve definition of "prototypical type" (P4) JDK-8246280: Refine API to model sealed classes and interfaces in javax.lang.model (P4) JDK-8320803: Update SourceVersion.RELEASE_22 description for language changes (P4) JDK-8309964: Use directed inheritDoc for javax.lang.model API core-libs/javax.naming: (P3) JDK-8313657: com.sun.jndi.ldap.Connection.cleanup does not close connections on SocketTimeoutErrors (P3) JDK-8277954: Replace use of monitors with explicit locks in the JDK LDAP provider implementation (P3) JDK-8314063: The socket is not closed in Connection::createSocket when the handshake failed for LDAP connection core-libs/javax.script: (P5) JDK-8319668: Fixup of jar filename typo in BadFactoryTest.sh core-svc: (P2) JDK-8310863: Build failure after JDK- 8305341 (P4) JDK-8305341: Alignment should be enforced by alignas instead of compiler specific attributes (P4) JDK-8320361: Doc error in RemoteRecordingStream.java (P4) JDK-8313602: increase timeout for jdk/classfile/CorpusTest.java (P4) JDK-8309673: Refactor ref_at methods in SA ConstantPool core-svc/debugger: (P2) JDK-8315406: [REDO] serviceability/jdwp/AllModulesCommandTest.java ignores VM flags (P3) JDK-8301639: JDI and JDWP specs should clarify potential deadlock issues with method invocation (P4) JDK-8315421: [BACKOUT] 8314834 serviceability/jdwp/AllModulesCommandTest.java ignores VM flags (P4) JDK-8318736: com/sun/jdi/JdwpOnThrowTest.java failed with "transport error 202: bind failed: Address already in use" (P4) JDK-8309757: com/sun/jdi/ReferrersTest.java fails with virtual test thread factory (P4) JDK-8309752: com/sun/jdi/SetLocalWhileThreadInNative.java fails with virtual test thread factory due to OpaqueFrameException (P4) JDK-8318957: Enhance agentlib:jdwp help output by info about allow option (P4) JDK-8309335: Get rid of use of reflection to call Thread.isVirtual() in nsk/jdi/EventRequestManager/stepRequests/stepreq001t.java (P4) JDK-8232839: JDI AfterThreadDeathTest.java failed due to "FAILED: Did not get expected IllegalThreadStateException on a StepRequest.enable()" (P4) JDK-8313804: JDWP support for -Djava.net.preferIPv6Addresses=system (P4) JDK-8317920: JDWP-agent sends broken exception event with onthrow option (P4) JDK-8304839: Move TestScaffold.main() to the separate class DebugeeWrapper (P4) JDK-8314834: serviceability/jdwp/AllModulesCommandTest.java ignores VM flags (P4) JDK-8286789: Test forceEarlyReturn002.java timed out (P4) JDK-8308499: Test vmTestbase/nsk/jdi/MethodExitRequest/addClassExclusionFilter/filter001/TestDescription.java failed: VMDisconnectedException (P4) JDK-8318573: The nsk.share.jpda.SocketConnection should fail if socket was closed. (P4) JDK-8314333: Update com/sun/jdi/ProcessAttachTest.java to use ProcessTools.createTestJvm(..) (P4) JDK-8310551: vmTestbase/nsk/jdb/interrupt/interrupt001/interrupt001.java timed out due to missing prompt (P4) JDK-8315486: vmTestbase/nsk/jdwp/ThreadReference/ForceEarlyReturn/forceEarlyReturn002/forceEarlyReturn002.java timed out (P5) JDK-8314481: JDWPTRANSPORT_ERROR_INTERNAL code in socketTransport.c can never be executed (P5) JDK-8282712: VMConnection.open() does not detect if VM failed to be created, resulting in NPE core-svc/java.lang.instrument: (P4) JDK-8316452: java/lang/instrument/modules/AppendToClassPathModuleTest.java ignores VM flags (P4) JDK-8318410: jdk/java/lang/instrument/BootClassPath/BootClassPathTest.sh fails on Japanese Windows (P4) JDK-8313277: Resolve multiple definition of 'normalize' when statically linking JDK native libraries with user code core-svc/java.lang.management: (P3) JDK-8299560: Assertion failed: currentQueryIndex >= 0 && currentQueryIndex < numberOfJavaProcessesAtInitialization (P4) JDK-8316446: 4 sun/management/jdp tests ignore VM flags (P4) JDK-8316447: 8 sun/management/jmxremote tests ignore VM flags (P4) JDK-8310816: GcInfoBuilder float/double signature mismatch (P4) JDK-8310628: GcInfoBuilder.c missing JNI Exception checks (P4) JDK-8306446: java/lang/management/ThreadMXBean/Locks.java transient failures (P4) JDK-8316445: Mark com/sun/management/HotSpotDiagnosticMXBean/CheckOrigin.java as vm.flagless (P4) JDK-8311000: missing @since info in jdk.management (P4) JDK-8324082: more monitoring test timeout adjustments (P4) JDK-8319876: Reduce memory consumption of VM_ThreadDump::doit (P4) JDK-8311222: strace004 can fail due to unexpected stack length after JDK-8309408 (P4) JDK-8320652: ThreadInfo.isInNative needs to be updated to say what executing native code means (P4) JDK-8319465: Typos in javadoc of com.sun.management.OperatingSystemMXBean methods core-svc/javax.management: (P4) JDK-8313174: Create fewer predictable port clashes in management tests (P4) JDK-8313355: javax/management/remote/mandatory/notif/ListenerScaleTest.java failed with "Exception: Failed: ratio=792.2791601423487" (P4) JDK-8319238: JMX ThreadPoolAccTest.java is too verbose and should fail before timeout (P4) JDK-8310988: Missing @since tags in java.management.rmi core-svc/tools: (P3) JDK-8309549: com/sun/tools/attach/warnings/DynamicLoadWarningTest.java fails on AIX (P3) JDK-8310191: com/sun/tools/attach/warnings/DynamicLoadWarningTest.java second failure on AIX (P4) JDK-8316464: 3 sun/tools tests ignore VM flags (P4) JDK-8315706: com/sun/tools/attach/warnings/DynamicLoadWarningTest.java real fix for failure on AIX (P4) JDK-8315702: jcmd Thread.dump_to_file slow with millions of virtual threads (P4) JDK-8310993: Missing @since tags in jdk.attach (P4) JDK-8209595: MonitorVmStartTerminate.java timed out (P4) JDK-8313854: Some tests in serviceability area fail on localized Windows platform (P4) JDK-8320687: sun.jvmstat.monitor.MonitoredHost.getMonitoredHost() throws unexpected exceptions when invoked concurrently (P4) JDK-8314476: TestJstatdPortAndServer.java failed with "java.rmi.NoSuchObjectException: no such object in table" deploy: (P4) JDK-8310999: Add @since info in jdk.jsobject files docs: (P4) JDK-8312105: Update troubleshooting docs to document new security category in -XshowSettings docs/guides: (P4) JDK-8318692: Add instructions for creating Ubuntu-based sysroot for cross compilation (P4) JDK-8313243: Document system properties for for TLS server and client for maximum chain length (P4) JDK-8318693: Fix rendering for code blocks nested under list items in building.md (P4) JDK-8319794: GC Tuning Guide: G1 Updates for JDK 22 (P4) JDK-8305977: Incomplete JSSE docs for FFDHE (P4) JDK-8320949: Update guide with new DTD and Catalog properties (P4) JDK-8322973: Update the Security Guide for this change globalization/translation: (P3) JDK-8322041: JDK 22 RDP1 L10n resource files update (P4) JDK-8301991: Convert l10n properties resource bundles to UTF-8 native hotspot/compiler: (P1) JDK-8315445: 8314748 causes crashes in x64 builds (P1) JDK-8317660: [BACKOUT] 8269393: store/load order not preserved when handling memory pool due to weakly ordered memory architecture of aarch64 (P1) JDK-8322985: [BACKOUT] 8318562: Computational test more than 2x slower when AVX instructions are used (P2) JDK-8314324: "8311557: [JVMCI] deadlock with JVMTI thread suspension" causes various failures (P2) JDK-8313756: [BACKOUT] 8308682: Enhance AES performance (P2) JDK-8313712: [BACKOUT] 8313632: ciEnv::dump_replay_data use fclose (P2) JDK-8315029: [BACKOUT] Generational ZGC: Tests crash with assert(index == 0 || is_power_of_2(index)) (P2) JDK-8317422: [JVMCI] concurrency issue in MethodData creation (P2) JDK-8318694: [JVMCI] disable can_call_java in most contexts for libjvmci compiler threads (P2) JDK-8319559: [JVMCI] ensureLinked must be able to call Java (P2) JDK-8313760: [REDO] Enhance AES performance (P2) JDK-8316880: AArch64: "stop: Header is not fast-locked" with -XX:-UseLSE since JDK-8315880 (P2) JDK-8321515: ARM32: Move method resolution information out of the cpCache properly (P2) JDK-8312495: assert(0 <= i && i < _len) failed: illegal index after JDK-8287061 on big endian platforms (P2) JDK-8313402: C1: Incorrect LoadIndexed value numbering (P2) JDK-8319372: C2 compilation fails with "Bad immediate dominator info" (P2) JDK-8317507: C2 compilation fails with "Exceeded _node_regs array" (P2) JDK-8313262: C2: Sinking node may cause required cast to be dropped (P2) JDK-8321712: C2: "failed: Multiple uses of register" in C2_MacroAssembler::vminmax_fp (P2) JDK-8318889: C2: add bailout after assert Bad graph detected in build_loop_late (P2) JDK-8323101: C2: assert(n->in(0) == nullptr) failed: divisions with zero check should already have bailed out earlier in split-if (P2) JDK-8324688: C2: Disable ReduceAllocationMerges by default (P2) JDK-8313248: C2: setScopedValueCache intrinsic exposes nullptr pre-values to store barriers (P2) JDK-8316392: compiler/interpreter/TestVerifyStackAfterDeopt.java failed with SIGBUS in PcDescContainer::find_pc_desc_internal (P2) JDK-8321974: Crash in ciKlass::is_subtype_of because TypeAryPtr::_klass is not initialized (P2) JDK-8321599: Data loss in AVX3 Base64 decoding (P2) JDK-8316396: Endless loop in C2 compilation triggered by AddNode::IdealIL (P2) JDK-8315582: Exclude compiler/codecache/CodeCacheFullCountTest.java with Xcomp (P2) JDK-8310829: guarantee(!HAS_PENDING_EXCEPTION) failed in ExceptionTranslation::doit (P2) JDK-8314078: HotSpotConstantPool.lookupField() asserts due to field changes in ConstantPool.cpp (P2) JDK-8314244: Incorrect file headers in new tests from JDK-8312597 (P2) JDK-8318306: java/util/Arrays/Sorting.java fails with "Array is not sorted at 8228-th position: 8251.0 and 8153.0" (P2) JDK-8315637: JDK-8314249 broke libgraal (P2) JDK-8324983: Race in CompileBroker::possibly_add_compiler_threads (P2) JDK-8319705: RISC-V: signumF/D intrinsics fails compiler/intrinsics/math/TestSignumIntrinsic.java (P2) JDK-8323190: Segfault during deoptimization of C2-compiled code (P2) JDK-8312617: SIGSEGV in ConnectionGraph::verify_ram_nodes (P2) JDK-8314024: SIGSEGV in PhaseIdealLoop::build_loop_late_post_work due to bad immediate dominator info (P2) JDK-8313345: SuperWord fails due to CMove without matching Bool pack (P2) JDK-8317998: Temporarily disable malformed control flow assert to reduce noise in testing (P2) JDK-8321141: VM build issue on MacOS after JDK-8267532 (P2) JDK-8314688: VM build without C1 fails after JDK-8313372 (P2) JDK-8313530: VM build without C2 fails after JDK-8312579 (P2) JDK-8314951: VM build without C2 still fails after JDK-8313530 (P2) JDK-8319784: VM crash during heap dump after JDK-8287061 (P3) JDK-8314748: 1-10% regressions on Crypto micros (P3) JDK-8310844: [AArch64] C1 compilation fails because monitor offset in OSR buffer is too large for immediate (P3) JDK-8320682: [AArch64] C1 compilation fails with "Field too big for insn" (P3) JDK-8310459: [BACKOUT] 8304450: [vectorapi] Refactor VectorShuffle implementation (P3) JDK-8320175: [BACKOUT] 8316533: C2 compilation fails with assert(verify(phase)) failed: missing Value() optimization (P3) JDK-8317975: [JVMCI] assert(pointee != nullptr) failed: invariant (P3) JDK-8313421: [JVMCI] avoid locking class loader in CompilerToVM.lookupType (P3) JDK-8310425: [JVMCI] compiler/runtime/TestConstantDynamic: lookupConstant returned an object of incorrect type: null (P3) JDK-8312235: [JVMCI] ConstantPool should not force eager resolution (P3) JDK-8315566: [JVMCI] deadlock in JVMCI startup when bad option specified (P3) JDK-8314061: [JVMCI] DeoptimizeALot stress logic breaks deferred barriers (P3) JDK-8318940: [JVMCI] do not set HotSpotNmethod oop for a default HotSpotNmethod (P3) JDK-8314819: [JVMCI] HotSpotJVMCIRuntime.lookupType throws unexpected ClassNotFoundException (P3) JDK-8321225: [JVMCI] HotSpotResolvedObjectTypeImpl.isLeafClass shouldn't create strong references (P3) JDK-8312579: [JVMCI] JVMCI support for virtual Vector API objects (P3) JDK-8319980: [JVMCI] libgraal should reuse Thread instances as C2 does (P3) JDK-8309498: [JVMCI] race in CallSiteTargetValue recording (P3) JDK-8319748: [JVMCI] TestUseCompressedOopsFlagsWithUlimit.java crashes on libgraal (P3) JDK-8316453: [JVMCI] Using Xcomp on jargraal must eagerly initialize JVMCI (P3) JDK-8315082: [REDO] Generational ZGC: Tests crash with assert(index == 0 || is_power_of_2(index)) (P3) JDK-8308855: ARM32: TestBooleanVector crashes after 8300257 (P3) JDK-8312440: assert(cast != nullptr) failed: must have added a cast to pin the node (P3) JDK-8311023: assert(false) failed: EA: missing memory path (P3) JDK-8316659: assert(LockingMode != LM_LIGHTWEIGHT || flag == CCR0) failed: bad condition register (P3) JDK-8310159: Bulk copy with Unsafe::arrayCopy is slower compared to memcpy (P3) JDK-8299658: C1 compilation crashes in LinearScan::resolve_exception_edge (P3) JDK-8312909: C1 should not inline through interface calls with non-subtype receiver (P3) JDK-8310126: C1: Missing receiver null check in Reference::get intrinsic (P3) JDK-8301489: C1: ShortLoopOptimizer might lift instructions before their inputs (P3) JDK-8319764: C2 compilation asserts during incremental inlining because Phi input is out of bounds (P3) JDK-8314191: C2 compilation fails with "bad AD file" (P3) JDK-8316719: C2 compilation still fails with "bad AD file" (P3) JDK-8313626: C2 crash due to unexpected exception control flow (P3) JDK-8316756: C2 EA fails with "missing memory path" when encountering unsafe_arraycopy stub call (P3) JDK-8313720: C2 SuperWord: wrong result with -XX:+UseVectorCmov -XX:+UseCMoveUnconditionally (P3) JDK-8316594: C2 SuperWord: wrong result with hand unrolled loops (P3) JDK-8316679: C2 SuperWord: wrong result, load should not be moved before store if not comparable (P3) JDK-8318826: C2: "Bad graph detected in build_loop_late" with incremental inlining (P3) JDK-8315920: C2: "control input must dominate current control" assert failure (P3) JDK-8310299: C2: 8275201 broke constant folding of array store check in some cases (P3) JDK-8314233: C2: assert(assertion_predicate_has_loop_opaque_node(iff)) failed: unexpected (P3) JDK-8309902: C2: assert(false) failed: Bad graph detected in build_loop_late after JDK-8305189 (P3) JDK-8314116: C2: assert(false) failed: malformed control flow after JDK-8305636 (P3) JDK-8310130: C2: assert(false) failed: scalar_input is neither phi nor a matchin reduction (P3) JDK-8309266: C2: assert(final_con == (jlong)final_int) failed: final value should be integer (P3) JDK-8314106: C2: assert(is_valid()) failed: must be valid after JDK-8305636 (P3) JDK-8315377: C2: assert(u->find_out_with(Op_AddP) == nullptr) failed: more than 2 chained AddP nodes? (P3) JDK-8315088: C2: assert(wq.size() - before == EMPTY_LOOP_SIZE) failed: expect the EMPTY_LOOP_SIZE nodes of this body if empty (P3) JDK-8316105: C2: Back to back Parse Predicates from different loops but with same deopt reason are wrongly grouped together (P3) JDK-8313689: C2: compiler/c2/irTests/scalarReplacement/AllocationMergesTests.java fails intermittently with -XX:-TieredCompilation (P3) JDK-8317723: C2: CountedLoopEndNodes and Zero Trip Guards are wrongly treated as Runtime Predicate (P3) JDK-8303279: C2: crash in SubTypeCheckNode::sub() at IGVN split if (P3) JDK-8316414: C2: large byte array clone triggers "failed: malformed control flow" assertion failure on linux-x86 (P3) JDK-8303737: C2: Load can bypass subtype check that enforces it's from the right object type (P3) JDK-8303513: C2: LoadKlassNode::make fails with 'expecting TypeKlassPtr' (P3) JDK-8321542: C2: Missing ChaCha20 stub for x86_32 leads to crashes (P3) JDK-8267532: C2: Profile and prune untaken exception handlers (P3) JDK-8309203: C2: remove copy-by-value of GrowableArray for InterfaceSet (P3) JDK-8321284: C2: SIGSEGV in PhaseChaitin::gather_lrg_masks (P3) JDK-8317273: compiler/codecache/OverflowCodeCacheTest.java fails transiently on Graal (P3) JDK-8316661: CompilerThread leaks CodeBlob memory when dynamically stopping compiler thread in non-product (P3) JDK-8305636: Expand and clean up predicate classes and move them into separate files (P3) JDK-8312749: Generational ZGC: Tests crash with assert(index == 0 || is_power_of_2(index)) (P3) JDK-8316130: Incorrect control in LibraryCallKit::inline_native_notify_jvmti_funcs (P3) JDK-8309531: Incorrect result with unwrapped iotaShuffle. (P3) JDK-8321215: Incorrect x86 instruction encoding for VSIB addressing mode (P3) JDK-8313899: JVMCI exception Translation can fail in TranslatedException. (P3) JDK-8308103: Massive (up to ~30x) increase in C2 compilation time since JDK 17 (P3) JDK-8319111: Mismatched MemorySegment heap access is not consistently intrinsified (P3) JDK-8314580: PhaseIdealLoop::transform_long_range_checks fails with assert "was tested before" (P3) JDK-8305637: Remove Opaque1 nodes for Parse Predicates and clean up useless predicate elimination (P3) JDK-8317257: RISC-V: llvm build broken (P3) JDK-8320564: RISC-V: Minimal build failed after JDK-8316592 (P3) JDK-8309502: RISC-V: String.indexOf intrinsic may produce misaligned memory loads (P3) JDK-8304954: SegmentedCodeCache fails when using large pages (P3) JDK-8261837: SIGSEGV in ciVirtualCallTypeData::translate_from (P3) JDK-8320206: Some intrinsics/stubs missing vzeroupper on x86_64 (P3) JDK-8319301: Static analysis warnings after JDK-8318016 (P3) JDK-8319879: Stress mode to randomize incremental inlining decision (P3) JDK-8319455: Test compiler/print/CompileCommandMemLimit.java times out (P3) JDK-8314612: TestUnorderedReduction.java fails with -XX:MaxVectorSize=32 and -XX:+AlignVector (P3) JDK-8320209: VectorMaskGen clobbers rflags on x86_64 (P4) JDK-8280120: [IR Framework] Add attribute to @IR to enable/disable IR matching based on the architecture (P4) JDK-8309814: [IR Framework] Dump socket output string in which IR encoding was not found (P4) JDK-8314513: [IR Framework] Some internal IR Framework tests are failing after JDK-8310308 on PPC and Cascade Lake (P4) JDK-8309601: [JVMCI] AMD64#getLargestStorableKind returns incorrect mask kind (P4) JDK-8310673: [JVMCI] batch compilation for libgraal should work the same way as for C2 (P4) JDK-8317452: [JVMCI] Export symbols used by lightweight locking to JVMCI compilers. (P4) JDK-8313372: [JVMCI] Export vmIntrinsics::is_intrinsic_available results to JVMCI compilers. (P4) JDK-8315369: [JVMCI] failure to attach to a libgraal isolate during shutdown should not be fatal (P4) JDK-8313430: [JVMCI] fatal error: Never compilable: in JVMCI shutdown (P4) JDK-8309390: [JVMCI] improve copying system properties into libgraal (P4) JDK-8317689: [JVMCI] include error message when CreateJavaVM in libgraal fails (P4) JDK-8317139: [JVMCI] oop handles clearing message pollutes event log (P4) JDK-8315771: [JVMCI] Resolution of bootstrap methods with int[] static arguments (P4) JDK-8318086: [jvmci] RISC-V: Reuse target config from TargetDescription (P4) JDK-8312524: [JVMCI] serviceability/dcmd/compiler/CompilerQueueTest.java fails (P4) JDK-8315801: [PPC64] JNI code should be more similar to the Panama implementation (P4) JDK-8317661: [REDO] store/load order not preserved when handling memory pool due to weakly ordered memory architecture of aarch64 (P4) JDK-8317581: [s390x] Multiple test failure with LockingMode=2 (P4) JDK-8316935: [s390x] Use consistent naming for lightweight locking in MacroAssembler (P4) JDK-8306136: [vectorapi] Intrinsics of VectorMask.laneIsSet() (P4) JDK-8309978: [x64] Fix useless padding (P4) JDK-8282797: `CompileCommand` Parsing Errors Should Exit VM (P4) JDK-8319872: AArch64: [vectorapi] Implementation of unsigned (zero extended) casts (P4) JDK-8319970: AArch64: enable tests compiler/intrinsics/Test(Long|Integer)UnsignedDivMod.java on aarch64 (P4) JDK-8287325: AArch64: fix virtual threads with -XX:UseBranchProtection=pac-ret (P4) JDK-8307352: AARCH64: Improve itable_stub (P4) JDK-8309583: AArch64: Optimize firstTrue() when amount of elements < 8 (P4) JDK-8311130: AArch64: Sync SVE related CPU features with VM options (P4) JDK-8317502: Add asserts to check for non-null in ciInstance::java_lang_Class_klass (P4) JDK-8308966: Add intrinsic for float/double modulo for x86 AVX2 and AVX512 (P4) JDK-8317683: Add JIT memory statistics (P4) JDK-8321107: Add more test cases for JDK-8319372 (P4) JDK-8311946: Add support for libgraal specific jtreg tests (P4) JDK-8318078: ADLC: pass ASSERT and PRODUCT flags (P4) JDK-8314901: AES-GCM interleaved implementation using AVX2 instructions (P4) JDK-8316178: Better diagnostic header for CodeBlobs (P4) JDK-8316514: Better diagnostic header for VtableStub (P4) JDK-8264899: C1: -XX:AbortVMOnException does not work if all methods in the call stack are compiled with C1 and there are no exception handlers (P4) JDK-8315554: C1: Replace "cmp reg, 0" with "test reg, reg" on x86 (P4) JDK-8311813: C1: Uninitialized PhiResolver::_loop field (P4) JDK-8315545: C1: x86 cmove can use short branches (P4) JDK-8316533: C2 compilation fails with assert(verify(phase)) failed: missing Value() optimization (P4) JDK-8308749: C2 failed: regular loops only (counted loop inside infinite loop) (P4) JDK-8317987: C2 recompilations cause high memory footprint (P4) JDK-8308606: C2 SuperWord: remove alignment checks when not required (P4) JDK-8310886: C2 SuperWord: Two nodes should be isomorphic if they are loop invariant but pinned at different nodes outside the loop (P4) JDK-8312980: C2: "malformed control flow" created during incremental inlining (P4) JDK-8307927: C2: "malformed control flow" with irreducible loop (P4) JDK-8310727: C2: *_of() methods in PhaseIterGVN should use uint for the node index (P4) JDK-8318049: C2: assert(!failure) failed: Missed optimization opportunity in PhaseIterGVN (P4) JDK-8316361: C2: assert(!failure) failed: Missed optimization opportunity in PhaseIterGVN with -XX:VerifyIterativeGVN=10 (P4) JDK-8318959: C2: define MachNode::fill_new_machnode() statically (P4) JDK-8309660: C2: failed: XMM register should be 0-15 (UseKNLSetting and ConvF2HF) (P4) JDK-8308340: C2: Idealize Fma nodes (P4) JDK-8287284: C2: loop optimization performs split_thru_phi infinitely many times (P4) JDK-8313672: C2: PhaseCCP does not correctly track analysis dependencies involving shift, convert, and mask (P4) JDK-8320403: C2: PrintIdeal is no longer dumped to tty when xtty is set (P4) JDK-8312332: C2: Refactor SWPointer out from SuperWord (P4) JDK-8309717: C2: Remove Arena::move_contents usage (P4) JDK-8311691: C2: Remove legacy code related to PostLoopMultiversioning (P4) JDK-8320379: C2: Sort spilling/unspilling sequence for better ld/st merging into ldp/stp on AArch64 (P4) JDK-8308869: C2: use profile data in subtype checks when profile has more than one class (P4) JDK-8318183: C2: VM may crash after hitting node limit (P4) JDK-8315038: Capstone disassembler stops when it sees a bad instruction (P4) JDK-8313632: ciEnv::dump_replay_data use fclose (P4) JDK-8309854: ciReplay TestServerVM test fails with Graal (P4) JDK-8317738: CodeCacheFullCountTest failed with "VirtualMachineError: Out of space in CodeCache for method handle intrinsic" (P4) JDK-8318811: Compiler directives parser swallows a character after line comments (P4) JDK-8318683: compiler/c2/irTests/TestPhiDuplicatedConversion.java "Failed IR Rules (2) of Methods (2)" (P4) JDK-8323651: compiler/c2/irTests/TestPrunedExHandler.java fails with -XX:+DeoptimizeALot (P4) JDK-8317831: compiler/codecache/CheckLargePages.java fails on OL 8.8 with unexpected memory string (P4) JDK-8315576: compiler/codecache/CodeCacheFullCountTest.java fails after JDK-8314837 (P4) JDK-8318981: compiler/compilercontrol/TestConflictInlineCommands.java fails intermittent with 'disallowed by CompileCommand' missing from stdout/stderr (P4) JDK-8316411: compiler/compilercontrol/TestConflictInlineCommands.java fails intermittent with force inline by CompileCommand missing (P4) JDK-8319449: compiler/print/CompileCommandPrintMemStat.java fails on Graal (P4) JDK-8315969: compiler/rangechecks/TestRangeCheckHoistingScaledIV.java: make flagless (P4) JDK-8318468: compiler/tiered/LevelTransitionTest.java fails with -XX:CompileThreshold=100 -XX:TieredStopAtLevel=1 (P4) JDK-8309894: compiler/vectorapi/VectorLogicalOpIdentityTest.java fails on SVE system with UseSVE=0 (P4) JDK-8315505: CompileTask timestamp printed can overflow (P4) JDK-8318562: Computational test more than 2x slower when AVX instructions are used (P4) JDK-8314220: Configurable InlineCacheBuffer size (P4) JDK-8312597: Convert TraceTypeProfile to UL (P4) JDK-8318817: Could not reserve enough space in CodeHeap 'profiled nmethods' (0K) (P4) JDK-8320347: Emulate vblendvp[sd] on ECore (P4) JDK-8321025: Enable Neoverse N1 optimizations for Neoverse V2 (P4) JDK-8321105: Enable UseCryptoPmullForCRC32 for Neoverse V2 (P4) JDK-8320898: exclude compiler/vectorapi/reshape/TestVectorReinterpret.java on ppc64(le) platforms (P4) JDK-8314452: Explicitly indicate inlining success/failure in PrintInlining (P4) JDK-8310316: Failing HotSpot Compiler directives are too verbose (P4) JDK-8310027: Fix -Wconversion warnings in nmethod and compiledMethod related code (P4) JDK-8316907: Fix nonnull-compare warnings (P4) JDK-8312200: Fix Parse::catch_call_exceptions memory leak (P4) JDK-8312077: Fix signed integer overflow, final part (P4) JDK-8310606: Fix signed integer overflow, part 3 (P4) JDK-8318455: Fix the compiler/sharedstubs/SharedTrampolineTest.java and SharedStubToInterpTest.java (P4) JDK-8309847: FrameForm and RegisterForm constructors should initialize all members (P4) JDK-8319747: galoisCounterMode_AESCrypt stack walking broken (P4) JDK-8315954: getArgumentValues002.java fails on Graal (P4) JDK-8318418: hsdis build fails with system binutils on Ubuntu (P4) JDK-8295795: hsdis does not build with binutils 2.39+ (P4) JDK-8319615: IGV incomplete gitignore (P4) JDK-8315604: IGV: dump and visualize node bottom and phase types (P4) JDK-8310220: IGV: dump graph after each IGVN step at level 4 (P4) JDK-8309463: IGV: Dynamic graph layout algorithm (P4) JDK-8320330: Improve implementation of RShift Value (P4) JDK-8316959: Improve InlineCacheBuffer pending queue management (P4) JDK-8320715: Improve the tests of test/hotspot/jtreg/compiler/intrinsics/float16 (P4) JDK-8310264: In PhaseChaitin::Split defs and phis are leaked (P4) JDK-8318490: Increase timeout for JDK tests that are close to the limit when run with libgraal (P4) JDK-8324074: increase timeout for jvmci test TestResolvedJavaMethod.java (P4) JDK-8317809: Insertion of free code blobs into code cache can be very slow during class unloading (P4) JDK-8309893: Integrate ReplicateB/S/I/L/F/D nodes to Replicate node (P4) JDK-8295210: IR framework should not whitelist -XX:-UseTLAB (P4) JDK-8310308: IR Framework: check for type and size of vector nodes (P4) JDK-8306922: IR verification fails because IR dump is chopped up (P4) JDK-8315680: java/lang/ref/ReachabilityFenceTest.java should run with -Xbatch (P4) JDK-8316885: jcmd: Compiler.CodeHeap_Analytics cmd does not inform about missing aggregate (P4) JDK-8315948: JDK-8315818 broke Xcomp on libgraal (P4) JDK-8315051: jdk/jfr/jvm/TestGetEventWriter.java fails with non-JVMCI GCs (P4) JDK-8310331: JitTester: Exclude java.lang.Math.random (P4) JDK-8316653: Large NMethodSizeLimit triggers assert during C1 code buffer allocation (P4) JDK-8308444: LoadStoreNode::result_not_used() is too conservative (P4) JDK-8314319: LogCompilation doesn't reset lateInlining when it encounters a failure. (P4) JDK-8310020: MacroAssembler::call_VM(_leaf) doesn't consistently check for conflict with C calling convention. (P4) JDK-8293069: Make -XX:+Verbose less verbose (P4) JDK-8320272: Make method_entry_barrier address shared (P4) JDK-8312547: Max/Min nodes Value implementation could be improved (P4) JDK-8314997: Missing optimization opportunities due to missing try_clean_mem_phi() calls (P4) JDK-8318445: More broken bailout chains in C2 (P4) JDK-8316181: Move the fast locking implementation out of the .ad files (P4) JDK-8312596: Null pointer access in Compile::TracePhase::~TracePhase after JDK-8311976 (P4) JDK-8309204: Obsolete DoReserveCopyInSuperWord (P4) JDK-8318480: Obsolete UseCounterDecay and remove CounterDecayMinIntervalLength (P4) JDK-8316702: Only evaluate buffer when IGVPrintLevelOption >= 5 (P4) JDK-8316918: Optimize conversions duplicated across phi nodes (P4) JDK-8318016: Per-compilation memory ceiling (P4) JDK-8311087: PhiNode::wait_for_region_igvn should break early (P4) JDK-8318671: Potential uninitialized uintx value after JDK-8317683 (P4) JDK-8320363: ppc64 TypeEntries::type_unknown logic looks wrong, missed optimization opportunity (P4) JDK-8295555: Primitive wrapper caches could be `@Stable` (P4) JDK-8312218: Print additional debug information when hitting assert(in_hash) (P4) JDK-8319256: Print more diagnostic information when an unexpected user is found in a Phi (P4) JDK-8310143: RandomCommandsTest fails due to unexpected VM exit code after JDK-8282797 (P4) JDK-8307625: Redundant receiver null check in LibraryCallKit::generate_method_call (P4) JDK-8314249: Refactor handling of invokedynamic in JVMCI ConstantPool (P4) JDK-8317235: Remove Access API use in nmethod class (P4) JDK-8316670: Remove effectively unused nmethodBucket::_count (P4) JDK-8314248: Remove HotSpotConstantPool::isResolvedDynamicInvoke (P4) JDK-8314056: Remove runtime platform check from frem/drem (P4) JDK-8312213: Remove unnecessary TEST instructions on x86 when flags reg will already be set (P4) JDK-8318489: Remove unused alignment_unit and alignment_offset (P4) JDK-8283140: Remove unused encoding classes/operands from x86_64.ad (P4) JDK-8304403: Remove unused methods in RangeCheckElimination::Bound (P4) JDK-8311125: Remove unused parameter 'phase' in AllocateNode::Ideal_allocation (P4) JDK-8319813: Remove upper limit on number of compiler phases in phasetype.hpp (P4) JDK-8319429: Resetting MXCSR flags degrades ecore (P4) JDK-8310581: retry_class_loading_during_parsing() is not used (P4) JDK-8314618: RISC-V: -XX:MaxVectorSize does not work as expected (P4) JDK-8320280: RISC-V: Avoid passing t0 as temp register to MacroAssembler::lightweight_lock/unlock (P4) JDK-8318222: RISC-V: C2 CmpU3 (P4) JDK-8318223: RISC-V: C2 CmpUL3 (P4) JDK-8318218: RISC-V: C2 CompressBits (P4) JDK-8318219: RISC-V: C2 ExpandBits (P4) JDK-8321002: RISC-V: C2 SignumVD (P4) JDK-8321001: RISC-V: C2 SignumVF (P4) JDK-8318224: RISC-V: C2 UDivI (P4) JDK-8318723: RISC-V: C2 UDivL (P4) JDK-8318225: RISC-V: C2 UModI (P4) JDK-8318226: RISC-V: C2 UModL (P4) JDK-8316743: RISC-V: Change UseVectorizedMismatchIntrinsic option result to warning (P4) JDK-8315070: RISC-V: Clean up platform dependent inline headers (P4) JDK-8319960: RISC-V: compiler/intrinsics/TestInteger/LongUnsignedDivMod.java failed with "counts: Graph contains wrong number of nodes" (P4) JDK-8316933: RISC-V: compiler/vectorapi/VectorCastShape128Test.java fails when using RVV (P4) JDK-8320911: RISC-V: Enable hotspot/jtreg/compiler/intrinsics/chacha/TestChaCha20.java (P4) JDK-8315716: RISC-V: implement ChaCha20 intrinsic (P4) JDK-8317971: RISC-V: implement copySignF/D and signumF/D intrinsics (P4) JDK-8318157: RISC-V: implement ensureMaterializedForStackWalk intrinsic (P4) JDK-8313322: RISC-V: implement MD5 intrinsic (P4) JDK-8316592: RISC-V: implement poly1305 intrinsic (P4) JDK-8318159: RISC-V: Improve itable_stub (P4) JDK-8319184: RISC-V: improve MD5 intrinsic (P4) JDK-8318827: RISC-V: Improve readability of fclass result testing (P4) JDK-8315612: RISC-V: intrinsic for unsignedMultiplyHigh (P4) JDK-8319408: RISC-V: MaxVectorSize is not consistently checked in several situations (P4) JDK-8310192: RISC-V: Merge vector min & max instructs with similar match rules (P4) JDK-8310268: RISC-V: misaligned memory access in String.Compare intrinsic (P4) JDK-8312569: RISC-V: Missing intrinsics for Math.ceil, floor, rint (P4) JDK-8319781: RISC-V: Refactor UseRVV related checks (P4) JDK-8319525: RISC-V: Rename *_riscv64.ad files to *_riscv.ad under riscv/gc (P4) JDK-8319412: RISC-V: Simple fix of indent in c2_MacroAssembler_riscv.hpp (P4) JDK-8311862: RISC-V: small improvements to shift immediate instructions (P4) JDK-8318953: RISC-V: Small refactoring for MacroAssembler::test_bit (P4) JDK-8320697: RISC-V: Small refactoring for runtime calls (P4) JDK-8320399: RISC-V: Some format clean-up in opto assembly code (P4) JDK-8313779: RISC-V: use andn / orn in the MD5 instrinsic (P4) JDK-8318805: RISC-V: Wrong comments instructions cost in riscv.ad (P4) JDK-8315931: RISC-V: xxxMaxVectorTestsSmokeTest fails when using RVV (P4) JDK-8310919: runtime/ErrorHandling/TestAbortVmOnException.java times out due to core dumps taking a long time on OSX (P4) JDK-8311964: Some jtreg tests failing on x86 with error 'unrecognized VM options' (C2 flags) (P4) JDK-8309974: some JVMCI tests fail when VM options include -XX:+EnableJVMCI (P4) JDK-8317677: Specialize Vtablestubs::entry_for() for VtableBlob (P4) JDK-8269393: store/load order not preserved when handling memory pool due to weakly ordered memory architecture of aarch64 (P4) JDK-8318027: Support alternative name to jdk.internal.vm.compiler (P4) JDK-8287061: Support for rematerializing scalar replaced objects participating in allocation merges (P4) JDK-8319572: Test jdk/incubator/vector/LoadJsvmlTest.java ignores VM flags (P4) JDK-8316699: TestDynamicConstant.java fails with release VMs (P4) JDK-8316422: TestIntegerUnsignedDivMod.java triggers "invalid layout" assert in FrameValues::validate (P4) JDK-8311923: TestIRMatching.java fails on RISC-V (P4) JDK-8027711: Unify wildcarding syntax for CompileCommand and CompileOnly (P4) JDK-8315750: Update subtype check profile collection on PPC following 8308869 (P4) JDK-8308662: Update the "java" tool specification for CompileOnly (P4) JDK-8316179: Use consistent naming for lightweight locking in MacroAssembler (P4) JDK-8317600: VtableStubs::stub_containing() table load not ordered wrt to stores (P4) JDK-8316125: Windows call_stub unnecessarily saves xmm16-31 when UseAVX>=3 (P4) JDK-8318509: x86 count_positives intrinsic broken for -XX:AVX3Threshold=0 (P4) JDK-8319406: x86: Shorter movptr(reg, imm) for 32-bit immediates (P4) JDK-8309130: x86_64 AVX512 intrinsics for Arrays.sort methods (int, long, float and double arrays) (P5) JDK-8314838: 3 compiler tests ignore vm flags (P5) JDK-8314837: 5 compiled/codecache tests ignore VM flags (P5) JDK-8307620: [IR Framework] Readme mentions JTREG_WHITE_LIST_FLAGS instead of JTREG_WHITELIST_FLAGS (P5) JDK-8320679: [JVMCI] invalid code in PushLocalFrame event message (P5) JDK-8317575: AArch64: C2_MacroAssembler::fast_lock uses rscratch1 for cmpxchg result (P5) JDK-8311588: C2: RepeatCompilation compiler directive does not choose stress seed randomly (P5) JDK-8315549: CITime misreports code/total nmethod sizes (P5) JDK-8319664: IGV always output on PhaseRemoveUseless (P5) JDK-8316669: ImmutableOopMapSet destructor not called (P5) JDK-8311976: Inconsistency in usage of CITimeVerbose to generate compilation logs (P5) JDK-8319649: inline_boxing_calls unused gvn variable (P5) JDK-8312420: Integrate Graal's blender micro benchmark (P5) JDK-8295191: IR framework timeout options expect ms instead of s (P5) JDK-8316273: JDK-8315818 broke JVMCIPrintProperties on libgraal (P5) JDK-8304684: Memory leak in DirectivesParser::set_option_flag (P5) JDK-8317266: Move nmethod::check_all_dependencies to codeCache.cpp and mark it NOT_PRODUCT (P5) JDK-8315024: Vector API FP reduction tests should not test for exact equality hotspot/gc: (P1) JDK-8319379: G1: gc/logging/TestUnifiedLoggingSwitchStress.java crashes after JDK-8318894 (P1) JDK-8321619: Generational ZGC: ZColorStoreGoodOopClosure is only valid for young objects (P1) JDK-8321216: SerialGC attempts to access the card table beyond the end of the heap during card table scan (P2) JDK-8319700: [AArch64] C2 compilation fails with "Field too big for insn" (P2) JDK-8311215: [BACKOUT] JDK-8047998 Abort the vm if MaxNewSize is not the same as NewSize when MaxHeapSize is the same as InitialHeapSize (P2) JDK-8311548: AArch64: [ZGC] Many tests fail with "assert(allocates2(pc)) failed: not in CodeBuffer memory" on some CPUs (P2) JDK-8310239: Add missing cross modifying fence in nmethod entry barriers (P2) JDK-8310743: assert(reserved_rgn != nullptr) failed: Add committed region, No reserved region found (P2) JDK-8309764: assert(Universe::is_in_heap(result)) failed: object not in heap 0x0000000000000010 (P2) JDK-8323610: G1: HeapRegion pin count should be size_t to avoid overflows (P2) JDK-8320253: G1: SIGSEGV in G1ParScanThreadState::trim_queue_to_threshold (P2) JDK-8309675: Generational ZGC: compiler/gcbarriers/UnsafeIntrinsicsTest.java fails in nmt_commit (P2) JDK-8310194: Generational ZGC: Lock-order asserts in JVMTI IterateThroughHeap (P2) JDK-8313593: Generational ZGC: NMT assert when the heap fails to expand (P2) JDK-8322957: Generational ZGC: Relocation selection must join the STS (P2) JDK-8317440: Lock rank checking fails when code root set is modified with the Servicelock held after JDK-8315503 (P2) JDK-8312099: SIGSEGV in RegisterNMethodOopClosure::do_oop(oopDesc**)+0x38 (P2) JDK-8321422: Test gc/g1/pinnedobjs/TestPinnedObjectTypes.java times out after completion (P2) JDK-8319666: Test gc/stress/gcbasher/TestGCBasherWithG1.java crashed: object not in heap (P2) JDK-8318109: Writing JFR records while a CHT has taken its lock asserts in rank checking (P2) JDK-8315031: YoungPLABSize and OldPLABSize not aligned by ObjectAlignmentInBytes (P3) JDK-8320807: [PPC64][ZGC] C1 generates wrong code for atomics (P3) JDK-8314573: G1: Heap resizing at Remark does not take existing eden regions into account (P3) JDK-8318720: G1: Memory leak in G1CodeRootSet after JDK-8315503 (P3) JDK-8170817: G1: Returning MinTLABSize from unsafe_max_tlab_alloc causes TLAB flapping (P3) JDK-8314990: Generational ZGC: Strong OopStorage stats reported as weak roots (P3) JDK-8316319: Generational ZGC: The SoftMaxHeapSize might be wrong when CDS decreases the MaxHeapSize (P3) JDK-8308643: Incorrect value of 'used' jvmstat counter (P3) JDK-8319969: os::large_page_init() turns off THPs for ZGC (P3) JDK-8316929: Shenandoah: Shenandoah degenerated GC and full GC need to cleanup old OopMapCache entries (P3) JDK-8299614: Shenandoah: STW mark should keep nmethod/oops referenced from stack chunk alive (P3) JDK-8311064: Windows builds fail without precompiled headers after JDK-8310728 (P4) JDK-8047998: Abort the vm if MaxNewSize is not the same as NewSize when MaxHeapSize is the same as InitialHeapSize (P4) JDK-8314019: Add gc logging to jdk/jfr/event/gc/detailed/TestZAllocationStallEvent.java (P4) JDK-8313954: Add gc logging to vmTestbase/vm/gc/containers/Combination05 (P4) JDK-8313224: Avoid calling JavaThread::current() in MemAllocator::Allocation constructor (P4) JDK-8030815: Code roots are not accounted for in region prediction (P4) JDK-8272147: Consolidate preserved marks handling with other STW collectors (P4) JDK-8311189: disable gc/z/TestHighUsage.java (P4) JDK-8311240: Eliminate usage of testcases.jar from TestMetaSpaceLog.java (P4) JDK-8316608: Enable parallelism in vmTestbase/gc/vector tests (P4) JDK-8310537: Fix -Wconversion warnings in gcUtil.hpp (P4) JDK-8313791: Fix just zPage.inline.hpp and xPage.inline.hpp (P4) JDK-8320331: G1 Full GC Heap verification relies on metadata not reset before verification (P4) JDK-8314157: G1: "yielded" is not initialized on some paths after JDK-8140326 (P4) JDK-8315605: G1: Add number of nmethods in code roots scanning statistics (P4) JDK-8310354: G1: Annotate G1MMUTracker::when_sec with const (P4) JDK-8248149: G1: change _cleaning_claimed from int to bool (P4) JDK-8319204: G1: Change G1CMTask::_termination_time_ms to wallclock time (P4) JDK-8315503: G1: Code root scan causes long GC pauses due to imbalanced iteration (P4) JDK-8140326: G1: Consider putting regions where evacuation failed into next collection set (P4) JDK-8315686: G1: Disallow evacuation of marking regions in a Prepare Mixed gc (P4) JDK-8314274: G1: Fix -Wconversion warnings around G1CardSetArray::_data (P4) JDK-8315242: G1: Fix -Wconversion warnings around GCDrainStackTargetSize (P4) JDK-8314932: G1: Fix -Wconversion warnings for simple cases inside g1 folder (P4) JDK-8314161: G1: Fix -Wconversion warnings in G1CardSetConfiguration::_bitmap_hash_mask (P4) JDK-8314119: G1: Fix -Wconversion warnings in G1CardSetInlinePtr::card_pos_for (P4) JDK-8315550: G1: Fix -Wconversion warnings in g1NUMA (P4) JDK-8314651: G1: Fix -Wconversion warnings in static fields of HeapRegion (P4) JDK-8318702: G1: Fix nonstandard indentation in g1HeapTransition.cpp (P4) JDK-8219357: G1: G1GCPhaseTimes::debug_phase uses unnecessary ResourceMark (P4) JDK-8320525: G1: G1UpdateRemSetTrackingBeforeRebuild::distribute_marked_bytes accesses partially unloaded klass (P4) JDK-8315219: G1: Improve allocator pathological case where it keeps doing direct allocations instead of retiring a PLAB (P4) JDK-8314100: G1: Improve collection set candidate selection code (P4) JDK-8318507: G1: Improve remset clearing for humongous candidates (P4) JDK-8315765: G1: Incorrect use of G1LastPLABAverageOccupancy (P4) JDK-8319541: G1: Inline G1RemoveSelfForwardsTask into RestoreRetainedRegionsTask (P4) JDK-8317188: G1: Make TestG1ConcRefinementThreads use createTestJvm (P4) JDK-8317042: G1: Make TestG1ConcMarkStepDurationMillis use createTestJvm (P4) JDK-8317218: G1: Make TestG1HeapRegionSize use createTestJvm (P4) JDK-8317316: G1: Make TestG1PercentageOptions use createTestJvm (P4) JDK-8317317: G1: Make TestG1RemSetFlags use createTestJvm (P4) JDK-8317358: G1: Make TestMaxNewSize use createTestJvm (P4) JDK-8309306: G1: Move is_obj_dead from HeapRegion to G1CollectedHeap (P4) JDK-8309538: G1: Move total collection increment from Cleanup to Remark (P4) JDK-8316428: G1: Nmethod count statistics only count last code root set iterated (P4) JDK-8317594: G1: Refactor find_empty_from_idx_reverse (P4) JDK-8313962: G1: Refactor G1ConcurrentMark::_num_concurrent_workers (P4) JDK-8310946: G1: Refactor G1Policy::next_gc_should_be_mixed (P4) JDK-8315854: G1: Remove obsolete comment in G1ReclaimEmptyRegionsTask (P4) JDK-8310541: G1: Remove redundant check in G1Policy::need_to_start_conc_mark (P4) JDK-8318649: G1: Remove unimplemented HeapRegionRemSet::add_code_root_locked (P4) JDK-8317797: G1: Remove unimplemented predict_will_fit (P4) JDK-8309852: G1: Remove unnecessary assert_empty in G1ParScanThreadStateSet destructor (P4) JDK-8315446: G1: Remove unused G1AllocRegion::attempt_allocation (P4) JDK-8314113: G1: Remove unused G1CardSetInlinePtr::card_at (P4) JDK-8315689: G1: Remove unused init_hash_seed (P4) JDK-8319313: G1: Rename G1EvacFailureInjector appropriately (P4) JDK-8315848: G1: Rename rs_ prefix to card_rs in analytics (P4) JDK-8315855: G1: Revise signature of set_humongous_candidate (P4) JDK-8319725: G1: Subtracting virtual time from wall time after JDK-8319204 (P4) JDK-8318713: G1: Use more accurate age in predict_eden_copy_time_ms (P4) JDK-8318894: G1: Use uint for age in G1SurvRateGroup (P4) JDK-8315087: G1: Use uint for G1 flags indicating percentage (P4) JDK-8310540: G1: Verification should use raw oop decode functions (P4) JDK-8323066: gc/g1/TestSkipRebuildRemsetPhase.java fails with 'Skipping Remembered Set Rebuild.' missing (P4) JDK-8316001: GC: Make TestArrayAllocatorMallocLimit use createTestJvm (P4) JDK-8316410: GC: Make TestCompressedClassFlags use createTestJvm (P4) JDK-8316973: GC: Make TestDisableDefaultGC use createTestJvm (P4) JDK-8317343: GC: Make TestHeapFreeRatio use createTestJvm (P4) JDK-8317228: GC: Make TestXXXHeapSizeFlags use createTestJvm (P4) JDK-8311239: GC: Remove trailing blank lines in source files (P4) JDK-8308843: Generational ZGC: Remove gc/z/TestHighUsage.java (P4) JDK-8320859: gtest high malloc footprint caused by BufferNodeAllocator stress test (P4) JDK-8318706: Implement JEP 423: Region Pinning for G1 (P4) JDK-8314276: Improve PtrQueue API around size/capacity (P4) JDK-8309627: Incorrect sorting of DirtyCardQueue buffers (P4) JDK-8308633: Increase precision of timestamps in g1 log (P4) JDK-8276094: JEP 423: Region Pinning for G1 (P4) JDK-8293114: JVM should trim the native heap (P4) JDK-8314551: More generic way to handshake GC threads with monitor deflation (P4) JDK-8319439: Move BufferNode from PtrQueue files to new files (P4) JDK-8317350: Move code cache purging out of CodeCache::UnloadingScope (P4) JDK-8318296: Move Space::initialize to ContiguousSpace (P4) JDK-8257076: os::scan_pages is empty on all platforms (P4) JDK-8319726: Parallel GC: Re-use object in object-iterator (P4) JDK-8316115: Parallel: Fix -Wconversion warnings around NUMA node ID (P4) JDK-8310031: Parallel: Implement better work distribution for large object arrays in old gen (P4) JDK-8321018: Parallel: Make some methods in ParCompactionManager private (P4) JDK-8315988: Parallel: Make TestAggressiveHeap use createTestJvm (P4) JDK-8317347: Parallel: Make TestInitialTenuringThreshold use createTestJvm (P4) JDK-8319205: Parallel: Reenable work stealing after JDK-8310031 (P4) JDK-8321013: Parallel: Refactor ObjectStartArray (P4) JDK-8318908: Parallel: Remove ExtendedCardValue (P4) JDK-8319713: Parallel: Remove PSAdaptiveSizePolicy::should_full_GC (P4) JDK-8315039: Parallel: Remove unimplemented PSYoungGen::oop_iterate (P4) JDK-8319620: Parallel: Remove unused PSPromotionManager::*_is_full getters and setters (P4) JDK-8321214: Parallel: Remove unused SpaceInfo::_min_dense_prefix (P4) JDK-8321273: Parallel: Remove unused UpdateOnlyClosure::_space_id (P4) JDK-8318801: Parallel: Remove unused verify_all_young_refs_precise (P4) JDK-8319203: Parallel: Rename addr_is_marked_imprecise (P4) JDK-8319376: ParallelGC: Forwarded objects found during heap inspection (P4) JDK-8315459: Print G1 reserved and committed sizes as separate items in VM.info and hs_err (P4) JDK-8315781: Reduce the max value of GCDrainStackTargetSize (P4) JDK-8311086: Remove jtreg/gc/startup_warnings (P4) JDK-8309468: Remove jvmti Allocate locker test case (P4) JDK-8323508: Remove TestGCLockerWithShenandoah.java line from TEST.groups (P4) JDK-8319106: Remove unimplemented TaskTerminator::do_delay_step (P4) JDK-8318155: Remove unnecessary virtual specifier in Space (P4) JDK-8315072: Remove unneeded AdaptivePaddedAverage::operator new (P4) JDK-8309907: Remove unused _print_gc_overhead_limit_would_be_exceeded (P4) JDK-8311249: Remove unused MemAllocator::obj_memory_range (P4) JDK-8313922: Remove unused WorkerPolicy::_debug_perturbation (P4) JDK-8318585: Rename CodeCache::UnloadingScope to UnlinkingScope (P4) JDK-8309899: Rename PtrQueueSet::buffer_size() (P4) JDK-8311639: Replace currentTimeMillis() with nanoTime() in jtreg/gc (P4) JDK-8318735: RISC-V: Enable related hotspot tests run on riscv (P4) JDK-8317318: Serial: Change GenCollectedHeap to SerialHeap in whitebox (P4) JDK-8316957: Serial: Change GenCollectedHeap to SerialHeap inside gc/serial folder (P4) JDK-8317354: Serial: Move DirtyCardToOopClosure to gc/serial folder (P4) JDK-8317675: Serial: Move gc/shared/generation to serial folder (P4) JDK-8310311: Serial: move Generation::contribute_scratch to DefNewGeneration (P4) JDK-8318647: Serial: Refactor BlockOffsetTable (P4) JDK-8319373: Serial: Refactor dirty cards scanning during Young GC (P4) JDK-8315933: Serial: Remove empty Generation::ensure_parsability (P4) JDK-8316295: Serial: Remove empty Generation::promotion_failure_occurred (P4) JDK-8319703: Serial: Remove generationSpec (P4) JDK-8317592: Serial: Remove Space::toContiguousSpace (P4) JDK-8318510: Serial: Remove TenuredGeneration::block_size (P4) JDK-8319306: Serial: Remove TenuredSpace::verify (P4) JDK-8316940: Serial: Remove unused declarations in genCollectedHeap (P4) JDK-8316420: Serial: Remove unused GenCollectedHeap::oop_iterate (P4) JDK-8316357: Serial: Remove unused GenCollectedHeap::space_containing (P4) JDK-8316021: Serial: Remove unused Generation::post_compact (P4) JDK-8317963: Serial: Remove unused GenerationIsInReservedClosure (P4) JDK-8316513: Serial: Remove unused invalidate_remembered_set (P4) JDK-8317994: Serial: Use SerialHeap in generation (P4) JDK-8310388: Shenandoah: Auxiliary bitmap is not madvised for THP (P4) JDK-8311978: Shenandoah: Create abstraction over heap metrics for heuristics (P4) JDK-8320888: Shenandoah: Enable ShenandoahVerifyOptoBarriers in debug builds (P4) JDK-8320969: Shenandoah: Enforce stable number of GC workers (P4) JDK-8316632: Shenandoah: Raise OOME when gc threshold is exceeded (P4) JDK-8321120: Shenandoah: Remove ShenandoahElasticTLAB flag (P4) JDK-8321122: Shenandoah: Remove ShenandoahLoopOptsAfterExpansion flag (P4) JDK-8320907: Shenandoah: Remove ShenandoahSelfFixing flag (P4) JDK-8321410: Shenandoah: Remove ShenandoahSuspendibleWorkers flag (P4) JDK-8320877: Shenandoah: Remove ShenandoahUnloadClassesFrequency support (P4) JDK-8317535: Shenandoah: Remove unused code (P4) JDK-8309956: Shenandoah: Strengthen the mark word check in string dedup (P4) JDK-8310110: Shenandoah: Trace page sizes (P4) JDK-8314935: Shenandoah: Unable to throw OOME on back-to-back Full GCs (P4) JDK-8311656: Shenandoah: Unused ShenandoahSATBAndRemarkThreadsClosure::_claim_token (P4) JDK-8311821: Simplify ParallelGCThreadsConstraintFunc after CMS removal (P4) JDK-8311026: Some G1 specific tests do not set -XX:+UseG1GC (P4) JDK-8309953: Strengthen and optimize oopDesc age methods (P4) JDK-8309890: TestStringDeduplicationInterned.java waits for the wrong condition (P4) JDK-8321369: Unproblemlist gc/cslocker/TestCSLocker.java (P4) JDK-8311646: ZGC: LIR_OpZStoreBarrier::_info shadows LIR_Op::_info (P4) JDK-8311508: ZGC: RAII use of IntelJccErratumAlignment (P5) JDK-8316906: Clarify TLABWasteTargetPercent flag (P5) JDK-8315548: G1: Document why VM_G1CollectForAllocation::doit() may allocate without completing a GC (P5) JDK-8311179: Generational ZGC: gc/z/TestSmallHeap.java failed with OutOfMemoryError (P5) JDK-8309403: Serial: Remove the useless adaptive size policy in GenCollectedHeap hotspot/jfr: (P2) JDK-8307526: [JFR] Better handling of tampered JFR repository (P2) JDK-8323540: assert((!((((method)->is_trace_flag_set(((1 << 4) << 8))))))) failed: invariant (P2) JDK-8322142: JFR: Periodic tasks aren't orphaned between recordings (P2) JDK-8323631: JfrTypeSet::write_klass can enqueue a CLD klass that is unloading (P2) JDK-8315827: Kitchensink.java and RenaissanceStressTest.java time out with jvmti module errors (P2) JDK-8312293: SIGSEGV in jfr.internal.event.EventWriter.putUncheckedByte after JDK-8312086 (P2) JDK-8309862: Unsafe list operations in JfrStringPool (P3) JDK-8322489: 22-b27: Up to 7% regression in all Footprint3-*-G1/ZGC (P3) JDK-8211238: @Deprecated JFR event (P3) JDK-8319206: [REDO] Event NativeLibraryLoad breaks invariant by taking a stacktrace when thread is in state _thread_in_native (P3) JDK-8313251: Add NativeLibraryLoad event (P3) JDK-8314211: Add NativeLibraryUnload event (P3) JDK-8315364: Assert thread state invariant for JFR stack trace capture (P3) JDK-8315220: Event NativeLibraryLoad breaks invariant by taking a stacktrace when thread is in state _thread_in_native (P3) JDK-8244289: fatal error: Possible safepoint reached by thread that does not allow it (P3) JDK-8312574: jdk/jdk/jfr/jvm/TestChunkIntegrity.java fails with timeout (P3) JDK-8309871: jdk/jfr/api/consumer/recordingstream/TestSetEndTime.java timed out (P3) JDK-8309296: jdk/jfr/event/runtime/TestAgentEvent.java fails due to "missing" dynamic JavaAgent (P3) JDK-8311007: jdk/jfr/tool/TestView.java can't find event (P3) JDK-8309238: jdk/jfr/tool/TestView.java failed with "exitValue = 134" (P3) JDK-8316454: JFR break locale settings (P3) JDK-8239508: JFR: @RemoveFields (P3) JDK-8316437: JFR: assert(!tl->has_java_buffer()) failed: invariant (P3) JDK-8313722: JFR: Avoid unnecessary calls to Events.from(Recording) (P3) JDK-8320805: JFR: Create view for deprecated methods (P3) JDK-8309959: JFR: Display N/A for missing data amount (P3) JDK-8312474: JFR: Improve logging to diagnose event stream timeout (P3) JDK-8310335: JFR: Modernize collections and switch statements (P3) JDK-8316927: JFR: Move shouldCommit check earlier for socket events (P3) JDK-8312533: JFR: No message for JFR.view when data is missing (P3) JDK-8321220: JFR: RecordedClass reports incorrect modifiers (P3) JDK-8311040: JFR: RecordedThread::getOSThreadId() should return -1 if thread is virtual (P3) JDK-8310266: JFR: Refactor after 'view' command (P3) JDK-8319374: JFR: Remove instrumentation for exception events (P3) JDK-8311245: JFR: Remove t.printStackTrace() in PeriodicEvents (P3) JDK-8318124: JFR: Rewrite instrumentation to use Class-File API (P3) JDK-8319072: JFR: Turn off events for JFR.view (P3) JDK-8321505: JFR: Update views (P3) JDK-8309928: JFR: View issues (P3) JDK-8316271: JfrJvmtiAgent::retransformClasses failed: JVMTI_ERROR_FAILS_VERIFICATION (P3) JDK-8317360: Missing null checks in JfrCheckpointManager and JfrStringPool initialization routines (P3) JDK-8315930: Revert "8315220: Event NativeLibraryLoad breaks invariant by taking a stacktrace when thread is in state _thread_in_native" (P3) JDK-8316241: Test jdk/jdk/jfr/jvm/TestChunkIntegrity.java failed (P3) JDK-8294401: Update jfr man page to include recently added features (P3) JDK-8273131: Update the java manpage markdown source for JFR filename expansion (P3) JDK-8288936: Wrong lock ordering writing G1HeapRegionTypeChange JFR event (P4) JDK-8317562: [JFR] Compilation queue statistics (P4) JDK-8288158: Add an anchor to each subcommand option on jfr html page (P4) JDK-8313394: Array Elements in OldObjectSample event has the incorrect description (P4) JDK-8310512: Cleanup indentation in jfc files (P4) JDK-8316400: Exclude jdk/jfr/event/runtime/TestResidentSetSizeEvent.java on AIX (P4) JDK-8313552: Fix -Wconversion warnings in JFR code (P4) JDK-8318701: Fix copyright year (P4) JDK-8311511: Improve description of NativeLibrary JFR event (P4) JDK-8320916: jdk/jfr/event/gc/stacktrace/TestParallelMarkSweepAllocationPendingStackTrace.java failed with "OutOfMemoryError: GC overhead limit exceeded" (P4) JDK-8316193: jdk/jfr/event/oldobject/TestListenerLeak.java java.lang.Exception: Could not find leak (P4) JDK-8315128: jdk/jfr/event/runtime/TestResidentSetSizeEvent.java fails with "The size should be less than or equal to peak" (P4) JDK-8305931: jdk/jfr/jcmd/TestJcmdDumpPathToGCRoots.java failed with "Expected chains but found none" (P4) JDK-8314905: jdk/jfr/tool/TestView.java fails with RuntimeException 'Invoked Concurrent' missing from stdout/stderr (P4) JDK-8311536: JFR TestNativeMemoryUsageEvents fails in huge pages configuration (P4) JDK-8314745: JFR: @StackFilter (P4) JDK-8313891: JFR: Incorrect exception message for RecordedObject::getInt (P4) JDK-8310661: JFR: Replace JVM.getJVM() with JVM (P4) JDK-8310561: JFR: Unify decodeDescriptors(String, String) (P4) JDK-8311823: JFR: Uninitialized EventEmitter::_thread_id field (P4) JDK-8316538: runtime/handshake/MixedHandshakeWalkStackTest.java crashes with JFR (P4) JDK-8313670: Simplify shared lib name handling code in some tests (P4) JDK-8221633: StartFlightRecording: consider moving mention of multiple comma-separated parameters to the front (P4) JDK-8312526: Test dk/jfr/event/oldobject/TestHeapDeep.java failed: Could not find ChainNode hotspot/jvmti: (P2) JDK-8300051: assert(JvmtiEnvBase::environments_might_exist()) failed: to enter event controller, JVM TI environments must exist (P2) JDK-8321219: runtime/jni/FastGetField: assert(is_interpreted_frame()) failed: interpreted frame expected (P2) JDK-8310211: serviceability/jvmti/thread/GetStackTrace/getstacktr03/getstacktr03.java failing (P3) JDK-8309612: [REDO] JDK-8307153 JVMTI GetThreadState on carrier should return STATE_WAITING (P3) JDK-8313816: Accessing jmethodID might lead to spurious crashes (P3) JDK-8308614: Enabling JVMTI ClassLoad event slows down vthread creation by factor 10 (P3) JDK-8311218: fatal error: stuck in JvmtiVTMSTransitionDisabler::VTMS_transition_disable (P3) JDK-8311556: GetThreadLocalStorage not working for vthreads mounted during JVMTI attach (P3) JDK-8310584: GetThreadState reports blocked and runnable for pinned suspended virtual threads (P3) JDK-8321069: JvmtiThreadState::state_for_while_locked() returns nullptr for an attached JNI thread with a java.lang.Thread object after JDK-8319935 (P3) JDK-8321685: Missing ResourceMark in code called from JvmtiEnvBase::get_vthread_jvf (P3) JDK-8312777: notifyJvmtiMount before notifyJvmtiUnmount (P3) JDK-8316658: serviceability/jvmti/RedefineClasses/RedefineLeakThrowable.java fails intermittently (P3) JDK-8303086: SIGSEGV in JavaThread::is_interp_only_mode() (P4) JDK-8307462: [REDO] VmObjectAlloc is not generated by intrinsics methods which allocate objects (P4) JDK-8320239: add dynamic switch for JvmtiVTMSTransitionDisabler sync protocol (P4) JDK-8320860: add-opens/add-exports require '=' in JAVA_TOOL_OPTIONS (P4) JDK-8313656: assert(!JvmtiExport::can_support_virtual_threads()) with -XX:-DoJVMTIVirtualThreadTransitions (P4) JDK-8319935: Ensure only one JvmtiThreadState is created for one JavaThread associated with attached native thread (P4) JDK-8311077: Fix -Wconversion warnings in jvmti code (P4) JDK-8314824: Fix serviceability/jvmti/8036666/GetObjectLockCount.java to use vm flags (P4) JDK-8318626: GetClassFields does not filter out ConstantPool.constantPoolOop field (P4) JDK-8310585: GetThreadState spec mentions undefined JVMTI_THREAD_STATE_MONITOR_WAITING (P4) JDK-8319244: implement JVMTI handshakes support for virtual threads (P4) JDK-8317635: Improve GetClassFields test to verify correctness of field order (P4) JDK-8310066: Improve test coverage for JVMTI GetThreadState on carrier and mounted vthread (P4) JDK-8308429: jvmti/StopThread/stopthrd007 failed with "NoClassDefFoundError: Could not initialize class jdk.internal.misc.VirtualThreads" (P4) JDK-8319961: JvmtiEnvBase doesn't zero _ext_event_callbacks (P4) JDK-8308762: Metaspace leak with Instrumentation.retransform (P4) JDK-8311301: MethodExitTest may fail with stack buffer overrun (P4) JDK-8312174: missing JVMTI events from vthreads parked during JVMTI attach (P4) JDK-8322538: remove fatal from JVM_VirtualThread functions for !INCLUDE_JVMTI (P4) JDK-8309663: test fails "assert(check_alignment(result)) failed: address not aligned: 0x00000008baadbabe" (P4) JDK-8313654: Test WaitNotifySuspendedVThreadTest.java timed out (P4) JDK-8319375: test/hotspot/jtreg/serviceability/jvmti/RedefineClasses/RedefineLeakThrowable.java runs into OutOfMemoryError: Metaspace on AIX (P4) JDK-8316233: VirtualThreadStart events should not be thread-filtered hotspot/other: (P4) JDK-8310948: Fix ignored-qualifiers warning in Hotspot (P4) JDK-8318126: Refresh manpages (P4) JDK-8319554: Select LogOutput* directly for stdout and stderr (P4) JDK-8318962: Update ProcessTools javadoc with suggestions in 8315097 (P5) JDK-8319165: hsdis binutils: warns on empty string as option string hotspot/runtime: (P1) JDK-8316698: build failure caused by JDK-8316456 (P1) JDK-8317335: Build on windows fails after 8316645 (P1) JDK-8313795: Fix for JDK-8313564 breaks ppc and s390x builds (P2) JDK-8315378: [BACKOUT] runtime/NMT/SummarySanityCheck.java failed with "Total committed (MMMMMM) did not match the summarized committed (NNNNNN)" (P2) JDK-8313438: [s390x] build broken after JDK-8301996 (P2) JDK-8320278: ARM32 build is broken after JDK-8301997 (P2) JDK-8315940: ARM32: Move field resolution information out of the cpCache (P2) JDK-8315698: Crash when comparing BasicType as int after JDK-8310577 (P2) JDK-8322282: Incorrect LoaderConstraintTable::add_entry after JDK-8298468 (P2) JDK-8323243: JNI invocation of an abstract instance method corrupts the stack (P2) JDK-8321066: Multiple JFR tests have started failing (P2) JDK-8310489: New test runtime/ClassInitErrors/TestStackOverflowDuringInit.java failed (P2) JDK-8323950: Null CLD while loading shared lambda proxy class with javaagent active (P2) JDK-8316468: os::write incorrectly handles partial write (P2) JDK-8319137: release _object in ObjectMonitor dtor to avoid races (P2) JDK-8310656: RISC-V: __builtin___clear_cache can fail silently. (P2) JDK-8315206: RISC-V: hwprobe query is_set return wrong value (P2) JDK-8321276: runtime/cds/appcds/dynamicArchive/DynamicSharedSymbols.java failed with "'17 2: jdk/test/lib/apps ' missing from stdout/stderr" (P2) JDK-8309637: runtime/handshake/HandshakeTimeoutTest.java fails with "has not cleared handshake op" and SIGILL (P2) JDK-8315795: runtime/Safepoint/TestAbortVMOnSafepointTimeout.java fails after JDK-8305507 (P2) JDK-8311981: Test gc/stringdedup/TestStringDeduplicationAgeThreshold.java#ZGenerational timed out (P2) JDK-8316746: Top of lock-stack does not match the unlocked object (P2) JDK-8320886: Unsafe_SetMemory0 is not guarded (P2) JDK-8318757: VM_ThreadDump asserts in interleaved ObjectMonitor::deflate_monitor calls (P3) JDK-8302351: "assert(!JavaThread::current()->is_interp_only_mode() || !nm->method()->is_continuation_enter_intrinsic() || ContinuationEntry::is_interpreted_call(return_pc)) failed: interp_only_mode but not in enterSpecial interpreted entry" in fixup_callers_callsite (P3) JDK-8318643: +UseTransparentHugePages must enable +UseLargePages (P3) JDK-8307350: -XX:ContendedPaddingWidth=256 has no effect on the padding of the Thread class (P3) JDK-8303549: [AIX] TestNativeStack.java is failing with exit value 1 (P3) JDK-8319253: [BACKOUT] Change LockingMode default from LM_LEGACY to LM_LIGHTWEIGHT (P3) JDK-8312394: [linux] SIGSEGV if kernel was built without hugepage support (P3) JDK-8309613: [Windows] hs_err files sometimes miss information about the code containing the error (P3) JDK-8320892: AArch64: Restore FPU control state after JNI (P3) JDK-8319973: AArch64: Save and restore FPCR in the call stub (P3) JDK-8316595: Alpine build fails after JDK-8314021 (P3) JDK-8320275: assert(_chunk->bitmap().at(index)) failed: Bit not set at index (P3) JDK-8320515: assert(monitor->object_peek() != nullptr) failed: Owned monitors should not have a dead object (P3) JDK-8310297: assert(static_cast(result) == thing) with ctw (P3) JDK-8315890: Attempts to load from nullptr in instanceKlass.cpp and unsafe.cpp (P3) JDK-8310735: Build failure after JDK-8310577 with GCC8 (P3) JDK-8322513: Build failure with minimal (P3) JDK-8309209: C2 failed "assert(_stack_guard_state == stack_guard_reserved_disabled) failed: inconsistent state" (P3) JDK-8312181: CDS dynamic dump crashes when verifying unlinked class from static archive (P3) JDK-8322657: CDS filemap fastdebug assert while loading Graal CE Polyglot in isolated classloader (P3) JDK-8316132: CDSProtectionDomain::get_shared_protection_domain should check for exception (P3) JDK-8313905: Checked_cast assert in CDS compare_by_loader (P3) JDK-8309228: Clarify EXPERIMENTAL flags comment in hotspot/share/runtime/globals.hpp (P3) JDK-8316436: ContinuationWrapper uses unhandled nullptr oop (P3) JDK-8303852: current_stack_region() gets called twice unnecessarily (P3) JDK-8315559: Delay TempSymbol cleanup to avoid symbol table churn (P3) JDK-8318895: Deoptimization results in incorrect lightweight locking stack (P3) JDK-8309067: gtest/AsyncLogGtest.java fails again in stderrOutput_vm (P3) JDK-8319104: GtestWrapper crashes with SIGILL in AsyncLogTest::test_asynclog_raw on AIX opt (P3) JDK-8320530: has_resolved_ref_index flag not restored after resetting entry (P3) JDK-8318986: Improve GenericWaitBarrier performance (P3) JDK-8312018: Improve reservation of class space and CDS (P3) JDK-8323595: is_aligned(p, alignof(OopT))) assertion fails in Jetty without compressed OOPs (P3) JDK-8321479: java -D-D crashes (P3) JDK-8311541: JavaThread::print_jni_stack doesn't support native stacks on all platforms (P3) JDK-8309761: Leak class loader constraints (P3) JDK-8317262: LockStack::contains(oop) fails "assert(t->is_Java_thread()) failed: incorrect cast to JavaThread" (P3) JDK-8310644: Make panama memory segment close use async handshakes (P3) JDK-8321539: Minimal build is broken by JDK-8320935 (P3) JDK-8312525: New test runtime/os/TestTrimNative.java#trimNative is failing: did not see the expected RSS reduction (P3) JDK-8314831: NMT tests ignore vm flags (P3) JDK-8318594: NMT: VM.native_memory crashes on assert if functionality isn't supported by OS (P3) JDK-8311092: Please disable runtime/jni/nativeStack/TestNativeStack.java on armhf (P3) JDK-8306561: Possible out of bounds access in print_pointer_information (P3) JDK-8317951: Refactor loading of zip library to help resolve JDK-8315220 (P3) JDK-8298443: Remove expired flags in JDK 22 (P3) JDK-8318776: Require supports_cx8 to always be true (P3) JDK-8309140: ResourceHashtable failed "assert(~(_allocation_t[0] | allocation_mask) == (uintptr_t)this) failed: lost resource object" (P3) JDK-8322154: RISC-V: JDK-8315743 missed change in MacroAssembler::load_reserved (P3) JDK-8315195: RISC-V: Update hwprobe query for new extensions (P3) JDK-8310874: Runthese30m crashes with klass should be in the placeholders during verification (P3) JDK-8305864: runtime/handshake/HandshakeDirectTest.java failed with "exit code: 134" (P3) JDK-8319828: runtime/NMT/VirtualAllocCommitMerge.java may fail if mixing interpreted and compiled native invocations (P3) JDK-8322163: runtime/Unsafe/InternalErrorTest.java fails on Alpine after JDK-8320886 (P3) JDK-8316711: SEGV in LoaderConstraintTable::find_loader_constraint after JDK-8310874 (P3) JDK-8314850: SharedRuntime::handle_wrong_method() gets called too often when resolving Continuation.enter (P3) JDK-8313419: Template interpreter produces no safepoint check for return bytecodes (P3) JDK-8318365: Test runtime/cds/appcds/sharedStrings/InternSharedString.java fails after JDK-8311538 (P3) JDK-8312182: THPs cause huge RSS due to thread start timing issue (P3) JDK-8314294: Unsafe::allocateMemory and Unsafe::freeMemory are slower than malloc/free (P3) JDK-8312620: WSL Linux build crashes after JDK-8310233 (P3) JDK-8320052: Zero: Use __atomic built-ins for atomic RMW operations (P3) JDK-8319883: Zero: Use atomic built-ins for 64-bit accesses (P4) JDK-8320830: [AIX] Dont mix os::dll_load() with direct dlclose() calls (P4) JDK-8315321: [aix] os::attempt_reserve_memory_at must map at the requested address or fail (P4) JDK-8311261: [AIX] TestAlwaysPreTouchStacks.java fails due to java.lang.RuntimeException: Did not find expected NMT output (P4) JDK-8219652: [aix] Tests failing with JNI attach problems. (P4) JDK-8313319: [linux] mmap should use MAP_FIXED_NOREPLACE if available (P4) JDK-8320061: [nmt] Multiple issues with peak accounting (P4) JDK-8312078: [PPC] JcmdScale.java Failing on AIX (P4) JDK-8307907: [ppc] Remove RTM locking implementation (P4) JDK-8316585: [REDO] runtime/InvocationTests spend a lot of time on dependency verification (P4) JDK-8309889: [s390] Missing return statement after calling jump_to_native_invoker method in generate_method_handle_dispatch. (P4) JDK-8308479: [s390x] Implement alternative fast-locking scheme (P4) JDK-8312014: [s390x] TestSigInfoInHsErrFile.java Failure (P4) JDK-8311609: [windows] Native stack printing lacks source information for dynamically loaded dlls (P4) JDK-8319233: AArch64: Build failure with clang due to -Wformat-nonliteral warning (P4) JDK-8316309: AArch64: VMError::print_native_stack() crashes on Java native method frame (P4) JDK-8321063: AArch64: Zero build fails after JDK-8320368 (P4) JDK-8318636: Add jcmd to print annotated process memory map (P4) JDK-8322321: Add man page doc for -XX:+VerifySharedSpaces (P4) JDK-8314684: Add overview docs to loaderConstraints.cpp (P4) JDK-8313781: Add regression tests for large page logging and user-facing error messages (P4) JDK-8305506: Add support for fractional values of SafepointTimeoutDelay (P4) JDK-8305507: Add support for grace period before AbortVMOnSafepointTimeout triggers (P4) JDK-8193513: add support for printing a stack trace on class loading (P4) JDK-8313638: Add test for dump of resolved references (P4) JDK-8316958: Add test for unstructured locking (P4) JDK-8313782: Add user-facing warning if THPs are enabled but cannot be used (P4) JDK-8319818: Address GCC 13.2.0 warnings (stringop-overflow and dangling-pointer) (P4) JDK-8320300: Adjust hs_err output in malloc/mmap error cases (P4) JDK-8305753: Allow JIT compilation for -Xshare:dump (P4) JDK-8312392: ARM32 build broken since 8311035 (P4) JDK-8309240: Array classes should be stored in dynamic CDS archive (P4) JDK-8317433: Async UL: Only grab lock once when write():ing (P4) JDK-8317432: Async UL: Use memcpy instead of strcpy in Message ctr (P4) JDK-8318591: avoid leaks in loadlib_aix.cpp reload_table() (P4) JDK-8316994: Avoid modifying ClassLoader and Module objects during -Xshare:dump (P4) JDK-8316546: Backout JDK-8315932: runtime/InvocationTests spend a lot of time on dependency verification (P4) JDK-8319318: bufferedStream fixed case can be removed (P4) JDK-8310275: Bug in assignment operator of ReservedMemoryRegion (P4) JDK-8309811: BytecodePrinter cannot handle unlinked classes (P4) JDK-8309808: BytecodeTracer prints wrong BSM for invokedynamic (P4) JDK-8320826: call allocate_shared_strings_array after all strings are interned (P4) JDK-8311538: CDS InternSharedString test fails on huge pages host - cannot find shared string (P4) JDK-8307468: CDS Lambda Proxy classes are regenerated in dynamic dump (P4) JDK-8311035: CDS should not use dump time JVM narrow Klass encoding to pre-compute Klass ids (P4) JDK-8315127: CDSMapTest fails with incorrect number of oop references (P4) JDK-8317730: Change byte_size to return size_t (P4) JDK-8281455: Change JVM options with small ranges from 64 to 32 bits, for gc_globals.hpp (P4) JDK-8308850: Change JVM options with small ranges that get -Wconversion warnings to 32 bits (P4) JDK-8315880: Change LockingMode default from LM_LEGACY to LM_LIGHTWEIGHT (P4) JDK-8314502: Change the comparator taking version of GrowableArray::find to be a template method (P4) JDK-8318089: Class space not marked as such with NMT when CDS is off (P4) JDK-8317294: Classloading throws exceptions over already pending exceptions (P4) JDK-8311788: ClassLoadUnloadTest fails on AIX after JDK-8193513 (P4) JDK-8313435: Clean up unused default methods code (P4) JDK-8317761: Combine two versions of print_statistics() in java.cpp (P4) JDK-8305765: CompressedClassPointers.java is unreliable due to ASLR (P4) JDK-8301327: convert assert to guarantee in Handle_IDiv_Exception (P4) JDK-8316967: Correct the scope of vmtimer in UnregisteredClasses::load_class (P4) JDK-8320335: Deprecate `RegisterFinalizersAtInit` option and code (P4) JDK-8312072: Deprecate for removal the -Xnoagent option (P4) JDK-8320212: Disable GCC stringop-overflow warning for affected files (P4) JDK-8321119: Disable java/foreign/TestHandshake.java on Zero VMs (P4) JDK-8313316: Disable runtime/ErrorHandling/MachCodeFramesInErrorFile.java on ppc64le (P4) JDK-8310494: Do not include constantPool.hpp from instanceKlass.hpp (P4) JDK-8295159: DSO created with -ffast-math breaks Java floating-point arithmetic (P4) JDK-8316427: Duplicated code for {obj,type}ArrayKlass::array_klass (P4) JDK-8316229: Enhance class initialization logging (P4) JDK-8317711: Exclude gtest/GTestWrapper.java on AIX (P4) JDK-8316961: Fallback implementations for 64-bit Atomic::{add,xchg} on 32-bit platforms (P4) JDK-8314832: Few runtime/os tests ignore vm flags (P4) JDK-8311847: Fix -Wconversion for assembler.hpp emit_int8,16 callers (P4) JDK-8313554: Fix -Wconversion warnings for ResolvedFieldEntry (P4) JDK-8310921: Fix -Wconversion warnings from GenerateOopMap (P4) JDK-8309685: Fix -Wconversion warnings in assembler and register code (P4) JDK-8313564: Fix -Wconversion warnings in classfile code (P4) JDK-8310920: Fix -Wconversion warnings in command line flags (P4) JDK-8310577: Fix -Wconversion warnings in interpreter and oops (P4) JDK-8309692: Fix -Wconversion warnings in javaClasses (P4) JDK-8310332: Fix -Wconversion warnings in MethodData (P4) JDK-8314265: Fix -Wconversion warnings in miscellaneous runtime code (P4) JDK-8314114: Fix -Wconversion warnings in os code, primarily linux (P4) JDK-8313785: Fix -Wconversion warnings in prims code (P4) JDK-8313882: Fix -Wconversion warnings in runtime code (P4) JDK-8310906: Fix -Wconversion warnings in runtime, oops and some code header files. (P4) JDK-8312121: Fix -Wconversion warnings in tribool.hpp (P4) JDK-8313249: Fix -Wconversion warnings in verifier code (P4) JDK-8312979: Fix assembler_aarch64.hpp after JDK-8311847 (P4) JDK-8319542: Fix boundaries of region to be tested with os::is_readable_range (P4) JDK-8317790: Fix Bug entry for exclusion of runtime/jni/terminatedThread/TestTerminatedThread.java on AIX (P4) JDK-8312190: Fix c++11-narrowing warnings in hotspot code (P4) JDK-8311575: Fix invalid format parameters (P4) JDK-8318474: Fix memory reporter for thread_count (P4) JDK-8308780: Fix the Java Integer types on Windows (P4) JDK-8310233: Fix THP detection on Linux (P4) JDK-8314588: gc/metaspace/TestMetaspaceInitialization.java failed "assert(capacity_until_gc >= committed_bytes) failed: capacity_until_gc: 3145728 < committed_bytes: 3211264" (P4) JDK-8314835: gtest wrappers should be marked as flagless (P4) JDK-8318071: IgnoreUnrecognizedVMOptions flag still causes failure in ArchiveHeapTestClass (P4) JDK-8312395: Improve assertions in growableArray (P4) JDK-8316969: Improve CDS module graph support for --module option (P4) JDK-8319955: Improve dependencies removal during class unloading (P4) JDK-8310228: Improve error reporting for uncaught native exceptions on Windows (P4) JDK-8318982: Improve Exceptions::special_exception (P4) JDK-8303815: Improve Metaspace test speed (P4) JDK-8316581: Improve performance of Symbol::print_value_on() (P4) JDK-8318709: Improve System.nanoTime performance on Windows (P4) JDK-8309753: Include array classes in the output of -XX:+PrintSharedArchiveAndExit (P4) JDK-8321183: Incorrect warning from cds about the modules file (P4) JDK-8311921: Inform about MaxExpectedDataSegmentSize in case of pthread_create failures on AIX (P4) JDK-8318484: Initial version of cdsConfig.hpp (P4) JDK-8313752: InstanceKlassFlags::print_on doesn't print the flag names (P4) JDK-8317692: jcmd GC.heap_dump performance regression after JDK-8292818 (P4) JDK-8310687: JDK-8303215 is incomplete (P4) JDK-8313874: JNI NewWeakGlobalRef throws exception for null arg (P4) JDK-8314080: JNI spec: clarify NewWeakGlobalRef handling of weak global references (P4) JDK-8312262: Klass::array_klass() should return ArrayKlass pointer (P4) JDK-8316440: LambdasInTwoArchives.java failed to find WhiteBox.class (P4) JDK-8307766: Linux: Provide the option to override the timer slack (P4) JDK-8318015: Lock inflation not needed for OSR or Deopt for new locking modes (P4) JDK-8319927: Log that IEEE rounding mode was corrupted by loading a library (P4) JDK-8319704: LogTagSet::set_output_level() should not accept NULL as LogOutput (P4) JDK-8318700: MacOS Zero cannot run gtests due to wrong JVM path (P4) JDK-8315061: Make LockingMode a product flag (P4) JDK-8314243: Make VM_Exit::wait_for_threads_in_native_to_block wait for user threads time configurable (P4) JDK-8314320: Mark runtime/CommandLine/ tests as flagless (P4) JDK-8304292: Memory leak related to ClassLoader::update_class_path_entry_list (P4) JDK-8314654: Metaspace: move locking out of MetaspaceArena (P4) JDK-8307356: Metaspace: simplify BinList handling (P4) JDK-8312329: Minimal build failure after JDK-8311541 (P4) JDK-8318029: Minor improvement to logging output in container at-requires (P4) JDK-8313141: Missing check for os_thread type in os_windows.cpp (P4) JDK-8315739: Missing null check in os::vm_min_address (P4) JDK-8312136: Modify runtime/ErrorHandling/TestDwarf.java to split dwarf and decoder testing (P4) JDK-8324041: ModuleOption.java failed with update release versioning scheme (P4) JDK-8319048: Monitor deflation unlink phase prolongs time to safepoint (P4) JDK-8319630: Monitor final audit log lacks separator (P4) JDK-8313081: MonitoringSupport_lock should be unconditionally initialized after 8304074 (P4) JDK-8320935: Move CDS config initialization code to cdsConfig.cpp (P4) JDK-8301996: Move field resolution information out of the cpCache (P4) JDK-8301997: Move method resolution information out of the cpCache (P4) JDK-8292692: Move MethodCounters inline functions out of method.hpp (P4) JDK-8318447: Move NMT source code to own subdirectory (P4) JDK-8319897: Move StackWatermark handling out of LockStack::contains (P4) JDK-8299825: Move StdoutLog and StderrLog to LogConfiguration (P4) JDK-8309065: Move the logic to determine archive heap location from CDS to G1 GC (P4) JDK-8310355: Move the stub test from initialize_final_stubs() to test/hotspot/gtest (P4) JDK-8313202: MutexLocker should disallow null Mutexes (P4) JDK-8318485: Narrow klass shift should be zero if encoding range extends to 0x1_0000_0000 (P4) JDK-8293850: need a largest_committed metric for each category of NMT's output (P4) JDK-8319314: NMT detail report slow or hangs for large number of mappings (P4) JDK-8319437: NMT should show library names in call stacks (P4) JDK-8310974: NMT: Arena diffs miss the scale (P4) JDK-8320370: NMT: Change MallocMemorySnapshot to simplify code. (P4) JDK-8317772: NMT: Make peak values available in release builds (P4) JDK-8314438: NMT: Performance benchmarks are needed to have a baseline for comparison of improvements (P4) JDK-8261491: NMT: Reduce memory footprint of reporting (P4) JDK-8315362: NMT: summary diff reports threads count incorrectly (P4) JDK-8310134: NMT: thread count in Thread section of VM.native_memory output confusing with virtual threads (P4) JDK-8309034: NoClassDefFoundError when initializing Long$LongCache (P4) JDK-8299790: os::print_hex_dump is racy (P4) JDK-8314163: os::print_hex_dump prints incorrectly for big endian platforms and unit sizes larger than 1 (P4) JDK-8310107: os::trace_page_sizes_for_requested_size should name alignment as requested page size (P4) JDK-8304939: os::win32::exit_process_or_thread should be marked noreturn (P4) JDK-8320368: Per-CPU optimization of Klass range reservation (P4) JDK-8320418: PPC64: invokevfinal_helper duplicates code to handle ResolvedMethodEntry (P4) JDK-8317132: Prepare HotSpot for permissive- (P4) JDK-8177481: Prepare Runtime code for -Wconversion (P4) JDK-8308903: Print detailed info for Java objects in -Xlog:cds+map (P4) JDK-8314020: Print instruction blocks in byte units (P4) JDK-8317240: Promptly free OopMapEntry after fail to insert the entry to OopMapCache (P4) JDK-8317919: pthread_attr_init handle return value and destroy pthread_attr_t object (P4) JDK-8310873: Re-enable locked_create_entry symbol check in runtime/NMT/CheckForProperDetailStackTrace.java for RISC-V (P4) JDK-8310076: Reduce inclusion of bytecodeStream.hpp (P4) JDK-8310225: Reduce inclusion of oopMapCache.hpp and generateOopMap.hpp (P4) JDK-8309878: Reduce inclusion of resolvedIndyEntry.hpp (P4) JDK-8313669: Reduced chance for zero-based nKlass encoding since JDK-8296565 (P4) JDK-8320304: Refactor and simplify monitor deflation functions (P4) JDK-8319999: Refactor MetaspaceShared::use_full_module_graph() (P4) JDK-8308463: Refactor regenerated class handling in lambdaFormInvokers.cpp (P4) JDK-8311648: Refactor the Arena/Chunk/ChunkPool interface (P4) JDK-8318587: refresh libraries cache on AIX in print_vm_info (P4) JDK-8320383: refresh libraries cache on AIX in VMError::report (P4) JDK-8316523: Relativize esp in interpreter frames (PowerPC only) (P4) JDK-8315069: Relativize extended_sp in interpreter frames (P4) JDK-8315966: Relativize initial_sp in interpreter frames (P4) JDK-8308984: Relativize last_sp (and top_frame_sp) in interpreter frames (P4) JDK-8299915: Remove ArrayAllocatorMallocLimit and associated code (P4) JDK-8320382: Remove CompressedKlassPointers::is_valid_base() (P4) JDK-8315998: Remove dead ClassLoaderDataGraphKlassIteratorStatic (P4) JDK-8320147: Remove DumpSharedSpaces (P4) JDK-8318383: Remove duplicated checks in os::get_native_stack() in posix implementation (P4) JDK-8319944: Remove DynamicDumpSharedSpaces (P4) JDK-8313207: Remove MetaspaceShared::_has_error_classes (P4) JDK-8306582: Remove MetaspaceShared::exit_after_static_dump() (P4) JDK-8319896: Remove monitor deflation from final audit (P4) JDK-8261894: Remove support for UseSHM (P4) JDK-8312492: Remove THP sanity checks at VM startup (P4) JDK-8314749: Remove unimplemented _Copy_conjoint_oops_atomic (P4) JDK-8317314: Remove unimplemented ObjArrayKlass::oop_oop_iterate_elements_bounded (P4) JDK-8316002: Remove unnecessary seen_dead_loader in ClassLoaderDataGraph::do_unloading (P4) JDK-8319778: Remove unreachable code in ObjectSynchronizer::exit (P4) JDK-8320054: Remove unused _count from NMT walker classes (P4) JDK-8315580: Remove unused java_lang_String::set_value_raw() (P4) JDK-8311180: Remove unused unneeded definitions from globalDefinitions (P4) JDK-8310510: Remove WordsPerLong (P4) JDK-8308603: Removing do_pending_ref/enclosing_ref from MetaspaceClosure (P4) JDK-8310146: Removing unused PerfLongVariant::_sampled (P4) JDK-8312585: Rename DisableTHPStackMitigation flag to THPStackMitigation (P4) JDK-8307312: Replace "int which" with "int cp_index" in constantPool (P4) JDK-8250269: Replace ATTRIBUTE_ALIGNED with alignas (P4) JDK-8311285: report some fontconfig related environment variables in hs_err file (P4) JDK-8321269: Require platforms to define DEFAULT_CACHE_LINE_SIZE (P4) JDK-8316098: Revise signature of numa_get_leaf_groups (P4) JDK-8309258: RISC-V: Add riscv_hwprobe syscall (P4) JDK-8315338: RISC-V: Change flags for stable extensions to non-experimental (P4) JDK-8315841: RISC-V: Check for hardware TSO support (P4) JDK-8315934: RISC-V: Disable conservative fences per vendor (P4) JDK-8316859: RISC-V: Disable detection of V through HWCAP (P4) JDK-8315652: RISC-V: Features string uses wrong separator for jtreg (P4) JDK-8311074: RISC-V: Fix -Wconversion warnings in some code header files (P4) JDK-8310949: RISC-V: Initialize UseUnalignedAccesses (P4) JDK-8319440: RISC-V: jdk can't be built with clang due to register keyword (P4) JDK-8310276: RISC-V: Make use of shadd macro-assembler function when possible (P4) JDK-8316645: RISC-V: Remove dependency on libatomic by adding cmpxchg 1b (P4) JDK-8316566: RISC-V: Zero extended narrow oop passed to Atomic::cmpxchg (P4) JDK-8318691: runtime/CompressedOops/CompressedClassPointersEncodingScheme.java fails with release VMs (P4) JDK-8314830: runtime/ErrorHandling/ tests ignore external VM flags (P4) JDK-8312049: runtime/logging/ClassLoadUnloadTest can be improved (P4) JDK-8293972: runtime/NMT/NMTInitializationTest.java#default_long-off failed with "Suspiciously long bucket chains in lookup table." (P4) JDK-8298992: runtime/NMT/SummarySanityCheck.java failed with "Total committed (MMMMMM) did not match the summarized committed (NNNNNN)" (P4) JDK-8314426: runtime/os/TestTrimNative.java is failing on slow machines (P4) JDK-8319633: runtime/posixSig/TestPosixSig.java intermittent timeouts on UNIX (P4) JDK-8318834: s390x: Debug builds are missing debug helpers (P4) JDK-8316895: SeenThread::print_action_queue called on a null pointer (P4) JDK-8314694: Separate checked_cast from globalDefinitions.hpp (P4) JDK-8308464: Shared array class should not always be loaded in boot loader (P4) JDK-8316693: Simplify at-requires checkDockerSupport() (P4) JDK-8311604: Simplify NOCOOPS requested addresses for archived heap objects (P4) JDK-8310108: Skip ReplaceCriticalClassesForSubgraphs when EnableJVMCI is specified (P4) JDK-8312434: SPECjvm2008/xml.transform with CDS fails with "can't seal package nu.xom" (P4) JDK-8311870: Split CompressedKlassPointers from compressedOops.hpp (P4) JDK-8320937: support latest VS2022 MSC_VER in abstract_vm_version.cpp (P4) JDK-8313616: support loading library members on AIX in os::dll_load (P4) JDK-8313678: SymbolTable can leak Symbols during cleanup (P4) JDK-8311583: tableswitch broken by JDK-8310577 (P4) JDK-8312625: Test serviceability/dcmd/vm/TrimLibcHeapTest.java failed: RSS use increased (P4) JDK-8316060: test/hotspot/jtreg/runtime/reflect/ReflectOutOfMemoryError.java may fail if heap is huge (P4) JDK-8314139: TEST_BUG: runtime/os/THPsInThreadStackPreventionTest.java could fail on machine with large number of cores (P4) JDK-8321683: Tests fail with AssertionError in RangeWithPageSize (P4) JDK-8318609: Upcall stubs should be smaller (P4) JDK-8317565: Update Manpage for obsoletion of UseSHM (P4) JDK-8313691: use close after failing os::fdopen in vmError and ciEnv (P4) JDK-8314752: Use google test string comparison macros (P4) JDK-8314743: Use of uninitialized local in SR_initialize after JDK-8314114 (P4) JDK-8310170: Use sp's argument to improve performance of outputStream::indent and remove SP_USE_TABS (P4) JDK-8315869: UseHeavyMonitors not used (P4) JDK-8310596: Utilize existing method frame::interpreter_frame_monitor_size_in_bytes() (P4) JDK-8307788: vmTestbase/gc/gctests/LargeObjects/large003/TestDescription.java timed out (P4) JDK-8315818: vmTestbase/nsk/jvmti/Allocate/alloc001/alloc001.java fails on libgraal (P4) JDK-8309599: WeakHandle and OopHandle release should clear obj pointer (P4) JDK-8315073: Zero build on macOS fails after JDK-8303852 (P4) JDK-8320582: Zero: Misplaced CX8 enablement flag (P4) JDK-8319777: Zero: Support 8-byte cmpxchg (P5) JDK-8314268: Missing include in assembler_riscv.hpp (P5) JDK-8311145: Remove check_with_errno duplicates (P5) JDK-8311581: Remove obsolete code and comments in TestLVT.java (P5) JDK-8318528: Rename TestUnstructuredLocking test (P5) JDK-8315743: RISC-V: Cleanup masm lr()/sc() methods (P5) JDK-8316186: RISC-V: Remove PlatformCmpxchg<4> hotspot/svc: (P1) JDK-8316228: jcmd tests are broken by 8314828 (P3) JDK-8311557: [JVMCI] deadlock with JVMTI thread suspension (P3) JDK-8321565: [REDO] Heap dump does not contain virtual Thread stack references (P3) JDK-8322237: Heap dump contains duplicate thread records for mounted virtual threads (P4) JDK-8315149: Add hsperf counters for CPU time of internal GC threads (P4) JDK-8313796: AsyncGetCallTrace crash on unreadable interpreter method pointer (P4) JDK-8314197: AttachListener::pd_find_operation always returning nullptr (P4) JDK-8309671: Avoid using jvmci.Compiler property to determine if Graal is enabled (P4) JDK-8316142: Enable parallelism in vmTestbase/nsk/monitoring/stress/lowmem tests (P4) JDK-8310380: Handle problems in core-related tests on macOS when codesign tool does not work (P4) JDK-8316691: Heap dump: separate stack traces for mounted virtual threads (P4) JDK-8314021: HeapDump: Optimize segmented heap file merging phase (P4) JDK-8320924: Improve heap dump performance by optimizing archived object checks (P4) JDK-8319650: Improve heap dump performance with class metadata caching (P4) JDK-8319948: jcmd man page needs to be updated (P4) JDK-8323241: jcmd manpage should use lists for argument lists (P4) JDK-8314828: Mark 3 jcmd command-line options test as vm.flagless (P4) JDK-8312916: Remove remaining usages of -Xdebug from test/hotspot/jtreg (P4) JDK-8319053: Segment dump files remain after parallel heap dump on Windows (P4) JDK-8314501: Shenandoah: sun/tools/jhsdb/heapconfig/JMapHeapConfigTest.java fails (P4) JDK-8316462: sun/jvmstat/monitor/MonitoredVm/MonitorVmStartTerminate.java ignores VM flags (P4) JDK-8316778: test hprof lib: invalid array element type from JavaValueArray.elementSize (P4) JDK-8306441: Two phase segmented heap dump (P5) JDK-8311775: [TEST] duplicate verifyHeapDump in several tests (P5) JDK-8317285: Misspellings in hprof test lib hotspot/svc-agent: (P2) JDK-8316562: serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java times out after JDK-8314829 (P2) JDK-8310618: Test serviceability/sa/ClhsdbDumpclass.java fails after 8242152: 'StackMapTable:' missing from stdout/stderr (P3) JDK-8311879: SA ClassWriter generates invalid invokedynamic code (P3) JDK-8242152: SA does not include StackMapTables when dumping .class files (P3) JDK-8314679: SA fails to properly attach to JVM after having just detached from a different JVM (P4) JDK-8313798: [aarch64] sun/tools/jhsdb/HeapDumpTestWithActiveProcess.java sometimes times out on aarch64 (P4) JDK-8314550: [macosx-aarch64] serviceability/sa/TestJmapCore.java fails with "sun.jvm.hotspot.debugger.UnmappedAddressException: 801000800" (P4) JDK-8313800: AArch64: SA stack walking code having trouble finding sender frame when invoking LambdaForms is involved (P4) JDK-8315648: Add test for JDK-8309979 changes (P4) JDK-8314389: AttachListener::pd_set_flag obsolete (P4) JDK-8309979: BootstrapMethods attribute is missing in class files recreated by SA (P4) JDK-8316342: CLHSDB "dumpclass" command produces invalid classes (P4) JDK-8311103: Enhancements and Fixes to SA ClassWriter (P4) JDK-8237542: JMapHeapConfigTest.java doesn't work with negative jlong values (P4) JDK-8189685: need PerfMemory class update and a volatile_static_field support in VMStructs (P4) JDK-8312246: NPE when HSDB visits bad oop (P4) JDK-8316417: ObjectMonitorIterator does not return the most recent monitor and is incorrect if no monitors exists (P4) JDK-8313357: Revisit requiring SA tests on OSX to either run as root or use sudo (P4) JDK-8314117: RISC-V: Incorrect VMReg encoding in RISCV64Frame.java (P4) JDK-8316182: RISC-V: SA stack walking code having trouble finding sender frame when invoking LambdaForms is involved (P4) JDK-8312623: SA add NestHost and NestMembers attributes when dumping class (P4) JDK-8294316: SA core file support is broken on macosx-x64 starting with macOS 12.x (P4) JDK-8311971: SA's ConstantPool.java uses incorrect computation to read long value in the constant pool (P4) JDK-8313631: SA: stack trace printed using "where" command does not show class name (P4) JDK-8314829: serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java ignores vm flags (P4) JDK-8307408: Some jdk/sun/tools/jhsdb tests don't pass test JVM args to the debuggee JVM (P4) JDK-8309605: StubRoutines are not used by SA (P4) JDK-8316401: sun/tools/jhsdb/JStackStressTest.java failed with "InternalError: We should have found a thread that owns the anonymous lock" (P4) JDK-8311102: Write annotations in the classfile dumped by SA (P5) JDK-8280743: HSDB "Monitor Cache Dump" command might throw NPE (P5) JDK-8312232: Remove sun.jvm.hotspot.runtime.VM.buildLongFromIntsPD() hotspot/test: (P1) JDK-8318964: Fix build failures caused by 8315097 (P3) JDK-8312194: test/hotspot/jtreg/applications/ctw/modules/jdk_crypto_ec.java cannot handle empty modules (P4) JDK-8313218: Disable RunThese24H testing until JDK-8282357 is fixed. (P4) JDK-8321307: Don't run in ATR duplicated and linux-x64 specific tasks on linux-aarch64 (P4) JDK-8319153: Fix: Class is a raw type in ProcessTools (P4) JDK-8314610: hotspot can't compile with the latest of gtest because of (P4) JDK-8310187: Improve Generational ZGC jtreg testing (P4) JDK-8315415: OutputAnalyzer.shouldMatchByLine() fails in some cases (P4) JDK-8315097: Rename createJavaProcessBuilder (P4) JDK-8303773: Replace "main.wrapper" with "test.thread.factory" property in test code (P4) JDK-8318825: runThese failed with "unable to create native thread: possibly out of memory or process/resource limits reached" (P4) JDK-8314242: Update applications/scimark/Scimark.java to accept VM flags (P4) JDK-8305962: update jcstress to 0.16 (P5) JDK-8320129: "top" command during jtreg failure handler does not display CPU usage on OSX infrastructure: (P4) JDK-8316946: jtreg failure handler pages are mislabelling the jcmd/thread/dump_to_file results. (P4) JDK-8312882: Update the CONTRIBUTING.md with pointers to lifecycle of a PR infrastructure/build: (P1) JDK-8313274: [BACKOUT] Relax prerequisites for java.base-jmod target (P2) JDK-8317802: jmh tests fail with Unable to find the resource: /META-INF/BenchmarkList after JDK-8306819 (P3) JDK-8286757: adlc tries to build with /pathmap but without /experimental:deterministic (P3) JDK-8316294: AIX: Build fopen system call fails on file _BUILD_LIBJDWP_objectfilenames.txt (P3) JDK-8317741: build error avx512fintrin.h in BUILD_LIB_SIMD_SORT on Alpine Linux x86_64 (P3) JDK-8315499: build using devkit on Linux ppc64le RHEL puts path to devkit into libsplashscreen (P3) JDK-8253620: Debug symbols for tests missing on macos and windows (P3) JDK-8323008: filter out harmful -std* flags added by autoconf from CXX (P3) JDK-8320663: Fix C syntax in LIB_SETUP_HSDIS_BINUTILS (P3) JDK-8304478: Initial nroff manpage generation for JDK 22 (P3) JDK-8317807: JAVA_FLAGS removed from jtreg running in JDK-8317039 (P3) JDK-8320258: Refresh building.md (P3) JDK-8318669: Target OS detection in 'test-prebuilt' makefile target is incorrect when running on MSYS2 (P3) JDK-8264425: Update building.md on non-English locales on Windows (P3) JDK-8310183: Update GitHub Actions to use boot JDK for building jtreg (P3) JDK-8313167: Update to use jtreg 7.3 (P3) JDK-8314495: Update to use jtreg 7.3.1 (P4) JDK-8313374: --enable-ccache's CCACHE_BASEDIR breaks builds (P4) JDK-8312466: /bin/nm usage in AIX makes needs -X64 flag (P4) JDK-8320932: [BACKOUT] dsymutil command leaves around temporary directories (P4) JDK-8315062: [GHA] get-bootjdk action should return the abolute path (P4) JDK-8315863: [GHA] Update checkout action to use v4 (P4) JDK-8320931: [REDO] dsymutil command leaves around temporary directories (P4) JDK-8307858: [REDO] JDK-8307194 Add make target for optionally building a complete set of all JDK and hotspot libjvm static libraries (P4) JDK-8313661: [REDO] Relax prerequisites for java.base-jmod target (P4) JDK-8311938: Add default cups include location for configure on AIX (P4) JDK-8310384: Add hooks for custom image creation (P4) JDK-8309880: Add support for linking libffi on Windows and Mac (P4) JDK-8311545: Allow test symbol files to be kept in the test image (P4) JDK-8317620: Build JDK tools with ModuleMainClass attribute (P4) JDK-8314555: Build with mawk fails on Windows (P4) JDK-8306630: Bump minimum boot jdk to JDK 21 (P4) JDK-8317970: Bump target macosx-x64 version to 11.00.00 (P4) JDK-8311955: c++filt is now ibm-llvm-cxxfilt when using xlc17 / clang on AIX (P4) JDK-8319570: Change to GCC 13.2.0 for building on Linux at Oracle (P4) JDK-8319573: Change to Visual Studio 2022 17.6.5 for building on Windows at Oracle (P4) JDK-8317560: Change to Xcode 14.3.1 for building on macOS at Oracle (P4) JDK-8317510: Change Windows debug symbol files naming to avoid losing info when an executable and a library share the same name (P4) JDK-8316893: Compile without -fno-delete-null-pointer-checks (P4) JDK-8294549: configure script should detect unsupported path (P4) JDK-8314554: Debian/Ubuntu should not link OpenJDK with --as-needed link option (P4) JDK-8320863: dsymutil command leaves around temporary directories (P4) JDK-8313082: Enable CreateCoredumpOnCrash for testing in makefiles (P4) JDK-8317039: Enable specifying the JDK used to run jtreg (P4) JDK-8310728: Enable Zc:inline flag in Visual Studio build (P4) JDK-8319197: Exclude hb-subset and hb-style from compilation (P4) JDK-8310376: Extend SetupTarget macro with DIR parameter (P4) JDK-8316461: Fix: make test outputs TEST SUCCESS after unsuccessful exit (P4) JDK-8303427: Fixpath confused if unix root contains "/jdk" (P4) JDK-8268719: Force execution (and source) code page used when compiling on Windows (P4) JDK-8306281: function isWsl() returns false on WSL2 (P4) JDK-8313707: GHA: Bootstrap sysroots with --variant=minbase (P4) JDK-8313428: GHA: Bump GCC versions for July 2023 updates (P4) JDK-8318039: GHA: Bump macOS and Xcode versions (P4) JDK-8320053: GHA: Cross-compile gtest code (P4) JDK-8314262: GHA: Cut down cross-compilation sysroots deeper (P4) JDK-8314730: GHA: Drop libfreetype6-dev transitional package in favor of libfreetype-dev (P4) JDK-8320358: GHA: ignore jdk* branches (P4) JDK-8314656: GHA: No need for Debian ports keyring installation after JDK-8313701 (P4) JDK-8320921: GHA: Parallelize hotspot_compiler test jobs (P4) JDK-8313701: GHA: RISC-V should use the official repository for bootstrap (P4) JDK-8314543: gitattributes: make diffs easier to read (P4) JDK-8318753: hsdis binutils may place libs in lib64 (P4) JDK-8318961: increase javacserver connection timeout values and max retry attempts (P4) JDK-8310454: Introduce static-libs-graal bundle (P4) JDK-8316648: jrt-fs.jar classes not reproducible between standard and bootcycle builds (P4) JDK-8310321: make JDKOPT_CHECK_CODESIGN_PARAMS more verbose (P4) JDK-8316894: make test TEST="jtreg:test/jdk/..." fails on AIX (P4) JDK-8318540: make test cannot run .jasm tests directly (P4) JDK-8314762: Make {@Incubating} conventional (P4) JDK-8316532: Native library copying in BuildMicrobenchmark.gmk cause dups on macOS (P4) JDK-8313244: NM flags handling in configure process (P4) JDK-8320942: Only set openjdk-target when cross compiling linux-aarch64 (P4) JDK-8314483: Optionally override copyright header in generated source (P4) JDK-8315060: Out of tree incremental build fails with ccache (P4) JDK-8315278: Patch 'print-targets' target to print targets separated by new line (P4) JDK-8310259: Pin msys2/setup-msys2 github action to a specific commit (P4) JDK-8309746: Reconfigure check should include make/conf/version-numbers.conf (P4) JDK-8320410: Reflow markdown in building.md (P4) JDK-8320334: Reflow markdown in testing.md (P4) JDK-8310379: Relax prerequisites for java.base-jmod target (P4) JDK-8312467: relax the builddir check in make/autoconf/basic.m4 (P4) JDK-8320769: Remove ill-adviced "make install" target (P4) JDK-8320899: Select the correct Makefile when running make in build directory (P4) JDK-8310129: SetupNativeCompilation LIBS should match the order of the other parameters (P4) JDK-8311247: Some cpp files are compiled with -std:c11 flag (P4) JDK-8315020: The macro definition for LoongArch64 zero build is not accurate. (P4) JDK-8320691: Timeout handler on Windows takes 2 hours to complete (P4) JDK-8309310: Update --release 21 symbol information for JDK 21 build 26 (P4) JDK-8310173: Update --release 21 symbol information for JDK 21 build 29 (P4) JDK-8320915: Update copyright year in build files (P4) JDK-8309934: Update GitHub Actions to use JDK 17 for building jtreg (P4) JDK-8314166: Update googletest to v1.14.0 (P4) JDK-8314444: Update jib-profiles.js to use JMH 1.37 devkit (P4) JDK-8314118: Update JMH devkit to 1.37 (P4) JDK-8320526: Use title case in building.md (P4) JDK-8310369: UTIL_ARG_WITH fails when arg is disabled (P4) JDK-8317601: Windows build on WSL broken after JDK-8317340 (P4) JDK-8317340: Windows builds are not reproducible if MS VS compiler install path differs (P5) JDK-8315786: [AIX] Build Disk Local Detection Issue with GNU-utils df on AIX (P5) JDK-8320763: Fix spacing arround assignment in spec.gmk.in (P5) JDK-8317327: Remove JT_JAVA dead code in jib-profiles.js (P5) JDK-8317357: Update links in building.md to use https rather than http (P5) JDK-8320767: Use := wherever possible in spec.gmk.in infrastructure/licensing: (P4) JDK-8267174: Many test files have the wrong Copyright header infrastructure/release_eng: (P1) JDK-8319547: Remove EA from the JDK 22 version string with first RC promotion other-libs: (P2) JDK-8313312: Add missing classpath exception copyright header (P3) JDK-8314075: Update JCov version for JDK 22 (P4) JDK-8313949: Missing word in GPLv2 license text in StackMapTableAttribute.java other-libs/other: (P4) JDK-8321163: [test] OutputAnalyzer.getExitValue() unnecessarily logs even when process has already completed (P5) JDK-8308646: Typo in ConstantValueAttribute performance/hotspot: (P4) JDK-8309976: Add microbenchmark for stressing code cache release-team: (P3) JDK-8322066: Update troff manpages in JDK 22 before RC security-libs: (P3) JDK-8318096: Introduce AsymmetricKey interface with a getParams method (P3) JDK-8315042: NPE in PKCS7.parseOldSignedData (P3) JDK-8316964: Security tools should not call System.exit (P3) JDK-8319128: sun/security/pkcs11 tests fail on OL 7.9 aarch64 (P4) JDK-8318240: [AIX] Cleaners.java test failure (P4) JDK-8318983: Fix comment typo in PKCS12Passwd.java (P4) JDK-8311170: Simplify and modernize equals and hashCode in security area (P4) JDK-8316341: sun/security/pkcs11/PKCS11Test.java needs adjustment on Linux ppc64le Ubuntu 22 security-libs/java.security: (P2) JDK-8314960: Add Certigna Root CA - 2 (P2) JDK-8318759: Add four DigiCert root certificates (P2) JDK-8317374: Add Let's Encrypt ISRG Root X2 (P2) JDK-8317373: Add Telia Root CA v2 (P2) JDK-8319187: Add three eMudhra emSign roots (P2) JDK-8314240: test/jdk/sun/security/pkcs/pkcs7/SignerOrder.java fails to compile (P2) JDK-8320372: test/jdk/sun/security/x509/DNSName/LeadingPeriod.java validity check failed (P3) JDK-8281658: Add a security category to the java -XshowSettings option (P3) JDK-8302017: Allocate BadPaddingException only if it will be thrown (P3) JDK-8310549: avoid potential leaks in KeystoreImpl.m related to JNU_CHECK_EXCEPTION early returns (P3) JDK-8311546: Certificate name constraints improperly validated with leading period (P3) JDK-8308474: DSA does not reset SecureRandom when initSign is called again (P3) JDK-8308592: Framework for CA interoperability testing (P3) JDK-8302233: HSS/LMS: keytool and jarsigner changes (P3) JDK-8312489: Increase jdk.jar.maxSignatureFileSize default which is too low for JARs such as WhiteSource/Mend unified agent jar (P3) JDK-8308398: Move SunEC crypto provider into java.base (P3) JDK-8296631: NSS tests failing on OL9 linux-aarch64 hosts (P3) JDK-8313206: PKCS11 tests silently skip execution (P3) JDK-8279254: PKCS9Attribute SigningTime always encoded in UTFTime (P3) JDK-8313575: Refactor PKCS11Test tests (P3) JDK-8295894: Remove SECOM certificate that is expiring in September 2023 (P3) JDK-8320597: RSA signature verification fails on signed data that does not encode params correctly (P3) JDK-8320192: SHAKE256 does not work correctly if n >= 137 (P3) JDK-8314283: Support for NSS tests on aarch64 platforms (P3) JDK-8320208: Update Public Suffix List to b5bf572 (P4) JDK-8318479: [jmh] the test security.CacheBench failed for multiple threads run (P4) JDK-8319213: Compatibility.java reads both stdout and stderr of JdkUtils (P4) JDK-8308453: Convert JKS test keystores in test/jdk/javax/net/ssl/etc to PKCS12 (P4) JDK-8313087: DerValue::toString should output a hex view of the values in byte array (P4) JDK-8314148: Fix variable scope in SunMSCAPI (P4) JDK-8295919: java.security.MessageDigest.isEqual does not adhere to @implNote (P4) JDK-8310629: java/security/cert/CertPathValidator/OCSP/OCSPTimeout.java fails with RuntimeException Server not ready (P4) JDK-8312461: JNI warnings in SunMSCApi provider (P4) JDK-8307144: namedParams in XECParameters and EdDSAParameters can be private final (P4) JDK-8312126: NullPointerException in CertStore.getCRLs after 8297955 (P4) JDK-8320049: PKCS10 would not discard the cause when throw SignatureException on invalid key (P4) JDK-8317332: Prepare security for permissive- (P4) JDK-8313226: Redundant condition test in X509CRLImpl (P4) JDK-8312578: Redundant javadoc in X400Address (P4) JDK-8314059: Remove PKCS7.verify() (P4) JDK-8309305: sun/security/ssl/SSLSocketImpl/BlockedAsyncClose.java fails with jtreg test timeout (P4) JDK-8308808: SunMSCAPI public keys returns internal key array (P4) JDK-8325096: Test java/security/cert/CertPathBuilder/akiExt/AKISerialNumber.java is failing (P4) JDK-8309667: TLS handshake fails because of ConcurrentModificationException in PKCS12KeyStore.engineGetEntry (P4) JDK-8304956: Update KeyStore.getDefaultType​() specification to return pkcs12 as fallback (P4) JDK-8175874: Update Security.insertProviderAt to specify behavior when requested position is out of range. security-libs/javax.crypto: (P2) JDK-8311592: ECKeySizeParameterSpec causes too many exceptions on third party providers (P3) JDK-8312306: Add more Reference.reachabilityFence() calls to the security classes using Cleaner (P3) JDK-8314045: ArithmeticException in GaloisCounterMode (P3) JDK-8318756: Create better internal buffer for AEADs (P3) JDK-8322100: Fix GCMIncrementByte4 & GCMIncrementDirect4, and increase overlap testing (P3) JDK-8322971: KEM.getInstance() should check if a 3rd-party security provider is signed (P4) JDK-4964430: (spec) missing IllegalStateException exception requirement for javax.crypto.Cipher.doFinal (P4) JDK-8318328: DHKEM should check XDH name in case-insensitive mode (P4) JDK-8309867: redundant class field RSAPadding.md (P5) JDK-8314199: Initial size PBEKeyFactory#validTypes is not up-to-date (P5) JDK-8315974: Make fields final in 'com.sun.crypto.provider' package security-libs/javax.crypto:pkcs11: (P2) JDK-8307185: pkcs11 native libraries make JNI calls into java code while holding GC lock (P3) JDK-8312428: PKCS11 tests fail with NSS 3.91 (P3) JDK-8319136: Skip pkcs11 tests on linux-aarch64 (P3) JDK-8295343: sun/security/pkcs11 tests fail on Linux RHEL 8.6 and newer (P3) JDK-8309214: sun/security/pkcs11/KeyStore/CertChainRemoval.java fails after 8301154 (P3) JDK-8161536: sun/security/pkcs11/sslecc/ClientJSSEServerJSSE.java fails with ProviderException (P4) JDK-8317144: Exclude sun/security/pkcs11/sslecc/ClientJSSEServerJSSE.java on Linux ppc64le security-libs/javax.net.ssl: (P2) JDK-8317967: Enhance test/jdk/javax/net/ssl/TLSCommon/SSLEngineTestCase.java to handle default cases (P3) JDK-8311596: Add separate system properties for TLS server and client for maximum chain length (P3) JDK-8313229: DHEKeySizing.java should be modified to use TLS versions TLSv1, TLSv1.1, TLSv1.2 (P4) JDK-8290005: com/sun/jndi/ldap/LdapCBPropertiesTest.java failling with NullPointerException (P4) JDK-8315422: getSoTimeout() would be in try block in SSLSocketImpl (P4) JDK-8319670: Improve comments describing system properties for TLS server and client for max chain length (P4) JDK-8293176: SSLEngine handshaker does not send an alert after a bad parameters (P4) JDK-8294985: SSLEngine throws IAE during parsing of X500Principal (P4) JDK-8295068: SSLEngine throws NPE parsing CertificateRequests (P4) JDK-8312259: StatusResponseManager unused code clean up (P4) JDK-8310106: sun.security.ssl.SSLHandshake.getHandshakeProducer() incorrectly checks handshakeConsumers (P4) JDK-8316671: sun/security/ssl/SSLSocketImpl/SSLSocketCloseHang.java test fails intermittent with Read timed out (P4) JDK-8310070: Test: javax/net/ssl/DTLS/DTLSWontNegotiateV10.java timed out (P4) JDK-8301686: TLS 1.3 handshake fails if server_name doesn't match resuming session (P4) JDK-8301379: Verify TLS_ECDH_* cipher suites cannot be negotiated security-libs/javax.security: (P4) JDK-8318689: jtreg is confused when folder name is the same as the test name security-libs/javax.smartcardio: (P3) JDK-8009550: PlatformPCSC should load versioned so security-libs/javax.xml.crypto: (P3) JDK-8319124: Update XML Security for Java to 3.0.3 security-libs/jdk.security: (P4) JDK-8312443: sun.security should use toLowerCase(Locale.ROOT) security-libs/org.ietf.jgss: (P3) JDK-8312512: sspi.cpp avoid some NULL checks related to free and delete security-libs/org.ietf.jgss:krb5: (P4) JDK-8316771: Krb5.java has not defined messages for all error codes (P4) JDK-8308540: On Kerberos TGT referral, if krb5.conf is missing realm, bad exception message (P4) JDK-8309356: Read files in includedir in alphanumeric order specification/language: (P2) JDK-8311828: JEP 456: Unnamed Variables & Patterns (P2) JDK-8315398: JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview) (P3) JDK-8300786: JEP 447: Statements before super(...) (Preview) (P3) JDK-8314219: JEP 459: String Templates (Second Preview) (P4) JDK-8312082: 12.1.4: Typo in non-normative text explaining candidate main methods (P4) JDK-8300639: 8.4.8: Link to 9.1.3 for discoverability of inheritance rules (P4) JDK-8320581: Clarify the conversions permitted in pattern matching (P4) JDK-8318294: Implement JEP 463: JLS Changes for Implicitly Declared Classes and Instance Main Methods (Second Preview) (P4) JDK-8308247: JLS changes for Statements before super() (Preview) (P4) JDK-8318293: JLS Changes for String Templates (Second Preview) (P4) JDK-8315533: JLS changes for Unnamed Variables & Patterns (P4) JDK-8309859: Make editorial changes to spec change document for JEPs 440&441 (P4) JDK-8311565: Remove spec change docs for JEPs 440 and 441 from the closed repo specification/vm: (P4) JDK-8312508: 4.10.2.2: fix merging of primitive array types (P4) JDK-8306629: 4.1: Allow v66.0 class files for Java SE 22 (P4) JDK-8210428: 4.7.9.1: Class type signatures vs binary names (P4) JDK-8302497: 4.9.2, 4.10.1: Clarify verification rules about uninitialized instances (P4) JDK-8314041: 5.3.5: Clarify meaning of "defining loader" when invoking class resolution (P4) JDK-8298116: 5.5: ConstantValue can initialize non-final fields (P4) JDK-8319310: putstatic/putfield: specify truncation of byte/short/char values tools: (P3) JDK-8318458: Update javac and java manpages with restricted method options (P4) JDK-8320533: Adjust capstone integration for v6 changes (P4) JDK-8315214: Do not run sun/tools/jhsdb tests concurrently (P4) JDK-8310460: Remove jdeps -profile option (P4) JDK-8313613: Use JUnit in langtools/lib tests (P4) JDK-8313612: Use JUnit in lib-test/jdk tests tools/jar: (P3) JDK-8318971: Better Error Handling for Jar Tool When Processing Non-existent Files (P4) JDK-8315644: increase timeout of sun/security/tools/jarsigner/Warning.java tools/javac: (P1) JDK-8315116: fix minor issue in copyright header introduced by JDK-8269957 that is breaking the build (P2) JDK-8310907: Add missing file (P2) JDK-8312814: Compiler crash when template processor type is a captured wildcard (P2) JDK-8311038: Incorrect exhaustivity computation (P2) JDK-8320001: javac crashes while adding type annotations to the return type of a constructor (P3) JDK-8187591: -Werror turns incubator module warning to an error (P3) JDK-8315248: AssertionError in Name.compareTo (P3) JDK-8314216: Case enumConstant, pattern compilation fails (P3) JDK-8320145: Compiler should accept final variable in Record Pattern (P3) JDK-8191460: crash in Annotate with duplicate declaration and annotation processing enabled (P3) JDK-8312229: Crash involving yield, switch and anonymous classes (P3) JDK-8321224: ct.sym for JDK 22 contains references to internal modules (P3) JDK-8321073: Defer policy of disabling annotation processing by default (P3) JDK-8310133: Effectivelly final condition not enforced in guards for binding variables from the same case (P3) JDK-8315452: Erroneous AST missing modifiers for partial input (P3) JDK-8269957: facilitate alternate impls of NameTable and Name (P3) JDK-8302865: Illegal bytecode for break from if with instanceof pattern matching condition (P3) JDK-8315457: Implement JEP 459: String Templates (Second Preview) (P3) JDK-8315458: Implement JEP 463: Implicitly Declared Classes and Instance Main Method (Second Preview) (P3) JDK-8310861: Improve location reporting for javac serial lint warnings (P3) JDK-8312093: Incorrect javadoc comment text (P3) JDK-8315534: Incorrect warnings about implicit annotation processing (P3) JDK-8313323: javac -g on a java file which uses unnamed variable leads to ClassFormatError when launching that class (P3) JDK-8318160: javac does not reject private method reference with type-variable receiver (P3) JDK-8309499: javac fails to report compiler.err.no.java.lang with annotation processing enabled (P3) JDK-8321207: javac is not accepting correct code (P3) JDK-8321164: javac with annotation processor throws AssertionError: Filling jrt:/... during JarFileObject[/...] (P3) JDK-8318144: Match on enum constants with body compiles but fails with MatchException (P3) JDK-8310314: Misplaced "unnamed classes are a preview feature and are disabled by default" error (P3) JDK-8314423: Multiple patterns without unnamed variables (P3) JDK-8310061: Note if implicit annotation processing is being used (P3) JDK-8320948: NPE due to unreported compiler error (P3) JDK-8305971: NPE in JavacProcessingEnvironment for missing enum constructor body (P3) JDK-8319220: Pattern matching switch with a lot of cases is unduly slow (P3) JDK-8268622: Performance issues in javac `Name` class (P3) JDK-8321739: Source launcher fails with "Not a directory" error (P3) JDK-8312619: Strange error message when switching over long (P3) JDK-8310128: Switch with unnamed patterns erroneously non-exhaustive (P3) JDK-8318913: The module-infos for --release data do not contain pre-set versions (P3) JDK-8225377: type annotations are not visible to javac plugins across compilation boundaries (P3) JDK-8321582: yield .class not parsed correctly. (P4) JDK-8316971: Add Lint warning for restricted method calls (P4) JDK-8306586: Add source 22 and target 22 to javac (P4) JDK-8310835: Address gaps in -Xlint:serial checks (P4) JDK-8312560: Annotation on Decomposed Record Component in Enhanced For Loop Fails Compilation (P4) JDK-8306607: Apply 80-column output to javac supported version output (P4) JDK-8317336: Assertion error thrown during 'this' escape analysis (P4) JDK-8320806: Augment test/langtools/tools/javac/versions/Versions.java for JDK 22 language changes (P4) JDK-8314621: ClassNotFoundException due to lambda reference to elided anonymous inner class (P4) JDK-8317818: Combinatorial explosion during 'this' escape analysis (P4) JDK-8320144: Compilation crashes when a custom annotation with invalid default value is used (P4) JDK-8319987: compilation of sealed classes leads to infinite recursion (P4) JDK-8194743: Compiler implementation for Statements before super() (P4) JDK-8315532: Compiler Implementation for Unnamed Variables & Patterns (P4) JDK-8306819: Consider disabling the compiler's default active annotation processing (P4) JDK-8319196: ExecutableElement.getReceiverType doesn't return receiver types for methods loaded from bytecode (P4) JDK-8312415: Expand -Xlint:serial checks to enum constants with specialized class bodies (P4) JDK-8311034: Fix typo in javac man page (P4) JDK-8306914: Implement JEP 458: Launch Multi-File Source-Code Programs (P4) JDK-8307168: Inconsistent validation and handling of --system flag arguments (P4) JDK-8316470: Incorrect error location for "invalid permits clause" depending on file order (P4) JDK-8310326: Incorrect position of the synthetic unnamed class (P4) JDK-8314632: Intra-case dominance check fails in the presence of a guard (P4) JDK-8313693: Introduce an internal utility for the Damerau–Levenshtein distance calculation (P4) JDK-8312821: Javac accepts char literal as template (P4) JDK-8317300: javac erroneously allows "final" in front of a record pattern (P4) JDK-8318837: javac generates wrong ldc instruction for dynamic constant loads (P4) JDK-8312984: javac may crash on a record pattern with too few components (P4) JDK-8309884: missing @since tags in `com.sun.source.*` (P4) JDK-8309883: no `@since` info in com.sun.tools.javac package-info.java, Main.java (P4) JDK-8314578: Non-verifiable code is emitted when two guards declare pattern variables in colon-switch (P4) JDK-8308399: Recommend --release when -source and -target are misused (P4) JDK-8309142: Refactor test/langtools/tools/javac/versions/Versions.java (P4) JDK-8320447: Remove obsolete `LintCategory.hidden` (P4) JDK-8321114: Rename "Unnamed Classes" to "Implicitly Declared Classes" better (P4) JDK-8310067: Restore javac manpage updates (P4) JDK-8314226: Series of colon-style fallthrough switch cases with guards compiled incorrectly (P4) JDK-8321182: SourceExample.SOURCE_14 comment should refer to 'switch expressions' instead of 'text blocks' (P4) JDK-8295058: test/langtools/tools/javac 116 test classes uses com.sun.tools.classfile library (P4) JDK-8313422: test/langtools/tools/javac 144 test classes uses com.sun.tools.classfile library (P4) JDK-8312204: unexpected else with statement causes compiler crash (P4) JDK-8317693: Unused parameter to Tokens.Token.comment method (P4) JDK-8309870: Using -proc:full should be considered requesting explicit annotation processing (P4) JDK-8315735: VerifyError when switch statement used with synchronized block (P4) JDK-8317048: VerifyError with unnamed pattern variable and more than one components (P5) JDK-8309511: Regression test ExtraImportSemicolon.java refers to the wrong bug tools/javadoc(tool): (P3) JDK-8316972: Add javadoc support for restricted methods (P3) JDK-6376959: Algorithm for Inheriting Method Comments seems to go not as documented (P3) JDK-8309595: Allow javadoc to process unnamed classes (P3) JDK-8320207: doclet incorrectly chooses code font for a See Also link (P3) JDK-8306980: Generated docs should contain correct Legal Documents (P3) JDK-8311264: JavaDoc index comparator is not transitive (P3) JDK-8314975: JavadocTester should set source path if not specified (P3) JDK-8321484: Make TestImplicitlyDeclaredClasses release independent (P3) JDK-8261930: New document for output generated by Standard Doclet (P3) JDK-8310575: no `@since` for StandardDoclet (P3) JDK-8285368: Overhaul doc-comment inheritance (P3) JDK-8219945: refactor/simplify structure of docs generated by javadoc (P3) JDK-8309957: Rename JDK-8309595 test to conform (P3) JDK-6934301: Support directed inheriting of class comments with @inheritDoc (P4) JDK-8317937: @sealedGraph: Links to inner classes fails in links (P4) JDK-8297346: [umbrella] Add @sealedGraph doclet tag where applicable (P4) JDK-8312445: Array types in annotation elements show square brackets twice (P4) JDK-8312201: Clean up common behavior in "page writers" and "member writers" (P4) JDK-8311974: Clean up Utils.getBlockTags (P4) JDK-8318082: ConcurrentModificationException from IndexWriter (P4) JDK-8314448: Coordinate DocLint and JavaDoc to report on unknown tags (P4) JDK-8308715: Create a mechanism for Implicitly Declared Class javadoc (P4) JDK-8320645: DocLint should use javax.lang.model to detect default constructors (P4) JDK-8314213: DocLint should warn about unknown standard tags (P4) JDK-8319046: Execute tests in source/class-file order in JavadocTester (P4) JDK-8319139: Improve diagnosability of `JavadocTester` output (P4) JDK-8303056: Improve support for Unicode characters and digits in JavaDoc search (P4) JDK-8313204: Inconsistent order of sections in generated class documentation (P4) JDK-8005622: Inherited Javadoc missing @throws (P4) JDK-8319339: Internal error on spurious markup in a hybrid snippet (P4) JDK-8313349: Introduce `abstract void HtmlDocletWriter.buildPage()` (P4) JDK-8302449: Issues with type parameters links in generic type links (P4) JDK-8317289: javadoc fails with -sourcepath if module-info.java contains import statements (P4) JDK-8288660: JavaDoc should be more helpful if it doesn't recognize a tag (P4) JDK-8320234: Merge doclint.Env.AccessKind with tool.AccessKind (P4) JDK-8309566: Migrate away from TagletWriter and TagletWriterImpl (P4) JDK-8284447: Remove the unused NestedClassWriter interface (P4) JDK-8319300: Remove unused methods in WorkArounds and Utils (P4) JDK-8313253: Rename methods in javadoc Comparators class (P4) JDK-8310118: Resource files should be moved to appropriate directories (P4) JDK-8275889: Search dialog has redundant scrollbars (P4) JDK-8312044: Simplify toolkit Builder/Writer world (P4) JDK-8315464: Uncouple AllClassesIndexWriter from IndexBuilder (P4) JDK-8319444: Unhelpful failure output in TestLegalNotices (P4) JDK-8308659: Use CSS scroll-margin instead of flexbox layout in API documentation (P4) JDK-8319988: Wrong heading for inherited nested classes tools/javap: (P3) JDK-8304446: javap --system flag doesn't override system APIs (P4) JDK-8294969: Convert jdk.jdeps javap to use the Classfile API (P5) JDK-8295059: test/langtools/tools/javap 12 test classes use com.sun.tools.classfile library tools/jlink: (P1) JDK-8323547: tools/jlink/plugins/SystemModuleDescriptors/ModuleMainClassTest.java fails to compile (P2) JDK-8310105: LoongArch64 builds are broken after JDK-8304913 (P2) JDK-8310019: MIPS builds are broken after JDK-8304913 (P3) JDK-8311591: Add SystemModulesPlugin test case that splits module descriptors with new local variables defined by DedupSetBuilder (P3) JDK-8315383: jlink SystemModulesPlugin incorrectly parses the options (P3) JDK-8313983: jmod create --target-platform should replace existing ModuleTarget attribute (P3) JDK-8240567: MethodTooLargeException thrown while creating a jlink image (P3) JDK-8322809: SystemModulesMap::classNames and moduleNames arrays do not match the order (P4) JDK-8297777: Convert jdk.jlink StringSharingPlugin to use Class File API (P4) JDK-8304006: jlink should create the jimage file in the native endian for the target platform (P4) JDK-8301569: jmod list option and jimage list --help not interpreted correctly on turkish locale (P4) JDK-8315578: PPC builds are broken after JDK-8304913 (P4) JDK-8315942: Sort platform enums and definitions after JDK-8304913 follow-ups (P4) JDK-8315579: SPARC64 builds are broken after JDK-8304913 (P5) JDK-8315444: Convert test/jdk/tools to Classfile API (P5) JDK-8294979: test/jdk/tools/jlink 3 test classes use ASM library tools/jpackage: (P3) JDK-8311877: [macos] Add CLI options to provide signing identity directly to codesign and productbuild (P3) JDK-8313904: [macos] All signing tests which verifies unsigned app images are failing (P3) JDK-8308042: [macOS] Developer ID Application Certificate not picked up by jpackage if it contains UNICODE characters (P3) JDK-8301247: JPackage app-image exe launches multiple exe's in JDK 17+ (P3) JDK-8294699: Launcher causes lingering busy cursor (P3) JDK-8322799: Test JPKG003-013: ServiceTest fails because the user cannot uninstall the "servicetest" package on OEL 9.2 x64 and OEL 9.2 64-bit Arm (aarch64) (P3) JDK-8312488: tools/jpackage/share/AppLauncherEnvTest.java fails with dynamically linked libstdc++ (P4) JDK-8320681: [macos] Test tools/jpackage/macosx/MacAppStoreJlinkOptionsTest.java timed out on macOS (P4) JDK-8310933: Copying from runtime image to application image should not follow symlinks (P4) JDK-8311104: dangling-gsl warning in libwixhelper.cpp (P4) JDK-8301856: Generated .spec file for RPM installers uninstalls desktop launcher on update (P4) JDK-8309032: jpackage does not work for module projects unless --module-path is specified (P4) JDK-8317283: jpackage tests run osx-specific checks on windows and linux (P4) JDK-8320858: Move jpackage tests to tier3 (P4) JDK-8320706: RuntimePackageTest.testUsrInstallDir test fails on Linux (P4) JDK-8316563: test tools/jpackage/linux/LinuxResourceTest.java fails on CentOS Linux release 8.5.2111 and Fedora 27 (P4) JDK-8314121: test tools/jpackage/share/RuntimePackageTest.java#id0 fails on RHEL8 (P4) JDK-8316897: tools/jpackage/junit tests fail on AIX after JDK-8316547 (P4) JDK-8320249: tools/jpackage/share/AddLauncherTest.java#id1 fails intermittently on Windows in verifyDescription (P4) JDK-8319338: tools/jpackage/share/RuntimeImageTest.java fails with -XX:+UseZGC (P4) JDK-8303959: tools/jpackage/share/RuntimePackageTest.java fails with java.lang.AssertionError missing files (P4) JDK-8314909: tools/jpackage/windows/Win8282351Test.java fails with java.lang.AssertionError: Expected [0]. Actual [1618]: (P4) JDK-8316547: Use JUnit.dir jtreg property with jpackage JUnit tests (P4) JDK-8311631: When multiple users run tools/jpackage/share/LicenseTest.java, Permission denied for writing /var/tmp/*.files (P4) JDK-8227529: With malformed --app-image the error messages are awful tools/jshell: (P2) JDK-8314614: jdk/jshell/ImportTest.java failed with "InternalError: Failed remote listen" (P3) JDK-8322003: JShell - Incorrect type inference in lists of records implementing interfaces (P3) JDK-8322532: JShell : Unnamed variable issue (P3) JDK-8311647: Memory leak in Java_jdk_internal_org_jline_terminal_impl_jna_linux_CLibraryImpl_ttyname_1r (P3) JDK-8313792: Verify 4th party information in src/jdk.internal.le/share/legal/jline.md (P4) JDK-8314327: Issues with JShell when using "local" execution engine (P4) JDK-8312140: jdk/jshell tests failed with JDI socket timeouts (P4) JDK-8319532: jshell - Non-sealed declarations sometimes break a snippet evaluation (P4) JDK-8315588: JShell does not accept underscore from JEP 443 even with --enable-preview (P4) JDK-8319311: JShell Process Builder should be configurable (P4) JDK-8314662: jshell shows duplicated signatures of javap (P4) JDK-8312475: org.jline.util.PumpReader signed byte problem tools/launcher: (P2) JDK-8304400: JEP 458: Launch Multi-File Source-Code Programs (P3) JDK-8310201: Reduce verbose locale output in -XshowSettings launcher option (P4) JDK-8227229: Deprecate the launcher -Xdebug/-debug flags that have not done anything since Java 6 (P4) JDK-8314491: Linux: jexec launched via PATH fails to find java (P4) JDK-8311653: Modify -XshowSettings launcher behavior (P4) JDK-8318295: Update launcher help for enable-native-access xml/javax.xml.stream: (P3) JDK-8322214: Return value of XMLInputFactory.getProperty() changed from boolean to String in JDK 22 early access builds xml/javax.xml.validation: (P4) JDK-8320602: Lock contention in SchemaDVFactory.getInstance() xml/jaxp: (P2) JDK-8316383: NullPointerException in AbstractSAXParser after JDK-8306632 (P3) JDK-8323571: Regression in source resolution process (P4) JDK-8306055: Add a built-in Catalog to JDK XML module (P4) JDK-8306632: Add a JDK Property for specifying DTD support (P4) JDK-8316996: Catalog API Enhancement: add a factory method (P4) JDK-8320918: Fix errors in the built-in Catalog implementation (P4) JDK-8321406: Null IDs should be resolved as before catalogs are added (P4) JDK-8305814: Update Xalan Java to 2.7.3 xml/org.w3c.dom: (P4) JDK-8311006: missing @since info in jdk.xml.dom (P4) JDK-8310991: missing @since tags in java.xml