RELEASE NOTES FOR: 17 ==================================================================================================== Notes generated: Fri Apr 16 02:06:23 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 (1585 total): ................................ done Loading issues (1585 total): ................................ done Resolving issues (1585 total): ............................... done Resolving parents (1585 total): ............................... done Resolving backports (1585 total): ............................... done JIRA Query: project = JDK AND issuetype = JEP AND fixVersion = 17 ORDER BY summary ASC Acquiring pages (5 total): . done Loading issues (5 total): . done Resolving issues (5 total): done Resolving parents (5 total): done Filtered 123 issues carried over, 1458 pushes left. Hint: Prefix bug IDs with https://bugs.openjdk.java.net/browse/ to reach the relevant JIRA entry. JAVA ENHANCEMENT PROPOSALS (JEP): 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 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. RELEASE NOTES, BY COMPONENT: 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.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) 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 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-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 have 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.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: 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 ALL FIXED ISSUES, BY COMPONENT AND PRIORITY: client-libs: (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-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-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-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-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 (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-8263439: getSupportedAttributeValues() throws NPE for Finishings attribute (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-8262829: Native crash in Win32PrintServiceLookup.getAllPrinterNames() (P3) JDK-6606673: Path2D.Double, Path2D.Float and GeneralPath ctors throw exception when initialCapacity is negative (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-8251036: SwingSet2 - Dragging internal frame inside jframe leaves artifacts with MetalLookAndFeel (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-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-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-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-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-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-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-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-8259585: [macos] Bad JNI lookup error : Accessible actions do not work on macOS (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-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-8259439: Apply java.io.Serial annotations in java.datatransfer (P4) JDK-8260426: awt debug_mem.c DMem_AllocateBlock might leak memory (P4) JDK-8263454: com.apple.laf.AquaFileChooserUI ignores the result of String.trim() (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-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-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-8261198: [macOS] Incorrect JNI parameters in number conversion in A11Y code (P3) JDK-8259729: Missed JNFInstanceOf -> IsInstanceOf conversion (P4) JDK-8257584: [macos] NullPointerException originating from LWCToolkit.java (P4) JDK-8263136: C4530 was reported from VS 2019 at access bridge client-libs/javax.swing: (P2) JDK-8265278: doc build fails after JDK-8262981 (P3) JDK-8216358: [accessibility] [macos] The focus is invisible when tab to "Image Radio Buttons" and "Image CheckBoxes" (P3) JDK-8263766: Confusing specification of JEditorPaneAccessibleHypertextSupport constructor (P3) JDK-8256109: Create implementation for NSAccessibilityButton protocol (P3) JDK-8261350: Create implementation for NSAccessibilityCheckBox 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-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-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 (P4) JDK-8264328: Broken license in javax/swing/JComboBox/8072767/bug8072767.java (P4) JDK-8263170: ComboBoxModel documentation refers to a nonexistent type (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-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-8202880: Test javax/swing/JPopupMenu/8075063/ContextMenuScrollTest.java fails (P5) JDK-6251901: BasicTextUI: installDefaults method are contrary to the documentation (P5) JDK-8260343: Delete obsolete classes in the Windows L&F core-libs: (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-8264827: Large mapped buffer/segment crash the VM when calling isLoaded (P4) JDK-8261422: Adjust problematic String.format calls in jdk/internal/util/Preconditions.java outOfBoundsMessage (P4) JDK-8258422: Cleanup unnecessary null comparison before instanceof check in java.base (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-8262199: issue in jli args.c (P4) JDK-8212035: merge jdk.test.lib.util.SimpleHttpServer with jaxp.library.SimpleHttpServer (P4) JDK-8262892: minor typo in implSpec comment (P4) JDK-8261975: Missing "classpath exception" in VectorSupport.java (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-8264029: Replace uses of StringBuffer with StringBuilder in java.base (P4) JDK-8257450: Start of release updates for JDK 17 (P4) JDK-8260869: Test java/foreign/TestHandshake.java fails intermittently (P4) JDK-8263190: Update java.io, java.math, and java.text to use instanceof pattern variable (P4) JDK-8263233: Update java.net and java.nio to use instanceof pattern variable (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: (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-8260273: DataOutputStream writeChars optimization (P4) JDK-8259943: FileDescriptor.close0 does not handle EINTR (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 (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: (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-8265019: Update tests for additional TestNG test permissions (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-8263108: Class initialization deadlock in java.lang.constant (P4) JDK-8254979: Class.getSimpleName() returns non-empty for lambda and method (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-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-8263892: More modifier order fixes in java.base (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-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-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-8260329: Update references to TAOCP to latest edition (P4) JDK-8264148: Update spec for exceptions retrofitted for exception chaining (P4) JDK-8262018: Wrong format in SAP copyright header of OsVersionTest core-libs/java.lang.invoke: (P3) JDK-8259922: MethodHandles.collectArguments does not throw IAE if pos is outside the arity range (P4) JDK-8261030: Avoid loading GenerateJLIClassesHelper at runtime (P4) JDK-8259911: byteArrayViewVarHandle should throw ArrayIndexOutOfBoundsException (P4) JDK-8255531: MethodHandles::permuteArguments throws NPE when duplicating dropped arguments (P4) JDK-8264288: Performance issue with MethodHandle.asCollector (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-8260605: Various java.lang.invoke cleanups 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: (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-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 core-libs/java.net: (P3) JDK-8262898: com/sun/net/httpserver/bugs/8199849/ParamTest.java times out (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-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 (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-8260520: Avoid getting permissions in JarFileFactory when no SecurityManager installed (P4) JDK-8241995: Clarify InetSocketAddress::toString specification (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-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-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-8255264: Support for identifying the full range of IPv4 localhost addresses on Windows 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-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-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-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-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-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-8253478: (se) epoll Selector should use eventfd for wakeup instead of pipe (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 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.sql: (P4) JDK-8263885: Use the blessed modifier order in java.sql/rowset/transation.xa core-libs/java.text: (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 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 core-libs/java.util: (P1) JDK-8264729: Random check-in failing header checks. (P3) JDK-8148937: (str) Adapt StringJoiner for Compact Strings (P3) JDK-8248862: Implement Enhanced Pseudo-Random Number Generators (P3) JDK-8264512: jdk/test/jdk/java/util/prefs/ExportNode.java relies on default platform encoding (P4) JDK-8260561: [doc] HexFormat has incorrect @since tag (P4) JDK-8247373: ArraysSupport.newLength doc, test, and exception message (P4) JDK-8251989: Hex formatting and parsing utility (P4) JDK-8263754: HexFormat 'fromHex' methods should be static (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-8263903: Use Cleaner instead of finalize to auto stop Timer thread 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 (P5) JDK-8264091: Use the blessed modifier order in java.logging core-libs/java.util.regex: (P3) JDK-8259074: regex benchmarks and tests core-libs/java.util.stream: (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-8247402: Documentation for Map::compute contains confusing implementation requirements core-libs/java.util:i18n: (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 core-libs/javax.lang.model: (P3) JDK-8261625: Add `Elements.isAutomaticModule(ModuleElement)` (P4) JDK-8257451: Add SourceVersion.RELEASE_17 (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-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 core-svc/debugger: (P3) JDK-8262486: Merge trivial JDWP agent changes from the loom repo to the jdk repo (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 (P5) JDK-8259350: Add some internal debugging APIs to the debug agent 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 core-svc/java.lang.management: (P4) JDK-8265104: CpuLoad and SystemCpuLoad in OperatingSystem MXBean returns -1.0 (P4) JDK-8258836: JNI local refs exceed capacity getDiagnosticCommandInfo (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 core-svc/tools: (P4) JDK-8257234: Add gz option to SA jmap to write a gzipped heap dump (P4) JDK-8258593: remove redundant codes in HeapObjectDumper (P5) JDK-8264396: Use the blessed modifier order in jdk.internal.jvmstat docs/guides: (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 hotspot: (P4) JDK-8261356: Clean up enum G1Mark (P4) JDK-8262099: jcmd VM.metaspace should report unlimited size if MaxMetaspaceSize isn't specified hotspot/compiler: (P1) JDK-8259629: aarch64 builds fail after JDK-8258932 (P1) JDK-8258438: build error in test/hotspot/gtest/runtime/test_os.cpp (P1) JDK-8261659: JDK-8261027 causes a Tier1 validate-source failure (P1) JDK-8264759: x86_32 Minimal VM build failure after JDK-8262355 (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-8261522: [PPC64] AES intrinsics write beyond the destination array (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-8261812: C2 compilation fails with assert(!had_error) failed: bad dominance (P2) JDK-8263189: C2: assert(!had_error) failed: bad dominance (P2) JDK-8263587: C2: JVMS not cloned when needs_clone_jvms() is true (P2) JDK-8262295: C2: Out-of-Bounds Array Load from Clone Source (P2) JDK-8261912: Code IfNode::fold_compares_helper more defensively (P2) JDK-8261022: Fix incorrect result of Math.abs() with char type (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-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-8262739: String inflation C2 intrinsic prevents insertion of anti-dependencies (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-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-8262894: [macos_aarch64] SIGBUS in Assembler::ld_st2 (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-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-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-8263352: assert(use == polladr) failed: the use should be a safepoint polling (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-8260420: C2 compilation fails with assert(found_sfpt) failed: no node in loop that's not input to safepoint (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-8263971: C2 crashes with SIGFPE with -XX:+StressGCM and -XX:+StressIGVN (P3) JDK-8258243: C2: assert failed ("Bad derived pointer") with -XX:+VerifyRegisterAllocator (P3) JDK-8257513: C2: assert((constant_addr - _masm.code()->consts()->start()) == con.offset()) (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-8263891: Changes for 8076985 missed the fix. (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-8263501: compiler/oracle/TestInvalidCompileCommand.java fails with release VMs (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-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-8259777: Incorrect predication condition generated by ADLC (P3) JDK-8259710: Inlining trace leaks memory (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-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-8256215: Shenandoah: re-organize saving/restoring machine state in assembler code (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-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 (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-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-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-8258932: AArch64: Enhance floating-point Min/MaxReductionV with fminp/fmaxp (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-8258953: AArch64: move NEON instructions to aarch64_neon.ad (P4) JDK-8264352: AArch64: Optimize vector "not/andNot" for NEON and SVE (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-8264109: Add vectorized implementation for VectorMask.andNot() (P4) JDK-8263206: assert(*error_msg != '\0') failed: Must have error_message while parsing -XX:CompileCommand=unknown (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-8260255: C1: LoopInvariantCodeMotion constructor can leave some fields uninitialized (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-8263781: C2: Cannot hoist independent load above arraycopy (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-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-8258653: CallJavaNode::_bci is not in use (P4) JDK-8255216: Change _directive->BreakAtCompileOption to env()->break_at_compile() (P4) JDK-8264151: ciMethod::ensure_method_data() should return false is loading resulted in empty state (P4) JDK-8258059: Clean up MethodData::profile_unsafe (P4) JDK-8263989: Cleanup in EA (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-8263904: compiler/intrinsics/bmi/verifycode/BzhiTestI2L.java fails on x86_32 (P4) JDK-8258682: compiler/intrinsics/mathexact/sanity tests fail with RepeatCompilation (P4) JDK-8259928: compiler/jvmci tests fail with -Xint (P4) JDK-8264466: Cut-paste error in InterfaceCalls JMH (P4) JDK-8258010: Debug build failure with clang-10 due to -Wdeprecated-copy (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-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-8261553: Efficient mask generation using BMI2 BZHI instruction (P4) JDK-8252709: Enable JVMCI when building linux-aarch64 at Oracle (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-8263248: IGV: accept graphs without node categories (P4) JDK-8265125: IGV: cannot edit forms with NetBeans GUI builder (P4) JDK-8259984: IGV: Crash when drawing control flow before GCM (P4) JDK-8261336: IGV: enhance default filters (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-8259044: JVM lacks data type qualifier when using -XX:+PrintAssembly with AArch64-Neon backend (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-8261270: MakeMethodNotCompilableTest fails with -XX:TieredStopAtLevel={1,2,3} (P4) JDK-8261447: MethodInvocationCounters frequently run into overflow (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-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-8261675: ObjectValue::set_visited(bool) sets _visited false (P4) JDK-8261137: Optimization of Box nodes in uncommon_trap (P4) JDK-8264020: Optimize double negation elimination (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-8260334: Remove deprecated sv_for_node_id() from Compile (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-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-8264135: UnsafeGetStableArrayElement should account for different JIT implementation details (P4) JDK-8260577: Unused code in AbstractCompiler after Shark compiler removal (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-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-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-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-8258857: Zero: non-PCH release build fails after JDK-8258074 (P5) JDK-8261666: [mlvm] Remove WhiteBoxHelper (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-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-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-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-8261859: gc/g1/TestStringDeduplicationTableRehash.java failed with "RuntimeException: 'Rehash Count: 0' found in stdout" (P2) JDK-8262197: JDK-8242032 uses wrong contains_reference() in assertion code (P2) JDK-8259252: Shenandoah: Shenandoah build failed on AArch64 after JDK-8258459 (P2) JDK-8265082: test/hotspot/jtreg/gc/g1/TestG1SkipCompaction.java fails validate-source (P3) JDK-8257145: Performance regression with -XX:-ResizePLAB after JDK-8079555 (P3) JDK-8261448: Preserve GC stack watermark across safepoints in StackWalk (P3) JDK-8264052: Shenandoah: Backout 8263832 (P3) JDK-8265012: Shenandoah: Backout JDK-8264718 (P3) JDK-8264279: Shenandoah: Missing handshake after JDK-8263427 (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 (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-8074101: Add verification that all tasks are actually claimed during roots processing (P4) JDK-8264271: Avoid creating non_oop_word oops (P4) JDK-8265052: Break circular include dependency in objArrayOop.inline.hpp (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-8258534: Epsilon: clean up unused includes (P4) JDK-8259231: Epsilon: improve performance under contention during virtual space expansion (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-8264818: G1: Improve liveness check for empty pinned regions after full gc marking (P4) JDK-8262185: G1: Prune collection set candidates early (P4) JDK-8260200: G1: Remove unnecessary update in FreeRegionList::remove_starting_at (P4) JDK-8264423: G1: Rename full gc attribute table states (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-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-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-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-8210100: ParallelGC should use parallel WeakProcessor (P4) JDK-8263551: Provide shared lock-free FIFO queue implementation (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-8264026: Remove dependency between free collection set and eagerly reclaim humongous object tasks (P4) JDK-8261804: Remove field _processing_is_mt, calculate it instead (P4) JDK-8228748: Remove GCLocker::_doing_gc (P4) JDK-8257970: Remove julong types in os::limit_heap_by_allocatable_memory (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-8260263: Remove PtrQueue::_qset (P4) JDK-8261309: Remove remaining StoreLoad barrier with UseCondCardMark for Serial/Parallel GC (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-8261799: Remove unnecessary cast in psParallelCompact.hpp (P4) JDK-8262235: Remove unnecessary logic in hugetlbfs_sanity_check() (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-8261473: Shenandoah: Add breakpoint support (P4) JDK-8260408: Shenandoah: adjust inline hints after JDK-8255019 (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-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-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-8262876: Shenandoah: Fix comments regarding VM_ShenandoahOperation inheritances (P4) JDK-8260421: Shenandoah: Fix conc_mark_roots timing name and indentations (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-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-8255019: Shenandoah: Split STW and concurrent mark into separate classes (P4) JDK-8259580: Shenandoah: uninitialized label in VerifyThreadGCState (P4) JDK-8261251: Shenandoah: Use object size for full GC humongous compaction (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-8257676: Simplify WeakProcessorPhase (P4) JDK-8264424: Support OopStorage bulk allocation (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-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-8262973: Verify ParCompactionManager instance in PCAdjustPointerClosure (P4) JDK-8256814: WeakProcessorPhases may be redundant (P4) JDK-8259870: zBarrier.inline.hpp should not include javaClasses.hpp (P4) JDK-8263579: ZGC: Concurrent mark hangs with debug loglevel (P4) JDK-8261028: ZGC: SIGFPE when MaxVirtMemFraction=0 (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 hotspot/jfr: (P1) JDK-8260524: validate-source fails on test/jdk/jdk/jfr/event/gc/detailed/TestGCLockerEvent.java (P2) JDK-8261157: Incorrect GPL header after JDK-8259956 (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-8257569: Failure observed with JfrVirtualMemory::initialize (P3) JDK-8259354: Fix race condition in AbstractEventStream.nextThreadName (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-8260565: JFR: Fix copyright header in tests (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-8258414: OldObjectSample events too expensive (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-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-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 (P4) JDK-8264149: BreakpointInfo::set allocates metaspace object in VM thread (P4) JDK-8263434: Dangling references after MethodComparator::methods_EMCP (P4) JDK-8264004: Don't use TRAPS if no exceptions are thrown (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-8262881: port JVM/DI tests from JDK-4413752 to JVM/TI (P4) JDK-8259627: Potential memory leaks in JVMTI after JDK-8227745 (P4) JDK-8264050: Remove unused field VM_HeapWalkOperation::_collecting_heap_roots (P4) JDK-8264411: serviceability/jvmti/HeapMonitor tests intermittently fail due to large TLAB size (P4) JDK-8263895: Test nsk/jvmti/GetThreadGroupChildren/getthrdgrpchld001/getthrdgrpchld001.cpp uses incorrect indices (P4) JDK-8260926: Trace resource exhausted events unconditionally (P4) JDK-8259799: vmTestbase/nsk/jvmti/Breakpoint/breakpoint001 is incorrect (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 (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-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-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 (P3) JDK-8253797: [cgroups v2] Account for the fact that swap accounting is disabled on some systems (P3) JDK-8260355: AArch64: deoptimization stub should save vector registers (P3) JDK-8195744: Avoid calling ClassLoader.checkPackageAccess if security manager is not installed (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-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-8261916: gtest/GTestWrapper.java vmErrorTest.unimplemented1_vm_assert failed (P3) JDK-8259786: initialize last parameter of getpwuid_r (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-8261262: Kitchensink24HStress.java crashed with EXCEPTION_ACCESS_VIOLATION (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-8263002: Remove CDS MiscCode region (P3) JDK-8236225: Remove expired flags in JDK 17 (P3) JDK-8255917: runtime/cds/SharedBaseAddress.java failed "assert(reserved_rgn != 0LL) failed: No reserved region" (P3) JDK-8261397: try catch Method failing to work when dividing an integer by 0 (P3) JDK-8258077: Using -Xcheck:jni can lead to a double-free after JDK-8193234 (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-8259349: -XX:AvgMonitorsPerThreadEstimate=1 does not work right (P4) JDK-8262896: [macos_aarch64] Crash in jni_fast_GetLongField (P4) JDK-8264240: [macos_aarch64] enable appcds support after JDK-8263002 (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-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-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-8264123: add ThreadsList.is_valid() support (P4) JDK-8263392: Allow current thread to be specified in ExceptionMark (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-8263446: Avoid unary minus over unsigned type in ObjectSynchronizer::dec_in_use_list_ceiling (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-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-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-8262426: Change TRAPS to Thread* for find_constrained_instance_or_array_klass() (P4) JDK-8263562: Checking if proxy_klass_head is still lambda_proxy_is_available (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-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-8250989: Consolidate buffer allocation code for CDS static/dynamic dumping (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-8257985: count_trailing_zeros doesn't handle 64-bit values on 32-bit JVM (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-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-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-8256717: Expire the long term obsoleted VM flags (P4) JDK-8262163: Extend settings printout in jcmd VM.metaspace (P4) JDK-8261949: fileStream::readln returns incorrect line string (P4) JDK-8259713: Fix comments about ResetNoHandleMark in deoptimization (P4) JDK-8234773: Fix ThreadsSMRSupport::_bootstrap_list (P4) JDK-8262828: Format of OS information is different on macOS (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-8262500: HostName entry in VM.info should be a new line (P4) JDK-8265120: hs_err improvement: align the output of Virtual space metadata (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-8260030: Improve stringStream buffer handling (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-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-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-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-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-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-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-8226416: MonitorUsedDeflationThreshold can cause repeated async deflation requests (P4) JDK-8264711: More runtime TRAPS cleanups (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-8259845: Move placeholder implementation details to cpp file and add logging (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-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-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-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-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-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-8263992: Remove dead code NativeLookup::base_library_lookup (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-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-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-8261662: Rename compute_loader_lock_object (P4) JDK-8260625: Rename MetaspaceExpand_lock (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-8261585: Restore HandleArea used in Deoptimization::uncommon_trap (P4) JDK-8263915: runtime/cds/appcds/MismatchedPathTriggerMemoryRelease.java fails when UseCompressedClassPointers is off (P4) JDK-8264672: runtime/ParallelLoad/ParallelSuperTest.java timed out (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-8260485: Simplify and unify handler vectors in Posix signal code (P4) JDK-8259068: Streamline class loader locking (P4) JDK-8258853: Support separate function declaration and definition with ENABLE_IF-based SFINAE (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-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-8231627: ThreadsListHandleInErrorHandlingTest.java fails in printing all threads (P4) JDK-8259397: ThreadsSMRSupport::print_info_on() should use try_lock_without_rank_check() (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-8263544: Unused argument in ConstantPoolCacheEntry::set_field() (P4) JDK-8264178: Unused method Threads::nmethods_do (P4) JDK-8258075: Use auto variable declarations for enum iteration (P4) JDK-8252173: Use handles instead of jobjects in modules.cpp (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-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-8261652: Remove some dead comments from os_bsd_x86 hotspot/svc: (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-8259242: Remove ProtectionDomainSet_lock (P4) JDK-8264565: Templatize num_arguments() functions of DCmd subclasses 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-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-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-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-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-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 (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 (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-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 infrastructure/build: (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 (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-8260406: Do not copy pure java source code to gensrc (P3) JDK-8261843: incorrect info in docs/building.html (P3) JDK-8251210: Link JDK api docs to other versions (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-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-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-8264224: Add macosx-aarch64 to Oracle build configurations (P4) JDK-8257913: Add more known library locations to simplify Linux cross-compilation (P4) JDK-8263667: Avoid running GitHub actions on branches named pr/* (P4) JDK-8264874: Build interim-langtools for HotSpot only if Graal is enabled (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-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-8259485: Document need for short paths when building on Windows (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-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-8263097: Update JMH devkit to 1.28 (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/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: (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-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-8256895: Add support for RFC 8954: Online Certificate Status Protocol (OCSP) Nonce Extension (P3) JDK-8179503: Java should support GET OCSP calls (P3) JDK-8246005: KeyStoreSpi::engineStore(LoadStoreParameter) spec mismatch to its behavior (P3) JDK-8255348: NPE in PKIXCertPathValidator event logging code (P3) JDK-8225081: Remove Telia Company CA certificate expiring in April 2021 (P3) JDK-8263105: security-libs doclint 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-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-8262862: Harden tests sun/security/x509/URICertStore/ExtensionsWithLDAP.java and krb5/canonicalize/Test.java (P4) JDK-8259517: Incorrect test path in test cases (P4) JDK-8254717: isAssignableFrom checks in KeyFactorySpi.engineGetKeySpec appear to be backwards (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-8260693: Provide the support for specifying a signer in keytool -genkeypair (P4) JDK-8259498: Reduce overhead of MD5 and SHA digests (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-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-8262316: Reducing locks in RSA Blinding (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-8263436: Silly array comparison in GaloisCounterMode.overlapDetection security-libs/javax.crypto:pkcs11: (P4) JDK-8258833: Cancel multi-part cipher operations in SunPKCS11 after failures (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-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-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-8259662: Don't wrap SocketExceptions into SSLExceptions in SSLSocketImpl (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-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-8259223: Simplify boolean expression in the SunJSSE provider (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-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 security-libs/jdk.security: (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 (P3) JDK-8258855: Two tests sun/security/krb5/auto/ReplayCacheTestProc.java and ReplayCacheTestProcWithMD5.java failed on OL8.3 (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-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: (P4) JDK-8261936: Remove spec change documents for records & pattern matching tools: (P4) JDK-8261096: Convert jlink tool to use Stream.toList() (P5) JDK-8264087: Use the blessed modifier order in jdk.jconsole tools/javac: (P2) JDK-8264373: javac hangs when annotation is declared with sealed public modifier (P3) JDK-8255464: Cannot access ModuleTree in a CompilationUnitTree (P3) JDK-8236490: Compiler bug relating to @NonNull annotation (P3) JDK-8262421: doclint warnings in jdk.compiler module (P3) JDK-8259050: Error recovery in lexer could be improved (P3) JDK-8261203: Incorrectly escaped javadoc html with type annotations (P3) JDK-8259235: javac crashes while attributing super method invocation (P3) JDK-8259359: javac does not attribute unexpected super constructor invocation qualifier, and may crash (P3) JDK-8250768: javac should be adapted to changes in JEP 12 (P3) JDK-8264306: Non deterministic generation of java/lang/invoke/MemberName.class (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-8261606: Surprising behavior of step over in String switch (P3) JDK-8261457: test/langtools/tools/javac/T8187978 can fail if ArrayList class is modified (P4) JDK-8257453: Add source 17 and target 17 to javac (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-8259905: Compiler treats 'sealed' keyword as 'var' keyword (P4) JDK-8263688: Coordinate equals, hashCode and compareTo of JavacFileManager.PathAndContainer (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-8260593: javac can skip a temporary local variable when pattern matching over a local variable (P4) JDK-8255757: Javac emits duplicate pool entries on array::clone (P4) JDK-8259820: JShell does not handle -source 8 properly (P4) JDK-8264696: Multi-catch clause causes compiler exception because it uses the package-private supertype (P4) JDK-8260053: Optimize Tokens' use of Names (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-8261444: Remove unused fields in Lower (P4) JDK-8257204: Remove usage of -Xhtmlversion option from javac (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-8257457: Update --release 16 symbol information for JDK 16 build 28 (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-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-8262899: TestRedirectLinks fails (P3) JDK-8157682: @inheritDoc doesn't work with @exception (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-8261665: Clean up naming of StringContent and FixedStringContent (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-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-8261976: Normalize id's used by the standard doclet (P3) JDK-8223355: Redundant output by javadoc (P3) JDK-8261623: reference to javac internals in Extern class (P3) JDK-8263473: Update annotation terminology (2) (P3) JDK-8259283: use new HtmlId and HtmlIds classes (P3) JDK-8259726: Use of HashSet leads to undefined order in test output (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-8259216: javadoc omits method receiver for any nested type annotation (P4) JDK-8264191: Javadoc search is broken in Internet Explorer (P4) JDK-8264220: jdk/javadoc/doclet/testRelatedPackages/TestRelatedPackages.java fails to compile (P4) JDK-8263528: Make static page ids safe from collision with language elements (P4) JDK-8264655: Minor internal doc comment cleanup (P4) JDK-8261654: Missing license header in Signatures.java (P4) JDK-8263050: move HtmlDocletWriter.verticalSeparator to IndexWriter (P4) JDK-8259723: Move Table class to formats.html package (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-8261499: Simplify HTML for javadoc links (P4) JDK-8261263: Simplify javadoc link code (P4) JDK-8256312: Valid anchor 'id' value not allowed tools/javap: (P4) JDK-8260403: javap should be more robust in the face of invalid class files tools/jlink: (P2) JDK-8166727: javac crashed: [jimage.dll+0x1942] ImageStrings::find+0x28 (P3) JDK-8259814: test/jdk/tools/jlink/plugins/CompressorPluginTest.java has compilation issues (P4) JDK-8260337: Optimize ImageReader lookup, used by Class.getResource tools/jpackage: (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-8261839: Error creating runtime package on macos without mac-package-identifier (P3) JDK-8254702: jpackage app launcher crashes on CentOS (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-8259062: Remove MacAppStoreBundler (P3) JDK-8223188: Removed unnecessary #ifdef __cplusplus from .cpp sources (P4) JDK-8264403: [macos]: App names containing '.' characters results in an error message when launching (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-8248418: jpackage fails to extract main class and version from app module linked in external runtime (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-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 (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-8261450: JShell crashes with SIOOBE in tab completion (P4) JDK-8255273: jshell crashes with UnsupportedOperationException: Should not get here. (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-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 (P4) JDK-8258917: NativeMemoryTracking is handled by launcher inconsistenly xml/jaxp: (P2) JDK-8262041: javax/xml/jaxp/unittest/common/prettyprint/PrettyPrintTest.java fails after JDK-8260858 (P3) JDK-8249867: XML declaration is not followed by a newline (P4) JDK-8261670: Add javadoc for the XML processing limits (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