RELEASE NOTES FOR: 17 ==================================================================================================== Notes generated: Mon Jul 12 01:50:54 CEST 2021 JIRA Query: project = JDK AND (status in (Closed, Resolved)) AND (resolution not in ("Won't Fix", Duplicate, "Cannot Reproduce", "Not an Issue", Withdrawn)) AND (labels not in (release-note, testbug, openjdk-na, testbug) OR labels is EMPTY) AND (summary !~ 'testbug') AND (summary !~ 'problemlist') AND (summary !~ 'problem list') AND (summary !~ 'release note') AND (issuetype != CSR) AND fixVersion = 17 Acquiring pages (2643 total): ..................................................... done Loading issues (2643 total): ..................................................... done Resolving issues (2643 total): .................................................... done Resolving parents (2643 total): .................................................... done Resolving backports (2643 total): .................................................... done JIRA Query: project = JDK AND issuetype = JEP AND fixVersion = 17 ORDER BY summary ASC Acquiring pages (14 total): . done Loading issues (14 total): . done Resolving issues (14 total): done Resolving parents (14 total): done Filtered 126 issues carried over, 2511 pushes left. Hint: Prefix bug IDs with https://bugs.openjdk.java.net/browse/ to reach the relevant JIRA entry. JAVA ENHANCEMENT PROPOSALS (JEP): JEP 306: Restore Always-Strict Floating-Point Semantics Make floating-point operations consistently strict, rather than have both strict floating-point semantics (`strictfp`) and subtly different default floating-point semantics. This will restore the original floating-point semantics to the language and VM, matching the semantics before the introduction of strict and default floating-point modes in Java SE 1.2. JEP 356: Enhanced Pseudo-Random Number Generators Provide new interface types and implementations for pseudorandom number generators (PRNGs), including jumpable PRNGs and an additional class of splittable PRNG algorithms (LXM). JEP 382: New macOS Rendering Pipeline Implement a Java 2D internal rendering pipeline for macOS using the Apple Metal API as alternative to the existing pipeline, which uses the deprecated Apple OpenGL API. JEP 391: macOS/AArch64 Port Port the JDK to macOS/AArch64. JEP 398: Deprecate the Applet API for Removal Deprecate the Applet API for removal. It is essentially irrelevant since all web-browser vendors have either removed support for Java browser plug-ins or announced plans to do so. JEP 403: Strongly Encapsulate JDK Internals Strongly encapsulate all internal elements of the JDK, except for [critical internal APIs][crit] such as `sun.misc.Unsafe`. It will no longer be possible to relax the strong encapsulation of internal elements via a single command-line option, as was possible in JDK 9 through JDK 16. JEP 406: Pattern Matching for switch (Preview) Enhance the Java programming language with pattern matching for `switch` expressions and statements, along with extensions to the language of patterns. Extending pattern matching to `switch` allows an expression to be tested against a number of patterns, each with a specific action, so that complex data-oriented queries can be expressed concisely and safely. JEP 407: Remove RMI Activation Remove the Remote Method Invocation (RMI) Activation mechanism, while preserving the rest of RMI. JEP 409: Sealed Classes Enhance the Java programming language with [sealed classes and interfaces](https://cr.openjdk.java.net/~briangoetz/amber/datum.html). Sealed classes and interfaces restrict which other classes or interfaces may extend or implement them. JEP 410: Remove the Experimental AOT and JIT Compiler Remove the experimental Java-based ahead-of-time (AOT) and just-in-time (JIT) compiler. This compiler has seen little use since its introduction and the effort required to maintain it is significant. Retain the experimental Java-level JVM compiler interface (JVMCI) so that developers can continue to use externally-built versions of the compiler for JIT compilation. JEP 411: Deprecate the Security Manager for Removal Deprecate the Security Manager for removal in a future release. The Security Manager dates from Java 1.0. It has not been the primary means of securing client-side Java code for many years, and it has rarely been used to secure server-side code. To move Java forward, we intend to deprecate the Security Manager for removal in concert with the legacy Applet API ([JEP 398][jep398]). JEP 412: Foreign Function & Memory API (Incubator) 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 414: Vector API (Second 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 415: Context-Specific Deserialization Filters Allow applications to configure context-specific and dynamically-selected deserialization filters via a JVM-wide filter factory that is invoked to select a filter for each individual deserialization operation. RELEASE NOTES, BY COMPONENT: client-libs/2d: JDK-8266861: Temporarily make Metal the default 2D rendering pipeline for macOS The Early Access of JDK 17 for macOS, starting with build 17, uses the metal graphic rendering pipeline by default in order to achieve a better level of testing. We expect to switch back to OpenGL as the default rendering pipeling for macOS with build 23. You can revert to OpenGL by adding the following system property to your command line: -Dsun.java2d.opengl= “true”. When reporting bugs please specify if you have switched the default rendering pipeline. core-libs: JDK-8267055: JEP 403: Strongly Encapsulate JDK Internals Strongly encapsulate all internal elements of the JDK, except for [critical internal APIs][crit] such as `sun.misc.Unsafe`. With this change, the `java` launcher option [`--illegal-access`][relax] is obsolete. If used on the command line it causes a warning message to be issued, and otherwise has no effect. Existing code that must use internal classes, methods, or fields of the JDK can still be made to work by using the [`--add-opens`][add-opens] launcher option, or the [`Add-Opens`][modjar] JAR-file manifest attribute, to open specific packages. For further details, please see [JEP 403](https://openjdk.java.net/jeps/403). [crit]: https://openjdk.java.net/jeps/260#Description [relax]: https://openjdk.java.net/jeps/261#Relaxed-strong-encapsulation [add-opens]: https://openjdk.java.net/jeps/261#Breaking-encapsulation [modjar]: https://openjdk.java.net/jeps/261#Packaging:-Modular-JAR-files JDK-8268853: JEP 412: Foreign Function & Memory API (Incubator) 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. For further details, see [JEP 412](https://openjdk.java.net/jeps/412). core-libs/java.io: JDK-8265875: Console charset API `java.io.Console` has been updated to define a new method that returns the `Charset` for the console. The returned Charset may be different from the one returned from `Charset.defaultCharset()` method. For example, it returns `IBM437` while `Charset.defaultCharset()` returns `windows-1252` on Windows (en-US). Refer to the [CSR](https://bugs.openjdk.java.net/browse/JDK-8264209) for more detail. core-libs/java.lang: JDK-8266260: System property for the native character encoding name A new system property `native.encoding` has been introduced. This system property provides the underlying host environment's character encoding name. For example, typically it has `UTF-8` in Linux and macOS platforms, and `Cp1252` in Windows (en-US). Refer to the [CSR](https://bugs.openjdk.java.net/browse/JDK-8266075) for more detail. core-libs/java.net: JDK-8261521: Deprecate the socket impl factory mechanism The following static methods to set the system-wide socket implementation factories have been deprecated: - `static void ServerSocket.setSocketFactory​(SocketImplFactory fac)` - `static void Socket.setSocketImplFactory​(SocketImplFactory fac)` - `static void DatagramSocket.setDatagramSocketImplFactory​(DatagramSocketImplFactory fac)` These API points were used to statically configure a system-wide factory for the corresponding socket types in the `java.net` package. These methods have mostly been obsolete since Java 1.4. core-libs/java.nio: JDK-8266381: New implementation of java.nio.channels.Selector on Microsoft Windows The Windows implementation of the `java.nio.channels.Selector` API has been replaced in this release to use a new more scalable implementation. No behavior or compatibility issues were observed during testing of the new implementation. The old implementation has not been removed and the JDK can be configured to use the old implementation, if needed, by running with `-Djava.nio.channels.spi.SelectorProvider=sun.nio.ch.WindowsSelectorProvider` on the command line. core-libs/java.rmi: JDK-8269985: Removed RMI Activation The Remote Method Invocation (RMI) Activation mechanism has been removed. RMI Activation was an obsolete part of RMI that has been optional since Java SE 8. RMI Activation was deprecated for removal by [JEP 385](https://openjdk.java.net/jeps/385) in Java SE 15, and it was removed from this release by [JEP 407](https://openjdk.java.net/jeps/407). The `rmid` tool has also been removed. See JEP 385 for background, rationale, risks, and alternatives. The rest of RMI remains unchanged. core-libs/java.util:collections: JDK-8263397: Collections.unmodifiable* methods are idempotent for their corresponding collection. The `unmodifiable*` methods in `java.util.Collections` will no longer re-wrap a given collection with an unmodifiable view if that collection has already been wrapped by same method. JDK-8261476: TreeMap.computeIfAbsent Mishandles Existing Entries Whose Values Are null Enhancement JDK-8176894 inadvertently introduced erroneous behavior in the `TreeMap.computeIfAbsent` method. The other `TreeMap` methods that were modified by this enhancement are unaffected. The erroneous behavior is that, if the map contains an existing mapping whose value is null, the `computeIfAbsent` method immediately returns null. To conform with the specification, `computeIfAbsent` should instead call the mapping function and update the map with the function's result. core-libs/java.util:i18n: JDK-8265308: Support for CLDR Version 39 Locale data based on Unicode Consortium's CLDR has been upgraded to version 39. For the detailed locale data changes, please refer to the Unicode Consortium's CLDR release notes: - [http://cldr.unicode.org/index/downloads/cldr-39](http://cldr.unicode.org/index/downloads/cldr-39) JDK-8267552: ISO 639 language codes for Hebrew/Indonesian/Yiddish Historically, Java has been using old/obsolete ISO 639 language codes for those languages for compatibility. From Java 17, they default to the current codes. For example, "he" is now the language code for "Hebrew" instead of "iw". A new system property has also been introduced to revert to the legacy behavior. If `-Djava.locale.useOldISOCodes=true` is specified on the command line, it behaves the same way as the prior releases. core-libs/javax.lang.model: JDK-8246771: JEP 395: Records Summary -------- Enhance the Java programming language with [records][records], which are classes that act as transparent carriers for immutable data. Records can be thought of as _nominal tuples_. [records]: http://cr.openjdk.java.net/~briangoetz/amber/datum.html History -------- Records were proposed by [JEP 359](https://openjdk.java.net/jeps/359) and delivered in [JDK 14](https://openjdk.java.net/projects/jdk/14) as a [preview feature](http://openjdk.java.net/jeps/12). In response to feedback, the design was refined by [JEP 384](https://openjdk.java.net/jeps/384) and delivered in [JDK 15](https://openjdk.java.net/projects/jdk/15) as a preview feature for a second time. The refinements for the second preview were as follows: - In the first preview, canonical constructors were required to be `public`. In the second preview, if the canonical constructor is implicitly declared then its access modifier is the same as the record class; if the canonical constructor is explicitly declared then its access modifier must provide at least as much access as the record class. - The meaning of the `@Override` annotation was extended to include the case where the annotated method is an explicitly declared accessor method for a record component. - To enforce the intended use of compact constructors, it became a compile-time error to assign to any of the instance fields in the constructor body. - The ability to declare local record classes, local enum classes, and local interfaces was introduced. This JEP proposes to finalize the feature in JDK 16, with the following refinement: - Relax the longstanding restriction whereby an inner class cannot declare a member that is explicitly or implicitly static. This will become legal and, in particular, will allow an inner class to declare a member that is a record class. Additional refinements may be incorporated based on further feedback. Goals -------- - Devise an object-oriented construct that expresses a simple aggregation of values. - Help developers to focus on modeling immutable data rather than extensible behavior. - Automatically implement data-driven methods such as `equals` and accessors. - Preserve long-standing Java principles such as nominal typing and migration compatibility. Non-Goals -------- - While records do offer improved concision when declaring data carrier classes, it is not a goal to declare a "war on boilerplate". In particular, it is not a goal to address the problems of mutable classes which use the JavaBeans naming conventions. - It is not a goal to add features such as properties or annotation-driven code generation, which are often proposed to streamline the declaration of classes for "Plain Old Java Objects". Motivation -------- It is a common complaint that "Java is too verbose" or has "too much ceremony". Some of the worst offenders are classes that are nothing more than immutable _data carriers_ for a handful of values. Properly writing such a data-carrier class involves a lot of low-value, repetitive, error-prone code: constructors, accessors, `equals`, `hashCode`, `toString`, etc. For example, a class to carry x and y coordinates inevitably ends up like this: ``` class Point { private final int x; private final int y; Point(int x, int y) { this.x = x; this.y = y; } int x() { return x; } int y() { return y; } public boolean equals(Object o) { if (!(o instanceof Point)) return false; Point other = (Point) o; return other.x == x && other.y == y; } public int hashCode() { return Objects.hash(x, y); } public String toString() { return String.format("Point[x=%d, y=%d]", x, y); } } ``` Developers are sometimes tempted to cut corners by omitting methods such as `equals`, leading to surprising behavior or poor debuggability, or by pressing an alternate but not entirely appropriate class into service because it has the "right shape" and they don't want to declare yet another class. IDEs help us to _write_ most of the code in a data-carrier class, but don't do anything to help the _reader_ distill the design intent of "I'm a data carrier for `x` and `y`" from the dozens of lines of boilerplate. Writing Java code that models a handful of values should be easier to write, to read, and to verify as correct. While it is superficially tempting to treat records as primarily being about boilerplate reduction, we instead choose a more semantic goal: _modeling data as data_. (If the semantics are right, the boilerplate will take care of itself.) It should be easy and concise to declare data-carrier classes that _by default_ make their data immutable and provide idiomatic implementations of methods that produce and consume the data. Description -------- _Record classes_ are a new kind of class in the Java language. Record classes help to model plain data aggregates with less ceremony than normal classes. The declaration of a record class primarily consists of a declaration of its _state_; the record class then commits to an API that matches that state. This means that record classes give up a freedom that classes usually enjoy — the ability to decouple a class's API from its internal representation — but, in return, record class declarations become significantly more concise. More precisely, a record class declaration consists of a name, optional type parameters, a header, and a body. The header lists the _components_ of the record class, which are the variables that make up its state. (This list of components is sometimes referred to as the _state description_.) For example: ``` record Point(int x, int y) { } ``` Because record classes make the semantic claim of being transparent carriers for their data, a record class acquires many standard members automatically: - For each component in the header, two members: a `public` accessor method with the same name and return type as the component, and a `private` `final` field with the same type as the component; - A _canonical constructor_ whose signature is the same as the header, and which assigns each private field to the corresponding argument from a `new` expression which instantiates the record; - `equals` and `hashCode` methods which ensure that two record values are equal if they are of the same type and contain equal component values; and - A `toString` method that returns a string representation of all the record components, along with their names. In other words, the header of a record class describes its state, i.e., the types and names of its components, and the API is derived mechanically and completely from that state description. The API includes protocols for construction, member access, equality, and display. (We expect a future version to support deconstruction patterns to allow powerful pattern matching.) ### Constructors for record classes The rules for constructors in a record class are different than in a normal class. A normal class without any constructor declarations is automatically given a [_default constructor_](https://docs.oracle.com/javase/specs/jls/se14/html/jls-8.html#jls-8.8.9). In contrast, a record class without any constructor declarations is automatically given a _canonical constructor_ that assigns all the private fields to the corresponding arguments of the `new` expression which instantiated the record. For example, the record declared earlier — `record Point(int x, int y) { }` — is compiled as if it were: ``` record Point(int x, int y) { // Implicitly declared fields private final int x; private final int y; // Other implicit declarations elided ... // Implicitly declared canonical constructor Point(int x, int y) { this.x = x; this.y = y; } } ``` The canonical constructor may be declared explicitly with a list of formal parameters which match the record header, as shown above. It may also be declared more compactly, by eliding the list of formal parameters. In such a _compact canonical constructor_ the parameters are declared implicitly, and the private fields corresponding to record components cannot be assigned in the body but are automatically assigned to the corresponding formal parameter (`this.x = x;`) at the end of the constructor. The compact form helps developers focus on validating and normalizing parameters without the tedious work of assigning parameters to fields. For example, here is a compact canonical constructor that validates its implicit formal parameters: ``` record Range(int lo, int hi) { Range { if (lo > hi) // referring here to the implicit constructor parameters throw new IllegalArgumentException(String.format("(%d,%d)", lo, hi)); } } ``` Here is a compact canonical constructor that normalizes its formal parameters: ``` record Rational(int num, int denom) { Rational { int gcd = gcd(num, denom); num /= gcd; denom /= gcd; } } ``` This declaration is equivalent to the conventional constructor form: ``` record Rational(int num, int denom) { Rational(int num, int demon) { // Normalization int gcd = gcd(num, denom); num /= gcd; denom /= gcd; // Initialization this.num = num; this.denom = denom; } } ``` Record classes with implicitly declared constructors and methods satisfy important, and intuitive, semantic properties. For example, consider a record class `R` declared as follows: ``` record R(T1 c1, ..., Tn cn){ } ``` If an instance `r1` of `R` is copied in the following way: ``` R r2 = new R(r1.c1(), r1.c2(), ..., r1.cn()); ``` then, assuming `r1` is not the null reference, it is _always_ the case that the expression `r1.equals(r2)` will evaluate to `true`. Explicitly declared accessor and `equals` methods should respect this invariant. However, it is not generally possible for a compiler to check that explicitly declared methods respect this invariant. As an example, the following declaration of a record class should be considered bad style because its accessor methods "silently" adjust the state of a record instance, and the invariant above is not satisfied: ``` record SmallPoint(int x, int y) { public int x() { return this.x < 100 ? this.x : 100; } public int y() { return this.y < 100 ? this.y : 100; } } ``` In addition, for all record classes the implicitly declared `equals` method is implemented so that it is reflexive and that it behaves consistently with `hashCode` for record classes that have floating point components. Again, explicitly declared `equals` and `hashCode` methods should behave similarly. ### Rules for record classes There are numerous restrictions on the declaration of a record class in comparison to a normal class: - A record class declaration does not have an `extends` clause. The superclass of a record class is always `java.lang.Record`, similar to how the superclass of an enum class is always `java.lang.Enum`. Even though a normal class can explicitly extend its implicit superclass `Object`, a record cannot explicitly extend any class, even its implicit superclass `Record`. - A record class is implicitly `final`, and cannot be `abstract`. These restrictions emphasize that the API of a record class is defined solely by its state description, and cannot be enhanced later by another class. - The fields derived from the record components are `final`. This restriction embodies an _immutable by default_ policy that is widely applicable for data-carrier classes. - A record class cannot explicitly declare instance fields, and cannot contain instance initializers. These restrictions ensure that the record header alone defines the state of a record value. - Any explicit declarations of a member that would otherwise be automatically derived must match the type of the automatically derived member exactly, disregarding any annotations on the explicit declaration. Any explicit implementation of accessors or the `equals` or `hashCode` methods should be careful to preserve the semantic invariants of the record class. - A record class cannot declare `native` methods. If a record class could declare a `native` method then the behavior of the record class would by definition depend on external state rather than the record class's explicit state. No class with native methods is likely to be a good candidate for migration to a record. Beyond the restrictions above, a record class behaves like a normal class: - Instances of record classes are created using a `new` expression. - A record class can be declared top level or nested, and can be generic. - A record class can declare `static` methods, fields, and initializers. - A record class can declare instance methods. - A record class can implement interfaces. A record class cannot specify a superclass since that would mean inherited state, beyond the state described in the header. A record class can, however, freely specify superinterfaces and declare instance methods to implement them. Just as for classes, an interface can usefully characterize the behavior of many records. The behavior may be domain-independent (e.g., `Comparable`) or domain-specific, in which case records can be part of a _sealed_ hierarchy which captures the domain (see below). - A record class can declare nested types, including nested record classes. If a record class is itself nested, then it is implicitly static; this avoids an immediately enclosing instance which would silently add state to the record class. - A record class, and the components in its header, may be decorated with annotations. Any annotations on the record components are propagated to the automatically derived fields, methods, and constructor parameters, according to the set of applicable targets for the annotation. Type annotations on the types of record components are also propagated to the corresponding type uses in the automatically derived members. - Instances of record classes can be serialized and deserialized. However, the process cannot be customized by providing `writeObject`, `readObject`, `readObjectNoData`, `writeExternal`, or `readExternal` methods. The components of a record class govern serialization, while the canonical constructor of a record class governs deserialization. ### Local record classes A program that produces and consumes instances of a record class is likely to deal with many intermediate values that are themselves simple groups of variables. It will often be convenient to declare record classes to model those intermediate values. One option is to declare "helper" record classes that are static and nested, much as many programs declare helper classes today. A more convenient option would be to declare a record _inside a method_, close to the code which manipulates the variables. Accordingly we define _local record classes_, akin to the existing construct of [local classes](https://docs.oracle.com/javase/specs/jls/se14/html/jls-14.html#jls-14.3). In the following example, the aggregation of a merchant and a monthly sales figure is modeled with a local record class, `MerchantSales`. Using this record class improves the readability of the stream operations which follow: ``` List findTopMerchants(List merchants, int month) { // Local record record MerchantSales(Merchant merchant, double sales) {} return merchants.stream() .map(merchant -> new MerchantSales(merchant, computeSales(merchant, month))) .sorted((m1, m2) -> Double.compare(m2.sales(), m1.sales())) .map(MerchantSales::merchant) .collect(toList()); } ``` Local record classes are a particular case of nested record classes. Like nested record classes, local record classes are _implicitly static_. This means that their own methods cannot access any variables of the enclosing method; in turn, this avoids capturing an immediately enclosing instance which would silently add state to the record class. The fact that local record classes are implicitly static is in contrast to local classes, which are not implicitly static. In fact, local classes are never static — implicitly or explicitly — and can always access variables in the enclosing method. ### Local enum classes and local interfaces The addition of local record classes is an opportunity to add other kinds of implicitly-static local declarations. Nested enum classes and nested interfaces are already implicitly static, so for consistency we define local enum classes and local interfaces, which are also implicitly static. ### Static members of inner classes It is [currently specified](https://docs.oracle.com/javase/specs/jls/se14/html/jls-8.html#jls-8.1.3) to be a compile-time error if an inner class declares a member that is explicitly or implicitly static, unless the member is a constant variable. This means that, for example, an inner class cannot declare a record class member, since nested record classes are implicitly static. We relax this restriction in order to allow an inner class to declare members that are either explicitly or implicitly static. In particular, this allows an inner class to declare a static member that is a record class. ### Annotations on record components Record components have multiple roles in record declarations. A record component is a first-class concept, but each component also corresponds to a field of the same name and type, an accessor method of the same name and return type, and a formal parameter of the canonical constructor of the same name and type. This raises the question: When a component is annotated, what actually is being annotated? The answer is, "all of the elements to which this particular annotation is applicable." This enables classes that use annotations on their fields, constructor parameters, or accessor methods to be migrated to records without having to redundantly declare these members. For example, a class such as the following ``` public final class Card { private final @MyAnno Rank rank; private final @MyAnno Suit suit; @MyAnno Rank rank() { return this.rank; } @MyAnno Suit suit() { return this.suit; } ... } ``` can be migrated to the equivalent, and considerably more readable, record declaration: ``` public record Card(@MyAnno Rank rank, @MyAnno Suit suit) { ... } ``` The applicability of an annotation is declared using a `@Target` meta-annotation. Consider the following: ``` @Target(ElementType.FIELD) public @interface I1 {...} ``` This declares the annotation `@I1` that it is applicable to field declarations. We can declare that an annotation is applicable to more than one declaration; for example: ``` @Target({ElementType.FIELD, ElementType.METHOD}) public @interface I2 {...} ``` This declares an annotation `@I2` that it is applicable to both field declarations and method declarations. Returning to annotations on a record component, these annotations appear at the corresponding program points where they are applicable. In other words, the propagation is under the control of the developer using the `@Target` meta-annotation. The propagation rules are systematic and intuitive, and all that apply are followed: - If an annotation on a record component is applicable to a field declaration, then the annotation appears on the corresponding private field. - If an annotation on a record component is applicable to a method declaration, then the annotation appears on the corresponding accessor method. - If an annotation on a record component is applicable to a formal parameter, then the annotation appears on the corresponding formal parameter of the canonical constructor if one is not declared explicitly, or else to the corresponding formal parameter of the compact constructor if one is declared explicitly. - If an annotation on a record component is applicable to a type, the annotation will be propagated to all of the following: - the type of the corresponding field - the return type of the corresponding accessor method - the type of the corresponding formal parameter of the canonical constructor - the type of the record component (which is accessible at runtime via reflection) If a public accessor method or (non-compact) canonical constructor is declared explicitly, then it only has the annotations which appear on it directly; nothing is propagated from the corresponding record component to these members. A declaration annotation on a record component will not be amongst those associated with the record component at run time via the [reflection API](#Reflection-API) unless the annotation is meta-annotated with `@Target(RECORD_COMPONENT)`. ### Compatibility and migration The abstract class `java.lang.Record` is the common superclass of all record classes. Every Java source file implicitly imports the `java.lang.Record` class, as well as all other types in the `java.lang` package, regardless of whether you enable or disable preview features. However, if your application imports another class named `Record` from a different package, you might get a compiler error. Consider the following class declaration of `com.myapp.Record`: ``` package com.myapp; public class Record { public String greeting; public Record(String greeting) { this.greeting = greeting; } } ``` The following example, `org.example.MyappPackageExample`, imports `com.myapp.Record` with a wildcard but doesn't compile: ``` package org.example; import com.myapp.*; public class MyappPackageExample { public static void main(String[] args) { Record r = new Record("Hello world!"); } } ``` The compiler generates an error message similar to the following: ``` ./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous Record r = new Record("Hello world!"); ^ both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match ./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous Record r = new Record("Hello world!"); ^ both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match ``` Both `Record` in the `com.myapp` package and `Record` in the `java.lang` package are imported with wildcards. Consequently, neither class takes precedence, and the compiler generates an error message when it encounters the use of the simple name `Record`. To enable this example to compile, the `import` statement can be changed so that it imports the fully qualified name of `Record`: ``` import com.myapp.Record; ``` The introduction of classes in the `java.lang` package is rare but sometimes necessary. Previous examples are `Enum` in Java 5, `Module` in Java 9, and `Record` in Java 14. ### Java grammar ``` RecordDeclaration: {ClassModifier} `record` TypeIdentifier [TypeParameters] RecordHeader [SuperInterfaces] RecordBody RecordHeader: `(` [RecordComponentList] `)` RecordComponentList: RecordComponent { `,` RecordComponent} RecordComponent: {Annotation} UnannType Identifier VariableArityRecordComponent VariableArityRecordComponent: {Annotation} UnannType {Annotation} `...` Identifier RecordBody: `{` {RecordBodyDeclaration} `}` RecordBodyDeclaration: ClassBodyDeclaration CompactConstructorDeclaration CompactConstructorDeclaration: {ConstructorModifier} SimpleTypeName ConstructorBody ``` ### Class-file representation The `class` file of a record uses a `Record` attribute to store information about the record's components: ``` Record_attribute { u2 attribute_name_index; u4 attribute_length; u2 components_count; record_component_info components[components_count]; } record_component_info { u2 name_index; u2 descriptor_index; u2 attributes_count; attribute_info attributes[attributes_count]; } ``` If the record component has a generic signature that is different from the erased descriptor then there must be a `Signature` attribute in the `record_component_info` structure. ### Reflection API We add two public methods to `java.lang.Class`: - `RecordComponent[] getRecordComponents()` — Returns an array of `java.lang.reflect.RecordComponent` objects. The elements of this array correspond to the record's components, in the same order as they appear in the record declaration. Additional information can be extracted from each element of the array, including its name, annotations, and accessor method. - `boolean isRecord()` — Returns true if the given class was declared as a record. (Compare with `isEnum`.) Alternatives -------- Record classes can be considered a nominal form of _tuples_. Instead of record classes, we could implement structural tuples. However, while tuples might offer a lightweight means of expressing some aggregates, the result is often inferior aggregates: - A central aspect of Java's design philosophy is that _names matter_. Classes and their members have meaningful names, while tuples and tuple components do not. That is, a `Person` record class with components `firstName` and `lastName` is clearer and safer than an anonymous tuple of two strings. - Classes allow for state validation through their constructors; tuples typically do not. Some data aggregates (such as numeric ranges) have invariants that, if enforced by the constructor, can thereafter be relied upon. Tuples do not offer this ability. - Classes can have behavior that is based on their state; co-locating the state and behavior makes the behavior more discoverable and easier to access. Tuples, being raw data, offer no such facility. Dependencies -------- Record classes work well with another feature currently in preview, namely _sealed classes_ ([JEP 360](https://openjdk.java.net/jeps/360)). For example, a family of record classes can be explicitly declared to implement the same sealed interface: ``` package com.example.expression; public sealed interface Expr permits ConstantExpr, PlusExpr, TimesExpr, NegExpr {...} public record ConstantExpr(int i) implements Expr {...} public record PlusExpr(Expr a, Expr b) implements Expr {...} public record TimesExpr(Expr a, Expr b) implements Expr {...} public record NegExpr(Expr e) implements Expr {...} ``` The combination of record classes and sealed classes is sometimes referred to as [_algebraic data types_](https://en.wikipedia.org/wiki/Algebraic_data_type). Record classes allow us to express _products_, and sealed classes allow us to express _sums_. In addition to the combination of record classes and sealed classes, record classes lend themselves naturally to [pattern matching][patterns]. Because record classes couple their API to their state description, we will eventually be able to derive deconstruction patterns for record classes as well, and use sealed type information to determine exhaustiveness in `switch` expressions with type patterns or deconstruction patterns. [patterns]: https://cr.openjdk.java.net/~briangoetz/amber/pattern-match.html [sealed]: https://openjdk.java.net/jeps/360 [adts]: https://en.wikipedia.org/wiki/Algebraic_data_type core-svc/java.lang.instrument: JDK-8250552: Changes to the requirements of an agent's premain method to conform to the specification The `java.lang.instrument` implementation has changed in this release to require the agent `premain` and `agentmain` methods be public. The specification always required this but it was not enforced. Attempting to run with an agent where these methods are not public will fail with an exception such as: `java.lang.IllegalAccessException: method .premain must be declared public`. A related change in this release is that the `premain` and `agentmain` methods must be defined in the agent class, the implementation no longer searches for these methods in superclasses. core-svc/javax.management: JDK-8246771: JEP 395: Records Summary -------- Enhance the Java programming language with [records][records], which are classes that act as transparent carriers for immutable data. Records can be thought of as _nominal tuples_. [records]: http://cr.openjdk.java.net/~briangoetz/amber/datum.html History -------- Records were proposed by [JEP 359](https://openjdk.java.net/jeps/359) and delivered in [JDK 14](https://openjdk.java.net/projects/jdk/14) as a [preview feature](http://openjdk.java.net/jeps/12). In response to feedback, the design was refined by [JEP 384](https://openjdk.java.net/jeps/384) and delivered in [JDK 15](https://openjdk.java.net/projects/jdk/15) as a preview feature for a second time. The refinements for the second preview were as follows: - In the first preview, canonical constructors were required to be `public`. In the second preview, if the canonical constructor is implicitly declared then its access modifier is the same as the record class; if the canonical constructor is explicitly declared then its access modifier must provide at least as much access as the record class. - The meaning of the `@Override` annotation was extended to include the case where the annotated method is an explicitly declared accessor method for a record component. - To enforce the intended use of compact constructors, it became a compile-time error to assign to any of the instance fields in the constructor body. - The ability to declare local record classes, local enum classes, and local interfaces was introduced. This JEP proposes to finalize the feature in JDK 16, with the following refinement: - Relax the longstanding restriction whereby an inner class cannot declare a member that is explicitly or implicitly static. This will become legal and, in particular, will allow an inner class to declare a member that is a record class. Additional refinements may be incorporated based on further feedback. Goals -------- - Devise an object-oriented construct that expresses a simple aggregation of values. - Help developers to focus on modeling immutable data rather than extensible behavior. - Automatically implement data-driven methods such as `equals` and accessors. - Preserve long-standing Java principles such as nominal typing and migration compatibility. Non-Goals -------- - While records do offer improved concision when declaring data carrier classes, it is not a goal to declare a "war on boilerplate". In particular, it is not a goal to address the problems of mutable classes which use the JavaBeans naming conventions. - It is not a goal to add features such as properties or annotation-driven code generation, which are often proposed to streamline the declaration of classes for "Plain Old Java Objects". Motivation -------- It is a common complaint that "Java is too verbose" or has "too much ceremony". Some of the worst offenders are classes that are nothing more than immutable _data carriers_ for a handful of values. Properly writing such a data-carrier class involves a lot of low-value, repetitive, error-prone code: constructors, accessors, `equals`, `hashCode`, `toString`, etc. For example, a class to carry x and y coordinates inevitably ends up like this: ``` class Point { private final int x; private final int y; Point(int x, int y) { this.x = x; this.y = y; } int x() { return x; } int y() { return y; } public boolean equals(Object o) { if (!(o instanceof Point)) return false; Point other = (Point) o; return other.x == x && other.y == y; } public int hashCode() { return Objects.hash(x, y); } public String toString() { return String.format("Point[x=%d, y=%d]", x, y); } } ``` Developers are sometimes tempted to cut corners by omitting methods such as `equals`, leading to surprising behavior or poor debuggability, or by pressing an alternate but not entirely appropriate class into service because it has the "right shape" and they don't want to declare yet another class. IDEs help us to _write_ most of the code in a data-carrier class, but don't do anything to help the _reader_ distill the design intent of "I'm a data carrier for `x` and `y`" from the dozens of lines of boilerplate. Writing Java code that models a handful of values should be easier to write, to read, and to verify as correct. While it is superficially tempting to treat records as primarily being about boilerplate reduction, we instead choose a more semantic goal: _modeling data as data_. (If the semantics are right, the boilerplate will take care of itself.) It should be easy and concise to declare data-carrier classes that _by default_ make their data immutable and provide idiomatic implementations of methods that produce and consume the data. Description -------- _Record classes_ are a new kind of class in the Java language. Record classes help to model plain data aggregates with less ceremony than normal classes. The declaration of a record class primarily consists of a declaration of its _state_; the record class then commits to an API that matches that state. This means that record classes give up a freedom that classes usually enjoy — the ability to decouple a class's API from its internal representation — but, in return, record class declarations become significantly more concise. More precisely, a record class declaration consists of a name, optional type parameters, a header, and a body. The header lists the _components_ of the record class, which are the variables that make up its state. (This list of components is sometimes referred to as the _state description_.) For example: ``` record Point(int x, int y) { } ``` Because record classes make the semantic claim of being transparent carriers for their data, a record class acquires many standard members automatically: - For each component in the header, two members: a `public` accessor method with the same name and return type as the component, and a `private` `final` field with the same type as the component; - A _canonical constructor_ whose signature is the same as the header, and which assigns each private field to the corresponding argument from a `new` expression which instantiates the record; - `equals` and `hashCode` methods which ensure that two record values are equal if they are of the same type and contain equal component values; and - A `toString` method that returns a string representation of all the record components, along with their names. In other words, the header of a record class describes its state, i.e., the types and names of its components, and the API is derived mechanically and completely from that state description. The API includes protocols for construction, member access, equality, and display. (We expect a future version to support deconstruction patterns to allow powerful pattern matching.) ### Constructors for record classes The rules for constructors in a record class are different than in a normal class. A normal class without any constructor declarations is automatically given a [_default constructor_](https://docs.oracle.com/javase/specs/jls/se14/html/jls-8.html#jls-8.8.9). In contrast, a record class without any constructor declarations is automatically given a _canonical constructor_ that assigns all the private fields to the corresponding arguments of the `new` expression which instantiated the record. For example, the record declared earlier — `record Point(int x, int y) { }` — is compiled as if it were: ``` record Point(int x, int y) { // Implicitly declared fields private final int x; private final int y; // Other implicit declarations elided ... // Implicitly declared canonical constructor Point(int x, int y) { this.x = x; this.y = y; } } ``` The canonical constructor may be declared explicitly with a list of formal parameters which match the record header, as shown above. It may also be declared more compactly, by eliding the list of formal parameters. In such a _compact canonical constructor_ the parameters are declared implicitly, and the private fields corresponding to record components cannot be assigned in the body but are automatically assigned to the corresponding formal parameter (`this.x = x;`) at the end of the constructor. The compact form helps developers focus on validating and normalizing parameters without the tedious work of assigning parameters to fields. For example, here is a compact canonical constructor that validates its implicit formal parameters: ``` record Range(int lo, int hi) { Range { if (lo > hi) // referring here to the implicit constructor parameters throw new IllegalArgumentException(String.format("(%d,%d)", lo, hi)); } } ``` Here is a compact canonical constructor that normalizes its formal parameters: ``` record Rational(int num, int denom) { Rational { int gcd = gcd(num, denom); num /= gcd; denom /= gcd; } } ``` This declaration is equivalent to the conventional constructor form: ``` record Rational(int num, int denom) { Rational(int num, int demon) { // Normalization int gcd = gcd(num, denom); num /= gcd; denom /= gcd; // Initialization this.num = num; this.denom = denom; } } ``` Record classes with implicitly declared constructors and methods satisfy important, and intuitive, semantic properties. For example, consider a record class `R` declared as follows: ``` record R(T1 c1, ..., Tn cn){ } ``` If an instance `r1` of `R` is copied in the following way: ``` R r2 = new R(r1.c1(), r1.c2(), ..., r1.cn()); ``` then, assuming `r1` is not the null reference, it is _always_ the case that the expression `r1.equals(r2)` will evaluate to `true`. Explicitly declared accessor and `equals` methods should respect this invariant. However, it is not generally possible for a compiler to check that explicitly declared methods respect this invariant. As an example, the following declaration of a record class should be considered bad style because its accessor methods "silently" adjust the state of a record instance, and the invariant above is not satisfied: ``` record SmallPoint(int x, int y) { public int x() { return this.x < 100 ? this.x : 100; } public int y() { return this.y < 100 ? this.y : 100; } } ``` In addition, for all record classes the implicitly declared `equals` method is implemented so that it is reflexive and that it behaves consistently with `hashCode` for record classes that have floating point components. Again, explicitly declared `equals` and `hashCode` methods should behave similarly. ### Rules for record classes There are numerous restrictions on the declaration of a record class in comparison to a normal class: - A record class declaration does not have an `extends` clause. The superclass of a record class is always `java.lang.Record`, similar to how the superclass of an enum class is always `java.lang.Enum`. Even though a normal class can explicitly extend its implicit superclass `Object`, a record cannot explicitly extend any class, even its implicit superclass `Record`. - A record class is implicitly `final`, and cannot be `abstract`. These restrictions emphasize that the API of a record class is defined solely by its state description, and cannot be enhanced later by another class. - The fields derived from the record components are `final`. This restriction embodies an _immutable by default_ policy that is widely applicable for data-carrier classes. - A record class cannot explicitly declare instance fields, and cannot contain instance initializers. These restrictions ensure that the record header alone defines the state of a record value. - Any explicit declarations of a member that would otherwise be automatically derived must match the type of the automatically derived member exactly, disregarding any annotations on the explicit declaration. Any explicit implementation of accessors or the `equals` or `hashCode` methods should be careful to preserve the semantic invariants of the record class. - A record class cannot declare `native` methods. If a record class could declare a `native` method then the behavior of the record class would by definition depend on external state rather than the record class's explicit state. No class with native methods is likely to be a good candidate for migration to a record. Beyond the restrictions above, a record class behaves like a normal class: - Instances of record classes are created using a `new` expression. - A record class can be declared top level or nested, and can be generic. - A record class can declare `static` methods, fields, and initializers. - A record class can declare instance methods. - A record class can implement interfaces. A record class cannot specify a superclass since that would mean inherited state, beyond the state described in the header. A record class can, however, freely specify superinterfaces and declare instance methods to implement them. Just as for classes, an interface can usefully characterize the behavior of many records. The behavior may be domain-independent (e.g., `Comparable`) or domain-specific, in which case records can be part of a _sealed_ hierarchy which captures the domain (see below). - A record class can declare nested types, including nested record classes. If a record class is itself nested, then it is implicitly static; this avoids an immediately enclosing instance which would silently add state to the record class. - A record class, and the components in its header, may be decorated with annotations. Any annotations on the record components are propagated to the automatically derived fields, methods, and constructor parameters, according to the set of applicable targets for the annotation. Type annotations on the types of record components are also propagated to the corresponding type uses in the automatically derived members. - Instances of record classes can be serialized and deserialized. However, the process cannot be customized by providing `writeObject`, `readObject`, `readObjectNoData`, `writeExternal`, or `readExternal` methods. The components of a record class govern serialization, while the canonical constructor of a record class governs deserialization. ### Local record classes A program that produces and consumes instances of a record class is likely to deal with many intermediate values that are themselves simple groups of variables. It will often be convenient to declare record classes to model those intermediate values. One option is to declare "helper" record classes that are static and nested, much as many programs declare helper classes today. A more convenient option would be to declare a record _inside a method_, close to the code which manipulates the variables. Accordingly we define _local record classes_, akin to the existing construct of [local classes](https://docs.oracle.com/javase/specs/jls/se14/html/jls-14.html#jls-14.3). In the following example, the aggregation of a merchant and a monthly sales figure is modeled with a local record class, `MerchantSales`. Using this record class improves the readability of the stream operations which follow: ``` List findTopMerchants(List merchants, int month) { // Local record record MerchantSales(Merchant merchant, double sales) {} return merchants.stream() .map(merchant -> new MerchantSales(merchant, computeSales(merchant, month))) .sorted((m1, m2) -> Double.compare(m2.sales(), m1.sales())) .map(MerchantSales::merchant) .collect(toList()); } ``` Local record classes are a particular case of nested record classes. Like nested record classes, local record classes are _implicitly static_. This means that their own methods cannot access any variables of the enclosing method; in turn, this avoids capturing an immediately enclosing instance which would silently add state to the record class. The fact that local record classes are implicitly static is in contrast to local classes, which are not implicitly static. In fact, local classes are never static — implicitly or explicitly — and can always access variables in the enclosing method. ### Local enum classes and local interfaces The addition of local record classes is an opportunity to add other kinds of implicitly-static local declarations. Nested enum classes and nested interfaces are already implicitly static, so for consistency we define local enum classes and local interfaces, which are also implicitly static. ### Static members of inner classes It is [currently specified](https://docs.oracle.com/javase/specs/jls/se14/html/jls-8.html#jls-8.1.3) to be a compile-time error if an inner class declares a member that is explicitly or implicitly static, unless the member is a constant variable. This means that, for example, an inner class cannot declare a record class member, since nested record classes are implicitly static. We relax this restriction in order to allow an inner class to declare members that are either explicitly or implicitly static. In particular, this allows an inner class to declare a static member that is a record class. ### Annotations on record components Record components have multiple roles in record declarations. A record component is a first-class concept, but each component also corresponds to a field of the same name and type, an accessor method of the same name and return type, and a formal parameter of the canonical constructor of the same name and type. This raises the question: When a component is annotated, what actually is being annotated? The answer is, "all of the elements to which this particular annotation is applicable." This enables classes that use annotations on their fields, constructor parameters, or accessor methods to be migrated to records without having to redundantly declare these members. For example, a class such as the following ``` public final class Card { private final @MyAnno Rank rank; private final @MyAnno Suit suit; @MyAnno Rank rank() { return this.rank; } @MyAnno Suit suit() { return this.suit; } ... } ``` can be migrated to the equivalent, and considerably more readable, record declaration: ``` public record Card(@MyAnno Rank rank, @MyAnno Suit suit) { ... } ``` The applicability of an annotation is declared using a `@Target` meta-annotation. Consider the following: ``` @Target(ElementType.FIELD) public @interface I1 {...} ``` This declares the annotation `@I1` that it is applicable to field declarations. We can declare that an annotation is applicable to more than one declaration; for example: ``` @Target({ElementType.FIELD, ElementType.METHOD}) public @interface I2 {...} ``` This declares an annotation `@I2` that it is applicable to both field declarations and method declarations. Returning to annotations on a record component, these annotations appear at the corresponding program points where they are applicable. In other words, the propagation is under the control of the developer using the `@Target` meta-annotation. The propagation rules are systematic and intuitive, and all that apply are followed: - If an annotation on a record component is applicable to a field declaration, then the annotation appears on the corresponding private field. - If an annotation on a record component is applicable to a method declaration, then the annotation appears on the corresponding accessor method. - If an annotation on a record component is applicable to a formal parameter, then the annotation appears on the corresponding formal parameter of the canonical constructor if one is not declared explicitly, or else to the corresponding formal parameter of the compact constructor if one is declared explicitly. - If an annotation on a record component is applicable to a type, the annotation will be propagated to all of the following: - the type of the corresponding field - the return type of the corresponding accessor method - the type of the corresponding formal parameter of the canonical constructor - the type of the record component (which is accessible at runtime via reflection) If a public accessor method or (non-compact) canonical constructor is declared explicitly, then it only has the annotations which appear on it directly; nothing is propagated from the corresponding record component to these members. A declaration annotation on a record component will not be amongst those associated with the record component at run time via the [reflection API](#Reflection-API) unless the annotation is meta-annotated with `@Target(RECORD_COMPONENT)`. ### Compatibility and migration The abstract class `java.lang.Record` is the common superclass of all record classes. Every Java source file implicitly imports the `java.lang.Record` class, as well as all other types in the `java.lang` package, regardless of whether you enable or disable preview features. However, if your application imports another class named `Record` from a different package, you might get a compiler error. Consider the following class declaration of `com.myapp.Record`: ``` package com.myapp; public class Record { public String greeting; public Record(String greeting) { this.greeting = greeting; } } ``` The following example, `org.example.MyappPackageExample`, imports `com.myapp.Record` with a wildcard but doesn't compile: ``` package org.example; import com.myapp.*; public class MyappPackageExample { public static void main(String[] args) { Record r = new Record("Hello world!"); } } ``` The compiler generates an error message similar to the following: ``` ./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous Record r = new Record("Hello world!"); ^ both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match ./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous Record r = new Record("Hello world!"); ^ both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match ``` Both `Record` in the `com.myapp` package and `Record` in the `java.lang` package are imported with wildcards. Consequently, neither class takes precedence, and the compiler generates an error message when it encounters the use of the simple name `Record`. To enable this example to compile, the `import` statement can be changed so that it imports the fully qualified name of `Record`: ``` import com.myapp.Record; ``` The introduction of classes in the `java.lang` package is rare but sometimes necessary. Previous examples are `Enum` in Java 5, `Module` in Java 9, and `Record` in Java 14. ### Java grammar ``` RecordDeclaration: {ClassModifier} `record` TypeIdentifier [TypeParameters] RecordHeader [SuperInterfaces] RecordBody RecordHeader: `(` [RecordComponentList] `)` RecordComponentList: RecordComponent { `,` RecordComponent} RecordComponent: {Annotation} UnannType Identifier VariableArityRecordComponent VariableArityRecordComponent: {Annotation} UnannType {Annotation} `...` Identifier RecordBody: `{` {RecordBodyDeclaration} `}` RecordBodyDeclaration: ClassBodyDeclaration CompactConstructorDeclaration CompactConstructorDeclaration: {ConstructorModifier} SimpleTypeName ConstructorBody ``` ### Class-file representation The `class` file of a record uses a `Record` attribute to store information about the record's components: ``` Record_attribute { u2 attribute_name_index; u4 attribute_length; u2 components_count; record_component_info components[components_count]; } record_component_info { u2 name_index; u2 descriptor_index; u2 attributes_count; attribute_info attributes[attributes_count]; } ``` If the record component has a generic signature that is different from the erased descriptor then there must be a `Signature` attribute in the `record_component_info` structure. ### Reflection API We add two public methods to `java.lang.Class`: - `RecordComponent[] getRecordComponents()` — Returns an array of `java.lang.reflect.RecordComponent` objects. The elements of this array correspond to the record's components, in the same order as they appear in the record declaration. Additional information can be extracted from each element of the array, including its name, annotations, and accessor method. - `boolean isRecord()` — Returns true if the given class was declared as a record. (Compare with `isEnum`.) Alternatives -------- Record classes can be considered a nominal form of _tuples_. Instead of record classes, we could implement structural tuples. However, while tuples might offer a lightweight means of expressing some aggregates, the result is often inferior aggregates: - A central aspect of Java's design philosophy is that _names matter_. Classes and their members have meaningful names, while tuples and tuple components do not. That is, a `Person` record class with components `firstName` and `lastName` is clearer and safer than an anonymous tuple of two strings. - Classes allow for state validation through their constructors; tuples typically do not. Some data aggregates (such as numeric ranges) have invariants that, if enforced by the constructor, can thereafter be relied upon. Tuples do not offer this ability. - Classes can have behavior that is based on their state; co-locating the state and behavior makes the behavior more discoverable and easier to access. Tuples, being raw data, offer no such facility. Dependencies -------- Record classes work well with another feature currently in preview, namely _sealed classes_ ([JEP 360](https://openjdk.java.net/jeps/360)). For example, a family of record classes can be explicitly declared to implement the same sealed interface: ``` package com.example.expression; public sealed interface Expr permits ConstantExpr, PlusExpr, TimesExpr, NegExpr {...} public record ConstantExpr(int i) implements Expr {...} public record PlusExpr(Expr a, Expr b) implements Expr {...} public record TimesExpr(Expr a, Expr b) implements Expr {...} public record NegExpr(Expr e) implements Expr {...} ``` The combination of record classes and sealed classes is sometimes referred to as [_algebraic data types_](https://en.wikipedia.org/wiki/Algebraic_data_type). Record classes allow us to express _products_, and sealed classes allow us to express _sums_. In addition to the combination of record classes and sealed classes, record classes lend themselves naturally to [pattern matching][patterns]. Because record classes couple their API to their state description, we will eventually be able to derive deconstruction patterns for record classes as well, and use sealed type information to determine exhaustiveness in `switch` expressions with type patterns or deconstruction patterns. [patterns]: https://cr.openjdk.java.net/~briangoetz/amber/pattern-match.html [sealed]: https://openjdk.java.net/jeps/360 [adts]: https://en.wikipedia.org/wiki/Algebraic_data_type docs/release_notes: JDK-8261861: XML implementation specific features and properties Documentation for Implementation Specific Features and Properties has been added to the java.xml module summary. Along with the existing properties, two new properties are introduced in JDK 17. The following section describes the changes in more detail. 1) Add javadoc for the XML processing limits XML processing limits were introduced in JDK 7u45 and 8. They were previously documented in the Java Tutorial Processing Limits section. The definitions for these limits have been added to the module summary. See JDK-8261670. 2) Move the javadoc for `JAXP Lookup Mechanism` to module summary The javadoc for `JAXP Lookup Mechanism` has been moved to the module summary. The original javadocs in JAXP factories are replaced with a link to that in the module summary. See JDK-8261673. 3) Add a property to control newline after XML header for DOM LSSerializer The DOM Load and Save `LSSerializer` did not have an explicit control for whether or not the XML Declaration ends with a newline. In this release, a JDK implementation specific property `jdk.xml.isStandalone` and its corresponding System property `jdk.xml.isStandalone` have been added to control the addition of a newline and acts independently without having to set the pretty-print property. This property can be used to reverse the incompatible change introduced in Java SE 7 Update 4 with an update of Xalan 2.7.1 where a newline is omitted after the XML header. Usage: ``` // to set the property, get an instance of LSSerializer LSSerializer ser = impl.createLSSerializer(); // the isStandalone property is effective whether or not pretty-print is set ser.getDomConfig().setParameter("format-pretty-print", pretty ? true : false); ser.getDomConfig().setParameter("jdk.xml.isStandalone", standalone ? true : false); // to use the System property, set it before initializing a LSSerializer System.setProperty("jdk.xml.isStandalone", standalone ? “true” : "false"); // to clear the property, place the line anywhere after the LSSerializer is initialized System.clearProperty("jdk.xml.isStandalone"); ``` See JDK-8249867. 4) Add a property to control newline after XML header for XSLTC Serializer The XSLTC Serializer supported a property `http://www.oracle.com/xml/is-standalone`, introduced through JDK-7150637, to control whether or not the XML Declaration ends with a newline. It is however, not in compliant with the new specification for Implementation Specific Features and Properties. In order to maintain compatibility, the legacy property is preserved, and a new property `jdk.xml.xsltcIsStandalone` along with its corresponding System property `jdk.xml.xsltcIsStandalone` have been created to perform the same function for the XSLTC Serializer as the `isStandalone` property for DOMLS LSSerializer. Note that the former has an extra prefix `xsltc` to avoid conflict with the later in case it is set through the System property. Usage: ``` // to set the property, get an instance of the Transformer Transformer transformer = getTransformer(…); // the isStandalone property is effective whether or not pretty-print is set transformer.setOutputProperty(OutputKeys.INDENT, pretty ? "yes" : "no"); transformer.setOutputProperty("jdk.xml.xsltcIsStandalone", standalone ? "yes" : "no"); // to use the System property, set it before initializing a Transformer System.setProperty("jdk.xml.xsltcIsStandalone", standalone ? "yes" : "no"); // to clear the property, place the line anywhere after the Transformer is initialized System.clearProperty("jdk.xml.xsltcIsStandalone"); ``` See JDK-8260858. 5) Add existing features and properties and standardizing the prefix to jdk.xml Existing features and properties have been added to the `Implementation Specific Features and Properties` tables in the java.xml module summary. All of the features and properties, existing and new, now have a prefix `jdk.xml` as redefined in the `Naming Convention` section. System properties are searchable in the Java API documentation by the full name, such as `jdk.xml.entityExpansionLimit`. See JDK-8265252. hotspot/gc: JDK-8268105: Parallel GC Enables Adaptive Parallel Reference Processing by Default Parallel GC now ergonomically determines the optimal number of threads to use for processing `java.lang.ref.Reference` instances during garbage collection. The option `-XX:ParallelRefProcEnabled` is now `true` (enabled) by default. The change improves this phase of the garbage collection pause significantly on machines with more than one thread available for garbage collection. If you experience increased garbage collection pauses, you can revert to the original behavior by specifying `-XX:-ParallelRefProcEnabled` on the command line. The ergonomics of `java.lang.ref.Reference` processing can be tuned by using the experimental option `-XX:ReferencesPerThread` (default value: 1000). hotspot/jvmti: JDK-8268865: Deprecate JVM TI Heap functions 1.0 The following JVM TI functions have been deprecated in this release: IterateOverObjectsReachableFromObject IterateOverReachableObjects IterateOverHeap IterateOverInstancesOfClass These functions were superseded in JVM TI version 1.2 (Java SE 6) by more powerful and flexible versions. These functions will be changed to return an error in a future release to indicate that they are no longer implemented/supported. The VM flags `-Xlog:jvmti=trace and -XX:TraceJVMTI=` can be used to identify any residual usages of these functions, e.g. `-Xlog:jvmti=trace -XX:TraceJVMTI=IterateOverHeap` is one way to get trace output when IterateOverHeap is used. hotspot/runtime: JDK-8267178: Removal of sun.misc.Unsafe::defineAnonymousClass `sun.misc.Unsafe::defineAnonymousClass` API has been removed in JDK 17. The API replacement is `java.lang.invoke.MethodHandles.Lookup::defineHiddenClass` and `java.lang.invoke.MethodHandles.Lookup::defineHiddenClassWithClassData`. JDK-8267077: Unified Logging now supports asynchronous log flushing To avoid undesirable delays in a thread using unified logging, the user can now request that the unified logging system operate in asynchronous mode. This is done by passing the command-line option `-Xlog:async`. In asynchronous logging mode, log sites enqueue all logging messages to a buffer and a standalone thread is responsible for flushing them to the corresponding outputs. The intermediate buffer is bounded. On buffer exhaustion the enqueuing message is discarded. The user can control the size of the intermediate buffer using the command-line option `-XX:AsyncLogBufferSize=`. infrastructure/build: JDK-8266859: macOS on ARM early access available A new macOS is now available for ARM systems. The ARM port should behave similarly to the Intel port. There are no known feature differences. When reporting issues on macOS please specify if using ARM or x64. security-libs/java.security: JDK-8260597: Added 2 HARICA Root CA Certificates The following root certificates have been added to the cacerts truststore: ``` + HARICA + haricarootca2015 DN: CN=Hellenic Academic and Research Institutions RootCA 2015, O=Hellenic Academic and Research Institutions Cert. Authority, L=Athens, C=GR + haricaeccrootca2015 DN: CN=Hellenic Academic and Research Institutions ECC RootCA 2015, O=Hellenic Academic and Research Institutions Cert. Authority, L=Athens, C=GR ``` JDK-8259427: jarsigner tool warns if weak algorithms are used in signer’s certificate chain The `jarsigner` tool has been updated to warn users when weak keys or cryptographic algorithms are used in certificates of the signer’s certificate chain. JDK-8259735: New system property to enable the OCSP Nonce Extension A new system property `jdk.security.certpath.ocspNonce` has been added to enable the OCSP Nonce Extension. This system property is disabled by default, and can be enabled by setting it to the value `true`. If set to `true`, the JDK implementation of `PKIXRevocationChecker` includes a nonce extension containing a 16 byte nonce with each OCSP request. See [RFC 8954](https://tools.ietf.org/html/rfc8954) for more details on the OCSP Nonce Extension. JDK-8259640: Disable SHA-1 JARs JARs signed with SHA-1 algorithms are now restricted by default and treated as if they were unsigned. This applies to the algorithms used to digest, sign, and optionally timestamp the JAR. It also applies to the signature and digest algorithms of the certificates in the certificate chain of the code signer and the Timestamp Authority, and any CRLs or OCSP responses that are used to verify if those certificates have been revoked. In order to reduce the compatibility risk for applications that have been previously timestamped or use private CAs, there are two exceptions to this policy: - Any JAR signed with SHA-1 algorithms and timestamped prior to January 01, 2019 will not be restricted. - Any JAR signed with a SHA-1 certificate that does not chain back to a Root CA included by default in the JDK `cacerts` keystore will not be restricted. These exceptions may be removed in a future JDK release. Users can, at their own risk, remove these restrictions by modifying the `java.security` configuration file (or overriding it using the `java.security.properties` system property) and removing "SHA1 jdkCA & usage SignedJAR & denyAfter 2019-01-01" from the `jdk.certpath.disabledAlgorithms` security property and "SHA1 jdkCA & denyAfter 2019-01-01" from the `jdk.jar.disabledAlgorithms` security property. JDK-8258629: Clarify the Specification of KeyStoreSpi.engineStore(KeyStore.LoadStoreParameter) and in KeyStore.store(KeyStore.LoadStoreParameter) Methods The specifications of the `KeyStoreSpi.engineStore(KeyStore.LoadStoreParameter param)` and `KeyStore.store(KeyStore.LoadStoreParameter param)` methods have been updated to specify that an `UnsupportedOperationException` is thrown if the implementation does not support the `engineStore()` operation. This change adjusts the specification to match the existing behavior. JDK-8264968: Provide the support for specifying a signer in keytool -genkeypair command The `-signer` and `-signerkeypass` options have been added to the `-genkeypair` command of the `keytool` utility. The `-signer` option specifies the keystore alias of a `PrivateKeyEntry` for the signer and the `-signerkeypass` option specifies the password used to protect the signer’s private key. These options allow `keytool -genkeypair` to sign the certificate using the signer’s private key. This is especially useful for generating a certificate with a key agreement algorithm as its public key algorithm. JDK-8261361: Removed Telia Company's Sonera Class2 CA Certificate The following root certificate has been removed from the cacerts truststore: ``` + Telia Company + soneraclass2ca DN: CN=Sonera Class2 CA, O=Sonera, C=FI ``` JDK-8261922: Updated keytool to create AKID from the SKID of the issuing certificate as specified by RFC 5280 The `gencert` command of the `keytool` utility has been updated to create AKID from the SKID of the issuing certificate as specified by RFC 5280. security-libs/javax.crypto: JDK-8268135: SunJCE provider now supports KW and KWP modes with AES cipher The SunJCE provider has been enhanced to support the AES Key Wrap Algorithm (RFC 3394) and the AES Key Wrap with Padding Algorithm (RFC 5649). In earlier releases, the SunJCE provider supports RFC 3394 under the "AESWrap" cipher algorithm which can only be used to wrap and unwrap keys. With this enhancement, it adds two block cipher modes KW and KWP that support data encryption/decryption and key wrap/unwrap using AES. Please check the "SunJCE provider" section of the "JDK Providers Documentation" guide for more details. security-libs/javax.net.ssl: JDK-8260310: Configurable extensions with system properties Two new system properties have been added. The system property, "jdk.tls.client.disableExtensions", is used to disable TLS extensions used in the client. The system property, "jdk.tls.server.disableExtensions", is used to disable TLS extensions used in the server. If an extension is disabled, it will be neither produced nor processed in the handshake messages. The property string is a list of comma separated standard TLS extension names, as registered in the IANA documentation (for example, server_name, status_request and signature_algorithms_cert). Note that the extension names are case sensitive. Unknown, unsupported, misspelled and duplicated TLS extension name tokens will be ignored. Please note that the impact of blocking TLS extensions is complicated. For example, a TLS connection may not be able to be established if a mandatory extension is disabled. Please do not disable mandatory extensions, and do not use this feature unless you clearly understand the impact. security-libs/javax.xml.crypto: JDK-8261364: Disable SHA-1 XML Signatures XML signatures that use SHA-1 based digest or signature algorithms have been disabled by default. SHA-1 is no longer a recommended algorithm for digital signatures. If necessary, and at their own risk, applications can workaround this policy by modifying the `jdk.xml.dsig.secureValidationPolicy` security property and re-enabling the SHA-1 algorithms. JDK-8260551: Enable XML Signature secure validation mode by default The XML Signature secure validation mode has been enabled by default (previously it was not enabled by default unless running with a security manager). When enabled, validation of XML signatures are subject to stricter checking of algorithms and other constraints as specified by the `jdk.xml.dsig.secureValidationPolicy` security property. If necessary, and at their own risk, applications can disable the mode by setting the `org.jcp.xml.dsig.secureValidation` property to `Boolean.FALSE` with the `DOMValidateContext.setProperty()` API. security-libs/org.ietf.jgss:krb5: JDK-8262335: Deprecate 3DES and RC4 in Kerberos The des3-hmac-sha1 and rc4-hmac Kerberos encryption types (etypes) are now deprecated and disabled by default. Users can set "allow_weak_crypto = true" in the `krb5.conf` configuration file to re-enable them (along with other weak etypes including des-cbc-crc and des-cbc-md5) at their own risk. To disable a subset of the weak etypes, users can list preferred etypes explicitly in any of default_tkt_enctypes, default_tgs_enctypes, or permitted_enctypes settings. specification/language: JDK-8246771: JEP 395: Records Summary -------- Enhance the Java programming language with [records][records], which are classes that act as transparent carriers for immutable data. Records can be thought of as _nominal tuples_. [records]: http://cr.openjdk.java.net/~briangoetz/amber/datum.html History -------- Records were proposed by [JEP 359](https://openjdk.java.net/jeps/359) and delivered in [JDK 14](https://openjdk.java.net/projects/jdk/14) as a [preview feature](http://openjdk.java.net/jeps/12). In response to feedback, the design was refined by [JEP 384](https://openjdk.java.net/jeps/384) and delivered in [JDK 15](https://openjdk.java.net/projects/jdk/15) as a preview feature for a second time. The refinements for the second preview were as follows: - In the first preview, canonical constructors were required to be `public`. In the second preview, if the canonical constructor is implicitly declared then its access modifier is the same as the record class; if the canonical constructor is explicitly declared then its access modifier must provide at least as much access as the record class. - The meaning of the `@Override` annotation was extended to include the case where the annotated method is an explicitly declared accessor method for a record component. - To enforce the intended use of compact constructors, it became a compile-time error to assign to any of the instance fields in the constructor body. - The ability to declare local record classes, local enum classes, and local interfaces was introduced. This JEP proposes to finalize the feature in JDK 16, with the following refinement: - Relax the longstanding restriction whereby an inner class cannot declare a member that is explicitly or implicitly static. This will become legal and, in particular, will allow an inner class to declare a member that is a record class. Additional refinements may be incorporated based on further feedback. Goals -------- - Devise an object-oriented construct that expresses a simple aggregation of values. - Help developers to focus on modeling immutable data rather than extensible behavior. - Automatically implement data-driven methods such as `equals` and accessors. - Preserve long-standing Java principles such as nominal typing and migration compatibility. Non-Goals -------- - While records do offer improved concision when declaring data carrier classes, it is not a goal to declare a "war on boilerplate". In particular, it is not a goal to address the problems of mutable classes which use the JavaBeans naming conventions. - It is not a goal to add features such as properties or annotation-driven code generation, which are often proposed to streamline the declaration of classes for "Plain Old Java Objects". Motivation -------- It is a common complaint that "Java is too verbose" or has "too much ceremony". Some of the worst offenders are classes that are nothing more than immutable _data carriers_ for a handful of values. Properly writing such a data-carrier class involves a lot of low-value, repetitive, error-prone code: constructors, accessors, `equals`, `hashCode`, `toString`, etc. For example, a class to carry x and y coordinates inevitably ends up like this: ``` class Point { private final int x; private final int y; Point(int x, int y) { this.x = x; this.y = y; } int x() { return x; } int y() { return y; } public boolean equals(Object o) { if (!(o instanceof Point)) return false; Point other = (Point) o; return other.x == x && other.y == y; } public int hashCode() { return Objects.hash(x, y); } public String toString() { return String.format("Point[x=%d, y=%d]", x, y); } } ``` Developers are sometimes tempted to cut corners by omitting methods such as `equals`, leading to surprising behavior or poor debuggability, or by pressing an alternate but not entirely appropriate class into service because it has the "right shape" and they don't want to declare yet another class. IDEs help us to _write_ most of the code in a data-carrier class, but don't do anything to help the _reader_ distill the design intent of "I'm a data carrier for `x` and `y`" from the dozens of lines of boilerplate. Writing Java code that models a handful of values should be easier to write, to read, and to verify as correct. While it is superficially tempting to treat records as primarily being about boilerplate reduction, we instead choose a more semantic goal: _modeling data as data_. (If the semantics are right, the boilerplate will take care of itself.) It should be easy and concise to declare data-carrier classes that _by default_ make their data immutable and provide idiomatic implementations of methods that produce and consume the data. Description -------- _Record classes_ are a new kind of class in the Java language. Record classes help to model plain data aggregates with less ceremony than normal classes. The declaration of a record class primarily consists of a declaration of its _state_; the record class then commits to an API that matches that state. This means that record classes give up a freedom that classes usually enjoy — the ability to decouple a class's API from its internal representation — but, in return, record class declarations become significantly more concise. More precisely, a record class declaration consists of a name, optional type parameters, a header, and a body. The header lists the _components_ of the record class, which are the variables that make up its state. (This list of components is sometimes referred to as the _state description_.) For example: ``` record Point(int x, int y) { } ``` Because record classes make the semantic claim of being transparent carriers for their data, a record class acquires many standard members automatically: - For each component in the header, two members: a `public` accessor method with the same name and return type as the component, and a `private` `final` field with the same type as the component; - A _canonical constructor_ whose signature is the same as the header, and which assigns each private field to the corresponding argument from a `new` expression which instantiates the record; - `equals` and `hashCode` methods which ensure that two record values are equal if they are of the same type and contain equal component values; and - A `toString` method that returns a string representation of all the record components, along with their names. In other words, the header of a record class describes its state, i.e., the types and names of its components, and the API is derived mechanically and completely from that state description. The API includes protocols for construction, member access, equality, and display. (We expect a future version to support deconstruction patterns to allow powerful pattern matching.) ### Constructors for record classes The rules for constructors in a record class are different than in a normal class. A normal class without any constructor declarations is automatically given a [_default constructor_](https://docs.oracle.com/javase/specs/jls/se14/html/jls-8.html#jls-8.8.9). In contrast, a record class without any constructor declarations is automatically given a _canonical constructor_ that assigns all the private fields to the corresponding arguments of the `new` expression which instantiated the record. For example, the record declared earlier — `record Point(int x, int y) { }` — is compiled as if it were: ``` record Point(int x, int y) { // Implicitly declared fields private final int x; private final int y; // Other implicit declarations elided ... // Implicitly declared canonical constructor Point(int x, int y) { this.x = x; this.y = y; } } ``` The canonical constructor may be declared explicitly with a list of formal parameters which match the record header, as shown above. It may also be declared more compactly, by eliding the list of formal parameters. In such a _compact canonical constructor_ the parameters are declared implicitly, and the private fields corresponding to record components cannot be assigned in the body but are automatically assigned to the corresponding formal parameter (`this.x = x;`) at the end of the constructor. The compact form helps developers focus on validating and normalizing parameters without the tedious work of assigning parameters to fields. For example, here is a compact canonical constructor that validates its implicit formal parameters: ``` record Range(int lo, int hi) { Range { if (lo > hi) // referring here to the implicit constructor parameters throw new IllegalArgumentException(String.format("(%d,%d)", lo, hi)); } } ``` Here is a compact canonical constructor that normalizes its formal parameters: ``` record Rational(int num, int denom) { Rational { int gcd = gcd(num, denom); num /= gcd; denom /= gcd; } } ``` This declaration is equivalent to the conventional constructor form: ``` record Rational(int num, int denom) { Rational(int num, int demon) { // Normalization int gcd = gcd(num, denom); num /= gcd; denom /= gcd; // Initialization this.num = num; this.denom = denom; } } ``` Record classes with implicitly declared constructors and methods satisfy important, and intuitive, semantic properties. For example, consider a record class `R` declared as follows: ``` record R(T1 c1, ..., Tn cn){ } ``` If an instance `r1` of `R` is copied in the following way: ``` R r2 = new R(r1.c1(), r1.c2(), ..., r1.cn()); ``` then, assuming `r1` is not the null reference, it is _always_ the case that the expression `r1.equals(r2)` will evaluate to `true`. Explicitly declared accessor and `equals` methods should respect this invariant. However, it is not generally possible for a compiler to check that explicitly declared methods respect this invariant. As an example, the following declaration of a record class should be considered bad style because its accessor methods "silently" adjust the state of a record instance, and the invariant above is not satisfied: ``` record SmallPoint(int x, int y) { public int x() { return this.x < 100 ? this.x : 100; } public int y() { return this.y < 100 ? this.y : 100; } } ``` In addition, for all record classes the implicitly declared `equals` method is implemented so that it is reflexive and that it behaves consistently with `hashCode` for record classes that have floating point components. Again, explicitly declared `equals` and `hashCode` methods should behave similarly. ### Rules for record classes There are numerous restrictions on the declaration of a record class in comparison to a normal class: - A record class declaration does not have an `extends` clause. The superclass of a record class is always `java.lang.Record`, similar to how the superclass of an enum class is always `java.lang.Enum`. Even though a normal class can explicitly extend its implicit superclass `Object`, a record cannot explicitly extend any class, even its implicit superclass `Record`. - A record class is implicitly `final`, and cannot be `abstract`. These restrictions emphasize that the API of a record class is defined solely by its state description, and cannot be enhanced later by another class. - The fields derived from the record components are `final`. This restriction embodies an _immutable by default_ policy that is widely applicable for data-carrier classes. - A record class cannot explicitly declare instance fields, and cannot contain instance initializers. These restrictions ensure that the record header alone defines the state of a record value. - Any explicit declarations of a member that would otherwise be automatically derived must match the type of the automatically derived member exactly, disregarding any annotations on the explicit declaration. Any explicit implementation of accessors or the `equals` or `hashCode` methods should be careful to preserve the semantic invariants of the record class. - A record class cannot declare `native` methods. If a record class could declare a `native` method then the behavior of the record class would by definition depend on external state rather than the record class's explicit state. No class with native methods is likely to be a good candidate for migration to a record. Beyond the restrictions above, a record class behaves like a normal class: - Instances of record classes are created using a `new` expression. - A record class can be declared top level or nested, and can be generic. - A record class can declare `static` methods, fields, and initializers. - A record class can declare instance methods. - A record class can implement interfaces. A record class cannot specify a superclass since that would mean inherited state, beyond the state described in the header. A record class can, however, freely specify superinterfaces and declare instance methods to implement them. Just as for classes, an interface can usefully characterize the behavior of many records. The behavior may be domain-independent (e.g., `Comparable`) or domain-specific, in which case records can be part of a _sealed_ hierarchy which captures the domain (see below). - A record class can declare nested types, including nested record classes. If a record class is itself nested, then it is implicitly static; this avoids an immediately enclosing instance which would silently add state to the record class. - A record class, and the components in its header, may be decorated with annotations. Any annotations on the record components are propagated to the automatically derived fields, methods, and constructor parameters, according to the set of applicable targets for the annotation. Type annotations on the types of record components are also propagated to the corresponding type uses in the automatically derived members. - Instances of record classes can be serialized and deserialized. However, the process cannot be customized by providing `writeObject`, `readObject`, `readObjectNoData`, `writeExternal`, or `readExternal` methods. The components of a record class govern serialization, while the canonical constructor of a record class governs deserialization. ### Local record classes A program that produces and consumes instances of a record class is likely to deal with many intermediate values that are themselves simple groups of variables. It will often be convenient to declare record classes to model those intermediate values. One option is to declare "helper" record classes that are static and nested, much as many programs declare helper classes today. A more convenient option would be to declare a record _inside a method_, close to the code which manipulates the variables. Accordingly we define _local record classes_, akin to the existing construct of [local classes](https://docs.oracle.com/javase/specs/jls/se14/html/jls-14.html#jls-14.3). In the following example, the aggregation of a merchant and a monthly sales figure is modeled with a local record class, `MerchantSales`. Using this record class improves the readability of the stream operations which follow: ``` List findTopMerchants(List merchants, int month) { // Local record record MerchantSales(Merchant merchant, double sales) {} return merchants.stream() .map(merchant -> new MerchantSales(merchant, computeSales(merchant, month))) .sorted((m1, m2) -> Double.compare(m2.sales(), m1.sales())) .map(MerchantSales::merchant) .collect(toList()); } ``` Local record classes are a particular case of nested record classes. Like nested record classes, local record classes are _implicitly static_. This means that their own methods cannot access any variables of the enclosing method; in turn, this avoids capturing an immediately enclosing instance which would silently add state to the record class. The fact that local record classes are implicitly static is in contrast to local classes, which are not implicitly static. In fact, local classes are never static — implicitly or explicitly — and can always access variables in the enclosing method. ### Local enum classes and local interfaces The addition of local record classes is an opportunity to add other kinds of implicitly-static local declarations. Nested enum classes and nested interfaces are already implicitly static, so for consistency we define local enum classes and local interfaces, which are also implicitly static. ### Static members of inner classes It is [currently specified](https://docs.oracle.com/javase/specs/jls/se14/html/jls-8.html#jls-8.1.3) to be a compile-time error if an inner class declares a member that is explicitly or implicitly static, unless the member is a constant variable. This means that, for example, an inner class cannot declare a record class member, since nested record classes are implicitly static. We relax this restriction in order to allow an inner class to declare members that are either explicitly or implicitly static. In particular, this allows an inner class to declare a static member that is a record class. ### Annotations on record components Record components have multiple roles in record declarations. A record component is a first-class concept, but each component also corresponds to a field of the same name and type, an accessor method of the same name and return type, and a formal parameter of the canonical constructor of the same name and type. This raises the question: When a component is annotated, what actually is being annotated? The answer is, "all of the elements to which this particular annotation is applicable." This enables classes that use annotations on their fields, constructor parameters, or accessor methods to be migrated to records without having to redundantly declare these members. For example, a class such as the following ``` public final class Card { private final @MyAnno Rank rank; private final @MyAnno Suit suit; @MyAnno Rank rank() { return this.rank; } @MyAnno Suit suit() { return this.suit; } ... } ``` can be migrated to the equivalent, and considerably more readable, record declaration: ``` public record Card(@MyAnno Rank rank, @MyAnno Suit suit) { ... } ``` The applicability of an annotation is declared using a `@Target` meta-annotation. Consider the following: ``` @Target(ElementType.FIELD) public @interface I1 {...} ``` This declares the annotation `@I1` that it is applicable to field declarations. We can declare that an annotation is applicable to more than one declaration; for example: ``` @Target({ElementType.FIELD, ElementType.METHOD}) public @interface I2 {...} ``` This declares an annotation `@I2` that it is applicable to both field declarations and method declarations. Returning to annotations on a record component, these annotations appear at the corresponding program points where they are applicable. In other words, the propagation is under the control of the developer using the `@Target` meta-annotation. The propagation rules are systematic and intuitive, and all that apply are followed: - If an annotation on a record component is applicable to a field declaration, then the annotation appears on the corresponding private field. - If an annotation on a record component is applicable to a method declaration, then the annotation appears on the corresponding accessor method. - If an annotation on a record component is applicable to a formal parameter, then the annotation appears on the corresponding formal parameter of the canonical constructor if one is not declared explicitly, or else to the corresponding formal parameter of the compact constructor if one is declared explicitly. - If an annotation on a record component is applicable to a type, the annotation will be propagated to all of the following: - the type of the corresponding field - the return type of the corresponding accessor method - the type of the corresponding formal parameter of the canonical constructor - the type of the record component (which is accessible at runtime via reflection) If a public accessor method or (non-compact) canonical constructor is declared explicitly, then it only has the annotations which appear on it directly; nothing is propagated from the corresponding record component to these members. A declaration annotation on a record component will not be amongst those associated with the record component at run time via the [reflection API](#Reflection-API) unless the annotation is meta-annotated with `@Target(RECORD_COMPONENT)`. ### Compatibility and migration The abstract class `java.lang.Record` is the common superclass of all record classes. Every Java source file implicitly imports the `java.lang.Record` class, as well as all other types in the `java.lang` package, regardless of whether you enable or disable preview features. However, if your application imports another class named `Record` from a different package, you might get a compiler error. Consider the following class declaration of `com.myapp.Record`: ``` package com.myapp; public class Record { public String greeting; public Record(String greeting) { this.greeting = greeting; } } ``` The following example, `org.example.MyappPackageExample`, imports `com.myapp.Record` with a wildcard but doesn't compile: ``` package org.example; import com.myapp.*; public class MyappPackageExample { public static void main(String[] args) { Record r = new Record("Hello world!"); } } ``` The compiler generates an error message similar to the following: ``` ./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous Record r = new Record("Hello world!"); ^ both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match ./org/example/MyappPackageExample.java:6: error: reference to Record is ambiguous Record r = new Record("Hello world!"); ^ both class com.myapp.Record in com.myapp and class java.lang.Record in java.lang match ``` Both `Record` in the `com.myapp` package and `Record` in the `java.lang` package are imported with wildcards. Consequently, neither class takes precedence, and the compiler generates an error message when it encounters the use of the simple name `Record`. To enable this example to compile, the `import` statement can be changed so that it imports the fully qualified name of `Record`: ``` import com.myapp.Record; ``` The introduction of classes in the `java.lang` package is rare but sometimes necessary. Previous examples are `Enum` in Java 5, `Module` in Java 9, and `Record` in Java 14. ### Java grammar ``` RecordDeclaration: {ClassModifier} `record` TypeIdentifier [TypeParameters] RecordHeader [SuperInterfaces] RecordBody RecordHeader: `(` [RecordComponentList] `)` RecordComponentList: RecordComponent { `,` RecordComponent} RecordComponent: {Annotation} UnannType Identifier VariableArityRecordComponent VariableArityRecordComponent: {Annotation} UnannType {Annotation} `...` Identifier RecordBody: `{` {RecordBodyDeclaration} `}` RecordBodyDeclaration: ClassBodyDeclaration CompactConstructorDeclaration CompactConstructorDeclaration: {ConstructorModifier} SimpleTypeName ConstructorBody ``` ### Class-file representation The `class` file of a record uses a `Record` attribute to store information about the record's components: ``` Record_attribute { u2 attribute_name_index; u4 attribute_length; u2 components_count; record_component_info components[components_count]; } record_component_info { u2 name_index; u2 descriptor_index; u2 attributes_count; attribute_info attributes[attributes_count]; } ``` If the record component has a generic signature that is different from the erased descriptor then there must be a `Signature` attribute in the `record_component_info` structure. ### Reflection API We add two public methods to `java.lang.Class`: - `RecordComponent[] getRecordComponents()` — Returns an array of `java.lang.reflect.RecordComponent` objects. The elements of this array correspond to the record's components, in the same order as they appear in the record declaration. Additional information can be extracted from each element of the array, including its name, annotations, and accessor method. - `boolean isRecord()` — Returns true if the given class was declared as a record. (Compare with `isEnum`.) Alternatives -------- Record classes can be considered a nominal form of _tuples_. Instead of record classes, we could implement structural tuples. However, while tuples might offer a lightweight means of expressing some aggregates, the result is often inferior aggregates: - A central aspect of Java's design philosophy is that _names matter_. Classes and their members have meaningful names, while tuples and tuple components do not. That is, a `Person` record class with components `firstName` and `lastName` is clearer and safer than an anonymous tuple of two strings. - Classes allow for state validation through their constructors; tuples typically do not. Some data aggregates (such as numeric ranges) have invariants that, if enforced by the constructor, can thereafter be relied upon. Tuples do not offer this ability. - Classes can have behavior that is based on their state; co-locating the state and behavior makes the behavior more discoverable and easier to access. Tuples, being raw data, offer no such facility. Dependencies -------- Record classes work well with another feature currently in preview, namely _sealed classes_ ([JEP 360](https://openjdk.java.net/jeps/360)). For example, a family of record classes can be explicitly declared to implement the same sealed interface: ``` package com.example.expression; public sealed interface Expr permits ConstantExpr, PlusExpr, TimesExpr, NegExpr {...} public record ConstantExpr(int i) implements Expr {...} public record PlusExpr(Expr a, Expr b) implements Expr {...} public record TimesExpr(Expr a, Expr b) implements Expr {...} public record NegExpr(Expr e) implements Expr {...} ``` The combination of record classes and sealed classes is sometimes referred to as [_algebraic data types_](https://en.wikipedia.org/wiki/Algebraic_data_type). Record classes allow us to express _products_, and sealed classes allow us to express _sums_. In addition to the combination of record classes and sealed classes, record classes lend themselves naturally to [pattern matching][patterns]. Because record classes couple their API to their state description, we will eventually be able to derive deconstruction patterns for record classes as well, and use sealed type information to determine exhaustiveness in `switch` expressions with type patterns or deconstruction patterns. [patterns]: https://cr.openjdk.java.net/~briangoetz/amber/pattern-match.html [sealed]: https://openjdk.java.net/jeps/360 [adts]: https://en.wikipedia.org/wiki/Algebraic_data_type tools/javadoc(tool): JDK-8269413: Check for Empty Paragraphs DocLint (invoked from `javac` and `javadoc` with the `-Xdoclint` option) now checks for constructs that lead to empty paragraphs in the generated documentation, which might be flagged by an HTML validator. The most common cause is the redundant use of `

` at the end of block of text. JDK-8269411: Legal Headers for Generated Files The set of files generated by the Standard Doclet typically includes some files with associated licensing requirements. The Standard Doclet now provides support for including the associated legal files, with default behavior for the common case and a new command-line option (`--legal-notices`) to override that behavior when appropriate. JDK-8269402: Improved Output for @see Tags When a declaration has a series of `@see` tags, the output will be generated in the form of an HTML `

    ` list, instead of a simple comma-separated list of links. The style of the list will depend on the number and kind of the links. JDK-8269398: Improve Package Summary Pages The summary page for a package has been restructured to display the different kinds of classes and interfaces in a single tabbed table, instead of a series of separate tables. Additional links have been provided in the navigation bar at the top of the page, to aid in faster navigation to different parts of the page. JDK-8269405: Improve "Help" Page The content of the "Help" page generated by the Standard Doclet has been revised, improved, and new information added. * There is a new "Navigation" section, providing general information on how to navigate around the documentation. * The information about the different kinds of pages have been gathered into a new section, along with new information about pages that were not previously documented * There is a brief "table of contents" at the top of the page, providing links to all the sections and subsections on the page. In addition, the HELP link in the navigation bar for every kind of page now links directly to the section on the Help page for that kind of page. JDK-8269394: source details in error messages When JavaDoc reports an issue in an input source file, it will display the source line for the issue, and line containing a caret (`^`) pointing to the position on the line, in a manner similar to compiler (`javac`) diagnostic messages. JDK-8269410: "Related Packages" on a Package Summary Page. The summary page for a package now includes a section listing any "related packages". The set of related packages is determined heuristically on common naming conventions, and may include the following: * the "parent" package (that is, the package for which a package is a subpackage), * sibling packages (that is, other packages with the same parent package), and * any subpackages. The related packages need not all be in the same module. JDK-8269395: Improved Nested Class Summary When a class or interface has nested classes or interfaces, the list is improved to show the kind of class or interface, such as enum class, record class, annotation interface, as appropriate. JDK-8269400: New Page for "New API" and Improved "Deprecated" Page JavaDoc can now generate a page summarizing the recent changes in an API. The list of recent releases to be included is specified with the `--since` command-line option: these values are used to find declarations with matching `@since` tags to be included on the new page. The `--since-label` command-line option provides text to use in the heading of the "New API" page. On the page that summarizes deprecated items, you can view the items grouped by the release in which they were deprecated. JDK-8269407: Ids Used by the Standard Doclet "Multi-word" ids in the HTML generated by the Standard Doclet have been converted to a uniform style of lowercase words separated by hyphens. This primarily affects the ids used to navigate within the generated documentation and does not affect the ids used for field and method declarations, and which may be used in external pages to reference such declarations within the documentation. ALL FIXED ISSUES, BY COMPONENT AND PRIORITY: client-libs: (P2) JDK-8266545: 8261169 broke Harfbuzz build with gcc 7 and 8 (P3) JDK-8259869: [macOS] Remove desktop module dependencies on JNF Reference APIs (P3) JDK-8259651: [macOS] Replace JNF_COCOA_ENTER/EXIT macros (P3) JDK-8259343: [macOS] Update JNI error handling in Cocoa code. (P3) JDK-8189198: Add "forRemoval = true" to Applet API deprecations (P3) JDK-8258645: Bring Jemmy 1.3.11 to JDK test base (P3) JDK-8261352: Create implementation for component peer for all the components who should be ignored in a11y interactions (P3) JDK-8262981: Create implementation for NSAccessibilitySlider protocol (P3) JDK-8263420: Incorrect function name in NSAccessibilityStaticText native peer implementation (P3) JDK-8260616: Removing remaining JNF dependencies in the java.desktop module (P4) JDK-8197825: [Test] Intermittent timeout with javax/swing JColorChooser Test (P4) JDK-8263928: Add JAWT test files for mac (P4) JDK-8259522: Apply java.io.Serial annotations in java.desktop (P4) JDK-8266766: Arrays of types that cannot be an annotation member do not yield exceptions (P4) JDK-8263846: Bad JNI lookup getFocusOwner in accessibility code on Mac OS X (P4) JDK-8264428: Cleanup usages of StringBuffer in java.desktop (P4) JDK-8261977: Fix comment for getPrefixed() in canonicalize_md.c (P4) JDK-8198619: java/awt/Focus/FocusTraversalPolicy/ButtonGroupLayoutTraversal/ButtonGroupLayoutTraversalTest.java fails on mac (P4) JDK-8198621: java/awt/Focus/KeyEventForBadFocusOwnerTest/KeyEventForBadFocusOwnerTest.java fails on mac (P4) JDK-8225045: javax/swing/JInternalFrame/8146321/JInternalFrameIconTest.java fails on linux-x64 (P4) JDK-8257809: JNI warnings from Toolkit JPEG image decoding (P4) JDK-8240247: No longer need to wrap files with contentContainer (P4) JDK-8262161: Refactor manual I/O stream copying in java.desktop to use new convenience APIs (P4) JDK-8265793: Remove duplicate jtreg TEST.groups references for some client tests (P4) JDK-8265062: Remove duplication constant MaxTextureSize (P4) JDK-8260314: Replace border="1" on tables with CSS (P4) JDK-8258006: Replaces while cycles with iterator with enhanced for in java.desktop (P4) JDK-8259021: SharedSecrets should avoid double racy reads from non-volatile fields (P4) JDK-8197821: Test java/awt/font/TextLayout/LigatureCaretTest.java fails on Windows (P4) JDK-8197796: Test java/awt/Graphics2D/DrawString/DrawRotatedStringUsingRotatedFont.java fails on Windows (P4) JDK-8260291: The case instruction is not visible in dark mode (P4) JDK-8257852: ☂ : Remove JNF dependencies from java.desktop module (P5) JDK-8261010: Delete the Netbeans "default" license header (P5) JDK-8264680: Use the blessed modifier order in java.desktop client-libs/2d: (P2) JDK-8258484: AIX build fails in Harfbuzz with XLC 16.01.0000.0006 (P2) JDK-8267430: GraphicsDevice.setDisplayMode(REFRESH_RATE_UNKNOWN) throws IAE: Unable to set display mode! (P3) JDK-8267602: [macos] [lanai] java/awt/PrintJob/Text/stringwidth.sh doesn't exit on cancelling print dialog (P3) JDK-8256372: [macos] Unexpected symbol was displayed on JTextField with Monospaced font (P3) JDK-8144012: [PIT][macosx] Failure of closed/java/awt/FontClass/FontStringBounds.java (P3) JDK-8259232: Bad JNI lookup during printing (P3) JDK-8264475: CopyArea ignores clip state in metal rendering pipeline (P3) JDK-7018932: Drawing very large coordinates with a dashed Stroke can cause Java to hang (P3) JDK-8264047: Duplicate global variable 'jvm' in libjavajpeg and libawt (P3) JDK-8265761: Font with missed font family name is not properly printed on Windows (P3) JDK-8263439: getSupportedAttributeValues() throws NPE for Finishings attribute (P3) JDK-8226384: Implement a better logic to switch between OpenGL and Metal pipeline (P3) JDK-8260931: Implement JEP 382: New macOS Rendering Pipeline (P3) JDK-8258788: incorrect response to change in window insets [lanai] (P3) JDK-8263984: Invalidate printServices when there are no printers (P3) JDK-8264318: Lanai: DrawHugeImageTest.java fails on apple M1 (P3) JDK-8267116: Lanai: Incorrect AlphaComposite for VolatileImage graphics (P3) JDK-8266040: Lanai: Incorrect calculations of clipping boundaries (P3) JDK-8264317: Lanai: IncorrectUnmanagedImageRotatedClip.java fails on apple M1 (P3) JDK-8264143: Lanai: RenderPerfTest.BgrSwBlitImage has artefacts on apple M1 (P3) JDK-8264141: Lanai: RenderPerfTest.ClipFlatOval has artefacts on apple M1 (P3) JDK-8266159: macOS ARM + Metal pipeline shows artifacts on Swing Menu with Java L&F (P3) JDK-8262829: Native crash in Win32PrintServiceLookup.getAllPrinterNames() (P3) JDK-6606673: Path2D.Double, Path2D.Float and GeneralPath ctors throw exception when initialCapacity is negative (P3) JDK-8250658: Performance of ClipFlatOval Renderperf test is very low (P3) JDK-8262470: Printed GlyphVector outline with low DPI has bad quality on Windows (P3) JDK-8255800: Raster creation methods need some specification clean up (P3) JDK-8266520: Revert to OpenGL as the default 2D rendering pipeline for macOS (P3) JDK-8251036: SwingSet2 - Dragging internal frame inside jframe leaves artifacts with MetalLookAndFeel (P3) JDK-8265304: Temporarily make Metal the default 2D rendering pipeline for macOS (P3) JDK-8260695: The java.awt.color.ICC_Profile#getData/getData(int) are not thread safe (P3) JDK-8263622: The java.awt.color.ICC_Profile#setData invert the order of bytes for the "head" tag (P3) JDK-8262392: Update Mesa 3-D Headers to version 21.0.3 (P3) JDK-8261169: Upgrade HarfBuzz to the latest 2.8.0 (P3) JDK-8261170: Upgrade to FreeType 2.10.4 (P3) JDK-8260380: Upgrade to LittleCMS 2.12 (P3) JDK-8263488: Verify CWarningWindow works with metal rendering pipeline (P3) JDK-8263311: Watch registry changes for remote printers update instead of polling (P4) JDK-8012229: [lcms] Improve performance of color conversion for images with alpha channel (P4) JDK-8261549: Adjust memory size in MTLTexurePool.m (P4) JDK-8260432: allocateSpaceForGP in freetypeScaler.c might leak memory (P4) JDK-6211242: AreaAveragingScaleFilter(int, int): IAE is not specified (P4) JDK-8261107: ArrayIndexOutOfBoundsException in the ICC_Profile.getInstance(InputStream) (P4) JDK-6211257: BasicStroke.createStrokedShape(Shape): NPE is not specified (P4) JDK-8263486: Clean up MTLSurfaceDataBase.h (P4) JDK-8247370: Clean up unused printing code in awt_PrintJob.cpp (P4) JDK-8263894: Convert defaultPrinter and printers fields to local variables (P4) JDK-8264002: Delete outdated assumptions about ColorSpace initialization (P4) JDK-8263583: Emoji rendering on macOS (P4) JDK-6436374: Graphics.setColor(null) is not documented (P4) JDK-6206189: Graphics2D.clip specifies incorrectly that a 'null' is a valid value for this method (P4) JDK-8255790: GTKL&F: Java 16 crashes on initialising GTKL&F on Manjaro Linux (P4) JDK-6211198: ICC_Profile.getInstance(byte[]): IAE is not specified (P4) JDK-8259042: Inconsistent use of general primitives loops (P4) JDK-8263138: Initialization of sun.font.SunFontManager.platformFontMap is not thread safe (P4) JDK-8262915: java.awt.color.ColorSpace.getName() is not thread-safe (P4) JDK-4841153: java.awt.geom.Rectangle2D.add(double,double) documented incorrectly (P4) JDK-8263981: java.awt.image.ComponentSampleModel equals/hashcode use numBands twice (P4) JDK-8196301: java/awt/print/PrinterJob/Margins.java times out (P4) JDK-8252758: Lanai: Optimize index calculation while copying glyphs (P4) JDK-8261282: Lazy initialization of built-in ICC_Profile/ColorSpace classes is too lazy (P4) JDK-8263482: Make access to the ICC color profiles data multithread-friendly (P4) JDK-8263363: Minor cleanup of Lanai code - unused code removal and comments correction (P4) JDK-8263124: Missed initialization of baselineY in sun.font.StrikeMetrics (P4) JDK-8255710: Opensource unit/regression tests for CMM (P4) JDK-8264923: PNGImageWriter.write_zTXt throws Exception with a typo (P4) JDK-6986863: ProfileDeferralMgr throwing ConcurrentModificationException (P4) JDK-8259681: Remove the Marlin rendering engine (single-precision) (P4) JDK-8256321: Some "inactive" color profiles use the wrong profile class (P4) JDK-8261200: Some code in the ICC_Profile may not close file streams properly (P4) JDK-8263833: Stop disabling warnings for sunFont.c with gcc (P4) JDK-8198422: Test java/awt/font/StyledMetrics/BoldSpace.java is unstable (P4) JDK-8198343: Test java/awt/print/PrinterJob/TestPgfmtSetMPA.java may fail w/o printer (P5) JDK-8262497: Delete unused utility methods in ICC_Profile class (P5) JDK-8263051: Modernize the code in the java.awt.color package client-libs/java.awt: (P2) JDK-8261231: Windows IME was disabled after DnD operation (P3) JDK-8264786: [macOS] All Swing/AWT apps cause Allow Notifications prompt to appear when app is launched (P3) JDK-8259585: [macOS] Bad JNI lookup error : Accessible actions do not work on macOS (P3) JDK-8256465: [macos] Java frame and dialog presented full screen freeze application (P3) JDK-8270216: [macOS] Update named used for Java run loop mode (P3) JDK-8182043: Access to Windows Large Icons (P3) JDK-8260619: Add final modifier to several DataFlavor static fields (P3) JDK-8250804: Can't set the application icon image for Unity WM on Linux. (P3) JDK-8262446: DragAndDrop hangs on Windows (P3) JDK-8257500: Drawing MultiResolutionImage with ImageObserver "leaks" memory (P3) JDK-8076313: GraphicsEnvironment does not detect changes in count of monitors on Linux OS (P3) JDK-8262461: handle wcstombsdmp return value correctly in unix awt_InputMethod.c (P3) JDK-8258805: Japanese characters not entered by mouse click on Windows 10 (P3) JDK-7194219: java/awt/Component/UpdatingBootTime/UpdatingBootTime.html fails on Linux (P3) JDK-8264846: Regression ~5% in J2dBench.bimg_misc on Linux after JDK-8263142 (P3) JDK-8227077: Test java/awt/Modal/ZOrderTest6271792/ZOrderTest.java fails (P3) JDK-8262420: typo: @implnote in java.desktop module (P3) JDK-8239894: Xserver crashes when the wrong high refresh rate is used (P4) JDK-8252015: [macos11] java.awt.TrayIcon requires updates for template images (P4) JDK-8047218: [TEST_BUG] java/awt/FullScreen/AltTabCrashTest/AltTabCrashTest.java fails with exception (P4) JDK-8055801: [TEST_BUG] There is no red icon for the frame (P4) JDK-8259439: Apply java.io.Serial annotations in java.datatransfer (P4) JDK-8263362: Avoid division by 0 in java/awt/font/TextJustifier.java justify (P4) JDK-8260426: awt debug_mem.c DMem_AllocateBlock might leak memory (P4) JDK-8266949: Check possibility to disable OperationTimedOut on Unix (P4) JDK-8263454: com.apple.laf.AquaFileChooserUI ignores the result of String.trim() (P4) JDK-8268481: Delete JAWT test files for mac (P4) JDK-8263142: Delete unused entry points in libawt/libawt_xawt/libawt_headless (P4) JDK-8257414: Drag n Drop target area is wrong on high DPI systems (P4) JDK-8254024: Enhance native libs for AWT and Swing to work with GraalVM Native Image (P4) JDK-8265005: Introduce the new client property for mac: apple.awt.windowTitleVisible (P4) JDK-8196300: java/awt/TextArea/TextAreaScrolling/TextAreaScrolling.java times out (P4) JDK-8213126: java/awt/Window/MainKeyWindow/TestMainKeyWindow.java time-out on mac10.13 (P4) JDK-8259511: java/awt/Window/MainKeyWindowTest/TestMainKeyWindow.java failed with "RuntimeException: Test failed: 20 failure(s)" (P4) JDK-8261533: Java_sun_font_CFont_getCascadeList leaks memory according to Xcode (P4) JDK-8260462: Missing in Modality.html (P4) JDK-8264344: Outdated links in JavaComponentAccessibility.m (P4) JDK-8194129: Regression automated Test '/open/test/jdk/java/awt/Window/ShapedAndTranslucentWindows/TranslucentChoice.java' fails (P4) JDK-8257853: Remove dependencies on JNF's JNI utility functions in AWT and 2D code (P4) JDK-8263530: sun.awt.X11.ListHelper.removeAll() should use clear() (P4) JDK-8168408: Test java/awt/Focus/ActualFocusedWindowTest/ActualFocusedWindowBlockingTest.java fails intermittentently on windows (P4) JDK-8225116: Test OwnedWindowsLeak.java intermittently fails (P4) JDK-6278172: TextComponent.getSelectedText() throws StringIndexOutOfBoundsException (P4) JDK-8260315: Typo "focul" instead of "focus" in FocusSpec.html (P4) JDK-8254850: Update terminology in java.awt.GridBagLayout source code comments (P5) JDK-8259519: The java.awt.datatransfer.DataFlavor#ioInputStreamClass field is redundant client-libs/java.awt:i18n: (P4) JDK-8263490: [macos] Crash occurs on JPasswordField with activated InputMethod client-libs/javax.accessibility: (P3) JDK-8208747: [a11y] [macos] In Optionpane Demo, inside ComponentDialog Example, unable to navigate to all items, with VO on (P3) JDK-8261198: [macOS] Incorrect JNI parameters in number conversion in A11Y code (P3) JDK-8259729: Missed JNFInstanceOf -> IsInstanceOf conversion (P3) JDK-8267066: New NSAccessibility peers should return they roles and subroles directly (P3) JDK-8268775: Password is being converted to String in AccessibleJPasswordField (P4) JDK-8257584: [macos] NullPointerException originating from LWCToolkit.java (P4) JDK-8263136: C4530 was reported from VS 2019 at access bridge client-libs/javax.imageio: (P4) JDK-8266171: -Warray-bounds happens in imageioJPEG.c (P4) JDK-8266174: -Wmisleading-indentation happens in libmlib_image sources client-libs/javax.sound: (P3) JDK-8266421: Deadlock in Sound System (P4) JDK-8266248: Compilation failure in PLATFORM_API_MacOSX_MidiUtils.c with Xcode 12.5 client-libs/javax.swing: (P2) JDK-8265278: doc build fails after JDK-8262981 (P2) JDK-8265528: Specification of BasicSplitPaneDivider::getMinimumSize,getPreferredSize doesn't match with its behavior. (P3) JDK-8216358: [accessibility] [macos] The focus is invisible when tab to "Image Radio Buttons" and "Image CheckBoxes" (P3) JDK-8264398: BevelBorderUIResource​(int, Color, Color) and BevelBoder(int, Color, Color) spec should clarify about usage of highlight and shadow color (P3) JDK-8263766: Confusing specification of JEditorPaneAccessibleHypertextSupport constructor (P3) JDK-8264302: Create implementation for Accessibility native peer for Splitpane java role (P3) JDK-8264305: Create implementation for native accessibility peer for Statusbar java role (P3) JDK-8256109: Create implementation for NSAccessibilityButton protocol (P3) JDK-8261350: Create implementation for NSAccessibilityCheckBox protocol peer (P3) JDK-8264290: Create implementation for NSAccessibilityComponentGroup protocol peer (P3) JDK-8256126: Create implementation for NSAccessibilityImage protocol peer (P3) JDK-8261351: Create implementation for NSAccessibilityRadioButton protocol (P3) JDK-8256111: Create implementation for NSAccessibilityStaticText protocol (P3) JDK-8256110: Create implementation for NSAccessibilityStepper protocol (P3) JDK-8264304: Create implementation for NSAccessibilityToolbar protocol peer (P3) JDK-8264299: Create implementation of native accessibility peer for ScrollPane and ScrollBar Java Accessibility roles (P3) JDK-8265291: Error in Javadoc for doAccessibleAction API in AccessibleJSlider class (P3) JDK-8231286: HTML font size too large with high-DPI scaling and W3C_LENGTH_UNITS (P3) JDK-8260687: Inherited font size is smaller than expected when using StyleSheet to add styles (P3) JDK-8263768: JFormattedTextField.AbstractFormatter.getDocumentFilter()/getNavigationFilter() spec doesn't mention what the default impls return and what does it mean (P3) JDK-8256019: JLabel HTML text does not support translucent text colors (P3) JDK-8263970: Manual test javax/swing/JTextField/JapaneseReadingAttributes/JapaneseReadingAttributes.java failed (P3) JDK-8261094: Open javax/swing/text/html/CSS/4765271/bug4765271.java (P3) JDK-8264218: Public method javax.swing.JMenu.setComponentOrientation() has no spec (P3) JDK-8263907: Specification of CellRendererPane::paintComponent(..Rectangle) should clearly mention which method it delegates the call to (P3) JDK-8263481: Specification of JComponent::setDefaultLocale doesn't mention that passing 'null' restores VM's default locale (P3) JDK-8263472: Specification of JComponent::updateUI should document that the default implementation does nothing (P3) JDK-8255880: UI of Swing components is not redrawn after their internal state changed (P3) JDK-8164484: Unity, JTable cell editor, javax/swing/JComboBox/6559152/bug6559152.java (P3) JDK-8268087: Update documentation of the JPasswordField (P4) JDK-8264328: Broken license in javax/swing/JComboBox/8072767/bug8072767.java (P4) JDK-7133530: closed/javax/swing/JRadioButton/4314194/bug4314194.java fails (P4) JDK-8263170: ComboBoxModel documentation refers to a nonexistent type (P4) JDK-8049700: Deprecate obsolete classes and methods in javax/swing/plaf/basic (P4) JDK-8049649: Fix doclint warnings in javax.swing.plaf.basic package (P4) JDK-8263977: GTK L&F: Cleanup duplicate checks in GTKStyle and GTKLookAndFeel (P4) JDK-8262085: Hovering Metal HTML Tooltips in different windows cause IllegalArgExc on Linux (P4) JDK-8257664: HTMLEditorKit: Wrong CSS relative font sizes (P4) JDK-8196090: javax/swing/JComboBox/6559152/bug6559152.java fails (P4) JDK-8196092: javax/swing/JComboBox/8032878/bug8032878.java fails (P4) JDK-8196093: javax/swing/JComboBox/8072767/bug8072767.java fails (P4) JDK-8261689: javax/swing/JComponent/7154030/bug7154030.java still fails with "Exception: Failed to hide opaque button" (P4) JDK-8196466: javax/swing/JFileChooser/8062561/bug8062561.java fails (P4) JDK-8260331: javax/swing/JInternalFrame/8146321/JInternalFrameIconTest.java failed with "ERROR: icon and imageIcon not same." (P4) JDK-8266249: javax/swing/JPopupMenu/7156657/bug7156657.java fails on macOS (P4) JDK-8258924: javax/swing/JSplitPane/4201995/bug4201995.java fails in GTk L&F (P4) JDK-8258554: javax/swing/JTable/4235420/bug4235420.java fails in GTK L&F (P4) JDK-8264526: javax/swing/text/html/parser/Parser/8078268/bug8078268.java timeout (P4) JDK-8253266: JList and JTable constructors should clear OPAQUE_SET before calling updateUI (P4) JDK-4710675: JTextArea.setComponentOrientation does not work with correct timing (P4) JDK-8048109: JToggleButton does not fire actionPerformed under certain conditions (P4) JDK-8263410: ListModel javadoc refers to non-existent interface (P4) JDK-8263496: MetalHighContrastTheme.getControlHighlight cleanup (P4) JDK-8193942: Regression automated test '/open/test/jdk/javax/swing/JFrame/8175301/ScaledFrameBackgroundTest.java' fails (P4) JDK-8196439: Regression automated Test 'javax/swing/JComboBox/8032878/bug8032878.java' fails (P4) JDK-8263235: sanity/client/SwingSet/src/ColorChooserDemoTest.java failed throwing java.lang.NoClassDefFoundError (P4) JDK-8264950: Set opaque for JTooltip in config file of NimbusLookAndFeel (P4) JDK-8163367: Test javax/swing/JComboBox/8033069/bug8033069NoScrollBar.java javax/swing/JComboBox/8033069/bug8033069ScrollBar.java fails intermittently (P4) JDK-8202880: Test javax/swing/JPopupMenu/8075063/ContextMenuScrollTest.java fails (P4) JDK-8199079: Test javax/swing/UIDefaults/6302464/bug6302464.java is unstable (P4) JDK-8039270: The background color of the button can't be displayed and when pressed the button, the background color can not be changed in accordance with the case described. (P4) JDK-8075915: The eight controls without black backgrounds with WinLAF & GTK LAF & Nimbus LAF (P5) JDK-6251901: BasicTextUI: installDefaults method are contrary to the documentation (P5) JDK-8260343: Delete obsolete classes in the Windows L&F core-libs: (P2) JDK-8268342: java/foreign/channels/TestAsyncSocketChannels.java fails with "IllegalStateException: This segment is already closed" (P2) JDK-8268566: java/foreign/TestResourceScope.java timed out (P2) JDK-8268147: need to update reference to testng module for jtreg6 (P3) JDK-8262883: doccheck: Broken links in java.base (P3) JDK-8262428: doclint warnings in java.xml module (P3) JDK-8262433: doclint: reference error in module jdk.incubator.foreign (P3) JDK-8266851: Implement JEP 403: Strongly Encapsulate JDK Internals (P3) JDK-8266753: jdk/test/lib/process/ProcTest.java failed with "Exception: Proc abnormal end" (P3) JDK-8264827: Large mapped buffer/segment crash the VM when calling isLoaded (P3) JDK-8268129: LibraryLookup::ofDefault leaks symbols from loaded libraries (P3) JDK-8268428: Test java/foreign/TestResourceScope.java fails: expected [M] but found [N] (P3) JDK-8255355: Test Plan for JEP 356: Enhanced Pseudo-Random Number Generators (P4) JDK-8266168: -Wmaybe-uninitialized happens in check_code.c (P4) JDK-8266173: -Wmaybe-uninitialized happens in jni_util.c (P4) JDK-8268131: 2 java/foreign tests timed out (P4) JDK-8261422: Adjust problematic String.format calls in jdk/internal/util/Preconditions.java outOfBoundsMessage (P4) JDK-8261880: Change nested classes in java.base to static nested classes where possible (P4) JDK-8258422: Cleanup unnecessary null comparison before instanceof check in java.base (P4) JDK-8266155: Convert java.base to use Stream.toList() (P4) JDK-8253497: Core Libs Terminology Refresh (P4) JDK-8257620: Do not use objc_msgSend_stret to get macOS version (P4) JDK-8263104: fix warnings for empty paragraphs (P4) JDK-8266398: Implement JEP 306 (P4) JDK-8264774: Implementation of Foreign Function and Memory API (Incubator) (P4) JDK-8267043: IntelliJ project doesn't handle generated sources correctly (P4) JDK-8262199: issue in jli args.c (P4) JDK-8268227: java/foreign/TestUpcall.java still times out (P4) JDK-8265033: JEP 412: Foreign Function & Memory API (Incubator) (P4) JDK-8212035: merge jdk.test.lib.util.SimpleHttpServer with jaxp.library.SimpleHttpServer (P4) JDK-8266918: merge_stack in check_code.c add NULL check (P4) JDK-8262892: minor typo in implSpec comment (P4) JDK-8261975: Missing "classpath exception" in VectorSupport.java (P4) JDK-8267190: Optimize Vector API test operations (P4) JDK-8080272: Refactor I/O stream copying to use InputStream.transferTo/readAllBytes and Files.copy (P4) JDK-8261237: remove isClassPathAttributePresent method (P4) JDK-8263560: Remove needless wrapping with BufferedInputStream (P4) JDK-8267921: Remove redundant loop from sun.reflect.misc.ReflectUtil.privateCheckPackageAccess() (P4) JDK-8264029: Replace uses of StringBuffer with StringBuilder in java.base (P4) JDK-8268296: ScopedMemoryAccess build error with readonly filesystems (P4) JDK-8257450: Start of release updates for JDK 17 (P4) JDK-8260869: Test java/foreign/TestHandshake.java fails intermittently (P4) JDK-8267180: Typo in copyright header for HashesTest (P4) JDK-8263190: Update java.io, java.math, and java.text to use instanceof pattern variable (P4) JDK-8267670: Update java.io, java.math, and java.text to use switch expressions (P4) JDK-8263233: Update java.net and java.nio to use instanceof pattern variable (P4) JDK-8268056: Update java.net and java.nio to use switch expressions (P4) JDK-8265426: Update java.security to use instanceof pattern variable (P4) JDK-8266579: Update test/jdk/java/lang/ProcessHandle/PermissionTest.java & test/jdk/java/sql/testng/util/TestPolicy.java (P4) JDK-8263552: Use String.valueOf() for char-to-String conversions (P4) JDK-8263658: Use the blessed modifier order in java.base (P4) JDK-8262989: Vectorize VectorShuffle checkIndexes, wrapIndexes and laneIsValid methods core-libs/java.io: (P2) JDK-8266797: Fix for 8266610 breaks the build on macos (P2) JDK-8266014: Regression brought by optimization done with JDK-4926314 (P3) JDK-6766844: ByteArrayInputStream#read with a byte array of length 0 not consistent with InputStream when at EOF (P3) JDK-8266460: java.io tests fail on null stream with upgraded jtreg/TestNG (P3) JDK-8251942: PrintStream specification is not clear which flush method is automatically invoked (P4) JDK-6245663: (spec) File.renameTo(File) changes the file-system object, not the File instance (P4) JDK-8248383: Clarify java.io.Reader.read(char[], ...) behavior for full array (P4) JDK-8247918: Clarify Reader.skip behavior for end of stream (P4) JDK-8258444: Clean up specifications of java.io.Reader.read(char[],int,int) in subclass overrides (P4) JDK-8264208: Console charset API (P4) JDK-8260273: DataOutputStream writeChars optimization (P4) JDK-8259943: FileDescriptor.close0 does not handle EINTR (P4) JDK-8267569: java.io.File.equals contains misleading Javadoc (P4) JDK-8265918: java/io/Console/CharsetTest.java failed with "expect: spawn id exp6 not open" (P4) JDK-8266610: Method RandomAccessFile#length() returns 0 for block devices on linux. (P4) JDK-4926314: Optimize Reader.read(CharBuffer) (P4) JDK-8264777: Overload optimized FileInputStream::readAllBytes (P4) JDK-8266857: PipedOutputStream.sink should be volatile (P4) JDK-8266078: Reader.read(CharBuffer) advances Reader position for read-only Charbuffers (P4) JDK-8261301: StringWriter.flush() is NOOP but documentation does not indicate it core-libs/java.io:serialization: (P3) JDK-8261160: Add a deserialization JFR event (P3) JDK-8268826: Cleanup Override in Context-Specific Deserialization Filters (P3) JDK-8264859: Implement Context-Specific Deserialization Filters (P4) JDK-8267751: (test) jtreg.SkippedException has no serial VersionUID (P4) JDK-8263320: [test] Add Object Stream Formatter to work with test utility HexPrinter (P4) JDK-8248318: Remove superfluous use of boxing in ObjectStreamClass core-libs/java.lang: (P2) JDK-8267421: j.l.constant.DirectMethodHandleDesc.Kind.valueOf(int) implementation doesn't conform to the spec regarding REF_invokeInterface handling (P3) JDK-8191441: (Process) add Readers and Writer access to java.lang.Process streams (P3) JDK-8225667: Clarify the behavior of System::gc w.r.t. reference processing (P3) JDK-8262875: doccheck: empty paragraphs, etc in java.base module (P3) JDK-8261154: Memory leak in Java_java_lang_ClassLoader_defineClass0 with long class names (P3) JDK-8258956: Memory Leak in StringCoding on ThreadLocal resultCached StringCoding.Result (P3) JDK-8267529: StringJoiner can create a String that breaks String::equals (P3) JDK-8265020: tests must be updated for new TestNG module name (P3) JDK-8268236: The documentation of the String.regionMatches method contains error (P3) JDK-8269543: The warning for System::setSecurityManager should only appear once for each caller (P3) JDK-8265019: Update tests for additional TestNG test permissions (P4) JDK-8269929: (test) Add diagnostic info to ProceessBuilder/Basic.java for unexpected output (P4) JDK-8265173: [test] divert spurious log output away from stream under test in ProcessBuilder Basic test (P4) JDK-8263729: [test] divert spurious output away from stream under test in ProcessBuilder Basic test (P4) JDK-8169629: Annotations with lambda expressions cause AnnotationFormatError (P4) JDK-8261123: Augment discussion of equivalence classes in Object.equals and comparison methods (P4) JDK-8261003: Bad Copyright header format after JDK-8183372 (P4) JDK-8253702: BigSur version number reported as 10.16, should be 11.nn (P4) JDK-8264544: Case-insensitive comparison issue with supplementary characters. (P4) JDK-8257086: Clarify differences between {Float, Double}.equals and == (P4) JDK-8262841: Clarify the behavior of PhantomReference::refersTo (P4) JDK-8263108: Class initialization deadlock in java.lang.constant (P4) JDK-8254979: Class.getSimpleName() returns non-empty for lambda and method (P4) JDK-8265418: Clean-up redundant null-checks of Class.getPackageName() (P4) JDK-8268224: Cleanup references to "strictfp" in core lib comments (P4) JDK-8266399: Core libs update for JEP 306 (P4) JDK-8261621: Delegate Unicode history from JLS to j.l.Character (P4) JDK-8253409: Double-rounding possibility in float fma (P4) JDK-8262351: Extra '0' in java.util.Formatter for '%012a' conversion with a sign character (P4) JDK-8226810: Failed to launch JVM because of NullPointerException occured on System.props (P4) JDK-8262471: Fix coding style in src/java.base/share/classes/java/lang/CharacterDataPrivateUse.java (P4) JDK-8262744: Formatter '%g' conversion uses wrong format for BigDecimal rounding up to limits (P4) JDK-8263677: Improve Character.isLowerCase/isUpperCase lookups (P4) JDK-8261290: Improve error message for NumberFormatException on null input (P4) JDK-8264032: Improve thread safety of Runtime.version() (P4) JDK-8132984: incorrect type for Reference.discovered (P4) JDK-8265130: Make ConstantDesc class hierarchy sealed (P4) JDK-8263892: More modifier order fixes in java.base (P4) JDK-8265356: need code example for getting canonical constructor of a Record (P4) JDK-8240632: Note differences between IEEE 754-2019 math lib special cases and java.lang.Math (P4) JDK-8264609: Number.{byteValue, shortValue} spec should use @implSpec (P4) JDK-8266622: Optimize Class.descriptorString() and Class.getCanonicalName0() (P4) JDK-8263038: Optimize String.format for simple specifiers (P4) JDK-8261036: Reduce classes loaded by CleanerFactory initialization (P4) JDK-8250523: Remove abortOnException diagnostic option from TestHumongousNonArrayAllocation.java (P4) JDK-8263091: Remove CharacterData.isOtherUppercase/-Lowercase (P4) JDK-8259842: Remove Result cache from StringCoding (P4) JDK-8260391: Remove StringCoding::err (P4) JDK-8249646: Runtime.exec(String, String[], File) documentation contains literal {@link ...} (P4) JDK-8265989: System property for the native character encoding name (P4) JDK-8266774: System property values for stdout/err on Windows UTF-8 (P4) JDK-8261753: Test java/lang/System/OsVersionTest.java still failing on BigSur patch versions after JDK-8253702 (P4) JDK-8263358: Update java.lang to use instanceof pattern variable (P4) JDK-8268124: Update java.lang to use switch expressions (P4) JDK-8260329: Update references to TAOCP to latest edition (P4) JDK-8264148: Update spec for exceptions retrofitted for exception chaining (P4) JDK-8268736: Use apiNote in AutoCloseable.close javadoc (P4) JDK-8262018: Wrong format in SAP copyright header of OsVersionTest (P5) JDK-8264678: Incomplete comment in build.tools.generatecharacter.GenerateCharacter core-libs/java.lang.invoke: (P3) JDK-8263087: Add a MethodHandle combinator that switches over a set of MethodHandles (P3) JDK-8266269: Lookup::accessClass fails with IAE when accessing an arrayClass with a protected inner class as component class (P3) JDK-8259922: MethodHandles.collectArguments does not throw IAE if pos is outside the arity range (P3) JDK-8269426: Rename test/jdk/java/lang/invoke/t8150782 to accessClassAndFindClass (P4) JDK-8266925: Add a test to verify that hidden class's members are not statically invocable (P4) JDK-8267995: Add reference to JVMS class file format in Lookup::defineHiddenClass (P4) JDK-8224158: assertion related to NPE at DynamicCallSiteDesc::withArgs should be reworded (P4) JDK-8261030: Avoid loading GenerateJLIClassesHelper at runtime (P4) JDK-8259911: byteArrayViewVarHandle should throw ArrayIndexOutOfBoundsException (P4) JDK-8267612: Declare package-private VarHandle.AccessMode/AccessType counts (P4) JDK-8265079: Implement VarHandle invoker caching (P4) JDK-8174222: LambdaMetafactory: validate inputs and improve documentation (P4) JDK-8255531: MethodHandles::permuteArguments throws NPE when duplicating dropped arguments (P4) JDK-8264288: Performance issue with MethodHandle.asCollector (P4) JDK-8265135: Reduce work initializing VarForms (P4) JDK-8263508: Remove dead code in MethodHandleImpl (P4) JDK-8263821: Remove unused MethodTypeForm canonicalization codes (P4) JDK-8263450: Simplify LambdaForm.useCount (P4) JDK-8265061: Simplify MethodHandleNatives::canBeCalledVirtual (P4) JDK-8263380: Unintended use of Objects.nonNull in VarHandles (P4) JDK-8267321: Use switch expression for VarHandle$AccessMode lookup (P4) JDK-8260605: Various java.lang.invoke cleanups (P5) JDK-8268192: LambdaMetafactory with invokespecial causes VerificationError (P5) JDK-8267614: Outline VarHandleGuards exact behavior checks core-libs/java.lang.module: (P4) JDK-8259395: Patching automatic module with additional packages re-creates module without "requires java.base" core-libs/java.lang:class_loading: (P4) JDK-8262277: URLClassLoader.getResource throws undocumented IllegalArgumentException core-libs/java.lang:reflect: (P2) JDK-8269351: Proxy::newProxyInstance and MethodHandleProxies::asInterfaceInstance should reject sealed interfaces (P3) JDK-8224243: Add implSpec's to AccessibleObject and seal Executable (P3) JDK-8266783: java/lang/reflect/Proxy/DefaultMethods.java fails with jtreg 6 (P4) JDK-8228988: AnnotationParser throws NullPointerException on incompatible member type (P4) JDK-8266598: Exception values for AnnotationTypeMismatchException are not always informative (P4) JDK-8263102: Expand documention of Method.isBridge (P4) JDK-8263333: Improve links from core reflection to JLS and JVMS (P4) JDK-8205502: Make exception message from AnnotationInvocationHandler more informative (P4) JDK-8262807: Note assumptions of core reflection modeling and parameter handling (P4) JDK-8265591: Remove vestiages of intermediate JSR 175 annotation format (P4) JDK-8263763: Synthetic constructor parameters of enum are not considered for annotation indices (P4) JDK-8265174: Update Class.getDeclaredMethods to discuss synthetic and bridge methods (P4) JDK-8261851: Update ReflectionCallerCacheTest.java test to use ForceGC from test library core-libs/java.math: (P4) JDK-8261366: Add discussion of IEEE 754 to BigDecimal (P4) JDK-8264161: BigDecimal#stripTrailingZeros can throw undocumented ArithmeticException (P4) JDK-8260596: Comment cleanup in BigInteger (P4) JDK-8263726: divideToIntegralValue typo on BigDecimal documentation (P4) JDK-8261862: Expand discussion of rationale for BigDecimal equals/compareTo semantics (P4) JDK-8262927: Explicitly state fields examined for BigDecimal.hashCode (P4) JDK-8261940: Fix references to IOException in BigDecimal javadoc (P4) JDK-8265700: Regularize throws clauses in BigDecimal core-libs/java.net: (P3) JDK-8267938: (sctp) SCTP channel factory methods should check platform support (P3) JDK-8265367: [macos-aarch64] 3 java/net/httpclient/websocket tests fail with "IOException: No buffer space available" (P3) JDK-8265369: [macos-aarch64] java/net/MulticastSocket/Promiscuous.java failed with "SocketException: Cannot allocate memory" (P3) JDK-8269772: [macos-aarch64] test compilation failed with "SocketException: No buffer space available" (P3) JDK-8262898: com/sun/net/httpserver/bugs/8199849/ParamTest.java times out (P3) JDK-8266897: com/sun/net/httpserver/FilterTest.java fails intermittently with AssertionError (P3) JDK-7146776: Deadlock between URLStreamHandler.getHostAddress and file.Handler.openconnection (P3) JDK-8235139: Deprecate the socket impl factory mechanism (P3) JDK-8264048: Fix caching in Jar URL connections when an entry is missing (P3) JDK-8258582: HttpClient: the HttpClient doesn't explicitly shutdown its default executor when stopping. (P3) JDK-8260925: HttpsURLConnection does not work with other JSSE provider. (P3) JDK-8255227: java/net/httpclient/FlowAdapterPublisherTest.java intermittently failing with TestServer: start exception: java.io.IOException: Invalid preface (P3) JDK-8265362: java/net/Socket/UdpSocket.java fails with "java.net.BindException: Address already in use" (macos-aarch64) (P3) JDK-8263818: Release JNI local references in get/set-InetXXAddress-member helper functions of net_util.c (P3) JDK-8258696: Temporarily revert use of pattern match instanceof until docs-reference is fixed (P3) JDK-8237352: Update DatagramSocket to add support for joining multicast groups (P3) JDK-8266250: WebSocketTest and WebSocketProxyTest call assertEquals(List, List) (P4) JDK-8265226: (dc) API note in DatagramChannel.open should link to StandardProtocolFamily.UNIX (P4) JDK-8261601: (sctp) free memory in early return in Java_sun_nio_ch_sctp_SctpChannelImpl_receive0 (P4) JDK-8261791: (sctp) handleSendFailed in SctpChannelImpl.c potential leaks (P4) JDK-8259493: [test] Use HexFormat instead of adhoc hex utilities in network code and locale SoftKeys (P4) JDK-8262935: Add missing logging to sun.net.httpserver.ServerImpl (P4) JDK-8265123: Add static factory methods to com.sun.net.httpserver.Filter (P4) JDK-8266761: AssertionError in sun.net.httpserver.ServerImpl.responseCompleted (P4) JDK-8260520: Avoid getting permissions in JarFileFactory when no SecurityManager installed (P4) JDK-8241995: Clarify InetSocketAddress::toString specification (P4) JDK-8267262: com/sun/net/httpserver/Filter improve API documentation of static methods (P4) JDK-8252831: Correct "no comment" warnings in jdk.net module (P4) JDK-8260366: ExtendedSocketOptions can deadlock in some circumstances (P4) JDK-8253100: Fix "no comment" warnings in java.base/java.net (P4) JDK-8262296: Fix remaining doclint warnings in jdk.httpserver (P4) JDK-8262195: Harden tests that use the HostsFileNameService (jdk.net.hosts.file property) (P4) JDK-8263899: HttpClient throws NPE in AuthenticationFilter when parsing www-authenticate head (P4) JDK-8268023: Improve diagnostic for HandshakeFailureTest (P4) JDK-8262027: Improve how HttpConnection detects a closed channel when taking/returning a connection to the pool (P4) JDK-8257736: InputStream from BodyPublishers.ofInputStream() leaks when IOE happens (P4) JDK-8255583: Investigate creating a test to trigger the condition in KeepAliveStreamCleaner (P4) JDK-8235140: Investigate deprecation of the Socket/ServerSocket impl factory mechanism (P4) JDK-8264975: java/net/DatagramSocket/DatagramSocketMulticasting.java fails infrequently (P4) JDK-8264824: java/net/Inet6Address/B6206527.java doesn't close ServerSocket properly (P4) JDK-8259628: jdk/net/ExtendedSocketOption/AsynchronousSocketChannelNAPITest.java fails intermittently (P4) JDK-8187450: JNI local refs exceeds capacity warning in NetworkInterface::getAll (P4) JDK-8263506: Make sun.net.httpserver.UnmodifiableHeaders unmodifiable (P4) JDK-8263080: Obsolete relationship in MulticastSocket API documentation. (P4) JDK-8263442: Potential bug in jdk.internal.net.http.common.Utils.CONTEXT_RESTRICTED (P4) JDK-8259631: Reapply pattern match instanceof use in HttpClientImpl (P4) JDK-8260043: Reduce allocation in sun.net.www.protocol.jar.Handler.parseURL (P4) JDK-8259699: Reduce char[] copying in URLEncoder.encode(String, Charset) (P4) JDK-8263905: Remove finalize methods for SocketInput/OutputStream (P4) JDK-8261750: Remove internal class sun.net.www.MimeLauncher (P4) JDK-8250565: Remove terminally deprecated constructor in java.net.URLDecoder (P4) JDK-8255477: Remove unused method URL.set(String protocol, String host, int port, String file, String ref) (P4) JDK-8267990: Revisit some uses of `synchronized` in the HttpClient API (P4) JDK-8255264: Support for identifying the full range of IPv4 localhost addresses on Windows (P4) JDK-8268133: Update java/net/Authenticator tests to eliminate dependency on sun.net.www.MessageHeader and some other internal APIs core-libs/java.nio: (P1) JDK-8265018: (fs) Build issue with FileDispatcherImpl.c:31:10: fatal error: 'sys/mount.h' file not found (aix) (P2) JDK-8265231: (fc) ReadDirect and WriteDirect tests fail after fix for JDK-8264821 (P2) JDK-8260304: (se) EPollSelectorImpl wakeup mechanism broken on Linux 32-bit (P3) JDK-8263742: (bf) MappedByteBuffer.force() should use the capacity as its upper bound (P3) JDK-4833719: (bf) Views of MappedByteBuffers are not MappedByteBuffers, and cannot be forced (P3) JDK-8232861: (fc) FileChannel.force fails on WebDAV file systems (macOS) (P3) JDK-8269074: (fs) Files.copy fails to copy from /proc on some linux kernel versions (P3) JDK-8260691: (fs) LinuxNativeDispatcher should link to xattr functions (P3) JDK-8259865: (fs) test/jdk/java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java failing on macOS 10.13 (P3) JDK-8264821: DirectIOTest fails on a system with large block size (P3) JDK-8262430: doclint warnings in java.base module (P3) JDK-8267564: JDK-8252971 causes SPECjbb2015 socket exceptions on Windows when MKS is installed (P3) JDK-8262926: JDK-8260966 broke AIX build (P4) JDK-8257212: (bf spec) Clarify byte order of the buffer returned by CharBuffer.subsequence(int,int) (P4) JDK-8266320: (bf) ReadOnlyBufferException in heap buffer put(String,int,int) should not be conditional (P4) JDK-8265699: (bf) Scopes passed to ScopedMemoryAccess.copy[Swap]Memory in incorrect order (P4) JDK-8260694: (fc) Clarify FileChannel.transferFrom to better describe "no bytes available" case (P4) JDK-8264502: (fc) FileDispatcherImpl.setDirect0 might return uninitialized variable on some platforms (P4) JDK-6539707: (fc) MappedByteBuffer.force() method throws an IOException in a very simple test (P4) JDK-8259218: (fs) Add links in from overloaded methods in java.nio.file.Files (P4) JDK-8260966: (fs) Consolidate Linux and macOS implementations of UserDefinedFileAttributeView (P4) JDK-8262957: (fs) Fail fast in UnixFileStore.isExtendedAttributesEnabled (P4) JDK-8265175: (fs) Files.copy(Path,Path,CopyOption...) should use sendfile on Linux (P4) JDK-8263898: (fs) Files.newOutputStream on the "NUL" special device throws FileSystemException: "nul: Incorrect function" (win) (P4) JDK-8262844: (fs) FileStore.supportsFileAttributeView might return false negative in case of ext3 (P4) JDK-8266589: (fs) Improve performance of Files.copy() on macOS using copyfile(3) (P4) JDK-8264111: (fs) Leaking NativeBuffers in case of errors during UnixUserDefinedFileAttributeView.read/write (P4) JDK-8259947: (fs) Optimize UnixPath.encode implementation (P4) JDK-8257971: (fs) Remove unused code from WindowsPath.subpath(begin, end) (P4) JDK-8030048: (fs) Support UserDefinedFileAttributeView/extended attributes on OS X / HFS+ (P4) JDK-8262958: (fs) UnixUserDefinedFileAttributeView cleanup (P4) JDK-8264400: (fs) WindowsFileStore equality depends on how the FileStore was constructed (P4) JDK-8265100: (fs) WindowsFileStore.hashCode() should read cached hash code once (P4) JDK-8266369: (se) Add wepoll based Selector (P4) JDK-8253478: (se) epoll Selector should use eventfd for wakeup instead of pipe (P4) JDK-8264031: (zipfs) Typo in ZipFileSystem.deleteFile ZipException (P4) JDK-8265448: (zipfs): Reduce read contention in ZipFileSystem (P4) JDK-8264762: ByteBuffer.byteOrder(BIG_ENDIAN).asXBuffer.put(Xarray) and ByteBuffer.byteOrder(nativeOrder()).asXBuffer.put(Xarray) are slow (P4) JDK-8264779: Fix doclint warnings in java/nio (P4) JDK-8264539: Improve failure message of java/nio/file/WatchService/SensitivityModifier.java (P4) JDK-8259274: Increase timeout duration in sun/nio/ch/TestMaxCachedBufferSize.java (P4) JDK-8257966: Instrument test/jdk/java/nio/channels/spi/SelectorProvider/inheritedChannel/StateTestService.java (P4) JDK-8264200: java/nio/channels/DatagramChannel/SRTest.java fails intermittently (P4) JDK-8129776: The optimized Stream returned from Files.lines should unmap the mapped byte buffer (if created) when closed (P4) JDK-8257074: Update the ByteBuffers micro benchmark (P4) JDK-8252971: WindowsFileAttributes does not know about Unix domain sockets (P5) JDK-8241619: (fs) Files.newByteChannel(path, Set.of(CREATE_NEW, READ)) does not throw a FileAlreadyExistsException when the file exists (P5) JDK-8264112: (fs) Reorder methods/constructor/fields in UnixUserDefinedFileAttributeView.java (P5) JDK-8266820: micro java/nio/SelectorWakeup.java has wrong copyright header core-libs/java.nio.charsets: (P3) JDK-8261744: Implement CharsetDecoder ASCII and latin-1 fast-paths (P4) JDK-8263890: Broken links to Unicode.org (P4) JDK-8263979: Cleanup duplicate check in Unicode.contains (P4) JDK-8261254: Initialize charset mapping data lazily (P4) JDK-8261418: Reduce decoder creation overheads for sun.nio.cs.ext Charsets (P5) JDK-8264332: Use the blessed modifier order in jdk.charsets core-libs/java.rmi: (P3) JDK-8263550: JEP 407: Remove RMI Activation (P4) JDK-8267544: (test) rmi test NonLocalSkeleton fails if network has multiple adapters with the same address (P4) JDK-8267123: Remove RMI Activation core-libs/java.sql: (P4) JDK-8263885: Use the blessed modifier order in java.sql/rowset/transation.xa core-libs/java.text: (P3) JDK-8266784: java/text/Collator/RuleBasedCollatorTest.java fails with jtreg 6 (P3) JDK-8262108: SimpleDateFormat formatting broken for sq_MK Locale (P4) JDK-8264765: BreakIterator sees bogus sentence boundary in parenthesized “i.e.” phrase (P4) JDK-8259528: Broken Link for [java.text.Normalizer.Form] (P4) JDK-8261728: SimpleDateFormat should link to DateTimeFormatter (P4) JDK-8269704: Typo in j.t.Normalizer.normalize() core-libs/java.time: (P3) JDK-8260356: (tz) Upgrade time-zone data to tzdata2021a (P3) JDK-8246788: ZoneRules invariants can be broken (P4) JDK-8259048: (tz) Upgrade time-zone data to tzdata2020f (P4) JDK-8266846: Add java.time.InstantSource (P4) JDK-8263668: Update java.time to use instanceof pattern variable (P4) JDK-8265746: Update java.time to use instanceof pattern variable (part II) core-libs/java.util: (P1) JDK-8264729: Random check-in failing header checks. (P2) JDK-8267939: Clarify the specification of iterator and spliterator forEachRemaining (P2) JDK-8266527: RandomTestCoverage.java failing due to API removal (P3) JDK-8148937: (str) Adapt StringJoiner for Compact Strings (P3) JDK-8265208: [JEP-356] : SplittableRandom and SplittableGenerators - splits() methods does not throw NullPointerException when source is null (P3) JDK-8248862: Implement Enhanced Pseudo-Random Number Generators (P3) JDK-8265137: java.util.Random suddenly has new public methods nowhere documented (P3) JDK-8264512: jdk/test/jdk/java/util/prefs/ExportNode.java relies on default platform encoding (P3) JDK-8265279: Remove unused RandomGeneratorFactory.all(Class category) (P3) JDK-8266552: Technical corrections to java/util/random/package-info.java (P4) JDK-8260561: [doc] HexFormat has incorrect @since tag (P4) JDK-8247373: ArraysSupport.newLength doc, test, and exception message (P4) JDK-8267452: Delegate forEachRemaining in Spliterators.iterator() (P4) JDK-8251989: Hex formatting and parsing utility (P4) JDK-8263754: HexFormat 'fromHex' methods should be static (P4) JDK-8265496: Improve null check in DeflaterOutputStream/InflaterInputStream (P4) JDK-8260221: java.util.Formatter throws wrong exception for mismatched flags in %% conversion (P4) JDK-8258584: java/util/HexFormat/HexFormatTest.java fails on x86_32 (P4) JDK-8264791: java/util/Random/RandomTestBsi1999.java failed "java.security.SecureRandom nextFloat consecutive" (P4) JDK-8264976: Minor numeric bug in AbstractSplittableWithBrineGenerator.makeSplitsSpliterator (P4) JDK-8261306: ServiceLoader documentation has malformed Unicode escape (P4) JDK-8260401: StackOverflowError on open WindowsPreferences (P4) JDK-8265237: String.join and StringJoiner can be improved further (P4) JDK-8267587: Update java.util to use enhanced switch (P4) JDK-8267110: Update java.util to use instanceof pattern variable (P4) JDK-8263903: Use Cleaner instead of finalize to auto stop Timer thread (P5) JDK-8264514: HexFormat implementation tweaks core-libs/java.util.concurrent: (P2) JDK-8259800: timeout in tck test testForkJoin(ForkJoinPool8Test) (P3) JDK-8246585: ForkJoin updates (P3) JDK-8229253: forkjoin/FJExceptionTableLeak.java fails "AssertionError: failed to satisfy condition" (P3) JDK-8264572: ForkJoinPool.getCommonPoolParallelism() reports always 1 (P3) JDK-8258187: IllegalMonitorStateException in ArrayBlockingQueue (P3) JDK-8234131: Miscellaneous changes imported from jsr166 CVS 2021-01 (P3) JDK-8260461: Modernize jsr166 tck tests (P4) JDK-8254973: CompletableFuture.ThreadPerTaskExecutor does not throw NPE in #execute (P4) JDK-8246677: LinkedTransferQueue and SynchronousQueue synchronization updates (P4) JDK-8260664: Phaser.arrive() memory consistency effects (P4) JDK-8258217: PriorityBlockingQueue constructor spec and behavior mismatch (P4) JDK-8257671: ThreadPoolExecutor.Discard*Policy: rejected tasks are not cancelled core-libs/java.util.jar: (P2) JDK-8260010: UTF8ZipCoder not thread-safe since JDK-8243469 (P4) JDK-8260617: Merge ZipFile encoding check with the initial hash calculation (P4) JDK-8259867: Move encoding checks into ZipCoder core-libs/java.util.logging: (P3) JDK-8252883: AccessDeniedException caused by delayed file deletion on Windows (P4) JDK-8266646: Add more diagnostic to java/lang/System/LoggerFinder/modules (P4) JDK-8263382: java/util/logging/ParentLoggersTest.java failed with "checkLoggers: getLoggerNames() returned unexpected loggers" (P5) JDK-8265961: Fix comments in logging.properties (P5) JDK-8264091: Use the blessed modifier order in java.logging core-libs/java.util.regex: (P3) JDK-8259074: regex benchmarks and tests (P4) JDK-8037397: RegEx pattern matching loses character class after intersection (&&) operator core-libs/java.util.stream: (P4) JDK-8265029: Preserve SIZED characteristics on slice operations (skip, limit) (P4) JDK-8252399: Update mapMulti documentation to use type test pattern instead of instanceof once JEP 375 exits preview (P5) JDK-8259816: Typo in java.util.stream package description core-libs/java.util:collections: (P3) JDK-8193031: Collections.addAll is likely to perform worse than Collection.addAll (P3) JDK-8259622: TreeMap.computeIfAbsent deviates from spec (P4) JDK-6323374: (coll) Optimize Collections.unmodifiable* and synchronized* (P4) JDK-8199318: add idempotent copy operation for Map.Entry (P4) JDK-8247402: Documentation for Map::compute contains confusing implementation requirements (P4) JDK-8268077: java.util.List missing from Collections Framework Overview core-libs/java.util:i18n: (P3) JDK-8187649: ArrayIndexOutOfBoundsException in java.util.JapaneseImperialCalendar (P3) JDK-8265375: Bootcycle builds fail with StackOverflowError in cldrconverter (P3) JDK-8269513: Clarify the spec wrt `useOldISOCodes` system property (P3) JDK-8262110: DST starts from incorrect time in 2038 (P3) JDK-8261179: Norwegian Bokmål Locale fallback issue (P3) JDK-8258794: Support for CLDR version 39 (P3) JDK-8073446: TimeZone getOffset API does not return a DST offset between years 2038-2137 (P4) JDK-8263090: Avoid reading volatile fields twice in Locale.getDefault(Category) (P4) JDK-8257964: Broken Calendar#getMinimalDaysInFirstWeek with java.locale.providers=HOST (P4) JDK-8261919: java/util/Locale/LocaleProvidersRun.java failed with "RuntimeException: Expected log was not emitted. LogRecord: null" (P4) JDK-8261279: sun/util/resources/cldr/TimeZoneNamesTest.java timed out (P4) JDK-8263202: Update Hebrew/Indonesian/Yiddish ISO 639 language codes to current (P4) JDK-8258795: Update IANA Language Subtag Registry to Version 2021-05-11 core-libs/javax.lang.model: (P3) JDK-8261625: Add `Elements.isAutomaticModule(ModuleElement)` (P3) JDK-8265319: implement Sealed Classes as a standard feature in Java, javax.lang.model changes (P3) JDK-8267861: Update SourceVersion with new language features in 16 and 17 (P4) JDK-8257451: Add SourceVersion.RELEASE_17 (P4) JDK-8258535: jvm.ClassReader should set the accessor to the corresponding record component (P4) JDK-8005295: Use mandated information for printing of repeating annotations core-libs/javax.naming: (P3) JDK-8258753: StartTlsResponse.close() hangs due to synchronization issues (P4) JDK-8265309: com/sun/jndi/dns/ConfigTests/Timeout.java fails with "Address already in use" BindException (P4) JDK-8259707: LDAP channel binding does not work with StartTLS extension (P4) JDK-8263855: Use the blessed modifier order in java.management/naming (P4) JDK-8260506: VersionHelper cleanup (P5) JDK-8263509: LdapSchemaParser.readNextTag checks array length incorrectly (P5) JDK-8048199: Replace anonymous inner classes with lambdas, where applicable, in JNDI core-libs/javax.script: (P4) JDK-8264326: Modernize javax.script.ScriptEngineManager and related classes' implementation core-libs/jdk.nashorn: (P3) JDK-8198540: Dynalink leaks memory when generating type converters (P3) JDK-8261483: jdk/dynalink/TypeConverterFactoryMemoryLeakTest.java failed with "AssertionError: Should have GCd a method handle by now" (P4) JDK-8262503: Support records in Dynalink core-svc: (P4) JDK-8254001: [Metrics] Enhance parsing of cgroup interface files for version detection (P4) JDK-8262379: Add regression test for JDK-8257746 (P4) JDK-8261131: jcmd jmap dump should not accept gz option with no value (P4) JDK-8266391: Replace use of reflection in jdk.internal.platform.Metrics core-svc/debugger: (P3) JDK-8265028: JDWP debug agent thread lookup can be made faster (P3) JDK-8262486: Merge trivial JDWP agent changes from the loom repo to the jdk repo (P3) JDK-8221503: vmTestbase/nsk/jdb/eval/eval001/eval001.java fails with: com.sun.jdi.InvalidTypeException: Can't assign double[][][] to double[][][] (P4) JDK-8259266: com/sun/jdi/JdbOptions.java failed with "RuntimeException: 'prop[boo] = >foo 2<' missing from stdout/stderr" (P4) JDK-8260878: com/sun/jdi/JdbOptions.java fails without jfr (P4) JDK-8253940: com/sun/jdi/JdwpAttachTest.java failed with "RuntimeException: ERROR: LingeredApp.startApp was able to attach" (P4) JDK-8259577: Dangling reference to temp_path in Java_sun_tools_attach_VirtualMachineImpl_getTempDir (P4) JDK-8224775: test/jdk/com/sun/jdi/JdwpListenTest.java failed to attach (P4) JDK-8265683: vmTestbase/nsk/jdb tests failed with "JDWP exit error AGENT_ERROR_INTERNAL(181)" (P5) JDK-8259350: Add some internal debugging APIs to the debug agent (P5) JDK-8263323: Debug Agent help output includes invalid URL core-svc/java.lang.instrument: (P3) JDK-8165276: Spec states to invoke the premain method in an agent class if it's public but implementation differs (P4) JDK-8260707: java/lang/instrument/PremainClass/InheritAgent0100.java times out (P4) JDK-8262002: java/lang/instrument/VerifyLocalVariableTableOnRetransformTest.sh failed with "TestCaseScaffoldException: DummyClassWithLVT did not match .class file" (P4) JDK-8266187: Memory leak in appendBootClassPath() core-svc/java.lang.management: (P4) JDK-8265153: add time based test for ThreadMXBean.getThreadInfo() and ThreadInfo.getLockOwnerName() (P4) JDK-8265104: CpuLoad and SystemCpuLoad in OperatingSystem MXBean returns -1.0 (P4) JDK-8268103: JNI functions incorrectly return a double after JDK-8265836 (P4) JDK-8258836: JNI local refs exceed capacity getDiagnosticCommandInfo (P4) JDK-8265836: OperatingSystemImpl.getCpuLoad() returns incorrect CPU load inside a container (P4) JDK-8260448: Simplify ManagementFactory$PlatformMBeanFinder core-svc/javax.management: (P3) JDK-8264124: Update MXBean specification and implementation to extend mapping of CompositeType to records (P4) JDK-8266567: Fix javadoc tag references in sun.management.jmxremote.ConnectorBootstrap (P4) JDK-8264028: Typo in javax.management.relation.RelationService::purgeRelations core-svc/tools: (P3) JDK-8228343: JCMD and attach fail to work across Linux Container boundary (P3) JDK-8196743: jstatd doesn't see new Java processes inside Docker container (P3) JDK-8237388: serviceability/dcmd/framework/VMVersionTest.java fails with connection refused error. (P4) JDK-8257234: Add gz option to SA jmap to write a gzipped heap dump (P4) JDK-8261034: improve jcmd GC.class_histogram to support parallel (P4) JDK-8258593: remove redundant codes in HeapObjectDumper (P4) JDK-8265612: revise the help info for jmap histo command (P5) JDK-8264396: Use the blessed modifier order in jdk.internal.jvmstat docs: (P3) JDK-8264730: Document java-options limitations docs/guides: (P2) JDK-8266022: Update jdk.certpath.disabledAlgorithms and jdk.jar.disabledAlgorithms in the JSSE Reference Guide (P3) JDK-8264204: Clarify note in section "Resuming Session Without Server-Side State" in JSSE Reference Guide (P3) JDK-8260311: Document New System Properties to configure TLS extensions (P3) JDK-8260390: Document new system property to enable the OCSP nonce extension (P3) JDK-8262373: Document the deprecation of 3DES and RC4 types (P3) JDK-8260556: Update Security Guide for Enable XML Signature secure validation mode by default (P3) JDK-8265006: Update SunPKCS11 provider guide with ChaCha20-Poly1305 cipher and ChaCha20 key gen (P4) JDK-8262375: Document jpackage Mac App Store signing. (P4) JDK-8266342: Typo in bug reporting instructions (P4) JDK-8265717: Update Java Virtual Machine Guide about CDS support for ZGC (P4) JDK-8263681: Update Kerberos 5 Mechanism security guide (P4) JDK-8260195: Update the Trouble-shooting Guide for option -Xcheck:jni docs/hotspot: (P3) JDK-8266614: update manpage for -Xlog:async docs/release_notes: (P4) JDK-8261856: Documenting the implementation specific features and properties docs/tools: (P4) JDK-8263203: jconsole Online User Guide has wrong URL hotspot: (P4) JDK-8261356: Clean up enum G1Mark (P4) JDK-8262099: jcmd VM.metaspace should report unlimited size if MaxMetaspaceSize isn't specified (P4) JDK-8265323: Leftover local variables in PcDesc hotspot/compiler: (P1) JDK-8259629: aarch64 builds fail after JDK-8258932 (P1) JDK-8267237: ARM32: bad AD file in matcher.cpp after 8266810 (P1) JDK-8268461: ARM32: vector intrinsics reaches ShouldNotReachHere (P1) JDK-8269580: assert(is_valid()) failed: invalid register (-1) (P1) JDK-8267357: build breaks with -Werror option on micro benchmark added for JDK-8256973 (P1) JDK-8258438: build error in test/hotspot/gtest/runtime/test_os.cpp (P1) JDK-8268289: build failure due to missing signed flag in x86 evcmpb instruction (P1) JDK-8261659: JDK-8261027 causes a Tier1 validate-source failure (P1) JDK-8269528: VectorAPI Long512VectorTest fails on X86 KNL target (P1) JDK-8264759: x86_32 Minimal VM build failure after JDK-8262355 (P1) JDK-8268125: ZGC: Clone oop array gets wrong acopy stub (P2) JDK-8265084: [BACKOUT] 8264954: unified handling for VectorMask object re-materialization during de-optimization (P2) JDK-8258015: [JVMCI] JVMCI_lock shouldn't be held while initializing box classes (P2) JDK-8268052: [JVMCI] non-default installed code must be marked as in_use (P2) JDK-8261522: [PPC64] AES intrinsics write beyond the destination array (P2) JDK-8269879: [PPC64] C2: Math.rint intrinsic uses wrong rounding mode (P2) JDK-8268362: [REDO] C2 crash when compile negative Arrays.copyOf length after loop (P2) JDK-8267370: [Vector API] Fix several crashes after JDK-8256973 (P2) JDK-8267531: [x86] Assembler::andb(Address,Register) encoding is incorrect (P2) JDK-8268739: AArch64: Build failure after JDK-8267663 (P2) JDK-8261142: AArch64: Incorrect instruction encoding when right-shifting vectors with shift amount equals to the element width (P2) JDK-8261660: AArch64: Race condition in stub code generation for LSE Atomics (P2) JDK-8268676: assert(!ik->is_interface() && !ik->has_subklass()) failed: inconsistent klass hierarchy (P2) JDK-8265132: C2 compilation fails with assert "missing precedence edge" (P2) JDK-8261812: C2 compilation fails with assert(!had_error) failed: bad dominance (P2) JDK-8263303: C2 compilation fails with assert(found_sfpt) failed: no node in loop that's not input to safepoint (P2) JDK-8267904: C2 crash when compile negative Arrays.copyOf length after loop (P2) JDK-8269088: C2 fails with assert(!n->is_Store() && !n->is_LoadStore()) failed: no node with a side effect (P2) JDK-8266615: C2 incorrectly folds subtype checks involving an interface array (P2) JDK-8267652: c2 loop unrolling by 8 results in reading memory past array (P2) JDK-8267988: C2: assert(!addp->is_AddP() || addp->in(AddPNode::Base)->is_top() || addp->in(AddPNode::Base) == n->in(AddPNode::Base)) failed: Base pointers must match (addp 1301) (P2) JDK-8263189: C2: assert(!had_error) failed: bad dominance (P2) JDK-8268672: C2: assert(!loop->is_member(u_loop)) failed: can be in outer loop or out of both loops only (P2) JDK-8269575: C2: assert(false) failed: graph should be schedulable after JDK-8252372 (P2) JDK-8268883: C2: assert(false) failed: unscheduable graph (P2) JDK-8268017: C2: assert(phi_type->isa_int() || phi_type->isa_ptr() || phi_type->isa_long()) failed: bad phi type (P2) JDK-8263587: C2: JVMS not cloned when needs_clone_jvms() is true (P2) JDK-8268347: C2: nested locks optimization may create unbalanced monitor enter/exit code (P2) JDK-8261147: C2: Node is wrongly marked as reduction resulting in a wrong execution due to wrong vector instructions (P2) JDK-8262295: C2: Out-of-Bounds Array Load from Clone Source (P2) JDK-8268301: Closed test: compiler/c2/6371167/Test.java fails after JDK-8267904 (P2) JDK-8261912: Code IfNode::fold_compares_helper more defensively (P2) JDK-8269775: compiler/codegen/ClearArrayTest.java failed with "assert(false) failed: bad AD file" (P2) JDK-8269828: corrections in some instruction patterns for KNL x86 platform (P2) JDK-8269285: Crash/miscompile in CallGenerator::for_method_handle_inline after JDK-8191998 (P2) JDK-8267424: CTW: C1 fails with "State must not be null" (P2) JDK-8266257: Fix foreign linker build issues for ppc and s390 (P2) JDK-8261022: Fix incorrect result of Math.abs() with char type (P2) JDK-8265105: gc/arguments/TestSelectDefaultGC.java fails when compiler1 is disabled (P2) JDK-8261914: IfNode::fold_compares_helper faces non-canonicalized bool when running JRuby JSON workload (P2) JDK-8253795: Implementation of JEP 391: macOS/AArch64 Port (P2) JDK-8266480: Implicit null check optimization does not update control of hoisted memory operation (P2) JDK-8263361: Incorrect arraycopy stub selected by C2 for SATB collectors (P2) JDK-8264940: java/lang/invoke/6998541/Test6998541.java failed "guarantee(ik->is_initialized()) failed: java/lang/Byte$ByteCache must be initialized" (P2) JDK-8262093: java/util/concurrent/tck/JSR166TestCase.java failed "assert(false) failed: unexpected node" (P2) JDK-8267773: PhaseStringOpts::int_stringSize doesn't handle min_jint correctly (P2) JDK-8262739: String inflation C2 intrinsic prevents insertion of anti-dependencies (P2) JDK-8267117: sun/hotspot/whitebox/CPUInfoTest.java fails on Ice Lake (P2) JDK-8253816: Support macOS W^X (P2) JDK-8263753: two new tests from JDK-8261671 fail with "Error. can not find ClassFileInstaller in test directory or libraries" (P2) JDK-8253839: Update tests and JDK code for macOS/Aarch64 (P3) JDK-8265784: [C2] Hoisting of DecodeN leaves MachTemp inputs behind (P3) JDK-8268641: [foreign] assert(allocates2(pc)) failed: not in CodeBuffer memory with ShenandoahGC (P3) JDK-8263776: [JVMCI] add helper to perform Java upcalls (P3) JDK-8264016: [JVMCI] add some thread local fields for use by JVMCI (P3) JDK-8261846: [JVMCI] c2v_iterateFrames can get out of sync with the StackFrameStream (P3) JDK-8264918: [JVMCI] getVtableIndexForInterfaceMethod doesn't check that type and method are related (P3) JDK-8263403: [JVMCI] output written to tty via HotSpotJVMCIRuntime can be garbled (P3) JDK-8258625: [JVMCI] refactor and unify JVMCI readFieldValue path (P3) JDK-8269745: [JVMCI] restore original qualified exports to Graal (P3) JDK-8262894: [macos_aarch64] SIGBUS in Assembler::ld_st2 (P3) JDK-8265126: [REDO] unified handling for VectorMask object re-materialization during de-optimization (P3) JDK-8268966: AArch64: 'bad AD file' in some vector conversion tests (P3) JDK-8262726: AArch64: C1 StubAssembler::call_RT can corrupt stack (P3) JDK-8264018: AArch64: NEON loadV2 and storeV2 addressing is wrong (P3) JDK-8263676: AArch64: one potential bug in C1 LIRGenerator::generate_address() (P3) JDK-8261649: AArch64: Optimize LSE atomics in C++ code (P3) JDK-8261027: AArch64: Support for LSE atomics C++ HotSpot code (P3) JDK-8263425: AArch64: two potential bugs in C1 LIRGenerator::generate_address() (P3) JDK-8269260: Add AVX512 and other SSE + AVX combinations testing for tests which generate vector instructions (P3) JDK-8262476: Add filter to speed up CompileCommand lookup (P3) JDK-8259339: AllocateUninitializedArray C2 intrinsic fails with void.class input (P3) JDK-8260716: Assert in MacroAssembler::clear_mem with -XX:-IdealizeClearArrayNode (P3) JDK-8266288: assert root method not found in witnessed_reabstraction_in_supers is too strong (P3) JDK-8263164: assert(_base >= VectorA && _base <= VectorZ) failed: Not a Vector while calling StoreVectorNode::memory_size() (P3) JDK-8238812: assert(false) failed: bad AD file (P3) JDK-8269771: assert(tmp == _callprojs.fallthrough_catchproj) failed: allocation control projection (P3) JDK-8263352: assert(use == polladr) failed: the use should be a safepoint polling (P3) JDK-8269063: Build failure due to VerifyReceiverTypes was not declared after JDK-8268405 (P3) JDK-8261235: C1 compilation fails with assert(res->vreg_number() == index) failed: conversion check (P3) JDK-8259619: C1: 3-arg StubAssembler::call_RT stack-use condition is incorrect (P3) JDK-8267806: C1: Relax inlining checks for not yet initialized classes (P3) JDK-8264958: C2 compilation fails with assert "n is later than its clone" (P3) JDK-8259236: C2 compilation fails with assert(is_power_of_2(value)) failed: value must be a power of 2: 8000000000000000 (P3) JDK-8261730: C2 compilation fails with assert(store->find_edge(load) != -1) failed: missing precedence edge (P3) JDK-8266028: C2 computes -0.0 for Math.pow(-0.0, 0.5) (P3) JDK-8263971: C2 crashes with SIGFPE with -XX:+StressGCM and -XX:+StressIGVN (P3) JDK-8265938: C2's conditional move optimization does not handle top Phi (P3) JDK-8258243: C2: assert failed ("Bad derived pointer") with -XX:+VerifyRegisterAllocator (P3) JDK-8269746: C2: assert(!in->is_CFG()) failed: CFG Node with no controlling input? (P3) JDK-8257513: C2: assert((constant_addr - _masm.code()->consts()->start()) == con.offset()) (P3) JDK-8268371: C2: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed (P3) JDK-8256934: C2: assert(C->live_nodes() <= C->max_node_limit()) failed: Live Node limit exceeded limit (P3) JDK-8259430: C2: assert(in_vt->length() == out_vt->length()) failed: mismatch on number of elements (P3) JDK-8261308: C2: assert(inner->is_valid_counted_loop(T_INT) && inner->is_strip_mined()) failed: OuterStripMinedLoop should have been removed (P3) JDK-8262017: C2: assert(n != __null) failed: Bad immediate dominator info. (P3) JDK-8268884: C2: Compile::remove_speculative_types must iterate top-down (P3) JDK-8267807: C2: Downcast receiver to target holder during inlining (P3) JDK-8263227: C2: inconsistent spilling due to dead nodes in exception block (P3) JDK-8267399: C2: java/text/Normalizer/ConformanceTest.java test failed with assertion (P3) JDK-8263972: C2: LoadVector/StoreVector type mismatch in MemNode::can_see_stored_value() (P3) JDK-8269230: C2: main loop in micro benchmark never executed (P3) JDK-8241502: C2: Migrate x86_64.ad to MacroAssembler (P3) JDK-8065760: CHA: Improve abstract method support (P3) JDK-8036580: CHA: Improve default method support (P3) JDK-8263891: Changes for 8076985 missed the fix. (P3) JDK-8252372: Check if cloning is required to move loads out of loops in PhaseIdealLoop::split_if_with_blocks_post() (P3) JDK-8260407: cmp != __null && cmp->Opcode() == Op_CmpL failure with -XX:StressLongCountedLoop=200000000 in lucene (P3) JDK-8264223: CodeHeap::verify fails extra_hops assertion in fastdebug test (P3) JDK-8257800: CompileCommand TypedMethodOptionMatcher::parse_method_pattern() may over consume (P3) JDK-8258225: compiler/c2/cr6340864/TestIntVect.java runs faster in interpreter (P3) JDK-8265767: compiler/eliminateAutobox/TestIntBoxing.java crashes on arm32 after 8264649 in debug VMs (P3) JDK-8268482: compiler/intrinsics/VectorizedMismatchTest.java failed with failed: length in range (P3) JDK-8269517: compiler/loopopts/TestPartialPeelingSinkNodes.java crashes with -XX:+VerifyGraphEdges (P3) JDK-8263501: compiler/oracle/TestInvalidCompileCommand.java fails with release VMs (P3) JDK-8269952: compiler/vectorapi/VectorCastShape*Test.java tests failed on avx2 machines (P3) JDK-8269179: Crash in TestMacroLogicVector::testSubWordBoolean: assert(_base >= VectorMask && _base <= VectorZ) failed: Not a Vector (P3) JDK-8263376: CTW (Shenandoah): assert(mems <= 1) failed: No node right after call if multiple mem projections (P3) JDK-8263448: CTW: fatal error: meet not symmetric (P3) JDK-8259508: CtwOfSpecJvm.java fails on MacOSX with _os_unfair_lock_recursive_abort in TDescriptorSource::CopySplicedDescriptorForName (P3) JDK-8261954: Dependencies: Improve iteration over class hierarchy under context class (P3) JDK-8265917: Different values computed by C2 and interpreter/C1 for Math.pow(x, 2.0) on x86_32 (P3) JDK-8263125: During deoptimization vectors should reassign scalarized payload after all objects are reallocated. (P3) JDK-8263672: fatal error: no reachable node should have no use (P3) JDK-8264006: Fix AOT library loading on CPUs with 256-byte dcache line (P3) JDK-8259475: Fix bad merge in compilerOracle (P3) JDK-8262298: G1BarrierSetC2::step_over_gc_barrier fails with assert "bad barrier shape" (P3) JDK-8259937: guarantee(loc != NULL) failed: missing saved register with native invoker (P3) JDK-8262837: handle split_USE correctly (P3) JDK-8263167: IGV: build fails with "taskdef AutoUpdate cannot be found" (P3) JDK-8261931: IGV: quick search fails on multi-line node labels (P3) JDK-8264795: IGV: Upgrade NetBeans platform (P3) JDK-8258746: illegal access to global field _jvmci_old_thread_counters by terminated thread causes crash (P3) JDK-8268366: Incorrect calculation of has_fpu_registers in C1 linear scan (P3) JDK-8259777: Incorrect predication condition generated by ADLC (P3) JDK-8259710: Inlining trace leaks memory (P3) JDK-8265956: JVM crashes when matching LShiftVB Node (P3) JDK-8265907: JVM crashes when matching VectorMaskCmp Node (P3) JDK-8269568: JVM crashes when running VectorMask query tests (P3) JDK-8268478: JVMCI tests failing after JDK-8268052 (P3) JDK-8265689: JVMCI: InternalError: Class java.lang.Object does not implement interface jdk.vm.ci.meta.JavaType (P3) JDK-8266854: LibraryCallKit::inline_preconditions_checkIndex modifies control flow even if the intrinsic bailed out (P3) JDK-8264360: Loop strip mining verification fails with "should be on the backedge" (P3) JDK-8261229: MethodData is not correctly initialized with TieredStopAtLevel=3 (P3) JDK-8263017: Read barriers are missing in nmethod printing code (P3) JDK-8266518: Refactor and expand scatter/gather tests (P3) JDK-8269304: Regression ~5% in 2005 in b27 (P3) JDK-8240281: Remove failing assertion code when selecting first memory state in SuperWord::co_locate_pack (P3) JDK-8264649: runtime/InternalApi/ThreadCpuTimesDeadlock.java crash in fastdebug C2 with -XX:-UseTLAB (P3) JDK-8269246: Scoped ByteBuffer vector access (P3) JDK-8268405: Several regressions 4-17% after CHA changes (P3) JDK-8256215: Shenandoah: re-organize saving/restoring machine state in assembler code (P3) JDK-8264320: ShouldNotReachHere in Compile::print_inlining_move_to() (P3) JDK-8268369: SIGSEGV in PhaseCFG::implicit_null_check due to missing null check (P3) JDK-8251462: Simplify compilation policy (P3) JDK-8260338: Some fields in HaltNode is not cloned (P3) JDK-8259398: Super word not applied to a loop with byteArrayViewVarHandle (P3) JDK-8259584: SuperWord::fix_commutative_inputs checks in_bb(fin1) instead of in_bb(fin2) (P3) JDK-8260650: test failed with "assert(false) failed: infinite loop in PhaseIterGVN::optimize" (P3) JDK-8268353: Test libsvml.so is and is not present in jdk image (P3) JDK-8267212: test/jdk/java/util/Collections/FindSubList.java intermittent crash with "no reachable node should have no use" (P3) JDK-8269335: Unable to load svml library (P3) JDK-8264954: unified handling for VectorMask object re-materialization during de-optimization (P3) JDK-8260653: Unreachable nodes keep speculative types alive (P3) JDK-8257772: Vectorizing clear memory operation using AVX-512 masked operations (P3) JDK-8262465: Very long compilation times and high memory consumption in C2 debug builds (P3) JDK-8265154: vinserti128 operand mix up for KNL platforms (P3) JDK-8265349: vmTestbase/../stress/compiler/deoptimize/Test.java fails with OOME due to CodeCache exhaustion. (P3) JDK-8266074: Vtable-based CHA implementation (P4) JDK-8259846: [BACKOUT] JDK-8259278 Optimize Vector API slice and unslice operations (P4) JDK-8262011: [JVMCI] allow printing to tty from unattached libgraal thread (P4) JDK-8266923: [JVMCI] expose StackOverflow::_stack_overflow_limit to JVMCI (P4) JDK-8252600: [JVMCI] remove mx configuration (P4) JDK-8267338: [JVMCI] revive JVMCI API removed by JDK-8243287 (P4) JDK-8258715: [JVMCI] separate JVMCI code install timers for CompileBroker and hosted compilations (P4) JDK-8260372: [PPC64] Add support for JDK-8210498 and JDK-8222841 (P4) JDK-8261657: [PPC64] Cleanup StoreCM nodes after CMS removal (P4) JDK-8256431: [PPC64] Implement Base64 encodeBlock() for Power64-LE (P4) JDK-8259822: [PPC64] Support the prefixed instruction format added in POWER10 (P4) JDK-8259316: [REDO] C1/C2 compiler support for blackholes (P4) JDK-8265128: [REDO] Optimize Vector API slice and unslice operations (P4) JDK-8264173: [s390] Improve Hardware Feature Detection And Reporting (P4) JDK-8260502: [s390] NativeMovRegMem::verify() fails because it's too strict (P4) JDK-8263260: [s390] Support latest hardware (z14 and z15) (P4) JDK-8260501: [Vector API] Improve register usage for shift operations on x86 (P4) JDK-8267663: [vector] Add unsigned comparison operators on AArch64 (P4) JDK-8266184: a few compiler/debug tests don't check exit code (P4) JDK-8267098: AArch64: C1 StubFrames end confusingly (P4) JDK-8258932: AArch64: Enhance floating-point Min/MaxReductionV with fminp/fmaxp (P4) JDK-8267616: AArch64: Fix AES assertion messages in stubGenerator_aarch64.cpp (P4) JDK-8261072: AArch64: Fix MacroAssembler::get_thread convention (P4) JDK-8264409: AArch64: generate better code for Vector API allTrue (P4) JDK-8256245: AArch64: Implement Base64 decoding intrinsic (P4) JDK-8256438: AArch64: Implement match rules with ROR shift register value (P4) JDK-8266609: AArch64: include FP/LR space in LIR_Assembler::initial_frame_size_in_bytes() (P4) JDK-8258953: AArch64: move NEON instructions to aarch64_neon.ad (P4) JDK-8264352: AArch64: Optimize vector "not/andNot" for NEON and SVE (P4) JDK-8264973: AArch64: Optimize vector max/min/add reduction of two integers with NEON pairwise instructions (P4) JDK-8261071: AArch64: Refactor interpreter native wrappers (P4) JDK-8263649: AArch64: update cas.m4 to match current AD file (P4) JDK-8264564: AArch64: use MOVI instead of FMOV to zero FP register (P4) JDK-8259287: AbstractCompiler marks const in wrong position for is_c1/is_c2/is_jvmci (P4) JDK-8263354: Accumulated C2 code cleanups (P4) JDK-8263200: Add -XX:StressCCP to CTW (P4) JDK-8266962: Add arch supporting check for "Op_VectorLoadConst" before creating the node (P4) JDK-8265480: add basic JVMCI support for JEP 309: Dynamic Class-File Constants (P4) JDK-8265129: Add intrinsic support for JVM.getClassId (P4) JDK-8263026: Add more documentation for the test framework (P4) JDK-8263006: Add optimization for Max(*)Node and Min(*)Node (P4) JDK-8268417: Add test from JDK-8268360 (P4) JDK-8264109: Add vectorized implementation for VectorMask.andNot() (P4) JDK-8267969: Add vectorized implementation for VectorMask.eq() (P4) JDK-8266332: Adler32 intrinsic for x86 64-bit platforms (P4) JDK-8263206: assert(*error_msg != '\0') failed: Must have error_message while parsing -XX:CompileCommand=unknown (P4) JDK-8265911: assert(comp != __null) failed: Compiler instance missing (P4) JDK-8263353: assert(CompilerOracle::option_matches_type(option, value)) failed: Value must match option type (P4) JDK-8264054: Bad XMM performance on java.lang.MathBench.sqrtDouble (P4) JDK-8263985: BCEscapeAnalyzer::invoke checks target->is_loaded() twice (P4) JDK-8259373: c1 and jvmci runtime code use ResetNoHandleMark incorrectly (P4) JDK-8264626: C1 should be able to inline excluded methods (P4) JDK-8265711: C1: Intrinsify Class.getModifier method (P4) JDK-8260255: C1: LoopInvariantCodeMotion constructor can leave some fields uninitialized (P4) JDK-8266798: C1: More types of instruction can also apply LoopInvariantCodeMotion (P4) JDK-8267239: C1: RangeCheckElimination for % operator if divisor is IntConstant (P4) JDK-8263679: C1: Remove vtable call (P4) JDK-8262299: C2 compilation fails with "modified node was not processed by IGVN.transform_old()" (P4) JDK-8259706: C2 compilation fails with assert(vtable_index == Method::invalid_vtable_index) failed: correct sentinel value (P4) JDK-8262256: C2 intrinsincs should not modify IR when bailing out (P4) JDK-8252237: C2: Call to compute_separating_interferences has wrong argument order (P4) JDK-8263781: C2: Cannot hoist independent load above arraycopy (P4) JDK-8267151: C2: Don't create dummy Opaque1Node for outmost unswitched IfNode (P4) JDK-8267979: C2: Fix verification code in SubTypeCheckNode::Ideal() (P4) JDK-8258894: C2: Forbid GCM to move stores into loops (P4) JDK-8263775: C2: igv_print() crash unexpectedly when called from debugger (P4) JDK-8266388: C2: Improve constant ShiftCntV on x86 (P4) JDK-8256535: C2: randomize CCP processing order for stress testing (P4) JDK-8263577: C2: reachable nodes shouldn't have dead uses at the end of optimizations (P4) JDK-8266328: C2: Remove InlineWarmCalls (P4) JDK-8265322: C2: Simplify control inputs for BarrierSetC2::obj_allocate (P4) JDK-8258653: CallJavaNode::_bci is not in use (P4) JDK-8255216: Change _directive->BreakAtCompileOption to env()->break_at_compile() (P4) JDK-8267947: CI: Preserve consistency between has_subklass() and is_subclass_of() (P4) JDK-8264151: ciMethod::ensure_method_data() should return false is loading resulted in empty state (P4) JDK-8265262: CITime - 'other' incorrectly calculated (P4) JDK-8266874: Clean up C1 canonicalizer for TableSwitch/LookupSwitch (P4) JDK-8258059: Clean up MethodData::profile_unsafe (P4) JDK-8263989: Cleanup in EA (P4) JDK-8266449: cleanup jtreg tags in compiler/intrinsics/sha/cli tests (P4) JDK-8266505: Cleanup LibraryCallKit::make_unsafe_address() (P4) JDK-8263615: Cleanup tightly_coupled_allocation (P4) JDK-8264957: Cleanup unused array Type::dual_type (P4) JDK-8261029: Code heap page sizes not traced correctly using os::trace_page_sizes (P4) JDK-8259035: Comments for load order of hsdis should be updated (P4) JDK-8266438: Compile::remove_useless_nodes does not remove opaque nodes (P4) JDK-8266232: compiler.c1.TestRangeCheckEliminated should be run in driver mode (P4) JDK-8266088: compiler/arguments/TestPrintOptoAssemblyLineNumbers test should user driver mode (P4) JDK-8266181: compiler/eliminateAutobox/TestEliminateBoxInDebugInfo should be in driver mode (P4) JDK-8263904: compiler/intrinsics/bmi/verifycode/BzhiTestI2L.java fails on x86_32 (P4) JDK-8258682: compiler/intrinsics/mathexact/sanity tests fail with RepeatCompilation (P4) JDK-8268292: compiler/intrinsics/VectorizedMismatchTest.java fails with release VMs (P4) JDK-8259928: compiler/jvmci tests fail with -Xint (P4) JDK-8266180: compiler/vectorapi/TestVectorErgonomics should be run in driver mode (P4) JDK-8262060: compiler/whitebox/BlockingCompilation.java timed out (P4) JDK-8265403: consolidate definition of CPU features (P4) JDK-8265783: Create a separate library for x86 Intel SVML assembly intrinsics (P4) JDK-8264466: Cut-paste error in InterfaceCalls JMH (P4) JDK-8258010: Debug build failure with clang-10 due to -Wdeprecated-copy (P4) JDK-8259288: Debug build failure with clang-10 due to -Wimplicit-int-float-conversion (P4) JDK-8266499: Delete dead code in aarch64.ad (P4) JDK-8265245: depChecker_ don't have any functionalities (P4) JDK-8264548: Dependencies: ClassHierarchyWalker::is_witness() cleanups (P4) JDK-8264546: Dependencies: Context class is always an InstanceKlass (P4) JDK-8264872: Dependencies: Migrate to PerfData counters (P4) JDK-8264871: Dependencies: Miscellaneous cleanups in dependencies.cpp (P4) JDK-8261250: Dependencies: Remove unused dependency types (P4) JDK-8264873: Dependencies: Split ClassHierarchyWalker (P4) JDK-8264748: Do not include arguments.hpp from compilerDefinitions.hpp (P4) JDK-8262323: do not special case JVMCI in tiered compilation policy (P4) JDK-8260250: Duplicate check in DebugInformationRecorder::recorders_frozen (P4) JDK-8265914: Duplicated NotANode and not_a_node (P4) JDK-8261553: Efficient mask generation using BMI2 BZHI instruction (P4) JDK-8264104: Eliminate unnecessary vector mask conversion during VectorUnbox for floating point VectorMask (P4) JDK-8265940: Enable C2's optimization for Math.pow(x, 0.5) on all platforms (P4) JDK-8252709: Enable JVMCI when building linux-aarch64 at Oracle (P4) JDK-8266601: Fix bugs in AddLNode::Ideal transformations (P4) JDK-8264885: Fix the code style of macro in aarch64_neon_ad.m4 (P4) JDK-8262819: gc/shenandoah/compiler/TestLinkToNativeRBP.java fails with release VMs (P4) JDK-8265816: Handle new VectorMaskCast node for x86 (P4) JDK-8263248: IGV: accept graphs without node categories (P4) JDK-8265125: IGV: cannot edit forms with NetBeans GUI builder (P4) JDK-8262462: IGV: cannot remove specific groups imported via network (P4) JDK-8259984: IGV: Crash when drawing control flow before GCM (P4) JDK-8262725: IGV: crash when removing all graphs in a group (P4) JDK-8264842: IGV: different nodes sharing idx are treated as equal (P4) JDK-8265106: IGV: Enforce en-US locale while parsing ideal graph (P4) JDK-8261336: IGV: enhance default filters (P4) JDK-8265440: IGV: make node selection more visible (P4) JDK-8265587: IGV: track nodes across matching (P4) JDK-8257882: Implement linkToNative intrinsic on AArch64 (P4) JDK-8262097: Improve CompilerConfig ergonomics to fix a VM crash after JDK-8261229 (P4) JDK-8258751: Improve ExceptionHandlerTable dump (P4) JDK-8259773: Incorrect encoding of AVX-512 kmovq instruction (P4) JDK-8260928: InitArrayShortSize constraint func should print a helpful error message (P4) JDK-8266316: Integration of Vector API (second incubator) (P4) JDK-8256973: Intrinsic creation for VectorMask query (lastTrue,firstTrue,trueCount) APIs (P4) JDK-8254129: IR Test Framework to support regex-based matching on the IR in JTreg compiler tests (P4) JDK-8255915: jdk/incubator/vector/AddTest.java timed out (P4) JDK-8259044: JVM lacks data type qualifier when using -XX:+PrintAssembly with AArch64-Neon backend (P4) JDK-8267112: JVMCI compiler modules should be kept upgradable (P4) JDK-8261158: JVMState should not be shared between SafePointNodes (P4) JDK-8258553: Limit number of fields in instance to be considered for scalar replacement (P4) JDK-8257802: LogCompilation throws couldn't find bytecode on JDK 8 log (P4) JDK-8258792: LogCompilation: remove redundant check fixed by 8257518 (P4) JDK-8260169: LogCompilation: Unexpected method mismatch (P4) JDK-8262064: Make compiler/ciReplay tests ignore lambdas in compilation replay (P4) JDK-8266573: Make sure blackholes are tagged for all JVMCI paths (P4) JDK-8261270: MakeMethodNotCompilableTest fails with -XX:TieredStopAtLevel={1,2,3} (P4) JDK-8266150: mark hotspot compiler/arguments tests which ignore VM flags (P4) JDK-8266231: mark hotspot compiler/c1 tests which ignore VM flags (P4) JDK-8266230: mark hotspot compiler/c2 tests which ignore VM flags (P4) JDK-8266190: mark hotspot compiler/codecache tests which ignore VM flags (P4) JDK-8266188: mark hotspot compiler/cpuflags tests which ignore VM flags (P4) JDK-8266264: mark hotspot compiler/eliminateAutobox tests which ignore VM flags (P4) JDK-8266238: mark hotspot compiler/inlining tests which ignore VM flags (P4) JDK-8266401: mark hotspot compiler/intrinsics/sha/cli tests which ignore VM flags (P4) JDK-8266175: mark hotspot compiler/jsr292 tests which ignore VM flags (P4) JDK-8266169: mark hotspot compiler/jvmci tests which ignore VM flags (P4) JDK-8266166: mark hotspot compiler/linkage tests which ignore VM flags (P4) JDK-8266164: mark hotspot compiler/loopstripmining tests which ignore VM flags (P4) JDK-8266153: mark hotspot compiler/onSpinWait tests which ignore VM flags (P4) JDK-8266154: mark hotspot compiler/oracle tests which ignore VM flags (P4) JDK-8266161: mark hotspot compiler/rtm tests which ignore VM flags (P4) JDK-8266149: mark hotspot compiler/startup tests which ignore VM flags (P4) JDK-8266265: mark hotspot compiler/vectorization tests which ignore VM flags (P4) JDK-8265491: Math Signum optimization for x86 (P4) JDK-8261447: MethodInvocationCounters frequently run into overflow (P4) JDK-8266973: Migrate to ClassHierarchyIterator when enumerating subclasses (P4) JDK-8260301: misc gc/g1/unloading tests fails with "RuntimeException: Method could not be enqueued for compilation at level N" (P4) JDK-8263909: misc tests timed out on a particular test machine (P4) JDK-8267687: ModXNode::Ideal optimization is better than Parse::do_irem (P4) JDK-8256424: Move ciSymbol::symbol_name() to ciSymbols::symbol_name() (P4) JDK-8258961: move some fields of SafePointNode from public to protected (P4) JDK-8258074: Move some flags related to compiler to compiler_globals.hpp (P4) JDK-8266810: Move trivial Matcher code to cpu-specific header files (P4) JDK-8268174: Move x86-specific stub declarations into stubRoutines_x86.hpp (P4) JDK-8261675: ObjectValue::set_visited(bool) sets _visited false (P4) JDK-8261137: Optimization of Box nodes in uncommon_trap (P4) JDK-8266528: Optimize C2 VerifyIterativeGVN execution time (P4) JDK-8264020: Optimize double negation elimination (P4) JDK-8265325: Optimize StubRoutines::dpow() for Math.pow(x, 0.5) (P4) JDK-8264945: Optimize the code-gen for Math.pow(x, 0.5) (P4) JDK-8259278: Optimize Vector API slice and unslice operations (P4) JDK-8263058: Optimize vector shift with zero shift count (P4) JDK-8261008: Optimize Xor (P4) JDK-8264063: Outer Safepoint poll load should not reference the head of inner strip mined loop. (P4) JDK-8266951: Partial in-lining for vectorized mismatch operation using AVX512 masked instructions (P4) JDK-8266189: Remove C1 "IfInstanceOf" instruction (P4) JDK-8266561: Remove Compile::_save_argument_registers (P4) JDK-8266937: Remove Compile::reshape_address (P4) JDK-8260334: Remove deprecated sv_for_node_id() from Compile (P4) JDK-8268272: Remove JDK-8264874 changes because Graal was removed. (P4) JDK-8267800: Remove the '_dirty' set in BCEscapeAnalyzer (P4) JDK-8264805: Remove the experimental Ahead-of-Time Compiler (P4) JDK-8264806: Remove the experimental JIT compiler (P4) JDK-8266267: Remove unnecessary jumps in Intel Math Library StubRoutines (P4) JDK-8259583: Remove unused decode_env::_codeBuffer (P4) JDK-8262259: Remove unused variable in MethodLiveness::BasicBlock::compute_gen_kill_single (P4) JDK-8257498: Remove useless skeleton predicates (P4) JDK-8257137: Revise smov and umov in aarch64 assembler (P4) JDK-8260296: SA's dumpreplaydata fails (P4) JDK-8260637: Shenandoah: assert(_base == Tuple) failure during C2 compilation (P4) JDK-8263769: simplify PhaseMacroExpand::extract_call_projections() (P4) JDK-8264096: slowdebug jvm crashes when StrInflatedCopy match rule is not supported (P4) JDK-8261247: some compiler/whitebox/ tests fail w/ DeoptimizeALot (P4) JDK-8263504: Some OutputMachOpcodes fields are uninitialized (P4) JDK-8258772: Some runtime/cds tests fail with +LogCompilation or +StressX (P4) JDK-8262355: Support for AVX-512 opmask register allocation. (P4) JDK-8253818: Support macOS Aarch64 ABI for compiled wrappers (P4) JDK-8266165: TestNoWarningLoopStripMiningIterSet is runnable only on VM w/ G1, Shenandoah, Z and Epsilon (P4) JDK-8261225: TieredStopAtLevel should have no effect if TieredCompilation is disabled (P4) JDK-8260198: TypeInstPtr::dump2() emits multiple lines if Verbose is set (P4) JDK-8260576: Typo in compiler/runtime/safepoints/TestRegisterRestoring.java (P4) JDK-8259049: Uninitialized variable after JDK-8257513 (P4) JDK-8264480: Unreachable code in nmethod.cpp inside #ifdef DEBUG (P4) JDK-8264135: UnsafeGetStableArrayElement should account for different JIT implementation details (P4) JDK-8260577: Unused code in AbstractCompiler after Shark compiler removal (P4) JDK-8265967: Unused NullCheckNode forward declaration in node.hpp (P4) JDK-8264972: Unused TypeFunc declared in OptoRuntime (P4) JDK-8263612: Unused variables in C1 runtime (P4) JDK-8234930: Use MAP_JIT when allocating pages for code cache on macOS (P4) JDK-8247732: validate user-input intrinsic_ids in ControlIntrinsic (P4) JDK-8266317: Vector API enhancements (P4) JDK-8262096: Vector API fails to work due to VectorShape initialization exception (P4) JDK-8262998: Vector API intrinsincs should not modify IR when bailing out (P4) JDK-8268151: Vector API toShuffle optimization (P4) JDK-8262508: Vector API's ergonomics is incorrect (P4) JDK-8258856: VM build without C1/C2 fails after JDK-8243205 (P4) JDK-8258383: vmTestbase/gc/g1/unloading/tests/unloading_compilation_level[1,2,3] time out without TieredCompilation (P4) JDK-8264395: WB_EnqueueInitializerForCompilation fails with "method holder must be initialized" when called for uninitialized class (P4) JDK-8263582: WB_IsMethodCompilable ignores compiler directives (P4) JDK-8261671: X86 I2L conversion can be skipped for certain masked positive values (P4) JDK-8261542: X86 slice and unslice intrinsics for 256-bit byte/short vectors (P4) JDK-8267332: xor value should handle bounded values (P4) JDK-8258857: Zero: non-PCH release build fails after JDK-8258074 (P4) JDK-8267726: ZGC: array_copy_requires_gc_barriers too strict (P5) JDK-8261666: [mlvm] Remove WhiteBoxHelper (P5) JDK-8265915: adjust state_unloading_cycle compuation order in nmethod::is_unloading (P5) JDK-8263707: C1 RangeCheckEliminator support constant array and NewMultiArray (P5) JDK-8257709: C1: Double assignment in InstructionPrinter::print_stack (P5) JDK-8264359: Compiler directives should enable DebugNonSafepoints when PrintAssembly is requested (P5) JDK-8266251: compiler.inlining.InlineAccessors shouldn't do testing in driver VM (P5) JDK-8266256: compiler.vectorization.TestBufferVectorization does testing twice (P5) JDK-8266255: compiler/eliminateAutobox/TestEliminateBoxInDebugInfo.java uses wrong package name (P5) JDK-8263593: Fix multiple typos in hsdis README (P5) JDK-8258946: Fix optimization-unstable code involving signed integer overflow (P5) JDK-8260581: IGV: enhance node search (P5) JDK-8260360: IGV: Short name of combined nodes is hidden by background color (P5) JDK-8264557: Incorrect copyright year for test/micro/org/openjdk/bench/java/lang/MathBench.java after JDK-8264054 (P5) JDK-8259576: Misplaced curly brace in Matcher::find_shared_post_visit (P5) JDK-8266618: Remove broken -XX:-OptoRemoveUseless (P5) JDK-8266542: Remove broken -XX:-UseLoopSafepoints flag (P5) JDK-8267364: Remove mask.incr which is introduced by JDK-8256973 (P5) JDK-8263591: Two C2 compiler phases with the name "after matching" (P5) JDK-8260308: Update LogCompilation junit to 4.13.1 hotspot/gc: (P1) JDK-8261655: [PPC64] Build broken after JDK-8260941 (P1) JDK-8263040: fix for JDK-8262122 fails validate-source (P1) JDK-8262266: JDK-8262049 fails validate-source (P2) JDK-8269066: assert(ZAddress::is_marked(addr)) failed: Should be marked (P2) JDK-8265984: Concurrent GC: Some tests fail "assert(is_frame_safe(f)) failed: Frame must be safe" (P2) JDK-8267562: G1: Missing BOT in Open Archive regions causes long pauses (P2) JDK-8261859: gc/g1/TestStringDeduplicationTableRehash.java failed with "RuntimeException: 'Rehash Count: 0' found in stdout" (P2) JDK-8267972: Inline cache cleaning is not monotonic (P2) JDK-8262197: JDK-8242032 uses wrong contains_reference() in assertion code (P2) JDK-8269661: JNI_GetStringCritical does not lock char array (P2) JDK-8268524: nmethod::post_compiled_method_load_event racingly called on zombie (P2) JDK-8263107: PSPromotionManager::copy_and_push_safe_barrier needs acquire memory barrier (P2) JDK-8267073: Race between Card Redirtying and Freeing Collection Set regions results in missing remembered set entries with G1 (P2) JDK-8266773: Release VM is broken with GCC 9 after 8214237 (P2) JDK-8259252: Shenandoah: Shenandoah build failed on AArch64 after JDK-8258459 (P2) JDK-8267446: Taskqueue code fails with assert(bottom_relaxed() == age_top_relaxed()) failed: not empty (P2) JDK-8265082: test/hotspot/jtreg/gc/g1/TestG1SkipCompaction.java fails validate-source (P2) JDK-8266432: ZGC: GC allocation stalls can trigger deadlocks (P3) JDK-8003216: Add JFR event indicating explicit System.gc() call (P3) JDK-8240700: ARM32 clientvm: BarrierSetC1 encounters ARM32 ldrsb instruction offset limit (P3) JDK-8266489: Enable G1 to use large pages on Windows when region size is larger than 2m (P3) JDK-8268390: G1 concurrent gc upgrade to full gc not working (P3) JDK-8265259: G1: Fix HeapRegion::block_is_obj for unloading class in full gc (P3) JDK-8265119: G1: update_remset_before_rebuild mixes liveness in words with liveness in bytes (P3) JDK-8268576: jdk/jfr/event/gc/collection/TestSystemGc.java fails (P3) JDK-8268265: MutableSpaceUsedHelper::take_sample() hits assert(left >= right) failed: avoid overflow (P3) JDK-8241423: NUMA APIs fail to work in dockers due to dependent syscalls are disabled by default (P3) JDK-8266349: Pass down requested page size to reserve_memory_special (P3) JDK-8257145: Performance regression with -XX:-ResizePLAB after JDK-8079555 (P3) JDK-8261448: Preserve GC stack watermark across safepoints in StackWalk (P3) JDK-8266073: Regression ~2% in Derby after 8261804 (P3) JDK-8268350: Remove assert that ensures thread identifier remains the same (P3) JDK-8267703: runtime/cds/appcds/cacheObject/HeapFragmentationTest.java crashed with OutOfMemory (P3) JDK-8265759: Shenandoah: Avoid race for referent in assert (P3) JDK-8264052: Shenandoah: Backout 8263832 (P3) JDK-8265012: Shenandoah: Backout JDK-8264718 (P3) JDK-8266453: Shenandoah: Disable write protections before patching nmethod in nmethod_barrier on MacOSX/AArch64 (P3) JDK-8268127: Shenandoah: Heap size may be too small for region to align to large page size (P3) JDK-8264279: Shenandoah: Missing handshake after JDK-8263427 (P3) JDK-8266802: Shenandoah: Round up region size to page size unconditionally (P3) JDK-8265239: Shenandoah: Shenandoah heap region count could be off by 1 (P3) JDK-8266522: Shenandoah: Shenandoah LRB calls wrong runtime barrier on aarch64 (P3) JDK-8259962: Shenandoah: task queue statistics is inconsistent after JDK-8255019 (P3) JDK-8263427: Shenandoah: Trigger weak-LRB even when heap is stable (P3) JDK-8258239: Shenandoah: Used wrong closure to mark concurrent roots (P3) JDK-8265326: Strange Characters in G1GC GC Log (P3) JDK-8268388: Update large pages information in Java manpage (P3) JDK-8241354: ZGC still crashes in containers with NUMA due to get_mempolicy is disabled by default (P3) JDK-8260267: ZGC: Reduce mark stack usage (P3) JDK-8261759: ZGC: ZWorker Threads Continue Marking After System.exit() called (P4) JDK-8268537: (Temporary) Disable ParallelRefProcEnabled for Parallel GC (P4) JDK-8263723: [BACKOUT] MoveAndUpdateClosure::do_addr calls function with side-effects in an assert (P4) JDK-8261213: [BACKOUT] MutableSpace's end should be atomic (P4) JDK-8257959: Add gtest run with -XX:+UseLargePages (P4) JDK-8264489: Add more logging to LargeCopyWithMark.java (P4) JDK-8261401: Add sanity check for UseSHM large pages similar to the one used with hugetlb large pages (P4) JDK-8268122: Add specific gc cause for G1 full collections (P4) JDK-8074101: Add verification that all tasks are actually claimed during roots processing (P4) JDK-8256155: Allow multiple large page sizes to be used on Linux (P4) JDK-8252476: as_Worker_thread() doesn't check what it intends (P4) JDK-8260046: Assert left >= right in pointer_delta() methods (P4) JDK-8264271: Avoid creating non_oop_word oops (P4) JDK-8265052: Break circular include dependency in objArrayOop.inline.hpp (P4) JDK-8268163: Change the order of fallback full GCs in G1 (P4) JDK-8267464: Circular-dependency resilient inline headers (P4) JDK-8264513: Cleanup CardTableBarrierSetC2::post_barrier (P4) JDK-8258459: Decouple gc_globals.hpp from globals.hpp (P4) JDK-8259983: do not use uninitialized expand_ms value in G1CollectedHeap::expand_heap_after_young_collection (P4) JDK-8264268: Don't use oop types for derived pointers (P4) JDK-8204686: Dynamic parallel reference processing support for Parallel GC (P4) JDK-8258534: Epsilon: clean up unused includes (P4) JDK-8259231: Epsilon: improve performance under contention during virtual space expansion (P4) JDK-8265335: Epsilon: Minor typo in EpsilonElasticTLABDecay description (P4) JDK-8268331: Fix crash in humongous object eager reclaim logging (P4) JDK-8264783: G1 BOT verification should not verify beyond allocation threshold (P4) JDK-8260042: G1 Post-cleanup liveness printing occurs too early (P4) JDK-8264987: G1: Fill BOTs for Survivor-turned-to-Old regions in full gc (P4) JDK-8265330: G1: Fix comment in G1FullGCPrepareTask::G1CalculatePointersClosure (P4) JDK-8265461: G1: Forwarding pointer removal thread sizing (P4) JDK-8265681: G1: general cleanup for G1FullGCHeapRegionAttr (P4) JDK-8265394: G1: Improve assert in HeapRegion::reset_not_compacted_after_full_gc (P4) JDK-8265436: G1: Improve gc+phases log output during full gc (P4) JDK-8264818: G1: Improve liveness check for empty pinned regions after full gc marking (P4) JDK-8265842: G1: Introduce API to run multiple separate tasks in a single gangtask (P4) JDK-8266821: G1: Prefetch cards during merge heap roots phase (P4) JDK-8262185: G1: Prune collection set candidates early (P4) JDK-8266676: G1: Remove dead code init_node_id_to_index_map() (P4) JDK-8260200: G1: Remove unnecessary update in FreeRegionList::remove_starting_at (P4) JDK-8264423: G1: Rename full gc attribute table states (P4) JDK-8257774: G1: Trigger collect when free region count drops below threshold to prevent evacuation failures (P4) JDK-8265928: G1: Update copyright in several files (P4) JDK-8230486: G1BarrierSetAssembler::g1_write_barrier_post unnecessarily pushes/pops new_val (P4) JDK-8254239: G1ConcurrentMark.hpp unnecessarily disables MSVC++ warning 4522. (P4) JDK-8263387: G1GarbageCollection JFR event gets gc phase, not gc type (P4) JDK-8263495: Gather liveness info in the mark phase of G1 full gc (P4) JDK-8261230: GC tracing of page sizes are wrong in a few places (P4) JDK-8261661: gc/stress/TestReclaimStringsLeaksMemory.java fails because Reserved memory size is too big (P4) JDK-8184134: HeapRegion::LogOfHRGrainWords is unused (P4) JDK-8260208: Improve dummy object filling condition in G1CollectedHeap::fill_archive_regions in cds (P4) JDK-8262068: Improve G1 Full GC by skipping compaction for regions with high survival ratio (P4) JDK-8264041: Incorrect comments for ParallelCompactData::summarize_dense_prefix (P4) JDK-8214237: Join parallel phases post evacuation (P4) JDK-8264788: Make SequentialSubTasksDone use-once (P4) JDK-8259668: Make SubTasksDone use-once (P4) JDK-8258508: Merge G1RedirtyCardsQueue into qset (P4) JDK-8259778: Merge MutableSpace and ImmutableSpace (P4) JDK-8265450: Merge PreservedMarksSet::restore code paths (P4) JDK-8265064: Move clearing and setting of members into helpers in ReservedSpace (P4) JDK-8261905: Move implementation of OopStorage num_dead related functions (P4) JDK-8256955: Move includes of events.hpp out of header files (P4) JDK-8261509: Move per-thread StackWatermark from Thread to JavaThread class (P4) JDK-8258255: Move PtrQueue active flag to SATBMarkQueue (P4) JDK-8258251: Move PtrQueue behaviors to PtrQueueSet subclasses (P4) JDK-8258252: Move PtrQueue enqueue to PtrQueueSet subclasses (P4) JDK-8258254: Move PtrQueue flush to PtrQueueSet subclasses (P4) JDK-8258742: Move PtrQueue reset to PtrQueueSet subclasses (P4) JDK-8245025: MoveAndUpdateClosure::do_addr calls function with side-effects in an assert (P4) JDK-8259862: MutableSpace's end should be atomic (P4) JDK-8259020: null-check of g1 write_ref_field_pre_entry is not necessary (P4) JDK-8264166: OopStorage should support specifying MEMFLAGS for allocations (P4) JDK-8260044: Parallel GC: Concurrent allocation after heap expansion may cause unnecessary full gc (P4) JDK-8260045: Parallel GC: Waiting on ExpandHeap_lock may cause "expansion storm" (P4) JDK-8248314: Parallel: Parallelize parallel full gc Adjust Roots phase (P4) JDK-8264417: ParallelCompactData::region_offset should not accept pointers outside the current region (P4) JDK-8268443: ParallelGC Full GC should use parallel WeakProcessor (P4) JDK-8210100: ParallelGC should use parallel WeakProcessor (P4) JDK-8234446: Post-CMS workgroup hierarchy cleanup (P4) JDK-8266787: Potential overflow of pointer arithmetic in G1ArchiveAllocator (P4) JDK-8267611: Print more info when pointer_delta assert fails (P4) JDK-8263551: Provide shared lock-free FIFO queue implementation (P4) JDK-8261527: Record page size used for underlying mapping in ReservedSpace (P4) JDK-8260012: Reduce inclusion of collectedHeap.hpp and heapInspection.hpp (P4) JDK-8263964: Redundant check in ObjectStartArray::object_starts_in_range (P4) JDK-8264027: Refactor "CLEANUP" region printing (P4) JDK-8253420: Refactor HeapRegionManager::find_highest_free (P4) JDK-8262291: Refactor reserve_memory_special_huge_tlbfs (P4) JDK-8267914: Remove DeferredObjectToKlass workaround (P4) JDK-8264026: Remove dependency between free collection set and eagerly reclaim humongous object tasks (P4) JDK-8265435: Remove dummy lists in G1CalculatePointersClosure (P4) JDK-8261804: Remove field _processing_is_mt, calculate it instead (P4) JDK-8234020: Remove FullGCCount_lock (P4) JDK-8228748: Remove GCLocker::_doing_gc (P4) JDK-8257970: Remove julong types in os::limit_heap_by_allocatable_memory (P4) JDK-8266504: Remove leftovers from BarrierSetAssemblerC1 (P4) JDK-8249528: Remove obsolete comment in G1RootProcessor::process_java_roots (P4) JDK-8260574: Remove parallel constructs in GenCollectedHeap::process_roots (P4) JDK-8260643: Remove parallel version handling in CardTableRS::younger_refs_in_space_iterate() (P4) JDK-8259776: Remove ParallelGC non-CAS oldgen allocation (P4) JDK-8252089: Remove psParallelCompact internal debug counters (P4) JDK-8260263: Remove PtrQueue::_qset (P4) JDK-8261309: Remove remaining StoreLoad barrier with UseCondCardMark for Serial/Parallel GC (P4) JDK-8266491: Remove resolve and obj_equals leftovers from BarrierSetAssembler (P4) JDK-8263030: Remove Shenandoah leftovers from ReferenceProcessor (P4) JDK-8260449: Remove stale declaration of SATBMarkQueue::apply_closure_and_empty() (P4) JDK-8260941: Remove the conc_scan parameter for CardTable (P4) JDK-8234532: Remove ThreadLocalAllocBuffer::_fast_refill_waste since it is never set (P4) JDK-8261799: Remove unnecessary cast in psParallelCompact.hpp (P4) JDK-8262235: Remove unnecessary logic in hugetlbfs_sanity_check() (P4) JDK-8266295: Remove unused _concurrent_iteration_safe_limit (P4) JDK-8260415: Remove unused class ReferenceProcessorMTProcMutator (P4) JDK-8260416: Remove unused method ReferenceProcessor::is_mt_processing_set_up() (P4) JDK-8260414: Remove unused set_single_threaded_mode() method in task executor (P4) JDK-8259487: Remove unused StarTask (P4) JDK-8261803: Remove unused TaskTerminator in g1 full gc ref proc executor (P4) JDK-8268118: Rename bytes_os_cpu.inline.hpp files to bytes_os_cpu.hpp (P4) JDK-8268119: Rename copy_os_cpu.inline.hpp files to copy_os_cpu.hpp (P4) JDK-8269126: Rename G1AllowPreventiveGC option to G1UsePreventiveGC (P4) JDK-8267468: Rename refill waster counters in ThreadLocalAllocBuffer (P4) JDK-8267836: Separate eager reclaim remembered set threshold from G1RSetSparseRegionEntries (P4) JDK-8261473: Shenandoah: Add breakpoint support (P4) JDK-8268699: Shenandoah: Add test for JDK-8268127 (P4) JDK-8260408: Shenandoah: adjust inline hints after JDK-8255019 (P4) JDK-8267257: Shenandoah: Always deduplicate strings when it is enabled during full gc (P4) JDK-8260309: Shenandoah: Clean up ShenandoahBarrierSet (P4) JDK-8263041: Shenandoah: Cleanup C1 keep alive barrier check (P4) JDK-8260736: Shenandoah: Cleanup includes in ShenandoahGC and families (P4) JDK-8261842: Shenandoah: cleanup ShenandoahHeapRegionSet (P4) JDK-8261973: Shenandoah: Cleanup/simplify root verifier (P4) JDK-8266083: Shenandoah: Consolidate dedup/no dedup oop closures (P4) JDK-8261413: Shenandoah: Disable class-unloading in I-U mode (P4) JDK-8262398: Shenandoah: Disable nmethod barrier and stack watermark when running with passive mode (P4) JDK-8263433: Shenandoah: Don't expect forwarded objects in set_concurrent_mark_in_progress() (P4) JDK-8267875: Shenandoah: Duplicated code in ShenandoahBarrierSetC2::ideal_node() (P4) JDK-8256298: Shenandoah: Enable concurrent stack processing (P4) JDK-8264718: Shenandoah: enable string deduplication during root scanning (P4) JDK-8259377: Shenandoah: Enhance weak reference processing time tracking (P4) JDK-8266018: Shenandoah: fix an incorrect assert (P4) JDK-8262876: Shenandoah: Fix comments regarding VM_ShenandoahOperation inheritances (P4) JDK-8260421: Shenandoah: Fix conc_mark_roots timing name and indentations (P4) JDK-8266185: Shenandoah: Fix incorrect comment/assertion messages (P4) JDK-8259404: Shenandoah: Fix time tracking in parallel_cleaning (P4) JDK-8263832: Shenandoah: Fixing parallel thread iteration in final mark task (P4) JDK-8258490: Shenandoah: Full GC does not need to remark threads and drain SATB buffers (P4) JDK-8262885: Shenandoah: FullGC prologue does not need to save/restore heap has_forwarded_object flag (P4) JDK-8260591: Shenandoah: improve parallelism for concurrent thread root scans (P4) JDK-8260497: Shenandoah: Improve SATB flushing (P4) JDK-8255765: Shenandoah: Isolate concurrent, degenerated and full GC (P4) JDK-8259488: Shenandoah: Missing timing tracking for STW CLD root processing (P4) JDK-8265995: Shenandoah: Move ShenandoahInitMarkRootsClosure close to its use (P4) JDK-8258244: Shenandoah: Not expecting forwarded object in roots during mark after JDK-8240868 (P4) JDK-8261493: Shenandoah: reconsider bitmap access memory ordering (P4) JDK-8261838: Shenandoah: reconsider heap region iterators memory ordering (P4) JDK-8261501: Shenandoah: reconsider heap statistics memory ordering (P4) JDK-8261496: Shenandoah: reconsider pacing updates memory ordering (P4) JDK-8261500: Shenandoah: reconsider region live data memory ordering (P4) JDK-8261504: Shenandoah: reconsider ShenandoahJavaThreadsIterator::claim memory ordering (P4) JDK-8261503: Shenandoah: reconsider verifier memory ordering (P4) JDK-8260106: Shenandoah: refactor reference updating closures and related code (P4) JDK-8264727: Shenandoah: Remove extraneous whitespace from phase timings report (P4) JDK-8264374: Shenandoah: Remove leftover parallel reference processing argument (P4) JDK-8255837: Shenandoah: Remove ShenandoahConcurrentRoots class (P4) JDK-8260005: Shenandoah: Remove unused AlwaysTrueClosure in ShenandoahConcurrentRootScanner::roots_do() (P4) JDK-8263861: Shenandoah: Remove unused member in ShenandoahGCStateResetter (P4) JDK-8261984: Shenandoah: Remove unused ShenandoahPushWorkerQueuesScope class (P4) JDK-8260004: Shenandoah: Rename ShenandoahMarkCompact to ShenandoahFullGC (P4) JDK-8259849: Shenandoah: Rename store-val to IU-barrier (P4) JDK-8260212: Shenandoah: resolve-only UpdateRefsMode is not used (P4) JDK-8260998: Shenandoah: Restore reference processing statistics reporting (P4) JDK-8260048: Shenandoah: ShenandoahMarkingContext asserts are unnecessary (P4) JDK-8260584: Shenandoah: simplify "Concurrent Thread Roots" logging (P4) JDK-8260586: Shenandoah: simplify "Concurrent Weak References" logging (P4) JDK-8266845: Shenandoah: Simplify SBS::load_reference_barrier implementation (P4) JDK-8255019: Shenandoah: Split STW and concurrent mark into separate classes (P4) JDK-8266440: Shenandoah: TestReferenceShortcutCycle.java test failed on AArch64 (P4) JDK-8259580: Shenandoah: uninitialized label in VerifyThreadGCState (P4) JDK-8261251: Shenandoah: Use object size for full GC humongous compaction (P4) JDK-8266813: Shenandoah: Use shorter instruction sequence for checking if marking in progress (P4) JDK-8264324: Simplify allocation list management in OopStorage::reduce_deferred_updates (P4) JDK-8234534: Simplify CardTable code after CMS removal (P4) JDK-8258142: Simplify G1RedirtyCardsQueue (P4) JDK-8231672: Simplify the reference processing parallelization framework (P4) JDK-8257676: Simplify WeakProcessorPhase (P4) JDK-8199407: Skip Rebuild Remset Phase if there are no rebuild candidates (P4) JDK-8265066: Split ReservedSpace constructor to avoid default parameter (P4) JDK-8254598: StringDedupTable should use OopStorage (P4) JDK-8264424: Support OopStorage bulk allocation (P4) JDK-8264408: test_oopStorage no longer needs to disable some tests on WIN32 (P4) JDK-8261636: The test mapping in hugetlbfs_sanity_check should consider LargePageSizeInBytes (P4) JDK-8263705: Two shenandoah tests fail due to can't find ClassFileInstaller (P4) JDK-8143041: Unify G1CollectorPolicy::PauseKind and G1YCType (P4) JDK-8263721: Unify oop casting (P4) JDK-8265268: Unify ReservedSpace reservation code in initialize and try_reserve_heap (P4) JDK-8263852: Unused method SoftRefPolicy::use_should_clear_all_soft_refs (P4) JDK-8262087: Use atomic boolean type in G1FullGCAdjustTask (P4) JDK-8259851: Use boolean type for tasks in SubTasksDone (P4) JDK-8266904: Use function pointer typedefs in OopOopIterateDispatch (P4) JDK-8265414: Variable assigned but not used in G1FreeHumongousRegionClosure (P4) JDK-8262973: Verify ParCompactionManager instance in PCAdjustPointerClosure (P4) JDK-8267311: vmTestbase/gc/gctests/StringInternGC/StringInternGC.java eventually OOMEs (P4) JDK-8256814: WeakProcessorPhases may be redundant (P4) JDK-8267937: Wrong indentation in G1 gc+phases log for free cset subphases (P4) JDK-8259870: zBarrier.inline.hpp should not include javaClasses.hpp (P4) JDK-8265702: ZGC on macOS/aarch64 (P4) JDK-8263579: ZGC: Concurrent mark hangs with debug loglevel (P4) JDK-8268372: ZGC: dynamically select the number of concurrent GC threads used (P4) JDK-8265136: ZGC: Expose GarbageCollectorMXBeans for both pauses and cycles (P4) JDK-8265127: ZGC: Fix incorrect reporting of reclaimed memory (P4) JDK-8266217: ZGC: Improve the -Xlog:gc+init output for NUMA (P4) JDK-8267945: ZGC: Revert NUMA changes (JDK-8266217 and JDK-8241354) after JDK-8241423 (P4) JDK-8261028: ZGC: SIGFPE when MaxVirtMemFraction=0 (P4) JDK-8265116: ZGC: Steal local stacks instead of flushing them (P4) JDK-8266055: ZGC: ZHeap::print_extended_on() doesn't disable deferred delete (P4) JDK-8266426: ZHeapIteratorOopClosure does not handle native access properly (P5) JDK-8258382: Fix optimization-unstable code involving pointer overflow (P5) JDK-8217327: G1 Post-Cleanup region liveness printing should not print out-of-date efficiency (P5) JDK-8242032: G1 region remembered sets may contain non-coarse level PRTs for already coarsened regions (P5) JDK-8267924: Misleading G1 eager reclaim detail logging hotspot/jfr: (P1) JDK-8268138: docs build error after JDK-8263332 integration (P1) JDK-8260524: validate-source fails on test/jdk/jdk/jfr/event/gc/detailed/TestGCLockerEvent.java (P2) JDK-8266206: Build failure after JDK-8264752 with older GCCs (P2) JDK-8261157: Incorrect GPL header after JDK-8259956 (P2) JDK-8269125: Klass enqueue element size calculation wrong when traceid value cross compress limit (P2) JDK-8259995: Missing comma to separate years in copyright header (P2) JDK-8258396: SIGILL in jdk.jfr.internal.PlatformRecorder.rotateDisk() (P3) JDK-8249245: assert(((((JfrTraceIdBits::load(klass)) & ((JfrTraceIdEpoch::this_epoch_method_and_class_bits()))) != 0))) failed: invariant (P3) JDK-8203359: Container level resources events (P3) JDK-8257569: Failure observed with JfrVirtualMemory::initialize (P3) JDK-8259354: Fix race condition in AbstractEventStream.nextThreadName (P3) JDK-8268303: Incorrect casts in JfrWriterHost::write for Ticks and Tickspan (P3) JDK-8266595: jdk/jfr/jcmd/TestJcmdDump.java with slowdebug bits fails with AttachNotSupportedException (P3) JDK-8268702: JFR diagnostic commands lack argument descriptors when viewed using Platform MBean Server (P3) JDK-8269768: JFR Terminology Refresh (P3) JDK-8268424: JFR tests fail due to GC cause 'G1 Preventive Collection' not in the valid causes after JDK-8257774 (P3) JDK-8256156: JFR: Allow 'jfr' tool to show metadata without a recording (P3) JDK-8264768: JFR: Allow events to be printed to the log (P3) JDK-8262908: JFR: Allow JFR to stream events from a known repository path (P3) JDK-8265271: JFR: Allow use of .jfc options when starting JFR (P3) JDK-8263332: JFR: Dump recording from a recording stream (P3) JDK-8260565: JFR: Fix copyright header in tests (P3) JDK-8265407: JFR: Fix Typos (P3) JDK-8264309: JFR: Improve .jfc parser (P3) JDK-8264001: JFR: Modernize implementation (P3) JDK-8260862: JFR: New configure command for the jfr tool (P3) JDK-8268903: JFR: RecordingStream::dump is missing @since (P3) JDK-8265036: JFR: Remove use of -XX:StartFlightRecording= and -XX:FlightRecorderOptions= (P3) JDK-8238197: JFR: Rework setting and getting EventHandler (P3) JDK-8244190: JFR: When starting a JVM with -XX:StartFlightRecording, output is written to stdout (P3) JDK-8258414: OldObjectSample events too expensive (P3) JDK-8264752: SIGFPE crash with option FlightRecorderOptions:threadbuffersize=30M (P3) JDK-8261354: SIGSEGV at MethodIteratorHost (P3) JDK-8267579: Thread::cooked_allocated_bytes() hits assert(left >= right) failed: avoid underflow (P3) JDK-8268316: Typo in JFR jdk.Deserialization event (P4) JDK-8259808: Add JFR event to detect GC locker stall (P4) JDK-8264633: Add missing logging to PlatformRecording#stop (P4) JDK-8264017: Correctly report inlined frame in JFR sampling (P4) JDK-8260589: Crash in JfrTraceIdLoadBarrier::load(_jclass*) (P4) JDK-8261593: Do not use NULL pointer as write buffer parameter in jfrEmergencyDump.cpp write_repository_files (P4) JDK-8259036: Failed JfrVersionSystem invariant when VM built with -fno-elide-constructors (P4) JDK-8262329: Fix JFR parser exception messages (P4) JDK-8263395: Incorrect use of Objects.nonNull (P4) JDK-8258524: Instrumented EventHandler calls private instance method EventWriter.reset (P4) JDK-8259956: jdk.jfr.internal.ChunkInputStream#available should return the sum of remaining available bytes (P4) JDK-8265225: jdk/jfr/tool/TestConfigure.java fails to cleanup the output files after the testing (P4) JDK-8263725: JFR oldobject tests are not run when GCs are specified explicitly (P4) JDK-8254565: JFR: Incorrect verification of mirror events (P4) JDK-8259623: JfrTypeSet::_subsystem_callback is left dangling after use (P4) JDK-8263426: Reflow JfrNetworkUtilization::send_events (P4) JDK-8261190: restore original Alibaba copyright line in two files (P5) JDK-8264062: Use the blessed modifier order in jdk.jfr hotspot/jvmti: (P3) JDK-8258652: Assert in JvmtiThreadState::cur_stack_depth() can noticeably slow down debugging single stepping (P3) JDK-8268241: deprecate JVM TI Heap functions 1.0 (P3) JDK-8212155: Race condition when posting dynamic_code_generated event leads to JVM crash (P3) JDK-8268094: Some vmTestbase/nsk tests fail after ACC_STRICT/strictfp changes (P3) JDK-8268463: Windows 32bit build fails in DynamicCodeGenerated\libDynamicCodeGenerated.cpp (P4) JDK-8264149: BreakpointInfo::set allocates metaspace object in VM thread (P4) JDK-8264800: cleanup Threads_lock comments in JVM/TI function headers (P4) JDK-8263434: Dangling references after MethodComparator::methods_EMCP (P4) JDK-8264004: Don't use TRAPS if no exceptions are thrown (P4) JDK-8269558: fix of JDK-8252657 missed to update history at the end of JVM TI spec (P4) JDK-8258061: Improve diagnostic information about errors during class redefinition (P4) JDK-8262280: Incorrect exception handling for VMThread in class redefinition (P4) JDK-8259482: jni_Set/GetField_probe are the same as their _nh versions (P4) JDK-8252657: JVMTI agent is not unloaded when Agent_OnAttach is failed (P4) JDK-8265180: JvmtiCompiledMethodLoadEvent should include the stub section of nmethods (P4) JDK-8259375: JvmtiExport::jni_Get/SetField_probe calls do not need ResetNoHandleMark (P4) JDK-8257726: Make -XX:+StressLdcRewrite option a diagnostic option (P4) JDK-8268563: mark hotspot serviceability/jvmti tests which ignore external VM flags (P4) JDK-8262881: port JVM/DI tests from JDK-4413752 to JVM/TI (P4) JDK-8259627: Potential memory leaks in JVMTI after JDK-8227745 (P4) JDK-8266794: Remove dead code notify_allocation_jvmti_allocation_event (P4) JDK-8266497: Remove unnecessary EMCP liveness indication (P4) JDK-8264050: Remove unused field VM_HeapWalkOperation::_collecting_heap_roots (P4) JDK-8268530: resourcehogs/serviceability/jvmti/GetObjectSizeOverflow.java should be run in driver mode (P4) JDK-8264411: serviceability/jvmti/HeapMonitor tests intermittently fail due to large TLAB size (P4) JDK-8268534: some serviceability/jvmti tests should be run in driver mode (P4) JDK-8263895: Test nsk/jvmti/GetThreadGroupChildren/getthrdgrpchld001/getthrdgrpchld001.cpp uses incorrect indices (P4) JDK-8260926: Trace resource exhausted events unconditionally (P4) JDK-8264663: Update test SuspendWithCurrentThread.java to verify that suspend doesn't exit until resumed (P4) JDK-8259799: vmTestbase/nsk/jvmti/Breakpoint/breakpoint001 is incorrect (P4) JDK-8266002: vmTestbase/nsk/jvmti/ClassPrepare/classprep001 should skip events for unexpected classes (P4) JDK-8262092: vmTestbase/nsk/jvmti/scenarios/hotswap/HS102/hs102t001/TestDescription.java SIGSEGV in memmove_ssse3 (P4) JDK-8262083: vmTestbase/nsk/jvmti/SetEventNotificationMode/setnotif001/TestDescription.java failed with "No notification: event JVMTI_EVENT_FRAME_POP (61)" hotspot/other: (P2) JDK-8259978: PPC64 builds broken after JDK-8258004 (P3) JDK-8267130: Memory Overflow in Disassembler::load_library (P3) JDK-8268293: VectorAPI cast operation on mask and shuffle is broken (P4) JDK-8254050: HotSpot Style Guide should permit using the "override" virtual specifier (P4) JDK-8253881: Hotspot/Serviceability Terminology Refresh hotspot/runtime: (P1) JDK-8263465: JDK-8236847 causes tier1 build failure on linux-aarch64 (P1) JDK-8260579: PPC64 and S390 builds failures after JDK-8260467 (P2) JDK-8267235: [macos_aarch64] InterpreterRuntime::throw_pending_exception messing up LR results in crash (P2) JDK-8269614: [s390] Interpreter checks wrong bit for slow path instance allocation (P2) JDK-8265756: AArch64: initialize memory allocated for locals according to Windows AArch64 stack page growth requirement in template interpreter (P2) JDK-8266557: assert(SafepointMechanism::local_poll_armed(_handshakee)) failed: Must be (P2) JDK-8268014: Build failure on SUSE Linux Enterprise Server 11.4 (s390x) due to 'SYS_get_mempolicy' was not declared (P2) JDK-8261395: C1 crash "cannot make java calls from the native compiler" (P2) JDK-8263968: CDS: java/lang/ModuleLayer.EMPTY_LAYER should be singleton (P2) JDK-8261921: ClassListParser::current should be used only by main thread (P2) JDK-8265246: Fix macos-Aarch64 build after JDK-8263709 (P2) JDK-8259569: gtest os.dll_address_to_function_and_library_name_vm fails (P2) JDK-8266942: gtest/GTestWrapper.java os.iso8601_time_vm failed (P2) JDK-8266330: itableMethodEntry::initialize() asserts with archived old classes (P2) JDK-8266963: Remove safepoint poll introduced in 8262443 due to reentrance issue (P2) JDK-8259446: runtime/jni/checked/TestCheckedReleaseArrayElements.java fails with stderr not empty (P2) JDK-8258054: runtime/sealedClasses/GetPermittedSubclassesTest.java fails w/ jdk17 (P2) JDK-8253817: Support macOS Aarch64 ABI in Interpreter (P2) JDK-8264429: Test runtime/cds/appcds/VerifyWithDefaultArchive.java assumes OpenJDK build (P2) JDK-8267404: vmTestbase/vm/mlvm/anonloader/stress/oome/metaspace/Test.java failed with OutOfMemoryError (P3) JDK-8269668: [aarch64] java.library.path not including /usr/lib64 (P3) JDK-8266765: [BACKOUT] JDK-8255493 Support for pre-generated java.lang.invoke classes in CDS dynamic archive (P3) JDK-8253797: [cgroups v2] Account for the fact that swap accounting is disabled on some systems (P3) JDK-8263512: [macos_aarch64] issues with calling va_args functions from invoke_native (P3) JDK-8265292: [macos_aarch64] java/foreign/TestDowncall.java crashes with SIGBUS (P3) JDK-8265183: [macos_aarch64] java/foreign/TestIntrinsics.java crashes with SIGBUS (P3) JDK-8265182: [macos_aarch64] java/foreign/TestUpcall.java crashes with SIGBUS (P3) JDK-8260355: AArch64: deoptimization stub should save vector registers (P3) JDK-8265705: aarch64: KlassDecodeMovk mode broken (P3) JDK-8267350: Archived old interface extends interface with default method causes crash (P3) JDK-8269594: assert(_handle_mark_nesting > 1) failed: memory leak: allocating handle outside HandleMark (P3) JDK-8267952: async logging supports to dynamically change tags and decorators (P3) JDK-8195744: Avoid calling ClassLoader.checkPackageAccess if security manager is not installed (P3) JDK-8267042: bug in monitor locking/unlocking on ARM32 C1 due to uninitialized BasicObjectLock::_displaced_header (P3) JDK-8265605: Cannot call BootLoader::loadClassOrNull before initPhase2 (P3) JDK-8260349: Cannot programmatically retrieve Metaspace max set via JAVA_TOOL_OPTIONS (P3) JDK-8236847: CDS archive with 4K alignment unusable on machines with 64k pages (P3) JDK-8268470: CDS dynamic dump asserts with JFR RecordingStream (P3) JDK-8267347: CDS record_linking_constraint asserts with unregistered class (P3) JDK-8234693: Consolidate CDS static and dynamic archive dumping code (P3) JDK-8261860: Crash caused by lambda proxy class loaded in Shutdown hook (P3) JDK-8258800: Deprecate -XX:+AlwaysLockClassLoader (P3) JDK-8269064: Dropped messages of AsyncLogWriter cause memleak (P3) JDK-8261916: gtest/GTestWrapper.java vmErrorTest.unimplemented1_vm_assert failed (P3) JDK-8259786: initialize last parameter of getpwuid_r (P3) JDK-8268522: InstanceKlass::can_be_verified_at_dumptime() returns opposite value (P3) JDK-8260009: InstanceKlass::has_as_permitted_subclass() fails if subclass was redefined (P3) JDK-8264393: JDK-8258284 introduced dangling TLH race (P3) JDK-8261520: JDK-8261302 breaks runtime/NMT/CheckForProperDetailStackTrace.java (P3) JDK-8264760: JVM crashes when two threads encounter the same resolution error (P3) JDK-8261262: Kitchensink24HStress.java crashed with EXCEPTION_ACCESS_VIOLATION (P3) JDK-8267908: linux: thread_native_entry can scribble on stack frame (P3) JDK-8265798: Minimal build broken by JDK-8261090 (P3) JDK-8263455: NMT: assert on registering a region which completely engulfs an existing region (P3) JDK-8257746: Regression introduced with JDK-8250984 - memory might be null in some machines (P3) JDK-8243287: Removal of Unsafe::defineAnonymousClass (P3) JDK-8263002: Remove CDS MiscCode region (P3) JDK-8236225: Remove expired flags in JDK 17 (P3) JDK-8262376: ReplaceCriticalClassesForSubgraphs.java fails if --with-build-jdk is used (P3) JDK-8255917: runtime/cds/SharedBaseAddress.java failed "assert(reserved_rgn != 0LL) failed: No reserved region" (P3) JDK-8266056: runtime/stringtable/StringTableCleaningTest.java failed with "RuntimeException: Missing Callback in [10, 11]" (P3) JDK-8268638: semaphores of AsyncLogWriter may be broken when JVM is exiting. (P3) JDK-8267954: Shared classes that failed to load should not be loaded again (P3) JDK-8265218: trace_method_handle_stub fails to find calling frame on x86 (P3) JDK-8261397: try catch Method failing to work when dividing an integer by 0 (P3) JDK-8261445: Use memory_order_relaxed for os::random(). (P3) JDK-8258077: Using -Xcheck:jni can lead to a double-free after JDK-8193234 (P3) JDK-8265393: VM crashes if both -XX:+RecordDynamicDumpInfo and -XX:SharedArchiveFile options are specified (P3) JDK-8268377: Windows 32bit build fails after JDK-8268174 (P3) JDK-8263834: Work around gdb for HashtableEntry (P3) JDK-8259392: Zero error reporting is broken after JDK-8255711 (P3) JDK-8256732: Zero: broken +ZeroTLAB exposes badly initialized memory (P3) JDK-8261391: ZGC crash - SEGV in RevokeOneBias::do_thread (P4) JDK-8266176: -Wmaybe-uninitialized happens in libArrayIndexOutOfBoundsExceptionTest.c (P4) JDK-8266170: -Wnonnull happens in classLoaderData.inline.hpp (P4) JDK-8266172: -Wstringop-overflow happens in vmError.cpp (P4) JDK-8259349: -XX:AvgMonitorsPerThreadEstimate=1 does not work right (P4) JDK-8265831: 8257831 broke Windows x86 build (P4) JDK-8266419: [aix] in mmap mode, os::attempt_reserve_memory_at() fails to handle wrong mapping address (P4) JDK-8266222: [aix] In mmap-mode, partial releases with os::release_memory may trash internal bookkeeping (P4) JDK-8266506: [aix] Treat mapping attempt too close to BRK as a mapping error (P4) JDK-8258185: [JNI] Clarify the specification in relation to portable use of APIs that involve the Primitive Array Release Modes (P4) JDK-8262896: [macos_aarch64] Crash in jni_fast_GetLongField (P4) JDK-8264240: [macos_aarch64] enable appcds support after JDK-8263002 (P4) JDK-8262952: [macos_aarch64] os::commit_memory failure (P4) JDK-8262903: [macos_aarch64] Thread::current() called on detached thread (P4) JDK-8260369: [PPC64] Add support for JDK-8200555 (P4) JDK-8260368: [PPC64] GC interface needs enhancement to support GCs with load barriers (P4) JDK-8261957: [PPC64] Support for Concurrent Thread-Stack Processing (P4) JDK-8260022: [ppc] os::print_function_and_library_name shall resolve function descriptors transparently (P4) JDK-8266764: [REDO] JDK-8255493 Support for pre-generated java.lang.invoke classes in CDS dynamic archive (P4) JDK-8266503: [UL] Make Decorations safely copy-able and reduce their size (P4) JDK-8268602: a couple runtime/os tests don't check exit code (P4) JDK-8268591: a few runtime/jni tests don't need `/othervm` (P4) JDK-8266749: AArch64: Backtracing broken on PAC enabled systems (P4) JDK-8262491: AArch64: CPU description should contain compatible board list (P4) JDK-8264412: AArch64: CPU description should refer DMI (P4) JDK-8260029: aarch64: fix typo in verify_oop_array (P4) JDK-8264472: Add a test group for running CDS tests with -XX:+VerifySharedSpaces (P4) JDK-8264983: Add gtest for JDK-8264008 (P4) JDK-8259070: Add jcmd option to dump CDS (P4) JDK-8257700: Add logging for sealed classes in JVM_GetPermittedSubclasses (P4) JDK-8263559: Add missing initializers to VM_PopulateDumpSharedSpace (P4) JDK-8264644: Add PrintClassLoaderDataGraphAtExit to print the detailed CLD graph (P4) JDK-8260571: Add PrintMetaspaceStatistics to print metaspace statistics upon VM exit (P4) JDK-8255566: Add size validation when parsing values from VersionProps (P4) JDK-8264123: add ThreadsList.is_valid() support (P4) JDK-8267916: Adopt cast notation for CompilerThread conversions (P4) JDK-8268164: Adopt cast notation for WorkerThread conversions (P4) JDK-8263392: Allow current thread to be specified in ExceptionMark (P4) JDK-8252685: APIs that require JavaThread should take JavaThread arguments (P4) JDK-8261532: Archived superinterface class cannot be accessed (P4) JDK-8260899: ARM32: SyncOnValueBasedClassTest fails with assert(is_valid()) failed: invalid register (P4) JDK-8183569: Assert the same limits are used in parse_xss and globals.hpp (P4) JDK-8268165: AsyncLogging will crash if rotate() fails (P4) JDK-8267926: AsyncLogGtest.java fails on assert with: decorator was not part of the decorator set specified at creation. (P4) JDK-8263396: Atomic::CmpxchgByteUsingInt::set_byte_in_int needs an explicit cast (P4) JDK-8266892: avoid maybe-uninitialized gcc warnings on linux s390x (P4) JDK-8267396: Avoid recording "pc" in unhandled oops detector for better performance (P4) JDK-8267191: Avoid repeated SystemDictionaryShared::should_be_excluded calls (P4) JDK-8263446: Avoid unary minus over unsigned type in ObjectSynchronizer::dec_in_use_list_ceiling (P4) JDK-8265411: Avoid unnecessary Method::init_intrinsic_id calls (P4) JDK-8260236: better init AnnotationCollector _contended_group (P4) JDK-8259067: bootclasspath append takes out object lock (P4) JDK-8262472: Buffer overflow in UNICODE::as_utf8 for zero length output buffer (P4) JDK-8263908: Build fails due to initialize_static_field_for_dump defined but not used after JDK-8263771 (P4) JDK-8259957: Build failure without C1 Compiler after JDK-8258004 (P4) JDK-8268139: CDS ArchiveBuilder may reference unloaded classes (P4) JDK-8268778: CDS check_excluded_classes needs DumpTimeTable_lock (P4) JDK-8260341: CDS dump VM init code does not check exceptions (P4) JDK-8264150: CDS dumping code calls TRAPS functions in VM thread (P4) JDK-8263914: CDS fails to find the default shared archive on x86_32 (P4) JDK-8260902: CDS mapping errors should not lead to unconditional output (P4) JDK-8261479: CDS runtime code should check exceptions (P4) JDK-8263399: CDS should archive only classes allowed by module system (P4) JDK-8267754: cds/appcds/loaderConstraints/LoaderConstraintsTest.java fails on x86_32 due to customized class loader is not supported (P4) JDK-8264196: Change link_and_cleanup_shared_classes(CATCH) to CHECK (P4) JDK-8262424: Change multiple get_java_xxx() functions in thread.cpp into one function (P4) JDK-8247869: Change NONCOPYABLE to delete the operations (P4) JDK-8262227: Change SystemDictionary::find() to return an InstanceKlass*. (P4) JDK-8260471: Change SystemDictionary::X_klass calls to vmClasses::X_klass (P4) JDK-8267691: Change table to obsolete CriticalJNINatives in JDK 18, not 17 (P4) JDK-8264624: change the guarantee() calls added by JDK-8264123 to assert() calls (P4) JDK-8262426: Change TRAPS to Thread* for find_constrained_instance_or_array_klass() (P4) JDK-8266742: Check W^X state on possible safepoint (P4) JDK-8263562: Checking if proxy_klass_head is still lambda_proxy_is_available (P4) JDK-8267209: Child threads should defer logging to after child-parent handshake (P4) JDK-8266637: CHT: Add insert_and_get method (P4) JDK-8233378: CHT: Fast reset (P4) JDK-8233380: CHT: Node allocation and freeing (P4) JDK-8268088: Clarify Method::clear_jmethod_ids() related comments in ClassLoaderData::~ClassLoaderData() (P4) JDK-8267879: ClassLoaderMetaspace destructor asserts on !_frozen (P4) JDK-8266770: Clean pending exception before running dynamic CDS dump (P4) JDK-8264285: Clean the modification of ccstr JVM flags (P4) JDK-8258284: clean up issues with nested ThreadsListHandles (P4) JDK-8264732: Clean up LinkResolver::vtable_index_of_interface_method() (P4) JDK-8263884: Clean up os::is_allocatable() across Posix platforms (P4) JDK-8262046: Clean up parallel class loading code and comments (P4) JDK-8260522: Clean up warnings in hotspot JTReg runtime tests (P4) JDK-8261161: Clean up warnings in hotspot/jtreg/vmTestbase tests (P4) JDK-8265934: Cleanup _suspend_flags and _special_runtime_exit_condition (P4) JDK-8258469: Cleanup remaining safefetch test coding (P4) JDK-8261127: Cleanup THREAD/TRAPS/CHECK usage in CDS code (P4) JDK-8263709: Cleanup THREAD/TRAPS/CHECK usage in JRT_ENTRY routines (P4) JDK-8262910: Cleanup THREAD/TRAPS/naming and typing issues in ObjectMonitor and related code (P4) JDK-8264634: CollectCLDClosure collects duplicated CLDs when dumping dynamic archive (P4) JDK-8267371: Concurrent gtests take too long (P4) JDK-8250989: Consolidate buffer allocation code for CDS static/dynamic dumping (P4) JDK-8251392: Consolidate Metaspace Statistics (P4) JDK-8263564: Consolidate POSIX code for runtime exit support: os::shutdown, os::abort and os::die (P4) JDK-8262074: Consolidate the default value of MetaspaceSize (P4) JDK-8263191: Consolidate ThreadInVMfromJavaNoAsyncException and ThreadBlockInVMWithDeadlockCheck with existing wrappers (P4) JDK-8257912: Convert enum iteration to use range-based for loops (P4) JDK-8266130: convert Thread-SMR stress tests from counter based to time based (P4) JDK-8257985: count_trailing_zeros doesn't handle 64-bit values on 32-bit JVM (P4) JDK-8267213: cpuinfo_segv is incorrectly triaged as execution protection violation on x86_32 (P4) JDK-8267920: Create separate Events buffer for VMOperations (P4) JDK-8261075: Create stubRoutines.inline.hpp with SafeFetch implementation (P4) JDK-8264413: Data is written to file header even if its CRC32 was calculated (P4) JDK-8264593: debug.cpp utilities should be available in product builds. (P4) JDK-8266967: debug.cpp utility find() should print Java Object fields. (P4) JDK-8260191: Do not include access.hpp in oop.hpp (P4) JDK-8264797: Do not include klassVtable.hpp from instanceKlass.hpp (P4) JDK-8260307: Do not include method.hpp in frame.hpp (P4) JDK-8260306: Do not include osThread.hpp in thread.hpp (P4) JDK-8248877: Document API contract for MetaspaceObj subtypes (P4) JDK-8261023: Document why memory pretouch must be a store (P4) JDK-8264358: Don't create invalid oop in method handle tracing (P4) JDK-8256417: Exclude TestJFRWithJMX test from running with PodMan (P4) JDK-8268475: execute runtime/InvocationTests w/ -UseVtableBasedCHA (P4) JDK-8256717: Expire the long term obsoleted VM flags (P4) JDK-8262163: Extend settings printout in jcmd VM.metaspace (P4) JDK-8267553: Extra JavaThread assignment in ClassLoader::create_class_path_entry() (P4) JDK-8266404: Fatal error report generated with -XX:+CrashOnOutOfMemoryError should not contain suggestion to submit a bug report (P4) JDK-8261949: fileStream::readln returns incorrect line string (P4) JDK-8267555: Fix class file version during redefinition after 8238048 (P4) JDK-8259713: Fix comments about ResetNoHandleMark in deoptimization (P4) JDK-8265980: Fix systemDictionary and loaderConstraints printing (P4) JDK-8234773: Fix ThreadsSMRSupport::_bootstrap_list (P4) JDK-8265484: Fix up TRAPS usage in GenerateOopMap::compute_map and callers (P4) JDK-8262828: Format of OS information is different on macOS (P4) JDK-8265682: G1: Mutex::_name dangling in HeapRegionRemSet references after JDK-8264146 (P4) JDK-8262443: GenerateOopMap::do_interpretation can spin for a long time. (P4) JDK-8213177: GlobalCounter::CSContext could be an enum class (P4) JDK-8258415: gtest for committed memory leaks reservation (P4) JDK-8259897: gtest os.dll_address_to_function_and_library_name_vm fails on AIX (P4) JDK-8239386: handle ContendedPaddingWidth in vm_version_aarch64 (P4) JDK-8262454: Handshake timeout improvements, single target, kill unfinished thread (P4) JDK-8262094: Handshake timeout scaled wrong (P4) JDK-8265298: Hard VM crash when deadlock between "access" and higher ranked lock is detected (P4) JDK-8262500: HostName entry in VM.info should be a new line (P4) JDK-8266530: HotSpot changes for JEP 306 (P4) JDK-8265120: hs_err improvement: align the output of Virtual space metadata (P4) JDK-8266015: Implement AdapterHandlerLibrary lookup fast-path for common adapters (P4) JDK-8253819: Implement os/cpu for macOS/AArch64 (P4) JDK-8258058: improve description of OutOfMemoryError relevant flags (P4) JDK-8258810: Improve enum traits (P4) JDK-8263632: Improve exception handling of APIs in classLoader.cpp (P4) JDK-8266642: Improve ResolvedMethodTable hash function (P4) JDK-8260030: Improve stringStream buffer handling (P4) JDK-8265047: Inconsistent warning message in jcmd VM.log (P4) JDK-8255859: Incorrect comments in log.hpp (P4) JDK-8264008: Incorrect metaspace statistics after JEP 387 when UseCompressedClassPointers is off (P4) JDK-8259843: initialize dli_fname array before calling dll_address_to_library_name (P4) JDK-8249262: Initialize InstanceKlass::_package_entry during CDS dump time (P4) JDK-8261478: InstanceKlass::set_classpath_index does not match comments (P4) JDK-8264731: Introduce InstanceKlass::method_at_itable_or_null() (P4) JDK-8263589: Introduce JavaValue::get_oop/set_oop (P4) JDK-8251438: Issues with our POSIX set_signal_handler() (P4) JDK-8241403: JavaThread::get_thread_name() should be ThreadSMR-aware (P4) JDK-8265465: jcmd VM.cds should keep already dumped archive when exception happens (P4) JDK-8259539: JDK-8255711 broke trap messages (P4) JDK-8264524: jdk/internal/platform/docker/TestDockerMemoryMetrics.java fails due to swapping not working (P4) JDK-8262501: jdk17 libjvm link failure with --as-needed and clock_gettime in librt (P4) JDK-8269025: jsig/Testjsig.java doesn't check exit code (P4) JDK-8260404: jvm_io.h include missing in a number of files (P4) JDK-8262913: KlassFactory::create_from_stream should never return NULL (P4) JDK-8178348: left_n_bits(0) invokes undefined behavior (P4) JDK-8261268: LOAD_INSTANCE placeholders unneeded for parallelCapable class loaders (P4) JDK-8261966: macOS M1: report in hs_err log if we are running x86 code in emulation mode (Rosetta) (P4) JDK-8264273: macOS: zero VM is broken due to no member named 'is_cpu_emulated' after JDK-8261966 (P4) JDK-8262402: Make CATCH macro assert not fatal (P4) JDK-8266498: Make debug ps() call print_stack (P4) JDK-8262028: Make InstanceKlass::implementor return InstanceKlass (P4) JDK-8264146: Make Mutex point to rather than embed _name (P4) JDK-8263896: Make not_suspended parameter from ObjectMonitor::exit() have default value (P4) JDK-8259374: Make ThreadInVMfromNative have ResetNoHandleMark (P4) JDK-8263185: Mallinfo deprecated in glibc 2.33 (P4) JDK-8267917: mark hotspot containers tests which ignore external VM flags (P4) JDK-8268601: mark hotspot runtime/records tests which ignore external VM flags (P4) JDK-8268599: mark hotspot runtime/sealedClasses tests which ignore external VM flags (P4) JDK-8268598: mark hotspot runtime/stringtable tests which ignore external VM flags (P4) JDK-8268597: mark hotspot runtime/symboltable tests which ignore external VM flags (P4) JDK-8268596: mark hotspot runtime/verifier tests which ignore external VM flags (P4) JDK-8262326: MaxMetaspaceSize does not have to be aligned to metaspace commit alignment (P4) JDK-8264742: member variable _monitor of MonitorLocker is redundant (P4) JDK-8259214: MetaspaceClosure support for Arrays of MetaspaceObj (P4) JDK-8261480: MetaspaceShared::preload_and_dump should check exceptions (P4) JDK-8261449: Micro-optimize JVM_LatestUserDefinedLoader (P4) JDK-8258479: Minor cleanups in VMError (P4) JDK-8267095: Miscellaneous cleanups in vm.runtime.defmeth tests (P4) JDK-8260025: Missing comma in VM_Version_Ext::_family_id_amd (P4) JDK-8259859: Missing metaspace NMT memory tag (P4) JDK-8243205: Modularize JVM flags declaration (P4) JDK-8263421: Module image file is opened twice during VM startup (P4) JDK-8226416: MonitorUsedDeflationThreshold can cause repeated async deflation requests (P4) JDK-8264711: More runtime TRAPS cleanups (P4) JDK-8266087: Move 'buffer' declaration in get_user_name_slow() inside of linux specific code (P4) JDK-8265696: Move CDS sources to src/hotspot/shared/cds (P4) JDK-8261608: Move common CDS archive building code to archiveBuilder.cpp (P4) JDK-8260264: Move common os_ inline methods to a common posix source file (P4) JDK-8265933: Move Java monitor related fields from class Thread to JavaThread (P4) JDK-8259845: Move placeholder implementation details to cpp file and add logging (P4) JDK-8265932: Move safepoint related fields from class Thread to JavaThread (P4) JDK-8260019: Move some Thread subtypes out of thread.hpp (P4) JDK-8263974: Move SystemDictionary::verify_protection_domain (P4) JDK-8261125: Move VM_Operation to vmOperation.hpp (P4) JDK-8260467: Move well-known classes from systemDictionary.hpp to vmClasses.hpp (P4) JDK-8134540: Much nearly duplicated code for PerfMemory support (P4) JDK-8262165: NMT report should state how many callsites had been skipped (P4) JDK-8261238: NMT should not limit baselining by size threshold (P4) JDK-8261297: NMT: Final report should use scale 1 (P4) JDK-8261302: NMT: Improve malloc site table hashing (P4) JDK-8261600: NMT: Relax memory order for updating MemoryCounter and fix racy updating of peak values (P4) JDK-8261644: NMT: Simplifications and cleanups (P4) JDK-8261334: NMT: tuning statistic shows incorrect hash distribution (P4) JDK-8264346: nullptr_t undefined in global namespace for clang+libstdc++ (P4) JDK-8256301: ObjectMonitor::is_busy() should return bool (P4) JDK-8265313: Obsolete the unused AssertOnSuspendWaitFailure and TraceSuspendWaitFailures flags (P4) JDK-8263871: On sem_destroy() failing we should assert (P4) JDK-8258606: os::print_signal_handlers() should resolve the function name of the handlers (P4) JDK-8261939: os::strdup_check_oom() should be used in os::same_files() in os_windows.cpp (P4) JDK-8267118: OutOfMemoryError cannot be caught as a Throwable (P4) JDK-8262377: Parallel class resolution loses constant pool error (P4) JDK-8258048: Placeholder hash code is the same as Dictionary hash code (P4) JDK-8263557: Possible NULL dereference in Arena::destruct_contents() (P4) JDK-8263558: Possible NULL dereference in fast path arena free if ZapResourceArea is true (P4) JDK-8244540: Print more information with -XX:+PrintSharedArchiveAndExit (P4) JDK-8261167: print_process_memory_info add a close call after fopen (P4) JDK-8266891: Provide a switch to force the class space to a specific location (P4) JDK-8266536: Provide a variant of os::iso8601_time which works with arbitrary timestamps (P4) JDK-8265606: Reduce allocations in AdapterHandlerLibrary::get_adapter (P4) JDK-8261672: Reduce inclusion of classLoaderData.hpp (P4) JDK-8261106: Reduce inclusion of jniHandles.hpp (P4) JDK-8261868: Reduce inclusion of metaspace.hpp (P4) JDK-8264868: Reduce inclusion of registerMap.hpp and register.hpp (P4) JDK-8259882: Reduce the inclusion of perfData.hpp (P4) JDK-8202750: Reduce the use of get_canonical_path() in CDS (P4) JDK-8263771: Refactor javaClasses initialization code to isolate dumping code (P4) JDK-8259894: refactor parts of jvm.h into jvm_io.h and jvm_constants.h (P4) JDK-8266017: Refactor the *klass::array_klass_impl code to separate the non-exception-throwing API (P4) JDK-8214455: Relocate CDS archived regions to the top of the G1 heap (P4) JDK-8259372: remove AIX related USE_LIBRARY_BASED_TLS_ONLY and THREAD_LOCAL special handling (P4) JDK-8258018: Remove arrayOop.inline.hpp (P4) JDK-8263976: Remove block allocation from BasicHashtable (P4) JDK-8246112: Remove build-time and run-time checks for clock_gettime and CLOCK_MONOTONIC (P4) JDK-8265327: Remove check_safepoint_and_suspend_for_native_trans() (P4) JDK-8267934: remove dead code in CLD (P4) JDK-8268018: remove dead code in commitLimitter (P4) JDK-8263992: Remove dead code NativeLookup::base_library_lookup (P4) JDK-8265972: Remove declarations with no implementations in javaClasses.hpp (P4) JDK-8257731: Remove excessive include of stubRoutines.hpp (P4) JDK-8260629: Remove explicit instantiation of Hashtable with oop value (P4) JDK-8258937: Remove JVM IgnoreRewrites flag (P4) JDK-8259317: Remove JVM option BreakAtWarning (P4) JDK-8258908: Remove JVM option CleanChunkPoolAsync (P4) JDK-8258837: Remove JVM option DisableStartThread (P4) JDK-8258839: Remove JVM option ExitVMOnVerifyError (P4) JDK-8258838: Remove JVM option UseStackBanging (P4) JDK-8258912: Remove JVM options CountJNICalls and CountJVMCalls (P4) JDK-8260193: Remove JVM_GetInterfaceVersion() and JVM_DTraceXXX (P4) JDK-8265753: Remove manual JavaThread transitions to blocked (P4) JDK-8263998: Remove mentions of mc region in comments (P4) JDK-8267653: Remove Mutex::_safepoint_check_sometimes (P4) JDK-8263595: Remove oop type punning in JavaCallArguments (P4) JDK-8256213: Remove os::split_reserved_memory (P4) JDK-8259809: Remove PerfEvent class loading locking counters (P4) JDK-8261551: Remove special CDS handling in Metaspace::allocate (P4) JDK-8264997: Remove SystemDictionary::cache_get (P4) JDK-8258896: Remove the JVM ForceFloatExceptions option (P4) JDK-8264881: Remove the old development option MemProfiling (P4) JDK-8261280: Remove THREAD argument from compute_loader_lock_object (P4) JDK-8264193: Remove TRAPS parameters for modules and defaultmethods (P4) JDK-8264126: Remove TRAPS/THREAD parameter for class loading functions (P4) JDK-8264142: Remove TRAPS/THREAD parameters for verifier related functions (P4) JDK-8223056: Remove Type-Stable-Memory support for Parkers (P4) JDK-8265101: Remove unnecessary functions in os*.inline.hpp (P4) JDK-8265103: Remove unnecessary inclusion of oopMap.hpp (P4) JDK-8258004: Remove unnecessary inclusion of vm_version.hpp (P4) JDK-8265035: Remove unneeded exception check from refill_ic_stubs() (P4) JDK-8260222: remove unused _thread member SymbolTableLookup (P4) JDK-8261998: Remove unused shared entry support from utilities/hashtable (P4) JDK-8264051: Remove unused TRAPS parameters from runtime functions (P4) JDK-8266950: Remove vestigial support for non-strict floating-point execution (P4) JDK-8261662: Rename compute_loader_lock_object (P4) JDK-8267431: Rename InstanceKlass::has_old_class_version to can_be_verified_at_dumptime (P4) JDK-8260625: Rename MetaspaceExpand_lock (P4) JDK-8266822: Rename MetaspaceShared::is_old_class to be more explicit about what "old" means (P4) JDK-8263068: Rename safefetch.hpp to safefetch.inline.hpp (P4) JDK-8264538: Rename SystemDictionary::parse_stream (P4) JDK-8257815: Replace global log2 functions with efficient implementations (P4) JDK-8259486: Replace PreserveExceptionMark with implementation for CautiouslyPreserveExceptionMark (P4) JDK-8267953: restore 'volatile' to ObjectMonitor::_owner field (P4) JDK-8261585: Restore HandleArea used in Deoptimization::uncommon_trap (P4) JDK-8263915: runtime/cds/appcds/MismatchedPathTriggerMemoryRelease.java fails when UseCompressedClassPointers is off (P4) JDK-8267351: runtime/cds/SharedBaseAddress.java fails on x86_32 due to Unrecognized VM option 'UseCompressedOops' (P4) JDK-8267651: runtime/handshake/HandshakeTimeoutTest.java times out when dumping core (P4) JDK-8265017: runtime/HiddenClasses/StressHiddenClasses.java timed out on Win* OCI (P4) JDK-8268580: runtime/memory/LargePages/TestLargePagesFlags.java should be run in driver mode (P4) JDK-8264672: runtime/ParallelLoad/ParallelSuperTest.java timed out (P4) JDK-8268565: runtime/records/RedefineRecord.java should be run in driver mode (P4) JDK-8261552: s390: MacroAssembler::encode_klass_not_null() may produce wrong results for non-zero values of narrow klass base (P4) JDK-8257828: SafeFetch may crash if invoked in non-JavaThreads (P4) JDK-8265453: SafepointMechanism::should_process() should receive JavaThread* (P4) JDK-8256304: should MonitorUsedDeflationThreshold be experimental or diagnostic (P4) JDK-8260485: Simplify and unify handler vectors in Posix signal code (P4) JDK-8268544: some runtime/sealedClasses tests should be run in driver mode (P4) JDK-8268543: some runtime/verifier tests should be run in driver mode (P4) JDK-8265757: stack-use-after-scope in perfMemory_posix.cpp get_user_name_slow() (P4) JDK-8261090: Store old classfiles in static CDS archive (P4) JDK-8266252: Streamline AbstractInterpreter::method_kind (P4) JDK-8259068: Streamline class loader locking (P4) JDK-8229517: Support for optional asynchronous/buffered logging (P4) JDK-8255493: Support for pre-generated java.lang.invoke classes in CDS dynamic archive (P4) JDK-8258853: Support separate function declaration and definition with ENABLE_IF-based SFINAE (P4) JDK-8257831: Suspend with handshakes (P4) JDK-8254246: SymbolHashMapEntry wastes space (P4) JDK-8259839: SystemDictionary exports too much implementation (P4) JDK-8258408: SystemDictionary passes TRAPS to functions that don't throw exceptions (P4) JDK-8242300: SystemDictionary::resolve_super_or_fail() should look for the super class first (P4) JDK-8262328: Templatize JVMFlag boilerplate access methods (P4) JDK-8260630: Templatize literal_size (P4) JDK-8267339: Temporarily disable os.release_multi_mappings_vm on macOS x64 (P4) JDK-8257804: Test runtime/modules/ModuleStress/ModuleStressGC.java fails: 'package test defined in module jdk.test, exports list being walked' missing from stdout/stderr (P4) JDK-8259563: The CPU model name is printed multiple times when using -Xlog:os+cpu (P4) JDK-8191786: Thread-SMR hash table size should be dynamic (P4) JDK-8265867: thread.hpp defines some enums but no reference (P4) JDK-8264372: Threads::destroy_vm only ever returns true (P4) JDK-8231627: ThreadsListHandleInErrorHandlingTest.java fails in printing all threads (P4) JDK-8259397: ThreadsSMRSupport::print_info_on() should use try_lock_without_rank_check() (P4) JDK-8267839: trivial mem leak in numa (P4) JDK-8258576: Try to get zerobased CCS if heap is above 32 and CDS is disabled (P4) JDK-8262955: Unify os::fork_and_exec() across Posix platforms (P4) JDK-8263430: Uninitialized Method* variables after JDK-8233913 (P4) JDK-8265285: Unnecessary inclusion of bytecodeHistogram.hpp (P4) JDK-8263544: Unused argument in ConstantPoolCacheEntry::set_field() (P4) JDK-8264178: Unused method Threads::nmethods_do (P4) JDK-8263718: unused-result warning happens at os_linux.cpp (P4) JDK-8260194: Update the documentation for -Xcheck:jni (P4) JDK-8258075: Use auto variable declarations for enum iteration (P4) JDK-8252173: Use handles instead of jobjects in modules.cpp (P4) JDK-8267089: Use typedef KVHashtable for ID2KlassTable (P4) JDK-8253910: UseCompressedClassPointers depends on UseCompressedOops in vmError.cpp (P4) JDK-8264337: VM crashed when -XX:+VerifySharedSpaces (P4) JDK-8252148: vmError::controlled_crash should be #ifdef ASSERT and move tests to gtest (P4) JDK-8257530: vmTestbase/metaspace/stressDictionary/StressDictionary.java timed out (P4) JDK-8267293: vmTestbase/vm/mlvm/anonloader/stress/oome/metaspace/Test.java fails when JTREG_JOBS > 25 (P4) JDK-8266496: WBIsKlassAliveClosure.do_klass() fails for hidden classes (P4) JDK-8264540: WhiteBox.metaspaceReserveAlignment should return shared region alignment (P4) JDK-8262368: wrong verifier message for bogus return type (P4) JDK-8258073: x86_32 build broken after JDK-8257731 (P4) JDK-8259565: Zero: compiler/runtime/criticalnatives fails because CriticalJNINatives is not supported (P4) JDK-8259403: Zero: crash with NULL MethodHandle receiver (P4) JDK-8259228: Zero: rewrite (put|get)field from if-else chains to switches (P4) JDK-8259368: Zero: UseCompressedClassPointers does not depend on UseCompressedOops (P5) JDK-8263616: 'Deprecatd' typo in src/hotspot/share/classfile/classFileParser.cpp (P5) JDK-8265607: Avoid decrementing when no Symbol was created in ~SignatureStream (P5) JDK-8266412: Remove redundant TemplateInterpreter entries (P5) JDK-8261652: Remove some dead comments from os_bsd_x86 hotspot/svc: (P3) JDK-8269232: assert(!is_jweak(handle)) failed: wrong method for detroying jweak (P3) JDK-8267842: SIGSEGV in get_current_contended_monitor (P3) JDK-8265148: StackWatermarkSet being updated during AsyncGetCallTrace (P4) JDK-8260282: Add option to compress heap dumps created by -XX:+HeapDumpOnOutOfMemoryError (P4) JDK-8254941: Implement Serviceability Agent for macOS/AArch64 (P4) JDK-8262157: LingeredApp.startAppExactJvmOpts does not print app output when launching fails (P4) JDK-8268564: mark hotspot serviceability/attach tests which ignore external VM flags (P4) JDK-8268536: mark hotspot serviceability/dcmd tests which ignore external VM flags (P4) JDK-8268538: mark hotspot serviceability/logging tests which ignore external VM flags (P4) JDK-8268541: mark hotspot serviceability/sa tests which ignore external VM flags (P4) JDK-8268531: mark SDTProbesGNULinuxTest as ignoring external VM flags (P4) JDK-8266795: Remove dead code LowMemoryDetectorDisabler (P4) JDK-8259242: Remove ProtectionDomainSet_lock (P4) JDK-8268542: serviceability/logging/TestFullNames.java tests only 1st test case (P4) JDK-8268532: several serviceability/attach tests should be run in driver mode (P4) JDK-8268539: several serviceability/sa tests should be run in driver mode (P4) JDK-8264565: Templatize num_arguments() functions of DCmd subclasses (P4) JDK-8266337: ThreadTimesClosure doesn't handle exceptions properly hotspot/svc-agent: (P3) JDK-8261098: Add clhsdb "findsym" command (P3) JDK-8261692: Bugs in clhsdb history support (P3) JDK-8261702: ClhsdbFindPC can fail due to PointerFinder incorrectly thinking an address is in a .so (P3) JDK-8247514: Improve clhsdb 'findpc' ability to determine what an address points to by improving PointerFinder and PointerLocation classes (P3) JDK-8243455: Many SA tests can fail due to trying to get the stack trace of an active method (P3) JDK-8269830: SA's vm object vtable matching code sometimes matches on incorrect type (P3) JDK-8261269: When using clhsdb to "inspect" a java object, clhsdb prints "Oop for..." twice (P4) JDK-8258471: "search codecache" clhsdb command does not work (P4) JDK-8263546: Add "findsym" command to clhsdb.html help file (P4) JDK-8263342: Add --connect option to jhsdb hsdb/clhsdb (P4) JDK-8263636: Add --disable-registry option to jhsdb debugd (P4) JDK-8263635: Add --servername option to jhsdb debugd (P4) JDK-8262520: Add SA Command Line Debugger support to connect to debug server (P4) JDK-8261095: Add test for clhsdb "symbol" command (P4) JDK-8259008: ArithmeticException was thrown at "Monitor Cache Dump" on HSDB (P4) JDK-8261711: Clhsdb "versioncheck true" throws NPE every time (P4) JDK-8261929: ClhsdbFindPC fails with java.lang.RuntimeException: 'In java stack' missing from stdout/stderr (P4) JDK-8259045: Exception message from saproc.dll is garbled on Windows with Japanese locale (P4) JDK-8265505: findsym does not work on remote debug server (P4) JDK-8259009: G1 heap summary should be shown in "Heap Parameters" window on HSDB (P4) JDK-8263055: hsdb Command Line Debugger does not properly direct output for some commands (P4) JDK-8263140: Japanese chars garble in console window in HSDB (P4) JDK-8262466: linux libsaproc/DwarfParser.cpp delete DwarfParser object in early return (P4) JDK-8259037: livenmethods cannot find hsdis library (P4) JDK-8248876: LoadObject with bad base address created for exec file on linux (P4) JDK-8266038: Move newAddress() to JVMDebugger (P4) JDK-8263565: NPE was thrown when sun.jvm.hotspot.rmi.serverNamePrefix was set (P4) JDK-8263670: pmap and pstack in jhsdb do not work on debug server (P4) JDK-8257988: Remove JNF dependency from libsaproc/MacosxDebuggerLocal.m (P4) JDK-8264484: Replace uses of StringBuffer with StringBuilder in jdk.hotspot.agent (P4) JDK-8261607: SA attach is exceeding JNI Local Refs capacity (P4) JDK-8261710: SA DSO objects have sizes that are too large (P4) JDK-8266957: SA has not followed JDK-8220587 and JDK-8224965 (P4) JDK-8261431: SA: Add comments about load address of executable (P4) JDK-8262271: SA: Add new stress test that tests getting the stack trace of an active thread (P4) JDK-8176026: SA: Huge heap sizes cause a negative value to be displayed in the jhisto heap total (P4) JDK-8263477: serviceability/sa/ClhsdbDumpheap.java timed out (P4) JDK-8261857: serviceability/sa/ClhsdbPrintAll.java failed with "Test ERROR java.lang.RuntimeException: 'cannot be cast to' found in stdout" (P4) JDK-8262504: Some CLHSDB command cannot know they run on remote debugger (P4) JDK-8264734: Some SA classes could use better hashCode() implementation (P4) JDK-8255661: TestHeapDumpOnOutOfMemoryError fails with EOFException (P4) JDK-8266531: ZAddress::address() should be removed from SA (P5) JDK-8263572: Output from jstack mixed mode is misaligned hotspot/test: (P2) JDK-8263549: 8263412 can cause jtreg testlibrary split (P2) JDK-8263548: runtime/cds/appcds/SharedRegionAlignmentTest.java fails to compile after JDK-8263412 (P3) JDK-8267448: Add "ulimit -a" to environment.html (P3) JDK-8267805: Add UseVtableBasedCHA to the list of JVM flags known to jtreg (P4) JDK-8262188: Add test to verify trace page sizes logging on Linux (P4) JDK-8263412: ClassFileInstaller can't be used by classes outside of default package (P4) JDK-8264686: ClhsdbTestConnectArgument.java should use SATestUtils::validateSADebugDPrivileges (P4) JDK-8268279: gc/shenandoah/compiler/TestLinkToNativeRBP.java fails after LibraryLookup is gone (P4) JDK-8257229: gtest death tests fail with unrecognized stderr output (P4) JDK-8246494: introduce vm.flagless at-requires property (P4) JDK-8263659: Reflow GTestResultParser for better readability (P4) JDK-8263556: remove `@modules java.base` from tests (P4) JDK-8263555: use driver-mode to run ClassFileInstaller (P5) JDK-8252530: Fix inconsistencies in hotspot whitebox infrastructure: (P1) JDK-8268146: fix for JDK-8266254 fails validate-source (P3) JDK-8268768: idea.sh has been updated in surprising and incompatible ways (P3) JDK-8268901: JDK-8268768 missed removing two files (P3) JDK-8268185: Update GitHub Actions for jtreg 6 (P3) JDK-8266254: Update to use jtreg 6 infrastructure/build: (P1) JDK-8265982: JDK-8264188 breaks build on macOS-aarch64 (P2) JDK-8259656: fixpath.sh changes broke _NT_SYMBOL_PATH in RunTests.gmk (P2) JDK-8259924: GitHub actions fail on Linux x86_32 with "Could not configure libc6:i386" (P2) JDK-8259679: GitHub actions should use MSVC 14.28 (P2) JDK-8269148: Update minor GCC version in GitHub Actions pipeline (P3) JDK-8265483: All-caps “JAVA” in the top navigation bar (P3) JDK-8260272: bash configure --prefix does not work after JDK-8257679 (P3) JDK-8260518: Change default -mmacosx-version-min to 10.12 (P3) JDK-8265373: Change to GCC 10.3 for building on Linux at Oracle (P3) JDK-8265371: Change to Visual Studio 2019 16.9.3 for building on Windows at Oracle (P3) JDK-8260406: Do not copy pure java source code to gensrc (P3) JDK-8264188: Improve handling of assembly files in the JDK (P3) JDK-8261843: incorrect info in docs/building.html (P3) JDK-8268083: JDK-8267706 breaks bin/idea.sh on a Mac (P3) JDK-8251210: Link JDK api docs to other versions (P3) JDK-8266858: macOS port for ARM (P3) JDK-8260669: Missing quotes in fixpath.sh (P3) JDK-8258447: Move make/hotspot/hotspot.script to make/scripts (P3) JDK-8258449: Move make/hotspot/symbols to make/data (P3) JDK-8258445: Move make/templates to make/data (P3) JDK-8258411: Move module set configuration from Modules.gmk to conf dir (P3) JDK-8258420: Move URL configuration from Docs.gmk to conf dir (P3) JDK-8258426: Split up autoconf/version-numbers and move it to conf dir (P3) JDK-8258407: Split up CompileJavaModules.gmk into make/modules/$M/Java.gmk (P3) JDK-8268643: SVML lib shouldn't be generated when C2 is absent (P3) JDK-8261261: The version extra fields needs to be overridable in jib-profiles.js (P3) JDK-8264863: Update JCov version to support JDK 17 (P4) JDK-8267246: -XX:MaxRAMPercentage=0 is unreasonable for jtreg tests on many-core machines (P4) JDK-8264848: [macos] libjvm.dylib linker warning due to macOS version mismatch (P4) JDK-8261109: [macOS] Remove disabled warning for JNF in make/autoconf/flags-cflags.m4 (P4) JDK-8265192: [macos_aarch64] configure script fails if GNU uname in PATH (P4) JDK-8265431: Add -fno-delete-null-pointer-checks to clang builds (P4) JDK-8264224: Add macosx-aarch64 to Oracle build configurations (P4) JDK-8257913: Add more known library locations to simplify Linux cross-compilation (P4) JDK-8266465: Add wildcard to JTwork/JTreport exclude in jib-profiles.js (P4) JDK-8263667: Avoid running GitHub actions on branches named pr/* (P4) JDK-8267706: bin/idea.sh tries to use cygpath on WSL (P4) JDK-8264874: Build interim-langtools for HotSpot only if Graal is enabled (P4) JDK-8265782: Bump bootjdk to jdk-17+19 on macosx-aarch64 at Oracle (P4) JDK-8267304: Bump global JTReg memory limit to 768m (P4) JDK-8257459: Bump minimum boot jdk to JDK 16 (P4) JDK-8255776: Change build system for macOS/AArch64 (P4) JDK-8264623: Change to Xcode 12.4 for building on Macos at Oracle (P4) JDK-8266167: Clean up GCC 11 warnings (P4) JDK-8259559: COMPARE_BUILD can't compare patch files (P4) JDK-8258925: configure script failed on WSL (P4) JDK-8264650: Cross-compilation to macos/aarch64 (P4) JDK-8268861: Disable Windows-Aarch64 build in GitHub Actions (P4) JDK-8265531: doc/building.md should mention homebrew install freetype (P4) JDK-8259485: Document need for short paths when building on Windows (P4) JDK-8265666: Enable AIX build platform to make external debug symbols (P4) JDK-8259942: Enable customizations in CompileJavaModules.gmk and Main.gmk (P4) JDK-8262893: Enable more doclint checks in javadoc build (P4) JDK-8263856: Github Actions for macos/aarch64 cross-build (P4) JDK-8260460: GitHub actions still fail on Linux x86_32 with "Could not configure libc6:i386" (P4) JDK-8261149: Initial nroff manpage update for JDK 17 (P4) JDK-8256313: JavaCompilation.gmk needs to be updated not to use --doclint-format html5 option (P4) JDK-8268299: jvms tag produces incorrect URL (P4) JDK-8268142: Switch to jdk-17+24 for macosx-aarch64 at Oracle (P4) JDK-8266318: Switch to macos prefix for macOS bundles (P4) JDK-8260289: Unable to customize module lists after change JDK-8258411 (P4) JDK-8258143: Update --release 16 symbol information for JDK 16 build 30 or later (P4) JDK-8259512: Update --release 16 symbol information for JDK 16 build 31 (P4) JDK-8265343: Update Debian-based cross-compilation recipes (P4) JDK-8263097: Update JMH devkit to 1.28 (P4) JDK-8268214: Use system zlib and disable dtrace when building linux-aarch64 at Oracle (P4) JDK-8259949: x86 32-bit build fails when -fcf-protection is passed in the compiler flags install/test: (P4) JDK-8257995: [TEST_BUG] Add JPackage java manual test to verify publisher has been set other-libs: (P2) JDK-8268230: Foreign Linker API & Windows user32/kernel32: String conversion seems broken other-libs/other: (P4) JDK-8261938: ASN1Formatter.annotate should not return in the finally block (P4) JDK-8264809: test-lib fails to build due to some warnings in ASN1Formatter and jfr security-libs: (P3) JDK-8266293: Key protection using PBEWithMD5AndDES fails with "java.security.InvalidAlgorithmParameterException: Salt must be 8 bytes long" (P3) JDK-8268093: Manual Testcase: "sun/security/krb5/config/native/TestDynamicStore.java" Fails with NPE (P4) JDK-8267817: [TEST] Remove unnecessary init in test/micro/org/openjdk/bench/javax/crypto/full/AESGCMBench:setup (P4) JDK-8218686: Remove dependency on Mac OS X Native Framework: security (P4) JDK-8253866: Security Libs Terminology Refresh security-libs/java.security: (P2) JDK-8196415: Disable SHA-1 Signed JARs (P2) JDK-8263404: RsaPrivateKeySpec is always recognized as RSAPrivateCrtKeySpec in RSAKeyFactory.engineGetKeySpec (P3) JDK-8257858: [macOS]: Remove JNF dependency from libosxsecurity/KeystoreImpl.m (P3) JDK-8256421: Add 2 HARICA roots to cacerts truststore (P3) JDK-8259401: Add checking to jarsigner to warn weak algorithms used in signer’s cert chain (P3) JDK-8259338: Add expiry exception for identrustdstx3 alias to VerifyCACerts.java test (P3) JDK-8256895: Add support for RFC 8954: Online Certificate Status Protocol (OCSP) Nonce Extension (P3) JDK-8267397: AlgorithmId's OID cache is never refreshed (P3) JDK-8266459: Implement JEP 411: Deprecate the Security Manager for Removal (P3) JDK-8266400: importkeystore fails to a password less pkcs12 keystore (P3) JDK-8179503: Java should support GET OCSP calls (P3) JDK-8246005: KeyStoreSpi::engineStore(LoadStoreParameter) spec mismatch to its behavior (P3) JDK-8268678: LetsEncryptCA.java test fails as Let’s Encrypt Authority X3 is retired (P3) JDK-8255348: NPE in PKIXCertPathValidator event logging code (P3) JDK-8267543: Post JEP 411 refactoring: security (P3) JDK-8268349: Provide clear run-time warnings about Security Manager deprecation (P3) JDK-8225081: Remove Telia Company CA certificate expiring in April 2021 (P3) JDK-8263105: security-libs doclint cleanup (P3) JDK-8268525: Some new memory leak after JDK-8248268 and JDK-8255557 (P3) JDK-8258915: Temporary buffer cleanup (P3) JDK-8261778: Update JDK documentation links in Standard Algorithm Names page (P3) JDK-8257497: Update keytool to create AKID from the SKID of the issuing certificate as specified by RFC 5280 (P4) JDK-8258796: [test] Apply HexFormat to tests for java.security (P4) JDK-8267184: Add -Djava.security.manager=allow to tests calling System.setSecurityManager (P4) JDK-8261472: BasicConstraintsExtension::toString shows "PathLen:2147483647" if there is no pathLenConstraint (P4) JDK-8263978: Clarify why 0 argument is ignored in SecureRandom::setSeed (P4) JDK-8264956: Document new options in keytool -genkeypair to sign and generate the certificate (P4) JDK-8259517: Incorrect test path in test cases (P4) JDK-8254717: isAssignableFrom checks in KeyFactorySpi.engineGetKeySpec appear to be backwards (P4) JDK-8266220: keytool still prompt for store password on a password-less pkcs12 file if -storetype pkcs12 is specified (P4) JDK-8264606: More comment for ECDH public key validation (P4) JDK-8265227: Move Proc.java from security/testlibrary to test/lib (P4) JDK-8264864: Multiple byte tag not supported by ASN.1 encoding (P4) JDK-8259065: Optimize MessageDigest.getInstance (P4) JDK-8267521: Post JEP 411 refactoring: maximum covering > 50K (P4) JDK-8260693: Provide the support for specifying a signer in keytool -genkeypair (P4) JDK-8259498: Reduce overhead of MD5 and SHA digests (P4) JDK-8268267: Remove -Djavatest.security.noSecurityManager=true from jtreg runs (P4) JDK-8240997: Remove more "hack" word in security codes (P4) JDK-8265138: Simplify DerUtils::checkAlg (P4) JDK-8252055: Use java.util.HexFormat in java.security (P5) JDK-8264681: Use the blessed modifier order in java.security security-libs/javax.crypto: (P2) JDK-8261462: GCM ByteBuffer decryption problems (P3) JDK-8255557: Decouple GCM from CipherCore (P3) JDK-8261502: ECDHKeyAgreement: Allows alternate ECPrivateKey impl and revised exception handling (P3) JDK-8023980: JCE doesn't provide any class to handle RSA private key in PKCS#1 (P3) JDK-8248223: KeyAgreement spec update on multi-party key exchange support (P3) JDK-8236671: NullPointerException in JKS keystore (P3) JDK-8262316: Reducing locks in RSA Blinding (P3) JDK-8268621: SunJCE provider may throw unexpected NPE for un-initialized AES KW/KWP Ciphers (P3) JDK-8248268: Support KWP in addition to KW (P3) JDK-8264329: Z cannot be 1 for Diffie-Hellman key agreement (P4) JDK-8260274: Cipher.init(int, key) does not use highest priority provider for random bytes (P4) JDK-8269218: GaloisCounterMode.overlapDetection misses the JDK-8263436 fix again (P4) JDK-8263436: Silly array comparison in GaloisCounterMode.overlapDetection security-libs/javax.crypto:pkcs11: (P3) JDK-8269034: AccessControlException for SunPKCS11 daemon threads (P3) JDK-8255410: Add ChaCha20 and Poly1305 support to SunPKCS11 provider (P3) JDK-8240256: Better resource cleaning for SunPKCS11 Provider (P3) JDK-6676643: Improve current C_GetAttributeValue native implementation (P3) JDK-8268167: MultipleLogins.java failure on macosx-aarch64 (P3) JDK-8265500: Some impls of javax.crypto.Cipher.init() do not throw UnsupportedOperationExc for unsupported modes (P4) JDK-8258833: Cancel multi-part cipher operations in SunPKCS11 after failures (P4) JDK-8267721: Enable sun/security/pkcs11 tests for Amazon Linux 2 AArch64 (P4) JDK-8265462: Handle multiple slots in the NSS Internal Module from SunPKCS11's Secmod (P4) JDK-8259319: Illegal package access when SunPKCS11 requires SunJCE's classes (P4) JDK-8258851: Mismatch in SunPKCS11 provider registration properties and actual implementation (P4) JDK-8261355: No data buffering in SunPKCS11 Cipher encryption when the underlying mechanism has no padding (P4) JDK-8258186: Replace use of JNI_COMMIT mode with mode 0 security-libs/javax.net.ssl: (P2) JDK-8259582: Backout JDK-8237578 until all affected tests have been fixed (P3) JDK-8264948: Check for TLS extensions total length (P3) JDK-8217633: Configurable extensions with system properties (P3) JDK-8255148: Confusing log output: SSLSocket duplex close failed (P3) JDK-8169086: DTLS tests fail intermittently with too much loops or timeout (P3) JDK-8258914: javax/net/ssl/DTLS/RespondToRetransmit.java timed out (P3) JDK-8258736: No break in the loop (P3) JDK-8241248: NullPointerException in sun.security.ssl.HKDF.extract(HKDF.java:93) (P3) JDK-8263743: redundant lock in SSLSocketImpl (P3) JDK-8241372: Several test failures due to javax.net.ssl.SSLException: Connection reset (P3) JDK-8255867: SignatureScheme JSSE property does not preserve ordering in handshake messages (P3) JDK-8261969: SNIHostName should check if the encoded hostname conform to RFC 3490 (P3) JDK-8253368: TLS connection always receives close_notify exception (P4) JDK-8258852: Arrays.asList() for single item could be replaced with List.of() (P4) JDK-8259291: Cleanup unnecessary local variables (P4) JDK-8259385: Cleanup unused assignment (P4) JDK-8258804: Collection.toArray() should use empty array (P4) JDK-8228442: DHKeyExchange/LegacyDHEKeyExchange.java failed due to "SSLException: An established connection was aborted by the software in your host machine" (P4) JDK-8259662: Don't wrap SocketExceptions into SSLExceptions in SSLSocketImpl (P4) JDK-8266881: Enable debug log for SSLEngineExplorerMatchedSNI.java (P4) JDK-8259069: Fields could be final (P4) JDK-8253635: Implement toString() for SSLEngineImpl (P4) JDK-8259886: Improve SSL session cache performance and scalability (P4) JDK-8267750: Incomplete fix for JDK-8267683 (P4) JDK-8211227: Inconsistent TLS protocol version in debug output (P4) JDK-8258661: Inner class ResponseCacheEntry could be static (P4) JDK-8225438: javax/net/ssl/TLSCommon/TestSessionLocalPrincipal.java failed with Read timed out (P4) JDK-8237578: JDK-8214339 (SSLSocketImpl wraps SocketException) appears to not be fully fixed (P4) JDK-8262509: JSSE Server should check the legacy version in TLSv1.3 ClientHello (P4) JDK-8263188: JSSE should fail fast if there isn't supported signature algorithm (P4) JDK-8255283: Leading zeros in Diffie-Hellman keys are ignored (P4) JDK-8258514: Replace Collections.unmodifiableList with List.of (P4) JDK-8267683: rfc7301Grease8F value not displayed correctly in SSLParameters javadoc (P4) JDK-8259223: Simplify boolean expression in the SunJSSE provider (P4) JDK-8255674: SSLEngine class description is missing "case" in switch statement (P4) JDK-8263779: SSLEngine reports NEED_WRAP continuously without producing any further output (P4) JDK-8258828: The method local variable is not really used (P4) JDK-8260861: TrustStoreDescriptor log the same value (P4) JDK-8263137: Typos in sun.security.ssl.RenegoInfoExtension (P4) JDK-8261510: Use RFC numbers and protocol titles in sun.security.ssl.SSLExtension comments (P4) JDK-8264554: X509KeyManagerImpl calls getProtectionParameter with incorrect alias security-libs/javax.security: (P4) JDK-8263825: Remove unused and commented out member from NTLMException security-libs/javax.smartcardio: (P3) JDK-8252412: [macos11] system dynamic libraries removed from filesystem (P3) JDK-8263827: Suspend "missing" javadoc doclint checks for smartcardio security-libs/javax.xml.crypto: (P3) JDK-8241306: Add SignatureMethodParameterSpec subclass for RSASSA-PSS params (P3) JDK-8259709: Disable SHA-1 XML Signatures (P3) JDK-8259801: Enable XML Signature secure validation mode by default (P3) JDK-8255255: Update Apache Santuario (XML Signature) to version 2.2.1 (P4) JDK-8259535: ECDSA SignatureValue do not always have the specified length (P4) JDK-8264277: java.xml.crypto module should be granted FilePermission and SocketPermission security-libs/jdk.security: (P4) JDK-8266225: jarsigner is using incorrect security property to show weakness of certs (P4) JDK-8254942: Update the JAR file spec on EC and RSA signature block types security-libs/org.ietf.jgss: (P4) JDK-8210373: Deadlock in libj2gss.so when loading "j2gss" and "net" libraries in parallel. (P4) JDK-8250564: Remove terminally deprecated constructor in GSSUtil security-libs/org.ietf.jgss:krb5: (P3) JDK-8257860: [macOS]: Remove JNF dependency from libosxkrb5/SCDynamicStoreConfig.m (P3) JDK-8139348: Deprecate 3DES and RC4 in Kerberos (P4) JDK-8261481: Cannot read Kerberos settings in dynamic store on macOS Big Sur (P4) JDK-8258631: Remove sun.security.jgss.krb5.Krb5Util.getSubject() (P4) JDK-8267584: The java.security.krb5.realm system property only needs to be defined once (P4) JDK-8262389: Use permitted_enctypes if default_tkt_enctypes or default_tgs_enctypes is not present (P5) JDK-8263497: Clean up sun.security.krb5.PrincipalName::toByteArray specification/language: (P4) JDK-8261936: (Docs) Remove spec change documents for records & pattern matching (P4) JDK-8267658: 8.10.3: "floating point" rather than "floating-point" (P4) JDK-8261610: 9.6.4.1: Refine no-@Target to mean "applicable in all declaration contexts" (P4) JDK-8262890: JLS changes for Pattern Matching for switch (Preview) (P4) JDK-8244143: JLS changes for Restore Always-Strict Floating-Point Semantics (P4) JDK-8260515: JLS changes for Sealed Classes (P4) JDK-8268545: Patterns: Remove stale text about any patterns specification/vm: (P4) JDK-8257458: 4.1: Allow v61.0 class files for Java SE 17 (P4) JDK-8244144: JVMS changes for Restore Always-Strict Floating-Point Semantics (P4) JDK-8260516: JVMS changes for Sealed Classes tools: (P3) JDK-8258421: (jdeprscan) tools/jdeprscan/tests/jdk/jdeprscan/TestRelease.java failed with "error: cannot access jdk.internal.ValueBased" (P3) JDK-8265773: incorrect jdeps message "jdk8internals" to describe a removed JDK internal API (P4) JDK-8267162: Add jtreg test group definitions for langtools (P4) JDK-8267633: Clarify documentation of (Doc)TreeScanner (P4) JDK-8260560: convert jdeps and jdeprscan tools to use Stream.toList() (P4) JDK-8261096: Convert jlink tool to use Stream.toList() (P5) JDK-8264087: Use the blessed modifier order in jdk.jconsole tools/jar: (P3) JDK-8266835: Add a --validate option to the jar tool tools/javac: (P2) JDK-8264373: javac hangs when annotation is declared with sealed public modifier (P2) JDK-8268592: JDK-8262891 causes an NPE in Lint.augment (P2) JDK-8266596: StandardJavaFileManager: default impls of setLocationFromPaths(), getJavaFileObjectsFromPaths() methods don't throw IllegalArgumentException as specified (P2) JDK-8266631: StandardJavaFileManager: getJavaFileObjects() impl violates the spec (P3) JDK-8268871: Adjust javac to updated exhaustiveness specification (P3) JDK-8269738: AssertionError when combining pattern matching and function closure (P3) JDK-8261205: AssertionError: Cannot add metadata to an intersection type (P3) JDK-8268320: Better error recovery for broken patterns in switch (P3) JDK-8255464: Cannot access ModuleTree in a CompilationUnitTree (P3) JDK-8266036: class file for sun.misc.Contended not found (P3) JDK-8236490: Compiler bug relating to @NonNull annotation (P3) JDK-8268663: Crash when guards contain boolean expression (P3) JDK-8268766: Desugaring of pattern matching enum switch should be improved (P3) JDK-8262421: doclint warnings in jdk.compiler module (P3) JDK-8198317: Enhance JavacTool.getTask for flexibility (P3) JDK-8254571: Erroneous generic type inference in a lambda expression with a checked exception (P3) JDK-8259050: Error recovery in lexer could be improved (P3) JDK-8260517: implement Sealed Classes as a standard feature in Java (P3) JDK-8270151: IncompatibleClassChangeError on empty pattern switch statement case (P3) JDK-8261203: Incorrectly escaped javadoc html with type annotations (P3) JDK-8263614: javac allows local variables to be accessed from a static context (P3) JDK-8268333: javac crashes when pattern matching switch contains default case which is not last (P3) JDK-8269354: javac crashes when processing parenthesized pattern in instanceof (P3) JDK-8259235: javac crashes while attributing super method invocation (P3) JDK-8264843: Javac crashes with NullPointerException when finding unencoded XML in 
     tag
  (P3) JDK-8259359: javac does not attribute unexpected super constructor invocation qualifier, and may crash
  (P3) JDK-8269802: javac fails to compile nested pattern matching switches
  (P3) JDK-8269808: javac generates class with invalid stack map 
  (P3) JDK-8268748: Javac generates uncorrect bytecodes when using nested pattern variables
  (P3) JDK-8263432: javac may report an invalid package/class clash on case insensitive filesystems
  (P3) JDK-8250768: javac should be adapted to changes in JEP 12
  (P3) JDK-8266645: javac should not check for sealed supertypes in intersection types
  (P3) JDK-8269146: Missing unreported constraints on pattern and other case label combination
  (P3) JDK-8264306: Non deterministic generation of java/lang/invoke/MemberName.class 
  (P3) JDK-8267610: NPE at at jdk.compiler/com.sun.tools.javac.jvm.Code.emitop
  (P3) JDK-8226216: parameter modifiers are not visible to javac plugins across compilation boundaries
  (P3) JDK-8268896: Parenthesized pattern is not guarded by source level check
  (P3) JDK-8268961: Parenthesized pattern with guards does not work
  (P3) JDK-8242456: PreviewFeature.Feature enum removal of TEXT_BLOCKS 
  (P3) JDK-8263590: Rawtypes warnings should be produced for pattern matching in instanceof
  (P3) JDK-8259025: Record compact constructor using Objects.requireNonNull
  (P3) JDK-8260959: remove RECORDS from PreviewFeature.Feature enum
  (P3) JDK-8267832: SimpleVisitors and Scanners in jdk.compiler should use @implSpec
  (P3) JDK-8266591: StandardJavaFileManager::getJavaFileObjectsFromPaths() methods contain a typo in their spec
  (P3) JDK-8266590: StandardJavaFileManager::setLocationFromPaths() spec contains an error
  (P3) JDK-8261606: Surprising behavior of step over in String switch
  (P3) JDK-8267119: switch expressions lack support for deferred type-checking
  (P3) JDK-8269141: Switch statement containing pattern case label element gets in the loop during execution
  (P3) JDK-8269301: Switch statement with a pattern, constant and default label elements crash javac
  (P3) JDK-8270006: Switches with 'case null:' should be exhaustive
  (P3) JDK-8261457: test/langtools/tools/javac/T8187978 can fail if ArrayList class is modified
  (P3) JDK-8268670: yield statements doesn't allow ~ or ! unary operators in expression
  (P4) JDK-8257453: Add source 17 and target 17 to javac
  (P4) JDK-8266281: Assign Symbols to the package selector expression
  (P4) JDK-8266796: Clean up the unnecessary code in the method UnsharedNameTable#fromUtf
  (P4) JDK-8255729: com.sun.tools.javac.processing.JavacFiler.FilerOutputStream  is inefficient
  (P4) JDK-8257740: Compiler crash when compiling type annotation on multicatch inside lambda
  (P4) JDK-8262891: Compiler implementation for Pattern Matching for switch (Preview)
  (P4) JDK-8259905: Compiler treats 'sealed' keyword as 'var' keyword
  (P4) JDK-8200145: Conditional expression mistakenly treated as standalone
  (P4) JDK-8263621: Convert jdk.compiler to use Stream.toList()
  (P4) JDK-8263688: Coordinate equals, hashCode and compareTo of JavacFileManager.PathAndContainer
  (P4) JDK-8263445: Duplicate key compiler.err.expected.module in compiler.properties
  (P4) JDK-8230623: Extract command-line help for -Xlint sub-options to new --help-lint
  (P4) JDK-8069116: improve fatal error handling in JavaCompiler
  (P4) JDK-8216400: improve handling of IOExceptions in JavaCompiler.close()
  (P4) JDK-8263995: Incorrect double-checked locking in Types.arraySuperType()
  (P4) JDK-8231179: Investigate why tools/javac/options/BCPOrSystemNotSpecified.java fails on Window
  (P4) JDK-8232948: javac -h should mangle the overload argument signature
  (P4) JDK-8260593: javac can skip a temporary local variable when pattern matching over a local variable
  (P4) JDK-8244146: javac changes for JEP 306
  (P4) JDK-8263642: javac emits duplicate checkcast for first bound of intersection type in cast
  (P4) JDK-8255757: Javac emits duplicate pool entries on array::clone
  (P4) JDK-8263452: Javac slow compilation due to algorithmic complexity 
  (P4) JDK-8264181: javadoc tool Incorrect error message about malformed link
  (P4) JDK-8267361: JavaTokenizer reads octal numbers mistakenly
  (P4) JDK-8259820: JShell does not handle -source 8 properly
  (P4) JDK-8238213: Method resolution should stop on static error
  (P4) JDK-8264696: Multi-catch clause causes compiler exception because it uses the package-private supertype
  (P4) JDK-8257037: No javac warning when calling deprecated constructor with diamond
  (P4) JDK-8232765: NullPointerException at Types.eraseNotNeeded() when compiling a class
  (P4) JDK-8266675: Optimize IntHashTable for encapsulation and ease of use
  (P4) JDK-8260053: Optimize Tokens' use of Names
  (P4) JDK-8239596: PARAMETER annotation on receiver type does not cause error
  (P4) JDK-8260566: Pattern type X is a subtype of expression type Y message is incorrect
  (P4) JDK-8258460: Remove --doclint-format option from javac
  (P4) JDK-8267317: Remove DeferredTypeCompleter
  (P4) JDK-8267187: Remove deprecated constructor for Log
  (P4) JDK-8267708: Remove references to com.sun.tools.javadoc.**
  (P4) JDK-8267465: remove superfluous preview related annotations and test options
  (P4) JDK-8267578: Remove unnecessary preview checks
  (P4) JDK-8261444: Remove unused fields in Lower
  (P4) JDK-8257204: Remove usage of -Xhtmlversion option from javac
  (P4) JDK-8057543: Replace javac's Filter with Predicate (and lambdas)
  (P4) JDK-8266819: Separate the stop policies from the compile policies completely
  (P4) JDK-8258525: Some existing tests should use /nodynamiccopyright/ instead of the standard header
  (P4) JDK-8231622: SuppressWarning("serial") ignored on field serialVersionUID
  (P4) JDK-8266436: Synthetic constructor trees have non-null return type
  (P4) JDK-8267570: The comment of the class JavacParser is not appropriate
  (P4) JDK-8266027: The diamond finder does not find diamond candidates in field initializers
  (P4) JDK-8267580: The method JavacParser#peekToken is wrong when the first parameter is not zero
  (P4) JDK-8241187: ToolBox::grep should allow for negative filtering
  (P4) JDK-8203925: tools/javac/importscope/T8193717.java ran out of java heap
  (P4) JDK-8265270: Type.getEnclosingType() may fail with CompletionFailure
  (P4) JDK-8268549: Typo in file name in example for -Xlint:processing
  (P4) JDK-8257457: Update --release 16 symbol information for JDK 16 build 28
  (P4) JDK-8265827: Use pattern matching for instanceof at module jdk.compiler
  (P4) JDK-8265899: Use pattern matching for instanceof at module jdk.compiler(part 1)
  (P4) JDK-8265900: Use pattern matching for instanceof at module jdk.compiler(part 2)
  (P4) JDK-8265901: Use pattern matching for instanceof at module jdk.compiler(part 3)
  (P4) JDK-8264664: use text blocks in javac module tests
  (P4) JDK-8258897: Wrong translation of capturing local classes inside nested lambdas
  (P5) JDK-8263514: Minor issue in JavacFileManager.SortFiles.REVERSE
  (P5) JDK-8066694: Strange code in JavacParser.java
  (P5) JDK-8264258: Unknown lookups in the java package give misleading compilation errors
  (P5) JDK-8264331: Use the blessed modifier order in jdk.compiler

tools/javadoc(tool):
  (P2) JDK-8258056: jdk/javadoc/doclet/testHtmlTableTags/TestHtmlTableTags.java fails against jdk17
  (P2) JDK-8268318: Missing comma in copyright header
  (P2) JDK-8262899: TestRedirectLinks fails
  (P3) JDK-8246351:  elements in headings are of incorrect size
  (P3) JDK-8157682: @inheritDoc doesn't work with @exception
  (P3) JDK-8149138: [javadoc] Fix SerialFormBuilder eliminate String bashing
  (P3) JDK-8268972: Add default impl for recent new Reporter.print method
  (P3) JDK-8263300: add HtmlId for the block containing a class's description.
  (P3) JDK-8263043: Add test to verify order of tag output
  (P3) JDK-8232644: bugs in serialized-form.html
  (P3) JDK-8261665: Clean up naming of StringContent and FixedStringContent
  (P3) JDK-8259806: Clean up terminology on the "All Classes" page
  (P3) JDK-8258957: DocLint: check for HTML start element at end of body
  (P3) JDK-8257925: Enable more support for nested inline tags
  (P3) JDK-8267204: Expose access to underlying streams in Reporter
  (P3) JDK-8265613: False positives for "Related Packages"
  (P3) JDK-8259530: Generated docs contain MIT/GPL-licenced works without reproducing the licence
  (P3) JDK-8265684: implement Sealed Classes as a standard feature in Java, javadoc changes
  (P3) JDK-8262992: Improve `@see` output
  (P3) JDK-8258602: JavaDoc field summary does not indicate final modifier
  (P3) JDK-8262886: javadoc generates broken links with {@inheritDoc}
  (P3) JDK-8263198: javadoc HELP page
  (P3) JDK-8265042: javadoc HTML files not generated for types nested in records
  (P3) JDK-8267219: Javadoc method summary breaks when {@inheritDoc} from an empty parent
  (P3) JDK-8267126: javadoc should show "line and caret" for diagnostics.
  (P3) JDK-8262269: javadoc test TestGeneratedClasses.java fails on Windows
  (P3) JDK-8260388: Listing (sub)packages at package level of API documentation
  (P3) JDK-8262315: missing ';' in generated entities
  (P3) JDK-8268557: Module page uses unstyled table class
  (P3) JDK-8263468: New page for "recent" new API
  (P3) JDK-8261976: Normalize id's used by the standard doclet
  (P3) JDK-8269722: NPE in HtmlDocletWriter
  (P3) JDK-8223355: Redundant output  by javadoc
  (P3) JDK-8261623: reference to javac internals in Extern class
  (P3) JDK-8263321: Regression 8% in javadoc-steady in 17-b11
  (P3) JDK-8267434: Remove LinkOutput[Impl]
  (P3) JDK-8268774: Residual logging output written to STDOUT, not STDERR
  (P3) JDK-8267176: StandardDoclet should provide access to Reporter and Locale
  (P3) JDK-8263473: Update annotation terminology (2)
  (P3) JDK-8266779: Use  instead of ZERO_WIDTH_SPACE
  (P3) JDK-8259283: use new HtmlId and HtmlIds classes
  (P3) JDK-8259726: Use of HashSet leads to undefined order in test output
  (P4) JDK-8267575: Add new documentation group in HtmlStyle
  (P4) JDK-8263684: Avoid wrapping into BufferedWriter twice
  (P4) JDK-8261168: Convert javadoc tool to use Stream.toList()
  (P4) JDK-8267574: Dead code in HtmlStyle/HtmlDocletWriter
  (P4) JDK-8258659: Eliminate whitespace comments from generated pages
  (P4) JDK-8261079: Fix support for @hidden in classes and interfaces
  (P4) JDK-8260223: Handling of unnamed package in javadoc pages
  (P4) JDK-8263507: Improve structure of package summary pages
  (P4) JDK-8267709: Investigate differences between HtmlStyle and stylesheet.css
  (P4) JDK-8250766: javadoc adds redundant spaces when @see program element is wrapped
  (P4) JDK-8259216: javadoc omits method receiver for any nested type annotation
  (P4) JDK-8264191: Javadoc search is broken in Internet Explorer
  (P4) JDK-8247608: Javadoc: CSS margin is not applied consistently
  (P4) JDK-8264220: jdk/javadoc/doclet/testRelatedPackages/TestRelatedPackages.java fails to compile
  (P4) JDK-8249903: jdk/javadoc/doclet/testSerializedForm/TestSerializedForm.java needs to be updated after 8146022 got closed
  (P4) JDK-8249898: jdk/javadoc/tool/6176978/T6176978.java uses @ignore w/o bug-id
  (P4) JDK-8249899: jdk/javadoc/tool/InlineTagsWithBraces.java uses @ignore w/o bug-id
  (P4) JDK-8249897: jdk/javadoc/tool/LangVers.java uses @ignore w/o bug-id
  (P4) JDK-8266856: Make  element void
  (P4) JDK-8263528: Make static page ids safe from collision with language elements
  (P4) JDK-8267481: Make sure table row has correct number of cells
  (P4) JDK-8264655: Minor internal doc comment cleanup
  (P4) JDK-8261654: Missing license header in Signatures.java
  (P4) JDK-8267329: Modernize Javadoc code to use instanceof with pattern matching
  (P4) JDK-8263050: move HtmlDocletWriter.verticalSeparator to IndexWriter
  (P4) JDK-8266748: Move modifiers code to Signatures.java
  (P4) JDK-8259723: Move Table class to formats.html package
  (P4) JDK-8266044: Nested class summary should show kind of class or interface
  (P4) JDK-8255059: Regressions >5% in all Javadoc benchmarks in 16-b19
  (P4) JDK-8258655: remove <-- NewPage --> comment from generated pages
  (P4) JDK-8247957: remove doclint support for HTML 4
  (P4) JDK-8259727: Remove redundant "target" arguments to methods in Links
  (P4) JDK-8261609: remove remnants of XML-driven builders
  (P4) JDK-8264866: Remove unneeded WorkArounds.isAutomaticModule
  (P4) JDK-8268352: Rename javadoc Messager class to JavadocLog
  (P4) JDK-8266808: Search label still uses old search field id
  (P4) JDK-8261499: Simplify HTML for javadoc links
  (P4) JDK-8261263: Simplify javadoc link code
  (P4) JDK-8256312: Valid anchor 'id' value not allowed
  (P4) JDK-8267236: Versioned platform link in TestMemberSummary.java
  (P5) JDK-8266651: Convert Table method parameters from String to Content
  (P5) JDK-8263438: Unused method AbstractMemberWriter.isInherited 

tools/javap:
  (P4) JDK-8264561: javap get NegativeArraySizeException on bad instruction
  (P4) JDK-8260403: javap should be more robust in the face of invalid class files

tools/jconsole:
  (P3) JDK-8260690: JConsole User Guide Link from the Help menu is not accessible by keyboard

tools/jextract:
  (P2) JDK-8268888: Upstream 8268230: Foreign Linker API & Windows user32/kernel32: String conversion seems broken
  (P2) JDK-8268717: Upstream: 8268673: Stack walk across optimized entry frame on fresh native thread fails
  (P3) JDK-8268339: Upstream: 8267989: Exceptions thrown during upcalls should be handled
  (P3) JDK-8268327: Upstream: 8268169: The system lookup can not find stdio functions such as printf on Windows 10

tools/jlink:
  (P2) JDK-8166727: javac crashed: [jimage.dll+0x1942]  ImageStrings::find+0x28
  (P3) JDK-8266291: (jrtfs) Calling Files.exists may break the JRT filesystem
  (P3) JDK-8259814: test/jdk/tools/jlink/plugins/CompressorPluginTest.java has compilation issues
  (P3) JDK-8266461: tools/jmod/hashes/HashesTest.java fails: static @Test methods
  (P4) JDK-8260621: (jrtfs) ThreadLocal memory leak in ImageBufferCache when using jrtfs
  (P4) JDK-8240349: jlink should not leave partial image output directory on failure
  (P4) JDK-8267583: jmod fails on symlink to class file
  (P4) JDK-8260337: Optimize ImageReader lookup, used by Class.getResource
  (P4) JDK-8240347: remove undocumented options from jlink --help message

tools/jpackage:
  (P2) JDK-8266179: [macos] jpackage should specify architecture for produced pkg files
  (P2) JDK-8262300: jpackage app-launcher fails on linux when using JDK11 based runtime
  (P2) JDK-8264165: jpackage BasicTest fails after JDK-8220266: Check help text contains plaform specific parameters
  (P2) JDK-8261281: Linking jdk.jpackage fails for linux aarch32 builds after 8254702
  (P2) JDK-8263887: Re-create default icons
  (P3) JDK-8259570: (macos) tools/jpackage tests fails with 'hdiutil: couldn't eject "disk2" - Resource busy'
  (P3) JDK-8260335: [macos] Running app using relative path causes problems
  (P3) JDK-8263157: [macos]: java.library.path is being set incorrectly
  (P3) JDK-8264057: [redo] JDK-8248904: Add support to jpackage for the Mac App Store.
  (P3) JDK-8263536: Add @build tags to jpackage tests
  (P3) JDK-8248904: Add support to jpackage for the Mac App Store 
  (P3) JDK-8255899: Allow uninstallation of jpackage exe bundles
  (P3) JDK-8264055: backout JDK-8248904 in order to resubmit with additional attribution.
  (P3) JDK-8259238: Clean up Log.java and remove usage of non-final static variables.
  (P3) JDK-8269185: Directories in /opt/runtimepackagetest and /path/to/jdk-17 are different
  (P3) JDK-8261839: Error creating runtime package on macos without mac-package-identifier
  (P3) JDK-8269403: Fix jpackage tests to gracefully handle jpackage app launcher crashes
  (P3) JDK-8254702: jpackage app launcher crashes on CentOS
  (P3) JDK-8267764: jpackage cannot handle window screensaver files when EXE renamed as SCR
  (P3) JDK-8265152: jpackage cleanup fails on Windows with IOException deleting msi
  (P3) JDK-8241716: Jpackage functionality to let users choose whether to create shortcuts
  (P3) JDK-8261518: jpackage looks for main module in current dir when there is no module-path
  (P3) JDK-8267598: jpackage removes system libraries from java.library.path
  (P3) JDK-8259062: Remove MacAppStoreBundler
  (P3) JDK-8223188: Removed unnecessary #ifdef __cplusplus from .cpp sources
  (P3) JDK-8266456: Replace direct TKit.run() calls with jdk.jpackage.test.Annotations.Test annotation
  (P3) JDK-8268150: tier2: test/jdk/tools/jpackage/junit/junit.java needs updating for jtreg 6
  (P3) JDK-8269036: tools/jpackage/share/AppImagePackageTest.java failed with "hdiutil: create failed - Resource busy"
  (P3) JDK-8267403: tools/jpackage/share/FileAssociationsTest.java#id0 failed with "Error: Bundler "Mac PKG Package" (pkg) failed to produce a package"
  (P4) JDK-8249395: (macos) jpackage tests timeout on MacPro5_1 systems
  (P4) JDK-8263154: [macos] DMG builds have finder errors
  (P4) JDK-8264403: [macos]: App names containing '.' characters results in an error message when launching
  (P4) JDK-8264144: Add handling of "--about-url" CLI parameter for RPM/DEB packages
  (P4) JDK-8220266: add support for additional metadata in add/remove programs
  (P4) JDK-8263545: Convert jpackage to use Stream.toList()
  (P4) JDK-8259926: Error in jpackage sample usage in the help text
  (P4) JDK-8261845: File permissions of packages built by jpackage
  (P4) JDK-8267423: Fix copyrights in jpackage tests
  (P4) JDK-8266227: Fix help text for --mac-signing-keychain
  (P4) JDK-8248418: jpackage fails to extract main class and version from app module linked in external runtime
  (P4) JDK-8266603: jpackage: Add missing copyright file in Java runtime .deb installers
  (P4) JDK-8258755: jpackage: Invalid 32-bit exe when building app-image
  (P4) JDK-8261300: jpackage: rewrite while(0)/while(false) to proper blocks
  (P4) JDK-8261298: LinuxPackage.c, getJvmLauncherLibPath RPM->DEB typo
  (P4) JDK-8267056: tools/jpackage/share/RuntimePackageTest.java fails with NoSuchFileException
  (P4) JDK-8266129: tools/jpackage/windows/WinInstallerIconTest.java hangs with fastdebug
  (P4) JDK-8264551: Unexpected warning when jpackage creates an exe
  (P4) JDK-8263135: unique_ptr should not be used for types that are not pointers
  (P4) JDK-8236127: Use value of --icon CLI option to set icon for exe installers
  (P4) JDK-8261299: Use-after-free on failure path in LinuxPackage.c, getJvmLauncherLibPath
  (P5) JDK-8264334: Use the blessed modifier order in jdk.jpackage

tools/jshell:
  (P3) JDK-8261920: [AIX] jshell command throws java.io.IOError on non English locales
  (P3) JDK-8254196: jshell infinite loops when startup script contains System.exit call
  (P3) JDK-8268859: jshell throws exception while parsing illegal "case true"
  (P3) JDK-8247403: JShell: No custom input (e.g. from GUI) possible with JavaShellToolBuilder
  (P3) JDK-8267459: Pasting Unicode characters into JShell does not work.
  (P4) JDK-8257236: can't use var with a class named Z
  (P4) JDK-8263411: Convert jshell tool to use Stream.toList()
  (P4) JDK-8259863: doc: JShell snippet doesn't compile
  (P4) JDK-8265444: Javadocs:  jdk.jshell - small typo
  (P4) JDK-8238173: jshell - switch statement with a single default not return cause syntax error
  (P4) JDK-8261450: JShell crashes with SIOOBE in tab completion
  (P4) JDK-8255273: jshell crashes with UnsupportedOperationException: Should not get here.
  (P4) JDK-8267221: jshell feedback is incorrect when creating method with array varargs parameter
  (P4) JDK-8222850: jshell tool: Misleading cascade compiler error in switch expression with undefined vars
  (P4) JDK-8252409: JShell: Intersection types cause NoSuchFieldError
  (P4) JDK-8264221: Rewrite confusing stream API chain in SnippetMaps
  (P4) JDK-8262900: ToolBasicTest fails to access HTTP server it starts
  (P4) JDK-8264222: Use switch expression in jshell where possible
  (P5) JDK-8264333: Use the blessed modifier order in jdk.jshell

tools/launcher:
  (P2) JDK-8261785: Calling "main" method in anonymous nested class crashes the JVM
  (P3) JDK-8266877: Missing local debug information when debugging JEP-330
  (P4) JDK-8248843: java in source-file mode suggests javac-only options
  (P4) JDK-8258917: NativeMemoryTracking is handled by launcher inconsistenly

xml/javax.xml.transform:
  (P3) JDK-8265073: XML transformation and indentation when using xml:space
  (P4) JDK-8264766: ClassCastException during template compilation (Variable cannot be cast to Param)
  (P4) JDK-8266019: StreamResult(File) writes to incorrect file path if # is part of the file path

xml/javax.xml.xpath:
  (P2) JDK-8266559: XPathEvaluationResult.XPathResultType.NODESET maps to incorrect type

xml/jaxp:
  (P2) JDK-8262041: javax/xml/jaxp/unittest/common/prettyprint/PrettyPrintTest.java fails after JDK-8260858
  (P3) JDK-8256919: BCEL: Utility.encode forget to close
  (P3) JDK-8268222: javax/xml/jaxp/unittest/transform/Bug6216226Test.java failed, cannot delete file
  (P3) JDK-8249867: XML declaration is not followed by a newline
  (P4) JDK-8261670: Add javadoc for the XML processing limits
  (P4) JDK-8265248: Implementation Specific Properties: change prefix, plus add existing properties
  (P4) JDK-8260858: Implementation specific property xsltcIsStandalone for XSLTC Serializer
  (P4) JDK-8261209: isStandalone property: remove dependency on pretty-print
  (P4) JDK-8264454: Jaxp unit test from open jdk needs to be improved
  (P4) JDK-8261673: Move javadoc for the lookup mechanism to module-info
  (P4) JDK-8255035: Update BCEL to Version 6.5.0