Hello, world
\n" + " \n" + "\n"; ``` _Using a "two-dimensional" block of text_ ``` String html = """Hello, world
"""; ``` ### SQL example _Using "one-dimensional" string literals_ ``` String query = "SELECT \"EMP_ID\", \"LAST_NAME\" FROM \"EMPLOYEE_TB\"\n" + "WHERE \"CITY\" = 'INDIANAPOLIS'\n" + "ORDER BY \"EMP_ID\", \"LAST_NAME\";\n"; ``` _Using a "two-dimensional" block of text_ ``` String query = """ SELECT "EMP_ID", "LAST_NAME" FROM "EMPLOYEE_TB" WHERE "CITY" = 'INDIANAPOLIS' ORDER BY "EMP_ID", "LAST_NAME"; """; ``` ### Polyglot language example _Using "one-dimensional" string literals_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval("function hello() {\n" + " print('\"Hello, world\"');\n" + "}\n" + "\n" + "hello();\n"); ``` _Using a "two-dimensional" block of text_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval(""" function hello() { print('"Hello, world"'); } hello(); """); ``` Description ----------- > _This section is identical to the same section in this JEP's predecessor, [JEP 355](https://openjdk.java.net/jeps/355), except for the addition of the subsection on [new escape sequences](#New-escape-sequences)._ A _text block_ is a new kind of literal in the Java language. It may be used to denote a string anywhere that a _[string literal](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5)_ could appear, but offers greater expressiveness and less accidental complexity. A text block consists of zero or more content characters, enclosed by opening and closing delimiters. The _opening delimiter_ is a sequence of three double quote characters (`"""`) followed by zero or more white spaces followed by a line terminator. The _content_ begins at the first character after the line terminator of the opening delimiter. The _closing delimiter_ is a sequence of three double quote characters. The content ends at the last character before the first double quote of the closing delimiter. The content may include double quote characters directly, unlike the characters in a string literal. The use of `\"` in a text block is permitted, but not necessary or recommended. Fat delimiters (`"""`) were chosen so that `"` characters could appear unescaped, and also to visually distinguish a text block from a string literal. The content may include line terminators directly, unlike the characters in a string literal. The use of `\n` in a text block is permitted, but not necessary or recommended. For example, the text block: ``` """ line 1 line 2 line 3 """ ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3\n" ``` or a concatenation of string literals: ``` "line 1\n" + "line 2\n" + "line 3\n" ``` If a line terminator is not required at the end of the string, then the closing delimiter can be placed on the last line of content. For example, the text block: ``` """ line 1 line 2 line 3""" ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3" ``` A text block can denote the empty string, although this is not recommended because it needs two lines of source code: ``` String empty = """ """; ``` Here are some examples of ill-formed text blocks: ``` String a = """"""; // no line terminator after opening delimiter String b = """ """; // no line terminator after opening delimiter String c = """ "; // no closing delimiter (text block continues to EOF) String d = """ abc \ def """; // unescaped backslash (see below for escape processing) ``` ### Compile-time processing A text block is a [constant expression](https://docs.oracle.com/javase/specs/jls/se12/html/jls-15.html#jls-15.28) of type `String`, just like a string literal. However, unlike a string literal, the content of a text block is processed by the Java compiler in three distinct steps: 1. Line terminators in the content are translated to LF (`\u000A`). The purpose of this translation is to follow the principle of least surprise when moving Java source code across platforms. 2. Incidental white space surrounding the content, introduced to match the indentation of Java source code, is removed. 3. Escape sequences in the content are interpreted. Performing interpretation as the final step means developers can write escape sequences such as `\n` without them being modified or deleted by earlier steps. The processed content is recorded in the `class` file as a `CONSTANT_String_info` entry in the constant pool, just like the characters of a string literal. The `class` file does not record whether a `CONSTANT_String_info` entry was derived from a text block or a string literal. At run time, a text block is evaluated to an instance of `String`, just like a string literal. Instances of `String` that are derived from text blocks are indistinguishable from instances derived from string literals. Two text blocks with the same processed content will refer to the same instance of `String` due to [interning](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-5.html#jvms-5.1-300), just like for [string literals](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5-410). The following sections discuss compile-time processing in more detail. #### 1. Line terminators Line terminators in the content are _normalized_ from CR (`\u000D`) and CRLF (`\u000D\u000A`) to LF (`\u000A`) by the Java compiler. This ensures that the string derived from the content is equivalent across platforms, even if the source code has been translated to a platform encoding (see `javac -encoding`). For example, if Java source code that was created on a Unix platform (where the line terminator is LF) is edited on a Windows platform (where the line terminator is CRLF), then without normalization, the content would become one character longer for each line. Any algorithm that relied on LF being the line terminator might fail, and any test that needed to verify string equality with `String::equals` would fail. The escape sequences `\n` (LF), `\f` (FF), and `\r` (CR) are _not_ interpreted during normalization; escape processing happens later. #### 2. Incidental white space The text blocks [shown above](#Motivation) were easier to read than their concatenated string literal counterparts, but the obvious interpretation for the content of a text block would include the spaces added to indent the embedded string so that it lines up neatly with the opening delimiter. Here is the HTML example using dots to visualize the spaces that the developer added for indentation: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............."""; ``` Since the opening delimiter is generally positioned to appear on the same line as the statement or expression which consumes the text block, there is no real significance to the fact that 14 visualized spaces start each line. Including those spaces in the content would mean the text block denotes a string different from the one denoted by the concatenated string literals. This would hurt migration, and be a recurring source of surprise: it is overwhelmingly likely that the developer does _not_ want those spaces in the string. Also, the closing delimiter is generally positioned to align with the content, which further suggests that the 14 visualized spaces are insignificant. Spaces may also appear at the end of each line, especially when a text block is populated by copy-pasting snippets from other files (which may themselves have been formed by copy-pasting from yet more files). Here is the HTML example reimagined with some trailing white space, again using dots to visualize spaces: ``` String html = """ ................. .............. ..............Hello, world
.... .............. . ................. .............."""; ``` Trailing white space is most often unintentional, idiosyncratic, and insignificant. It is overwhelmingly likely that the developer does not care about it. Trailing white space characters are similar to line terminators, in that both are invisible artifacts of the source code editing environment. With no visual guide to the presence of trailing white space characters, including them in the content would be a recurring source of surprise, as it would affect the length, hash code, etc, of the string. Accordingly, an appropriate interpretation for the content of a text block is to differentiate _incidental white space_ at the start and end of each line, from _essential white space_. The Java compiler processes the content by removing incidental white space to yield what the developer intended. `String::indent` can then be used to further manipulate indentation if desired. Using `|` to visualize margins: ``` || | | |Hello, world
| | | || ``` The _re-indentation algorithm_ takes the content of a text block whose line terminators have been normalized to LF. It removes the same amount of white space from each line of content until at least one of the lines has a non-white space character in the leftmost position. The position of the opening `"""` characters has no effect on the algorithm, but the position of the closing `"""` characters does have an effect if placed on its own line. The algorithm is as follows: 1. Split the content of the text block at every LF, producing a list of _individual lines_. Note that any line in the content which was just an LF will become an empty line in the list of individual lines. 2. Add all _non-blank_ lines from the list of individual lines into a set of _determining lines_. (Blank lines -- lines that are empty or are composed wholly of white space -- have no visible influence on the indentation. Excluding blank lines from the set of determining lines avoids throwing off step 4 of the algorithm.) 3. If the last line in the list of individual lines (i.e., the line with the closing delimiter) is _blank_, then add it to the set of determining lines. (The indentation of the closing delimiter should influence the indentation of the content as a whole -- a [_significant trailing line_](#Significant-trailing-line-policy) policy.) 4. Compute the _common white space prefix_ of the set of determining lines, by counting the number of leading white space characters on each line and taking the minimum count. 5. Remove the common white space prefix from each _non-blank_ line in the list of individual lines. 6. Remove all trailing white space from all lines in the modified list of individual lines from step 5. This step collapses wholly-white-space lines in the modified list so that they are empty, but does not discard them. 7. Construct the result string by joining all the lines in the modified list of individual lines from step 6, using LF as the separator between lines. If the final line in the list from step 6 is empty, then the joining LF from the previous line will be the last character in the result string. The escape sequences `\b` (backspace), `\t` (tab) and `\s` (space) are _not_ interpreted by the algorithm; escape processing happens later. Similarly, the `\Hello, world
"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is zero, so zero white space is removed from the start of each line. The algorithm thus produces: (using `|` to visualize the left margin) ``` | | |Hello, world
| | ``` Alternatively, suppose the closing delimiter is not moved all the way to the left, but rather under the `t` of `html` so it is eight spaces deeper than the variable declaration: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ ........ ........ ........Hello, world
........ ........ ........"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is eight, so eight white spaces are removed from the start of each line. The algorithm thus preserves the essential indentation of the content relative to the closing delimiter: ``` | | |Hello, world
| | ``` Finally, suppose the closing delimiter is moved slightly to the _right_ of the content: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............. """; ``` The common white space prefix is 14, so 14 white spaces are removed from the start of each line. The trailing blank line is stripped to leave an empty line, which being the last line is then discarded. In other words, moving the closing delimiter to the right of the content has no effect, and the algorithm again preserves the essential indentation of the content: ``` | | |Hello, world
| | ``` #### 3. Escape sequences After the content is re-indented, any _escape sequences_ in the content are interpreted. Text blocks support all of the escape sequences supported in string literals, including `\n`, `\t`, `\'`, `\"`, and `\\`. See [section 3.10.6](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.6) of the _The Java Language Specification_ for the full list. Developers will have access to escape processing via `String::translateEscapes`, a new instance method. Interpreting escapes as the final step allows developers to use `\n`, `\f`, and `\r` for vertical formatting of a string without it affecting the translation of line terminators in step 1, and to use `\b` and `\t` for horizontal formatting of a string without it affecting the removal of incidental white space in step 2. For example, consider this text block that contains the `\r` escape sequence (CR): ``` String html = """ \r \rHello, world
\r \r \r """; ``` The CR escapes are not processed until after the line terminators have been normalized to LF. Using Unicode escapes to visualize LF (`\u000A`) and CR (`\u000D`), the result is: ``` |\u000D\u000A | \u000D\u000A |Hello, world
\u000D\u000A | \u000D\u000A |\u000D\u000A ``` Note that it is legal to use `"` and `""` freely inside a text block, except immediately before the closing delimiter. For example, the following text blocks are legal: ``` String story = """ "When I use a word," Humpty Dumpty said, in rather a scornful tone, "it means just what I choose it to mean - neither more nor less." "The question is," said Alice, "whether you can make words mean so many different things." "The question is," said Humpty Dumpty, "which is to be master - that's all." """; // Note the newline before the closing delimiter String code = """ String empty = ""; """; ``` However, a sequence of three `"` characters requires at least one `"` to be escaped, in order to avoid mimicking the closing delimiter. (A sequence of n `"` characters requires at least `Math.floorDiv(n,3)` of them to be escaped.) The use of `"` immediately before the closing delimiter also requires escaping. For example: ``` String code = """ String text = \""" A text block inside a text block \"""; """; String tutorial1 = """ A common character in Java programs is \""""; String tutorial2 = """ The empty string literal is formed from " characters as follows: \"\""""; System.out.println(""" 1 " 2 "" 3 ""\" 4 ""\"" 5 ""\""" 6 ""\"""\" 7 ""\"""\"" 8 ""\"""\""" 9 ""\"""\"""\" 10 ""\"""\"""\"" 11 ""\"""\"""\""" 12 ""\"""\"""\"""\" """); ``` ### New escape sequences To allow finer control of the processing of newlines and white space, we introduce two new escape sequences. First, the `\Hello, world
\n" + " \n" + "\n"; ``` _Using a "two-dimensional" block of text_ ``` String html = """Hello, world
"""; ``` ### SQL example _Using "one-dimensional" string literals_ ``` String query = "SELECT \"EMP_ID\", \"LAST_NAME\" FROM \"EMPLOYEE_TB\"\n" + "WHERE \"CITY\" = 'INDIANAPOLIS'\n" + "ORDER BY \"EMP_ID\", \"LAST_NAME\";\n"; ``` _Using a "two-dimensional" block of text_ ``` String query = """ SELECT "EMP_ID", "LAST_NAME" FROM "EMPLOYEE_TB" WHERE "CITY" = 'INDIANAPOLIS' ORDER BY "EMP_ID", "LAST_NAME"; """; ``` ### Polyglot language example _Using "one-dimensional" string literals_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval("function hello() {\n" + " print('\"Hello, world\"');\n" + "}\n" + "\n" + "hello();\n"); ``` _Using a "two-dimensional" block of text_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval(""" function hello() { print('"Hello, world"'); } hello(); """); ``` Description ----------- > _This section is identical to the same section in this JEP's predecessor, [JEP 355](https://openjdk.java.net/jeps/355), except for the addition of the subsection on [new escape sequences](#New-escape-sequences)._ A _text block_ is a new kind of literal in the Java language. It may be used to denote a string anywhere that a _[string literal](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5)_ could appear, but offers greater expressiveness and less accidental complexity. A text block consists of zero or more content characters, enclosed by opening and closing delimiters. The _opening delimiter_ is a sequence of three double quote characters (`"""`) followed by zero or more white spaces followed by a line terminator. The _content_ begins at the first character after the line terminator of the opening delimiter. The _closing delimiter_ is a sequence of three double quote characters. The content ends at the last character before the first double quote of the closing delimiter. The content may include double quote characters directly, unlike the characters in a string literal. The use of `\"` in a text block is permitted, but not necessary or recommended. Fat delimiters (`"""`) were chosen so that `"` characters could appear unescaped, and also to visually distinguish a text block from a string literal. The content may include line terminators directly, unlike the characters in a string literal. The use of `\n` in a text block is permitted, but not necessary or recommended. For example, the text block: ``` """ line 1 line 2 line 3 """ ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3\n" ``` or a concatenation of string literals: ``` "line 1\n" + "line 2\n" + "line 3\n" ``` If a line terminator is not required at the end of the string, then the closing delimiter can be placed on the last line of content. For example, the text block: ``` """ line 1 line 2 line 3""" ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3" ``` A text block can denote the empty string, although this is not recommended because it needs two lines of source code: ``` String empty = """ """; ``` Here are some examples of ill-formed text blocks: ``` String a = """"""; // no line terminator after opening delimiter String b = """ """; // no line terminator after opening delimiter String c = """ "; // no closing delimiter (text block continues to EOF) String d = """ abc \ def """; // unescaped backslash (see below for escape processing) ``` ### Compile-time processing A text block is a [constant expression](https://docs.oracle.com/javase/specs/jls/se12/html/jls-15.html#jls-15.28) of type `String`, just like a string literal. However, unlike a string literal, the content of a text block is processed by the Java compiler in three distinct steps: 1. Line terminators in the content are translated to LF (`\u000A`). The purpose of this translation is to follow the principle of least surprise when moving Java source code across platforms. 2. Incidental white space surrounding the content, introduced to match the indentation of Java source code, is removed. 3. Escape sequences in the content are interpreted. Performing interpretation as the final step means developers can write escape sequences such as `\n` without them being modified or deleted by earlier steps. The processed content is recorded in the `class` file as a `CONSTANT_String_info` entry in the constant pool, just like the characters of a string literal. The `class` file does not record whether a `CONSTANT_String_info` entry was derived from a text block or a string literal. At run time, a text block is evaluated to an instance of `String`, just like a string literal. Instances of `String` that are derived from text blocks are indistinguishable from instances derived from string literals. Two text blocks with the same processed content will refer to the same instance of `String` due to [interning](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-5.html#jvms-5.1-300), just like for [string literals](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5-410). The following sections discuss compile-time processing in more detail. #### 1. Line terminators Line terminators in the content are _normalized_ from CR (`\u000D`) and CRLF (`\u000D\u000A`) to LF (`\u000A`) by the Java compiler. This ensures that the string derived from the content is equivalent across platforms, even if the source code has been translated to a platform encoding (see `javac -encoding`). For example, if Java source code that was created on a Unix platform (where the line terminator is LF) is edited on a Windows platform (where the line terminator is CRLF), then without normalization, the content would become one character longer for each line. Any algorithm that relied on LF being the line terminator might fail, and any test that needed to verify string equality with `String::equals` would fail. The escape sequences `\n` (LF), `\f` (FF), and `\r` (CR) are _not_ interpreted during normalization; escape processing happens later. #### 2. Incidental white space The text blocks [shown above](#Motivation) were easier to read than their concatenated string literal counterparts, but the obvious interpretation for the content of a text block would include the spaces added to indent the embedded string so that it lines up neatly with the opening delimiter. Here is the HTML example using dots to visualize the spaces that the developer added for indentation: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............."""; ``` Since the opening delimiter is generally positioned to appear on the same line as the statement or expression which consumes the text block, there is no real significance to the fact that 14 visualized spaces start each line. Including those spaces in the content would mean the text block denotes a string different from the one denoted by the concatenated string literals. This would hurt migration, and be a recurring source of surprise: it is overwhelmingly likely that the developer does _not_ want those spaces in the string. Also, the closing delimiter is generally positioned to align with the content, which further suggests that the 14 visualized spaces are insignificant. Spaces may also appear at the end of each line, especially when a text block is populated by copy-pasting snippets from other files (which may themselves have been formed by copy-pasting from yet more files). Here is the HTML example reimagined with some trailing white space, again using dots to visualize spaces: ``` String html = """ ................. .............. ..............Hello, world
.... .............. . ................. .............."""; ``` Trailing white space is most often unintentional, idiosyncratic, and insignificant. It is overwhelmingly likely that the developer does not care about it. Trailing white space characters are similar to line terminators, in that both are invisible artifacts of the source code editing environment. With no visual guide to the presence of trailing white space characters, including them in the content would be a recurring source of surprise, as it would affect the length, hash code, etc, of the string. Accordingly, an appropriate interpretation for the content of a text block is to differentiate _incidental white space_ at the start and end of each line, from _essential white space_. The Java compiler processes the content by removing incidental white space to yield what the developer intended. `String::indent` can then be used to further manipulate indentation if desired. Using `|` to visualize margins: ``` || | | |Hello, world
| | | || ``` The _re-indentation algorithm_ takes the content of a text block whose line terminators have been normalized to LF. It removes the same amount of white space from each line of content until at least one of the lines has a non-white space character in the leftmost position. The position of the opening `"""` characters has no effect on the algorithm, but the position of the closing `"""` characters does have an effect if placed on its own line. The algorithm is as follows: 1. Split the content of the text block at every LF, producing a list of _individual lines_. Note that any line in the content which was just an LF will become an empty line in the list of individual lines. 2. Add all _non-blank_ lines from the list of individual lines into a set of _determining lines_. (Blank lines -- lines that are empty or are composed wholly of white space -- have no visible influence on the indentation. Excluding blank lines from the set of determining lines avoids throwing off step 4 of the algorithm.) 3. If the last line in the list of individual lines (i.e., the line with the closing delimiter) is _blank_, then add it to the set of determining lines. (The indentation of the closing delimiter should influence the indentation of the content as a whole -- a [_significant trailing line_](#Significant-trailing-line-policy) policy.) 4. Compute the _common white space prefix_ of the set of determining lines, by counting the number of leading white space characters on each line and taking the minimum count. 5. Remove the common white space prefix from each _non-blank_ line in the list of individual lines. 6. Remove all trailing white space from all lines in the modified list of individual lines from step 5. This step collapses wholly-white-space lines in the modified list so that they are empty, but does not discard them. 7. Construct the result string by joining all the lines in the modified list of individual lines from step 6, using LF as the separator between lines. If the final line in the list from step 6 is empty, then the joining LF from the previous line will be the last character in the result string. The escape sequences `\b` (backspace), `\t` (tab) and `\s` (space) are _not_ interpreted by the algorithm; escape processing happens later. Similarly, the `\Hello, world
"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is zero, so zero white space is removed from the start of each line. The algorithm thus produces: (using `|` to visualize the left margin) ``` | | |Hello, world
| | ``` Alternatively, suppose the closing delimiter is not moved all the way to the left, but rather under the `t` of `html` so it is eight spaces deeper than the variable declaration: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ ........ ........ ........Hello, world
........ ........ ........"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is eight, so eight white spaces are removed from the start of each line. The algorithm thus preserves the essential indentation of the content relative to the closing delimiter: ``` | | |Hello, world
| | ``` Finally, suppose the closing delimiter is moved slightly to the _right_ of the content: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............. """; ``` The common white space prefix is 14, so 14 white spaces are removed from the start of each line. The trailing blank line is stripped to leave an empty line, which being the last line is then discarded. In other words, moving the closing delimiter to the right of the content has no effect, and the algorithm again preserves the essential indentation of the content: ``` | | |Hello, world
| | ``` #### 3. Escape sequences After the content is re-indented, any _escape sequences_ in the content are interpreted. Text blocks support all of the escape sequences supported in string literals, including `\n`, `\t`, `\'`, `\"`, and `\\`. See [section 3.10.6](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.6) of the _The Java Language Specification_ for the full list. Developers will have access to escape processing via `String::translateEscapes`, a new instance method. Interpreting escapes as the final step allows developers to use `\n`, `\f`, and `\r` for vertical formatting of a string without it affecting the translation of line terminators in step 1, and to use `\b` and `\t` for horizontal formatting of a string without it affecting the removal of incidental white space in step 2. For example, consider this text block that contains the `\r` escape sequence (CR): ``` String html = """ \r \rHello, world
\r \r \r """; ``` The CR escapes are not processed until after the line terminators have been normalized to LF. Using Unicode escapes to visualize LF (`\u000A`) and CR (`\u000D`), the result is: ``` |\u000D\u000A | \u000D\u000A |Hello, world
\u000D\u000A | \u000D\u000A |\u000D\u000A ``` Note that it is legal to use `"` and `""` freely inside a text block, except immediately before the closing delimiter. For example, the following text blocks are legal: ``` String story = """ "When I use a word," Humpty Dumpty said, in rather a scornful tone, "it means just what I choose it to mean - neither more nor less." "The question is," said Alice, "whether you can make words mean so many different things." "The question is," said Humpty Dumpty, "which is to be master - that's all." """; // Note the newline before the closing delimiter String code = """ String empty = ""; """; ``` However, a sequence of three `"` characters requires at least one `"` to be escaped, in order to avoid mimicking the closing delimiter. (A sequence of n `"` characters requires at least `Math.floorDiv(n,3)` of them to be escaped.) The use of `"` immediately before the closing delimiter also requires escaping. For example: ``` String code = """ String text = \""" A text block inside a text block \"""; """; String tutorial1 = """ A common character in Java programs is \""""; String tutorial2 = """ The empty string literal is formed from " characters as follows: \"\""""; System.out.println(""" 1 " 2 "" 3 ""\" 4 ""\"" 5 ""\""" 6 ""\"""\" 7 ""\"""\"" 8 ""\"""\""" 9 ""\"""\"""\" 10 ""\"""\"""\"" 11 ""\"""\"""\""" 12 ""\"""\"""\"""\" """); ``` ### New escape sequences To allow finer control of the processing of newlines and white space, we introduce two new escape sequences. First, the `\Hello, world
\n" + " \n" + "\n"; ``` _Using a "two-dimensional" block of text_ ``` String html = """Hello, world
"""; ``` ### SQL example _Using "one-dimensional" string literals_ ``` String query = "SELECT \"EMP_ID\", \"LAST_NAME\" FROM \"EMPLOYEE_TB\"\n" + "WHERE \"CITY\" = 'INDIANAPOLIS'\n" + "ORDER BY \"EMP_ID\", \"LAST_NAME\";\n"; ``` _Using a "two-dimensional" block of text_ ``` String query = """ SELECT "EMP_ID", "LAST_NAME" FROM "EMPLOYEE_TB" WHERE "CITY" = 'INDIANAPOLIS' ORDER BY "EMP_ID", "LAST_NAME"; """; ``` ### Polyglot language example _Using "one-dimensional" string literals_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval("function hello() {\n" + " print('\"Hello, world\"');\n" + "}\n" + "\n" + "hello();\n"); ``` _Using a "two-dimensional" block of text_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval(""" function hello() { print('"Hello, world"'); } hello(); """); ``` Description ----------- > _This section is identical to the same section in this JEP's predecessor, [JEP 355](https://openjdk.java.net/jeps/355), except for the addition of the subsection on [new escape sequences](#New-escape-sequences)._ A _text block_ is a new kind of literal in the Java language. It may be used to denote a string anywhere that a _[string literal](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5)_ could appear, but offers greater expressiveness and less accidental complexity. A text block consists of zero or more content characters, enclosed by opening and closing delimiters. The _opening delimiter_ is a sequence of three double quote characters (`"""`) followed by zero or more white spaces followed by a line terminator. The _content_ begins at the first character after the line terminator of the opening delimiter. The _closing delimiter_ is a sequence of three double quote characters. The content ends at the last character before the first double quote of the closing delimiter. The content may include double quote characters directly, unlike the characters in a string literal. The use of `\"` in a text block is permitted, but not necessary or recommended. Fat delimiters (`"""`) were chosen so that `"` characters could appear unescaped, and also to visually distinguish a text block from a string literal. The content may include line terminators directly, unlike the characters in a string literal. The use of `\n` in a text block is permitted, but not necessary or recommended. For example, the text block: ``` """ line 1 line 2 line 3 """ ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3\n" ``` or a concatenation of string literals: ``` "line 1\n" + "line 2\n" + "line 3\n" ``` If a line terminator is not required at the end of the string, then the closing delimiter can be placed on the last line of content. For example, the text block: ``` """ line 1 line 2 line 3""" ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3" ``` A text block can denote the empty string, although this is not recommended because it needs two lines of source code: ``` String empty = """ """; ``` Here are some examples of ill-formed text blocks: ``` String a = """"""; // no line terminator after opening delimiter String b = """ """; // no line terminator after opening delimiter String c = """ "; // no closing delimiter (text block continues to EOF) String d = """ abc \ def """; // unescaped backslash (see below for escape processing) ``` ### Compile-time processing A text block is a [constant expression](https://docs.oracle.com/javase/specs/jls/se12/html/jls-15.html#jls-15.28) of type `String`, just like a string literal. However, unlike a string literal, the content of a text block is processed by the Java compiler in three distinct steps: 1. Line terminators in the content are translated to LF (`\u000A`). The purpose of this translation is to follow the principle of least surprise when moving Java source code across platforms. 2. Incidental white space surrounding the content, introduced to match the indentation of Java source code, is removed. 3. Escape sequences in the content are interpreted. Performing interpretation as the final step means developers can write escape sequences such as `\n` without them being modified or deleted by earlier steps. The processed content is recorded in the `class` file as a `CONSTANT_String_info` entry in the constant pool, just like the characters of a string literal. The `class` file does not record whether a `CONSTANT_String_info` entry was derived from a text block or a string literal. At run time, a text block is evaluated to an instance of `String`, just like a string literal. Instances of `String` that are derived from text blocks are indistinguishable from instances derived from string literals. Two text blocks with the same processed content will refer to the same instance of `String` due to [interning](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-5.html#jvms-5.1-300), just like for [string literals](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5-410). The following sections discuss compile-time processing in more detail. #### 1. Line terminators Line terminators in the content are _normalized_ from CR (`\u000D`) and CRLF (`\u000D\u000A`) to LF (`\u000A`) by the Java compiler. This ensures that the string derived from the content is equivalent across platforms, even if the source code has been translated to a platform encoding (see `javac -encoding`). For example, if Java source code that was created on a Unix platform (where the line terminator is LF) is edited on a Windows platform (where the line terminator is CRLF), then without normalization, the content would become one character longer for each line. Any algorithm that relied on LF being the line terminator might fail, and any test that needed to verify string equality with `String::equals` would fail. The escape sequences `\n` (LF), `\f` (FF), and `\r` (CR) are _not_ interpreted during normalization; escape processing happens later. #### 2. Incidental white space The text blocks [shown above](#Motivation) were easier to read than their concatenated string literal counterparts, but the obvious interpretation for the content of a text block would include the spaces added to indent the embedded string so that it lines up neatly with the opening delimiter. Here is the HTML example using dots to visualize the spaces that the developer added for indentation: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............."""; ``` Since the opening delimiter is generally positioned to appear on the same line as the statement or expression which consumes the text block, there is no real significance to the fact that 14 visualized spaces start each line. Including those spaces in the content would mean the text block denotes a string different from the one denoted by the concatenated string literals. This would hurt migration, and be a recurring source of surprise: it is overwhelmingly likely that the developer does _not_ want those spaces in the string. Also, the closing delimiter is generally positioned to align with the content, which further suggests that the 14 visualized spaces are insignificant. Spaces may also appear at the end of each line, especially when a text block is populated by copy-pasting snippets from other files (which may themselves have been formed by copy-pasting from yet more files). Here is the HTML example reimagined with some trailing white space, again using dots to visualize spaces: ``` String html = """ ................. .............. ..............Hello, world
.... .............. . ................. .............."""; ``` Trailing white space is most often unintentional, idiosyncratic, and insignificant. It is overwhelmingly likely that the developer does not care about it. Trailing white space characters are similar to line terminators, in that both are invisible artifacts of the source code editing environment. With no visual guide to the presence of trailing white space characters, including them in the content would be a recurring source of surprise, as it would affect the length, hash code, etc, of the string. Accordingly, an appropriate interpretation for the content of a text block is to differentiate _incidental white space_ at the start and end of each line, from _essential white space_. The Java compiler processes the content by removing incidental white space to yield what the developer intended. `String::indent` can then be used to further manipulate indentation if desired. Using `|` to visualize margins: ``` || | | |Hello, world
| | | || ``` The _re-indentation algorithm_ takes the content of a text block whose line terminators have been normalized to LF. It removes the same amount of white space from each line of content until at least one of the lines has a non-white space character in the leftmost position. The position of the opening `"""` characters has no effect on the algorithm, but the position of the closing `"""` characters does have an effect if placed on its own line. The algorithm is as follows: 1. Split the content of the text block at every LF, producing a list of _individual lines_. Note that any line in the content which was just an LF will become an empty line in the list of individual lines. 2. Add all _non-blank_ lines from the list of individual lines into a set of _determining lines_. (Blank lines -- lines that are empty or are composed wholly of white space -- have no visible influence on the indentation. Excluding blank lines from the set of determining lines avoids throwing off step 4 of the algorithm.) 3. If the last line in the list of individual lines (i.e., the line with the closing delimiter) is _blank_, then add it to the set of determining lines. (The indentation of the closing delimiter should influence the indentation of the content as a whole -- a [_significant trailing line_](#Significant-trailing-line-policy) policy.) 4. Compute the _common white space prefix_ of the set of determining lines, by counting the number of leading white space characters on each line and taking the minimum count. 5. Remove the common white space prefix from each _non-blank_ line in the list of individual lines. 6. Remove all trailing white space from all lines in the modified list of individual lines from step 5. This step collapses wholly-white-space lines in the modified list so that they are empty, but does not discard them. 7. Construct the result string by joining all the lines in the modified list of individual lines from step 6, using LF as the separator between lines. If the final line in the list from step 6 is empty, then the joining LF from the previous line will be the last character in the result string. The escape sequences `\b` (backspace), `\t` (tab) and `\s` (space) are _not_ interpreted by the algorithm; escape processing happens later. Similarly, the `\Hello, world
"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is zero, so zero white space is removed from the start of each line. The algorithm thus produces: (using `|` to visualize the left margin) ``` | | |Hello, world
| | ``` Alternatively, suppose the closing delimiter is not moved all the way to the left, but rather under the `t` of `html` so it is eight spaces deeper than the variable declaration: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ ........ ........ ........Hello, world
........ ........ ........"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is eight, so eight white spaces are removed from the start of each line. The algorithm thus preserves the essential indentation of the content relative to the closing delimiter: ``` | | |Hello, world
| | ``` Finally, suppose the closing delimiter is moved slightly to the _right_ of the content: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............. """; ``` The common white space prefix is 14, so 14 white spaces are removed from the start of each line. The trailing blank line is stripped to leave an empty line, which being the last line is then discarded. In other words, moving the closing delimiter to the right of the content has no effect, and the algorithm again preserves the essential indentation of the content: ``` | | |Hello, world
| | ``` #### 3. Escape sequences After the content is re-indented, any _escape sequences_ in the content are interpreted. Text blocks support all of the escape sequences supported in string literals, including `\n`, `\t`, `\'`, `\"`, and `\\`. See [section 3.10.6](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.6) of the _The Java Language Specification_ for the full list. Developers will have access to escape processing via `String::translateEscapes`, a new instance method. Interpreting escapes as the final step allows developers to use `\n`, `\f`, and `\r` for vertical formatting of a string without it affecting the translation of line terminators in step 1, and to use `\b` and `\t` for horizontal formatting of a string without it affecting the removal of incidental white space in step 2. For example, consider this text block that contains the `\r` escape sequence (CR): ``` String html = """ \r \rHello, world
\r \r \r """; ``` The CR escapes are not processed until after the line terminators have been normalized to LF. Using Unicode escapes to visualize LF (`\u000A`) and CR (`\u000D`), the result is: ``` |\u000D\u000A | \u000D\u000A |Hello, world
\u000D\u000A | \u000D\u000A |\u000D\u000A ``` Note that it is legal to use `"` and `""` freely inside a text block, except immediately before the closing delimiter. For example, the following text blocks are legal: ``` String story = """ "When I use a word," Humpty Dumpty said, in rather a scornful tone, "it means just what I choose it to mean - neither more nor less." "The question is," said Alice, "whether you can make words mean so many different things." "The question is," said Humpty Dumpty, "which is to be master - that's all." """; // Note the newline before the closing delimiter String code = """ String empty = ""; """; ``` However, a sequence of three `"` characters requires at least one `"` to be escaped, in order to avoid mimicking the closing delimiter. (A sequence of n `"` characters requires at least `Math.floorDiv(n,3)` of them to be escaped.) The use of `"` immediately before the closing delimiter also requires escaping. For example: ``` String code = """ String text = \""" A text block inside a text block \"""; """; String tutorial1 = """ A common character in Java programs is \""""; String tutorial2 = """ The empty string literal is formed from " characters as follows: \"\""""; System.out.println(""" 1 " 2 "" 3 ""\" 4 ""\"" 5 ""\""" 6 ""\"""\" 7 ""\"""\"" 8 ""\"""\""" 9 ""\"""\"""\" 10 ""\"""\"""\"" 11 ""\"""\"""\""" 12 ""\"""\"""\"""\" """); ``` ### New escape sequences To allow finer control of the processing of newlines and white space, we introduce two new escape sequences. First, the `\Hello, world
\n" + " \n" + "\n"; ``` _Using a "two-dimensional" block of text_ ``` String html = """Hello, world
"""; ``` ### SQL example _Using "one-dimensional" string literals_ ``` String query = "SELECT \"EMP_ID\", \"LAST_NAME\" FROM \"EMPLOYEE_TB\"\n" + "WHERE \"CITY\" = 'INDIANAPOLIS'\n" + "ORDER BY \"EMP_ID\", \"LAST_NAME\";\n"; ``` _Using a "two-dimensional" block of text_ ``` String query = """ SELECT "EMP_ID", "LAST_NAME" FROM "EMPLOYEE_TB" WHERE "CITY" = 'INDIANAPOLIS' ORDER BY "EMP_ID", "LAST_NAME"; """; ``` ### Polyglot language example _Using "one-dimensional" string literals_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval("function hello() {\n" + " print('\"Hello, world\"');\n" + "}\n" + "\n" + "hello();\n"); ``` _Using a "two-dimensional" block of text_ ``` ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); Object obj = engine.eval(""" function hello() { print('"Hello, world"'); } hello(); """); ``` Description ----------- > _This section is identical to the same section in this JEP's predecessor, [JEP 355](https://openjdk.java.net/jeps/355), except for the addition of the subsection on [new escape sequences](#New-escape-sequences)._ A _text block_ is a new kind of literal in the Java language. It may be used to denote a string anywhere that a _[string literal](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5)_ could appear, but offers greater expressiveness and less accidental complexity. A text block consists of zero or more content characters, enclosed by opening and closing delimiters. The _opening delimiter_ is a sequence of three double quote characters (`"""`) followed by zero or more white spaces followed by a line terminator. The _content_ begins at the first character after the line terminator of the opening delimiter. The _closing delimiter_ is a sequence of three double quote characters. The content ends at the last character before the first double quote of the closing delimiter. The content may include double quote characters directly, unlike the characters in a string literal. The use of `\"` in a text block is permitted, but not necessary or recommended. Fat delimiters (`"""`) were chosen so that `"` characters could appear unescaped, and also to visually distinguish a text block from a string literal. The content may include line terminators directly, unlike the characters in a string literal. The use of `\n` in a text block is permitted, but not necessary or recommended. For example, the text block: ``` """ line 1 line 2 line 3 """ ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3\n" ``` or a concatenation of string literals: ``` "line 1\n" + "line 2\n" + "line 3\n" ``` If a line terminator is not required at the end of the string, then the closing delimiter can be placed on the last line of content. For example, the text block: ``` """ line 1 line 2 line 3""" ``` is equivalent to the string literal: ``` "line 1\nline 2\nline 3" ``` A text block can denote the empty string, although this is not recommended because it needs two lines of source code: ``` String empty = """ """; ``` Here are some examples of ill-formed text blocks: ``` String a = """"""; // no line terminator after opening delimiter String b = """ """; // no line terminator after opening delimiter String c = """ "; // no closing delimiter (text block continues to EOF) String d = """ abc \ def """; // unescaped backslash (see below for escape processing) ``` ### Compile-time processing A text block is a [constant expression](https://docs.oracle.com/javase/specs/jls/se12/html/jls-15.html#jls-15.28) of type `String`, just like a string literal. However, unlike a string literal, the content of a text block is processed by the Java compiler in three distinct steps: 1. Line terminators in the content are translated to LF (`\u000A`). The purpose of this translation is to follow the principle of least surprise when moving Java source code across platforms. 2. Incidental white space surrounding the content, introduced to match the indentation of Java source code, is removed. 3. Escape sequences in the content are interpreted. Performing interpretation as the final step means developers can write escape sequences such as `\n` without them being modified or deleted by earlier steps. The processed content is recorded in the `class` file as a `CONSTANT_String_info` entry in the constant pool, just like the characters of a string literal. The `class` file does not record whether a `CONSTANT_String_info` entry was derived from a text block or a string literal. At run time, a text block is evaluated to an instance of `String`, just like a string literal. Instances of `String` that are derived from text blocks are indistinguishable from instances derived from string literals. Two text blocks with the same processed content will refer to the same instance of `String` due to [interning](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-5.html#jvms-5.1-300), just like for [string literals](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.5-410). The following sections discuss compile-time processing in more detail. #### 1. Line terminators Line terminators in the content are _normalized_ from CR (`\u000D`) and CRLF (`\u000D\u000A`) to LF (`\u000A`) by the Java compiler. This ensures that the string derived from the content is equivalent across platforms, even if the source code has been translated to a platform encoding (see `javac -encoding`). For example, if Java source code that was created on a Unix platform (where the line terminator is LF) is edited on a Windows platform (where the line terminator is CRLF), then without normalization, the content would become one character longer for each line. Any algorithm that relied on LF being the line terminator might fail, and any test that needed to verify string equality with `String::equals` would fail. The escape sequences `\n` (LF), `\f` (FF), and `\r` (CR) are _not_ interpreted during normalization; escape processing happens later. #### 2. Incidental white space The text blocks [shown above](#Motivation) were easier to read than their concatenated string literal counterparts, but the obvious interpretation for the content of a text block would include the spaces added to indent the embedded string so that it lines up neatly with the opening delimiter. Here is the HTML example using dots to visualize the spaces that the developer added for indentation: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............."""; ``` Since the opening delimiter is generally positioned to appear on the same line as the statement or expression which consumes the text block, there is no real significance to the fact that 14 visualized spaces start each line. Including those spaces in the content would mean the text block denotes a string different from the one denoted by the concatenated string literals. This would hurt migration, and be a recurring source of surprise: it is overwhelmingly likely that the developer does _not_ want those spaces in the string. Also, the closing delimiter is generally positioned to align with the content, which further suggests that the 14 visualized spaces are insignificant. Spaces may also appear at the end of each line, especially when a text block is populated by copy-pasting snippets from other files (which may themselves have been formed by copy-pasting from yet more files). Here is the HTML example reimagined with some trailing white space, again using dots to visualize spaces: ``` String html = """ ................. .............. ..............Hello, world
.... .............. . ................. .............."""; ``` Trailing white space is most often unintentional, idiosyncratic, and insignificant. It is overwhelmingly likely that the developer does not care about it. Trailing white space characters are similar to line terminators, in that both are invisible artifacts of the source code editing environment. With no visual guide to the presence of trailing white space characters, including them in the content would be a recurring source of surprise, as it would affect the length, hash code, etc, of the string. Accordingly, an appropriate interpretation for the content of a text block is to differentiate _incidental white space_ at the start and end of each line, from _essential white space_. The Java compiler processes the content by removing incidental white space to yield what the developer intended. `String::indent` can then be used to further manipulate indentation if desired. Using `|` to visualize margins: ``` || | | |Hello, world
| | | || ``` The _re-indentation algorithm_ takes the content of a text block whose line terminators have been normalized to LF. It removes the same amount of white space from each line of content until at least one of the lines has a non-white space character in the leftmost position. The position of the opening `"""` characters has no effect on the algorithm, but the position of the closing `"""` characters does have an effect if placed on its own line. The algorithm is as follows: 1. Split the content of the text block at every LF, producing a list of _individual lines_. Note that any line in the content which was just an LF will become an empty line in the list of individual lines. 2. Add all _non-blank_ lines from the list of individual lines into a set of _determining lines_. (Blank lines -- lines that are empty or are composed wholly of white space -- have no visible influence on the indentation. Excluding blank lines from the set of determining lines avoids throwing off step 4 of the algorithm.) 3. If the last line in the list of individual lines (i.e., the line with the closing delimiter) is _blank_, then add it to the set of determining lines. (The indentation of the closing delimiter should influence the indentation of the content as a whole -- a [_significant trailing line_](#Significant-trailing-line-policy) policy.) 4. Compute the _common white space prefix_ of the set of determining lines, by counting the number of leading white space characters on each line and taking the minimum count. 5. Remove the common white space prefix from each _non-blank_ line in the list of individual lines. 6. Remove all trailing white space from all lines in the modified list of individual lines from step 5. This step collapses wholly-white-space lines in the modified list so that they are empty, but does not discard them. 7. Construct the result string by joining all the lines in the modified list of individual lines from step 6, using LF as the separator between lines. If the final line in the list from step 6 is empty, then the joining LF from the previous line will be the last character in the result string. The escape sequences `\b` (backspace), `\t` (tab) and `\s` (space) are _not_ interpreted by the algorithm; escape processing happens later. Similarly, the `\Hello, world
"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is zero, so zero white space is removed from the start of each line. The algorithm thus produces: (using `|` to visualize the left margin) ``` | | |Hello, world
| | ``` Alternatively, suppose the closing delimiter is not moved all the way to the left, but rather under the `t` of `html` so it is eight spaces deeper than the variable declaration: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ ........ ........ ........Hello, world
........ ........ ........"""; ``` Including the trailing blank line with the closing delimiter, the common white space prefix is eight, so eight white spaces are removed from the start of each line. The algorithm thus preserves the essential indentation of the content relative to the closing delimiter: ``` | | |Hello, world
| | ``` Finally, suppose the closing delimiter is moved slightly to the _right_ of the content: ``` String html = """Hello, world
"""; ``` The spaces visualized with dots are considered to be incidental: ``` String html = """ .............. .............. ..............Hello, world
.............. .............. .............. """; ``` The common white space prefix is 14, so 14 white spaces are removed from the start of each line. The trailing blank line is stripped to leave an empty line, which being the last line is then discarded. In other words, moving the closing delimiter to the right of the content has no effect, and the algorithm again preserves the essential indentation of the content: ``` | | |Hello, world
| | ``` #### 3. Escape sequences After the content is re-indented, any _escape sequences_ in the content are interpreted. Text blocks support all of the escape sequences supported in string literals, including `\n`, `\t`, `\'`, `\"`, and `\\`. See [section 3.10.6](https://docs.oracle.com/javase/specs/jls/se12/html/jls-3.html#jls-3.10.6) of the _The Java Language Specification_ for the full list. Developers will have access to escape processing via `String::translateEscapes`, a new instance method. Interpreting escapes as the final step allows developers to use `\n`, `\f`, and `\r` for vertical formatting of a string without it affecting the translation of line terminators in step 1, and to use `\b` and `\t` for horizontal formatting of a string without it affecting the removal of incidental white space in step 2. For example, consider this text block that contains the `\r` escape sequence (CR): ``` String html = """ \r \rHello, world
\r \r \r """; ``` The CR escapes are not processed until after the line terminators have been normalized to LF. Using Unicode escapes to visualize LF (`\u000A`) and CR (`\u000D`), the result is: ``` |\u000D\u000A | \u000D\u000A |Hello, world
\u000D\u000A | \u000D\u000A |\u000D\u000A ``` Note that it is legal to use `"` and `""` freely inside a text block, except immediately before the closing delimiter. For example, the following text blocks are legal: ``` String story = """ "When I use a word," Humpty Dumpty said, in rather a scornful tone, "it means just what I choose it to mean - neither more nor less." "The question is," said Alice, "whether you can make words mean so many different things." "The question is," said Humpty Dumpty, "which is to be master - that's all." """; // Note the newline before the closing delimiter String code = """ String empty = ""; """; ``` However, a sequence of three `"` characters requires at least one `"` to be escaped, in order to avoid mimicking the closing delimiter. (A sequence of n `"` characters requires at least `Math.floorDiv(n,3)` of them to be escaped.) The use of `"` immediately before the closing delimiter also requires escaping. For example: ``` String code = """ String text = \""" A text block inside a text block \"""; """; String tutorial1 = """ A common character in Java programs is \""""; String tutorial2 = """ The empty string literal is formed from " characters as follows: \"\""""; System.out.println(""" 1 " 2 "" 3 ""\" 4 ""\"" 5 ""\""" 6 ""\"""\" 7 ""\"""\"" 8 ""\"""\""" 9 ""\"""\"""\" 10 ""\"""\"""\"" 11 ""\"""\"""\""" 12 ""\"""\"""\"""\" """); ``` ### New escape sequences To allow finer control of the processing of newlines and white space, we introduce two new escape sequences. First, the `\ Tag text
JDK-8238085: PIT: javax/swing/JSpinner/8223788/JSpinnerButtonFocusTest.java fails on mac
JDK-8239827: The test OpenByUNCPathNameTest.java should be changed to be manual
JDK-8240654: ZGC can cause severe UI application repaint issues
client-libs/2d:
JDK-8244621: [macos10.15] Garbled FX printing plus CoreText warnings on Catalina when building with Xcode 11
JDK-8244818: [macos] Java2D Queue Flusher crash while moving application window to external monitor
JDK-8220150: [macos] macos10.14 Mojave returns anti-aliased glyphs instead of aliased B&W glyphs
JDK-8235520: [macosx] Delete NSView based direct rendering mechanism
JDK-8238075: [OGL] Delete unused properties
JDK-8242557: Add length limit for strings in PNGImageWriter
JDK-8223090: Clean up obsolete logic & reference to Amble fonts.
JDK-8241829: Cleanup the code for PrinterJob on windows
JDK-8239149: Cleanups in SunFontManager.java and TrueTypeFont.java
JDK-8240342: Custom composite is ignored when printing an opaque image to a page
JDK-8233006: freetype incorrectly adjusts advances when emboldening rotated glyphs
JDK-5085520: Inconsistency in spec for RenderingHints.entrySet()
JDK-8236996: Incorrect Roboto font rendering on Windows with subpixel antialiasing
JDK-8235904: Infinite loop when rendering huge lines
JDK-8213129: java/awt/font/FontNames/LocaleFamilyNames.java times out in Win7
JDK-8221305: java/awt/FontMetrics/MaxAdvanceIsMax.java fails on MacOS + Solaris
JDK-8223935: PIT: java/awt/font/WindowsIndicFonts.java fails on windows10
JDK-8235147: Release HDC from passiveDCList sooner
JDK-8242325: Remove VIS version of medialib
JDK-8238942: Rendering artifacts with LCD text and fractional metrics
JDK-8239091: Reversed arguments in call to strstr in freetype "debug" code.
JDK-8230672: Specification for java.awt.FontMetrics.getMaxAdvance() is too prescriptive.
JDK-8196181: sun/java2d/GdiRendering/InsetClipping.java fails
JDK-8197797: Test java/awt/Graphics2D/DrawString/RotTransText.java fails on Windows
JDK-8224109: Text spaced incorrectly by drawString under rotation with fractional metrics
JDK-8242004: TextLayout throws Exception with a non-invertible transform
JDK-8231556: Wrong font ligatures used when 2 versions of same font used
client-libs/demo:
JDK-8237746: Fixing compiler warnings in src/demo/share/jfc
client-libs/java.awt:
JDK-8226806: [macOS 10.14] Methods of Java Robot should be called from appropriate thread
JDK-8237243: [macOS] java/awt/event/KeyEvent/DisabledTargetF10/DisabledTargetF10.html fails
JDK-8237222: [macos] java/awt/Focus/UnaccessibleChoice/AccessibleChoiceTest.java fails
JDK-8242174: [macos] The NestedModelessDialogTest test make the macOS unstable
JDK-7185258: [macosx] Deadlock in SunToolKit.realSync()
JDK-8230926: [macosx] Two apostrophes are entered instead of one with "U.S. International - PC" layout
JDK-8241087: Build failure with VS 2019 (16.5.0) due to C2039 and C2873
JDK-8221741: ClassCastException can happen when fontconfig.properties is used
JDK-8240290: Clean the "libawt_xawt" library from code for macOS
JDK-8238276: ComponentPeer.xxxImage are not implemented in some peers
JDK-8176040: Documentation of java.awt.Rectangle.add(java.awt.Point) is wrong.
JDK-8238575: DragSourceEvent.getLocation() returns wrong value on HiDPI screens (Windows)
JDK-8176359: Frame#setMaximizedbounds not working properly in multi screen environments
JDK-8240518: Incorrect JNU_ReleaseStringPlatformChars in Windows Print
JDK-8242498: Invalid "sun.awt.TimedWindowEvent" object leads to JVM crash
JDK-8232744: j.awt.Window::setShape(Shape) paints visible artifacts outside of the given shape
JDK-8238741: java.awt.Robot(GraphicsDevice) constructor does not follow the spec
JDK-8028701: java/awt/Focus/ShowFrameCheckForegroundTest/ShowFrameCheckForegroundTest.java fails
JDK-8196019: java/awt/Window/Grab/GrabTest.java fails on Windows
JDK-8234706: MenuPeer cleanup
JDK-8239124: Minimize the usage of AwtGraphicsConfigDataPtr in native
JDK-8235739: Rare NPE at WComponentPeer.getGraphics()
JDK-8245938: Remove unused print_stack(void) method from XToolkit.c
JDK-8221823: Requested JDialog width is ignored
JDK-8210231: Robot.delay() catches InterruptedException and prints stacktrace to stderr
JDK-8237049: Rollback the workaround for JDK-4533057
JDK-8231564: setMaximizedBounds is broken with large display scale and multiple monitors
JDK-8223108: Test java/awt/EventQueue/NonComponentSourcePost.java is unstable
JDK-8225126: Test SetBoundsPaintTest.html failed on Windows when desktop is scaled
JDK-8238936: The crash in XRobotPeer when the custom GraphicsDevice is used
JDK-8236163: The first getDefaultToolkit() hangs if invoked during the process's shutdown.
JDK-8243925: Toolkit#getScreenInsets() returns wrong value on HiDPI screens (Windows)
JDK-8233573: Toolkit.getScreenInsets(GraphicsConfiguration) may throw ClassCastException
JDK-8239819: XToolkit: Misread of screen information memory
client-libs/java.awt:i18n:
JDK-8239583: [AIX] simplify the native references in X input methods
client-libs/javax.accessibility:
JDK-8226253: JAWS reports wrong number of radio buttons when buttons are hidden
JDK-8249278: Revert JDK-8226253 which breaks the spec of AccessibleState.SHOWING for JList
client-libs/javax.imageio:
JDK-8238842: AIOOBE in GIFImageReader.initializeStringTable
JDK-6532025: GIF reader throws misleading exception with truncated images
JDK-8195841: PNGImageReader.readNullTerminatedString() doesnt check for non-null terminated strings with length equal to maxLen
client-libs/javax.sound:
JDK-8238738: AudioSystem.getMixerInfo() takes about 30 sec to report a gone audio device
JDK-8236980: Cleanup of toString methods in JavaSound
JDK-8238567: SoftMainMixer.processAudioBuffers(): Wrong handling of stoppedMixers
client-libs/javax.swing:
JDK-8249251: [dark_mode ubuntu 20.04] The selected menu is not highlighted in GTKLookAndFeel
JDK-8238813: [macos] closed test javax/swing/UIDefaults/4280340/bug4280340.java fails on macos
JDK-8238719: [macOS] Delete the property which use deprecated prefix "com.apple.macos."
JDK-8239312: [macos] javax/swing/JFrame/NSTexturedJFrame/NSTexturedJFrame.java
JDK-8238824: [macos] javax/swing/JSpinner/4840869/bug4840869.java fails on macos
JDK-8231042: [macos] JFileChooser creates new folder on ESC
JDK-8223788: [macos] JSpinner buttons in JColorChooser dialog may capture focus using TAB Key.
JDK-8229856: [macos] Opening a menu on a JTextField can clear the text selection
JDK-8239902: [macos] Remove direct usage of JSlider, JProgressBar classes in CAccessible class
JDK-8152332: [macosx] JFileChooser cannot be serialized on Mac OS X
JDK-7102679: [macosx] JFrame does not show JTextPane in content pane with the BorderLayout.NORTH constraints
JDK-8146330: [macosx] UIDefaults.keys() different size than UIDefaults.keySet()
JDK-7105119: [TEST_BUG] [macosx] In test UIDefaults.toString() must be called with the invokeLater()
JDK-8028123: [TEST_BUG] closed/javax/swing/JTree/4654916/bug4654916.java fails
JDK-8208566: [TEST_BUG] javax\swing\text\GlyphPainter2\6427244\bug6427244.java: Test failed
JDK-8233584: [Win LAF] When navigating the contents of the file list changes in Win LAF
JDK-8240202: A few client tests leave mouse buttons pressed
JDK-7020860: BasicTreeUI contains getters/setters with unclear spec
JDK-8216329: Cannot resize CheckBoxItemMenu in Synth L&F with setHorizontalTextPosition
JDK-8245668: closed test javax/swing/JComboBox/4765319/bug4765319.java fails on windows
JDK-8222759: com.sun.java.swing.plaf.gtk.GTKLookAndFeel has unnecessary casts to GTKStyleFactory
JDK-8245157: Deproblemlist closed javax/swing/JSpinner/4840869.java
JDK-8245273: Deproblemlist javax/swing/DataTransfer/DefaultNoDrop/DefaultNoDrop.java
JDK-8234913: Improve parsing of Length Units in javax/swing/text/html/CSS
JDK-8235818: Inline information from broken external links in java.desktop
JDK-8213123: javax/swing/JButton/4368790/bug4368790.java fails on mac
JDK-8196094: javax/swing/JFileChooser/8002077/bug8002077.java fails
JDK-8241291: JCK test javax_swing/text/DefaultStyledDocument/ElementSpec/ESpecCtor.html fails
JDK-8246263: jdk is not yet ready for new Copyright line.
JDK-8236635: JTabbedPane preferred size calculation is wrong for SCROLL_TAB_LAYOUT.
JDK-8224475: JTextPane does not show images in HTML rendering
JDK-8240633: Memory leaks in the implementations of FileChooserUI
JDK-8240877: NPE at javax.swing.text.html.FormView.appendBuffer with null option values
JDK-8242526: PIT: javax/swing/JInternalFrame/8020708/bug8020708.java fails in mach5 ubuntu system
JDK-8221902: PIT: javax/swing/JRadioButton/FocusTraversal/FocusTraversal.java fails on ubuntu
JDK-8040630: Popup menus and tooltips flicker with previous popup contents when first shown
JDK-8240690: Race condition between EDT and BasicDirectoryModel.FilesLoader.run0()
JDK-8153090: TAB key cannot change input focus after the radio button in the Color Selection dialog
JDK-8239334: Tab Size does not work correctly in JTextArea with setLineWrap on
JDK-8042376: Test closed/javax/swing/JPopupMenu/4791569/bug4791569.java fails with Accelerator didn't work
JDK-8067986: Test javax/swing/JComboBox/ConsumedKeyTest/ConsumedKeyTest.java fails
JDK-8226230: Test javax/swing/JInternalFrame/8020708/bug8020708.java fails on Ubuntu
JDK-8241228: Test jdk/javax/swing/UIDefaults/8146330/UIDefaultKeySizeTest.java is failing
JDK-8244557: test/jdk/javax/swing/JTabbedPane/TestBackgroundScrollPolicy.java failed
JDK-8226464: TitledBorder label appears cut off on hidpi devices
JDK-8178028: Typing 'C' cannot change the tab layout to WRAP_TAB_LAYOUT
JDK-8234733: We can't distinguish if the spinner button is pressed or unpressed
JDK-8172269: When checking the default behaviour for a scroll tab layout and checking the 'opaque' checkbox, the area behind tabs is not red.
JDK-8232243: Wrong caret position in JTextPane on Windows with a screen resolution > 100%
core-libs:
JDK-8245722: 32-bit build failures after JDK-8243491
JDK-8231111: Cgroups v2: Rework Metrics in java.base so as to recognize unified hierarchy
JDK-8239559: Cgroups: Incorrect detection logic on some systems
JDK-8243539: Copyright info (Year) should be updated for fix of 8241638
JDK-8242366: Fix JavaDoc warnings
JDK-8247115: Fix typos in java.lang.invoke and java.lang
JDK-8243491: Implementation of Foreign-Memory Access API (Second Incubator)
JDK-8248011: Improve javadoc of Foreign Memory Access API
JDK-8246050: Improve scalability of MemoryScope
JDK-8247696: Incorrect tail computation for large segments in AbstractMemorySegmentImpl::mismatch
JDK-8238380: java.base/unix/native/libjava/childproc.c "multiple definition" link errors with GCC10
JDK-8246040: java/foreign/TestAddressHandle fails on big endian platforms
JDK-8241144: Javadoc is not generated for new module jdk.nio.mapmode
JDK-8237521: Memory Access API fixes for 32-bit
JDK-8241014: Miscellaneous typos in documentation comments
JDK-8239563: Reduce public exports in dynamic libraries built from JDK static libraries
JDK-8249205: Remove unnecessary trademark symbols
JDK-8240725: Some functions might not work with CJK character
JDK-8225361: Start of release updates for JDK 15
JDK-8246095: Tweaks to memory access API
JDK-8237818: Typo in Unsafe: resposibility
JDK-8241727: Typos: empty lines in javadoc, inconsistent indents, etc. (core-libs only)
JDK-8241760: Typos: empty lines in javadoc, inconsistent indents, etc. (net and nio)
JDK-8230772: Umbrella: JDK 15 terminal deprecations
JDK-8245111: Update doc comments for improved processing by the Standard Doclet
JDK-8241627: Updating ASM to 8.0.1 for JDK 15
JDK-8242230: Whitespace typos, relaxed javadoc, formatting
core-libs/java.io:
JDK-8247896: Invalid (@throw) tags in 2 java.io classes
JDK-8249700: java/io/File/GetXSpace.java should be added to exclude list, and not @ignore-d
JDK-8244936: Reduce JNI overhead of accessing FileDescriptor
JDK-8246338: Reduce overhead of normalizing file paths
JDK-8246451: Reduce overhead of normalizing file paths with trailing slash
JDK-8241921: Remove leftover diagnostic from test/jdk/java/io/Serializable/records/SerialPersistentFieldsTest.java
JDK-8246592: Simplify checking of boolean file attributes
core-libs/java.io:serialization:
JDK-8248233: Avoid superfluous Class::isRecord invocations during deserialization
JDK-8238763: ObjectInputStream readUnshared method handling of Records
JDK-8247532: Records deserialization is slow
JDK-8247789: Remove use of reflection from test/jdk/java/io/Serializable/records/StreamRefTest.java
core-libs/java.lang:
JDK-8215401: Add isEmpty default method to CharSequence
JDK-8241374: add Math.absExact
JDK-8246098: API for Class::permittedSubclasses should clarify if returned elements are ordered or not
JDK-8237878: Archive ModuleLoaderMap mapper
JDK-8245658: Arrays.java has two occurrences of bad unicode constants in Javadoc.
JDK-8230800: Clarify String::stripIndent javadoc when string ends with line terminator
JDK-8241964: Clean up java.lang.Class javadoc
JDK-8236183: cleanup Java_jdk_internal_reflect_Reflection_getCallerClass naming
JDK-8233795: Consider adding a notion of a Value-based class to API Documentation index
JDK-8240971: Fix CSS styles in some doc comments
JDK-8247899: HTML errors and warnings in threadPrimitiveDeprecation.html
JDK-8245958: j.l.Record need to mention that canonical constructor may not be public
JDK-8238239: java.lang.Record spec clarifications
JDK-8241100: Make Boolean, Character, Byte, and Short implement Constable
JDK-8236075: Minor bootstrap improvements
JDK-8241947: Minor comment fixes for system property handling
JDK-8237576: Missing import in macosx/../ClassLoaderHelper
JDK-8241649: Optimize Character.toString
JDK-8240094: Optimize empty substring handling
JDK-8227045: Preview APIs support for sealed classes
JDK-8239365: ProcessBuilder test modifications for AIX execution
JDK-8240704: ProcessBuilder/checkHandles/CheckHandles.java failed "AssertionError: Handle use increased by more than 10 percent."
JDK-8232846: ProcessHandle.Info command with non-English shows question marks
JDK-8245398: Remove addition preview adornment from String::formatted
JDK-8243168: Remove addition preview adornment from String::stripIndent and String::translateEscapes
JDK-8240524: Remove explicit type argument in test jdk/java/lang/Boolean/MakeBooleanComparable.java
JDK-8230771: Remove terminally deprecated constructors in java.base
JDK-8241742: Remove the preview status for methods introduced for Text Blocks
JDK-8244855: Remove unused "getParent" function from Windows jni_util_md.c
JDK-8230744: Several classes throw OutOfMemoryError without message
JDK-8239383: Support for Unicode 13.0
JDK-8247444: Trust final fields in records
JDK-8217475: Unexpected StackOverflowError in "process reaper" thread
JDK-8242208: Use Method.getParameterCount where applicable
JDK-8239893: Windows handle Leak when starting processes using ProcessBuilder
core-libs/java.lang.invoke:
JDK-8244413: Avoid rebinds in MethodHandle.viewAsType
JDK-8245596: Clarify Lookup::defineHiddenClass spec @throws IAE if the bytes has ACC_MODULE flag set
JDK-8242012: Drop the uniqueness guarantee from the suffix of the name of a hidden class
JDK-8218173: exception during StringConcatFactory clinit breaks string concat with no fallback
JDK-8245959: Extend String concat testing to account for folded constants
JDK-8238358: Implementation of JEP 371: Hidden Classes
JDK-8246152: Improve String concat bootstrapping
JDK-8240242: improve the javadoc for Lookup::dropLookupModes w.r.t. dropping UNCONDITIONAL
JDK-8243574: java.lang.invoke.InvokerBytecodeGenerator.ClassData should be package-private
JDK-8220607: JEP 371: Hidden Classes
JDK-8246241: LambdaFormEditor should use a transform lookup key that is not a SoftReference
JDK-8238195: Lookup::defineClass should link the class to match the specification
JDK-8245061: Lookup::defineHiddenClass should throw ClassFormatError if the constant_pool entry at the this_class index is not Class_info structure
JDK-8245432: Lookup::defineHiddenClass should throw UnsupportedClassVersionError if the given bytes are of an unsupported major or minor version
JDK-8244961: MethodHandles::privateLookupIn throws NPE when called during initPhase2
JDK-8230301: Re-examine hardcoded defaults in GenerateJLIClassesPlugin
JDK-8245756: Reduce bootstrap cost of StringConcatFactory prependers
JDK-8245094: Reduce overhead of initializing the StringConcatFactory default strategy
JDK-8245455: Remove alternative StringConcatFactory strategies
JDK-8235521: Replacement API for Unsafe::ensureClassInitialized
JDK-8245024: Simplify and eagerly initialize StringConcatFactory
JDK-8245969: Simplify String concat constant folding
JDK-8246632: StringConcatFactory::makeConcatWithConstants no longer throws NullPointerException when an unexpected constant is null
JDK-8243274: suppress warnings in LookupDefineClass microbenchmarks due to JDK-8243156
JDK-8243575: Trivial javadoc fix of j.l.i.MethodHandles::arrayElementVarHandle
JDK-8243598: Typos in java.lang.invoke package-info
core-libs/java.lang.module:
JDK-8237484: Improve module system bootstrap
JDK-8241770: Module xxxAnnotation() methods throw NCDFE if module-info.class found as resource in unnamed module
JDK-8243666: ModuleHashes attribute generated for JMOD and JAR files depends on timestamps
JDK-8240734: ModuleHashes attribute not reproducible between builds
JDK-8243596: ModuleLayer::parents should return an unmodifiable list
JDK-8238599: Refactor and simplify implAddOpensToAllUnnamed
JDK-8247212: Use assistant markup in java.lang.module.ModuleDescriptor
JDK-8236705: Use single character variant of String.replace when applicable
core-libs/java.lang:class_loading:
JDK-8240975: Extend NativeLibraries to support explicit unloading
JDK-8228336: Refactor native library loading implementation
JDK-8247785: Small clarification of the javadoc about builtin class loaders
core-libs/java.lang:reflect:
JDK-8202469: (ann) Type annotations on type variable bounds that are also type variables are lost
JDK-8245678: Avoid allocations in Executable.getAllGenericParameterTypes
JDK-8225540: In core reflection note whether returned annotations are declaration or type annotations
JDK-8241789: Make citations of JLS and JVMS consistent in java.lang.Class
JDK-8230047: Remove legacy java.lang.reflect.ProxyGenerator_v49
JDK-8237805: Use inline @jls @jvms in core libs where appropriate
core-libs/java.math:
JDK-8241097: java/math/BigInteger/largeMemory/SymmetricRangeTests.java requires -XX:+CompactStrings
JDK-8240624: Note mapping of RoundingMode constants to equivalent IEEE 754-2019 policy
core-libs/java.net:
JDK-8238386: (sctp) jdk.sctp/unix/native/libsctp/SctpNet.c "multiple definition" link errors with GCC10
JDK-8237075: @since tag missing from DatagramSocket and MulticastSocket methods
JDK-8242044: Add basic HTTP/1.1 support to the HTTP/2 Test Server
JDK-8245569: Add jtreg tests for SO_INCOMING_NAPI_ID
JDK-8244652: Add test for non utf-8 response handling by websocket client
JDK-8243488: Add tests for set/get SendBufferSize and getReceiveBufferSize in DatagramSocket
JDK-8246132: AsynchronousSocketChannelNAPITest failing with a NotYetConnectedException
JDK-8236105: Behaviors of DatagramSocket/DatagramChannel::socket send methods are not always consistent
JDK-8248703: Clarify the behavior of java.net.NetworkInterface::equals
JDK-8237817: Clean up net-properties.html
JDK-8238231: Custom DatagramSocketImpl's create method not called when with protected constructor
JDK-7021373: DatagramPacket exception conditions are not clear
JDK-8237890: DatagramPacket::getSocketAddress doesn't specify what happens if address or port are not set
JDK-8243999: DatagramSocket and MulticastSocket constructors don't specify how a null InetAddress is handled
JDK-8243507: DatagramSocket constructors don’t always specify what happens when passed invalid parameters
JDK-8241988: DatagramSocket incorrectly caches the first set of socket options
JDK-8244933: DatagramSocket.connect does not specify that it may cause datagrams in the socket receive buffer to be discarded
JDK-8235783: DatagramSocket::connect and DatagramSocket::disconnect should allow an implementation to throw UncheckedIOException
JDK-8243246: HTTP Client sometimes gets java.io.IOException -> Invalid chunk header byte 32
JDK-8241138: http.nonProxyHosts=* causes StringIndexOutOfBoundsException in DefaultProxySelector
JDK-8242999: HTTP/2 client may not handle CONTINUATION frames correctly
JDK-8244205: HTTP/2 tunnel connections through proxy may be reused regardless of which proxy is selected
JDK-8236596: HttpClient leaves HTTP/2 sockets in CLOSE_WAIT, when using proxy tunnel
JDK-8244031: HttpClient should have more tests for HEAD requests
JDK-8235459: HttpRequest.BodyPublishers#ofFile(Path) assumes the default file system
JDK-8237470: HttpResponse.BodySubscriber::ofFile throws UOE with non-default file systems
JDK-8238579: HttpsURLConnection drops the timeout and hangs forever in read
JDK-8240533: Inconsistent Exceptions are thrown by DatagramSocket and DatagramChannel when sending a DatagramPacket to port 0.
JDK-8243408: Inconsistent Exceptions are thrown by MulticastSocket when sending a DatagramPacket to port 0
JDK-8240754: Instrument FlowTest.java to provide more debug traces.
JDK-8241378: j.net.URLConnection::getHeaderFieldKey(int) behavior does not reliably conform to its specification
JDK-8238270: java.net HTTP/2 client does not decrease stream count when receives 204 response
JDK-8237571: java/net/DatagramSocket/SendCheck.java is failing on Solaris
JDK-8234718: java/net/httpclient tests should cover TLSv1.3
JDK-8238990: java/net/httpclient/HandshakeFailureTest.java failed against TLSv1.3 on Windows
JDK-8246431: java/net/httpclient/PathSubscriber tests fail due to missing FilePermission
JDK-8238677: java/net/httpclient/ssltest/CertificateTest.java should not specify TLS version
JDK-8238740: java/net/httpclient/whitebox/FlowTestDriver.java should not specify a TLS protocol
JDK-8239052: java/net/httpclient/whitebox/SSLEchoTubeTestDriver.java failed with BufferUnderflowException against TLSv1.3
JDK-8235925: java/net/Socket/HttpProxy.java fails on IPv4 only hosts and other small cleanups
JDK-8245517: java/net/SocketOption/AfterClose.java fails with Invalid value 'READ_ONLY'
JDK-8239594: jdk.tls.client.protocols is not respected
JDK-8235674: JEP 373: Reimplement the Legacy DatagramSocket API
JDK-8240921: Minor correction to HttpResponse.BodySubscribers example
JDK-8237896: MulticastSocket should link to DatagramChannel as an alternative for multicasting.
JDK-8059309: network tests fail with "java.net.SocketException: Couldn't obtain phys addr" when run as "root"
JDK-8244958: preferIPv4Stack and preferIPv6Addresses do not affect addresses returned by HostsFileNameService
JDK-8230211: Prepare DatagramSocket for alternative DatagramSocketImpl
JDK-8242186: Reduce allocations in URLStreamHandler.parseURL for some cases
JDK-8241072: Reimplement the Legacy DatagramSocket API
JDK-8244582: Remove terminally deprecated Solaris-specific SO_FLOW_SLA socket option
JDK-8245828: Remove unnecessary NetworkPermission checks from jdk/net/ExtendedSocketOptions.java
JDK-8183369: RFC unconformity of HttpURLConnection with proxy
JDK-8243099: SO_INCOMING_NAPI_ID support
JDK-8241336: Some java.net tests failed with NoRouteToHostException on MacOS with special network configuration
JDK-8239595: ssl context version is not respected
JDK-8244853: The static build of libextnet is missing the JNI_OnLoad_extnet function
JDK-8129841: Update comment for Java_java_net_Inet6AddressImpl_getHostByAddr
JDK-5064980: URI compareTo inconsistent with equals for mixed-case escape sequences
JDK-8241389: URLConnection::getHeaderFields returns result inconsistent with getHeaderField/Key for FileURLConnection, FtpURLConnection
JDK-8240666: Websocket client's OpeningHandshake discards the HTTP response body
JDK-8236859: WebSocket over authenticating proxy fails with NPE
core-libs/java.nio:
JDK-8249543: (bf) Force DirectBufferAllocTest to run with -ExplicitGCInvokesConcurrent
JDK-8245121: (bf) XBuffer.put(Xbuffer src) can give unexpected result when storage overlaps
JDK-8053479: (dc) DatagramChannel.read() throws exception instead of discarding data when buffer too small
JDK-8239355: (dc) Initial value of SO_SNDBUF should allow sending large datagrams (macOS)
JDK-8236184: (dc) IP_MULTICAST_* and IP_TOS socket options not effective
JDK-8236925: (dc) Upgrade DatagramChannel socket adaptor to extend MulticastSocket
JDK-8241952: (fs) FileChannel.write(ByteBuffer src, long position) does not check for the FileChannel being closed first
JDK-8242292: (fs) FileSystems.getFileSystem(URI) should throw IAE if the URI scheme is null
JDK-8241568: (fs) UserPrincipalLookupService.lookupXXX failure with IOE "Operation not permitted"
JDK-4617266: (se spec) SelectionKey.OP_READ/OP_WRITE documentation errors
JDK-8242356: (se) epoll Selector should use epoll_create1 instead of epoll_create
JDK-8242006: (zipfs) Improve Zip FS FileChannel and SeekableByteChannel test coverage
JDK-8211917: (zipfs) Creating or updating a JAR file system should put the MANIFEST.MF at the start
JDK-7143743: (zipfs) Potential memory leak with zip provider
JDK-8239556: (zipfs) remove ExistingChannelCloser facility in zipfs implementation
JDK-8241883: (zipfs) SeekableByteChannel:close followed by SeekableByteChannel:close will throw an NPE
JDK-8229888: (zipfs) Updating an existing zip file does not preserve original permissions
JDK-8246282: [REDO] JDK-8245121 (bf) XBuffer.put(Xbuffer src) can give unexpected result when storage overlaps
JDK-8241305: Add protocol specific factory creation methods to SocketChannel and ServerSocketChannel
JDK-8247880: bad HTML(href==...) in table
JDK-8247959: doclint errors in NIO code
JDK-8241786: Improve heuristic to determine default network interface on macOS
JDK-8208281: java/nio/channels/AsynchronousSocketChannel/Basic.java timed out
JDK-8236804: java/nio/channels/FileChannel/MapWithSecurityManager.java should be run in othervm mode
JDK-8246729: MappedByteBuffer.force() throws IndexOutOfBoundsException
JDK-8250770: Net.java translateToSocketException does not handle IOException
JDK-8245623: Remove unused code in sun/nio/fs after Solaris removal
JDK-8245619: Remove unused methods in UnixNativeDispatcher
JDK-8236246: SelectorProvider support for creating a DatagramChannel that is not interruptible
core-libs/java.nio.charsets:
JDK-8232161: Align some one-way conversion in MS950 charset with Windows
JDK-8235834: IBM-943 charset encoder needs updating
JDK-8241311: Move some charset mapping tests from closed to open
JDK-8242541: Small charset issues (ISO8859-16, x-eucJP-Open, x-IBM834 and x-IBM949C)
JDK-8239965: XMLEncoder/Test4625418.java fails due to "Error: Cp943 - can't read properly"
core-libs/java.rmi:
JDK-6415694: Clarification in Javadoc for java.rmi.AlreadyBoundException
JDK-8245068: Implement Deprecation of RMI Activation
JDK-8244917: JEP 385: Deprecate RMI Activation for Removal
JDK-8241073: Pre-generated Stubs for javax.management, Activation, Naming
JDK-8225319: Remove rmic from the set of supported tools
JDK-8242462: Residual Cleanup of rmic removal
JDK-8242382: test/jdk/TEST.groups cleanup of sun/tools/java
core-libs/java.text:
JDK-8235699: ArrayIndexOutOfBoundsException in CalendarBuilder.toString
JDK-8243664: JavaDoc of CompactNumberFormat points to wrong enum
JDK-8242337: javadoc typo in NumberFormat::setMinimumFractionDigits
JDK-8227313: Support monetary grouping separator in DecimalFormat/DecimalFormatSymbols
core-libs/java.time:
JDK-8243541: (tz) Upgrade time-zone data to tzdata2020a
JDK-8187987: Add a mechanism to configure custom variants in HijrahChronology
JDK-8244245: localizedBy() should override localized values with default values
JDK-8235238: Parsing a time string ignores any custom TimeZoneNameProvider
JDK-8240626: Some of the java.time.chrono.Eras return empty display name for some styles and locales
JDK-8246261: TCKLocalTime.java failed due to "AssertionError: expected [18:14:22] but found [18:14:23]"
JDK-8246662: Test java/time/test/java/time/format/TestUnicodeExtension.java failed on japanese locale.
JDK-8239837: Typo in source code of ZoneOffsetTransitionRule leaking to Javadocs
JDK-8239520: ValueRange.of(long, long, long) does not throw IAE on invalid inputs
JDK-8236903: ZoneRules#getOffset throws DateTimeException for rules with last rules
JDK-8239836: ZoneRules.of() doesn't check transitionList/standardOffsetTL arguments validity
core-libs/java.util:
JDK-8222241: Example in ServiceLoader API docs should have one provides directive
JDK-8236641: Improve Set.of(...).iterator() warmup characteristics
JDK-8249258: java/util/StringJoiner/StringJoinerTest.java failed due to OOM
JDK-8236850: Operations on constant List/Set.of(element) instances does not consistently constant fold
JDK-8196334: Optimize UUID#fromString
JDK-8238684: Override getOrDefault in immutable Map implementations
JDK-8244293: Remove outdated @apiNote in java.util.Objects
JDK-8246183: Scanner/ScanTest.java fails due to SIGSEGV in StubRoutines::jshort_disjoint_arraycopy
JDK-8230743: StringJoiner does not handle too large strings correctly
JDK-8246696: Test: java/util/StringJoiner/StringJoinerTest.java failing with OOM
JDK-8246697: Test: StringJoinerTest and related MergeTest failing with OOM
core-libs/java.util.jar:
JDK-8242842: Avoid reallocating name when checking for trailing slash in ZipFile.getEntryPos
JDK-8193066: Avoid use of capturing lambdas in JarFile
JDK-8234466: Class loading deadlock involving X509Factory#commitEvent()
JDK-8243254: Examine ZipFile slash optimization for non-ASCII compatible charsets
JDK-8239351: Give more meaningful InternalError messages in Deflater.c
JDK-8242596: Improve JarFile.getEntry performance for multi-release jar files
JDK-8242848: Improve performance of InflaterOutputStream.write()
JDK-8240235: jdk.test.lib.util.JarUtils updates jar files incorrectly
JDK-8243469: Lazily encode name in ZipFile.getEntryPos
JDK-8211974: move test/jdk/lib/testlibrary/java/util/jar/*.java to top-level library or a local library
JDK-8242959: Optimize ZipFile.getEntry by folding lookups for name and name+'/'
JDK-8237508: Simplify JarFile.isInitializing
JDK-8249097: test/lib/jdk/test/lib/util/JarBuilder.java has a bad copyright
JDK-8246129: ZIP entries created for DOS epoch include local timezone metadata
core-libs/java.util.logging:
JDK-8239013: java.util.logging.Logger catalog cache keeps strong references to ResourceBundles
JDK-8245867: Logger/bundleLeak/BundleTest.java fails due to "OutOfMemoryError: Java heap space"
core-libs/java.util.regex:
JDK-8214245: Case insensitive matching doesn't work correctly for some character classes
JDK-8216332: Grapheme regex does not work with emoji sequences
JDK-8237599: Greedy matching against supplementary chars fails to respect the region
JDK-8235930: java.util.regex.PrintPattern does not print a link to the next node
JDK-8246198: Minor typo injava/util/regex/Pattern.java
JDK-8241055: Regex Grapheme Matcher Performance Depends too much on Total Input Sequence Size
JDK-8235812: Unicode linebreak with quantifier does not match valid input
JDK-8236034: Use optimized Ques node for curly {0,1} quantifier
core-libs/java.util.stream:
JDK-8238919: (doc) Broken code snippet in the java.util.stream package documentation
JDK-8244624: Improve handling of JarFile META-INF resources
JDK-8242281: IntStream.html#reduce doc should not mention average
core-libs/java.util:collections:
JDK-8046362: IdentityHashMap.hash comments should be clarified
JDK-8242327: List spec should state that unmodifiable lists implement RandomAccess
JDK-8161558: ListIterator should not discard cause on exception
JDK-8243655: Map.replace javadoc code snippet typo
JDK-8245677: Optimize lookups in empty HashMaps
JDK-8176894: Provide specialized implementation for default methods putIfAbsent, computeIfAbsent, computeIfPresent, compute, merge in TreeMap
core-libs/java.util:i18n:
JDK-8234347: "Turkey" meta time zone does not generate composed localized names
JDK-8242283: Can't start JVM when java home path includes non-ASCII character
JDK-8174270: Consolidate ICU sources in one location
JDK-8245241: Incorrect locale provider preference is not logged
JDK-8246721: java/util/Locale/LocaleProvidersRun.java failed on Windows platforms.
JDK-8236548: Localized time zone name inconsistency between English and other locales
JDK-8244459: Optimize the hash map size in LocaleProviderAdapters
JDK-8244767: Potential non-terminated string in getEncodingInternal() on Windows
JDK-8244152: Remove unnecessary hash map resize in LocaleProviderAdapters
JDK-8238203: Return value of GetUserDefaultUILanguage() should be handled as LANGID
JDK-8239480: Support for CLDR version 37
JDK-8242010: Update IANA Language Subtag Registry to Version 2020-04-01
JDK-8243504: Update ICU4J to version 67.1
JDK-8241082: Upgrade IANA Language Subtag Registry data to 03-16-2020 version
core-libs/javax.lang.model:
JDK-8246368: Add override for return tag of Modifier::toString
JDK-8244673: Add periods to SourceVersion.isName javadoc
JDK-8235497: Add SourceVersion.RELEASE_15
JDK-8240130: Improve and update discussion of visitor evolution warnings
JDK-8227044: javax.lang.model for sealed classes
JDK-8239478: Make specification of SourceVersion.isName explicit for dotted names
JDK-8225495: Note whether returned annotations are declaration annotations or type annotations
JDK-8193553: Provide better guidance on using javax.lang.model visitors
JDK-8239092: Provide explicit specification for getKind methods of javax.lang.model
JDK-8246290: Refine specification of javax.lang.model.element.Modifier::toString
JDK-8245146: Update description of SourceVersion.RELEASE_15 with text blocks
core-libs/javax.naming:
JDK-8241130: com.sun.jndi.ldap.EventSupport.removeDeadNotifier: java.lang.NullPointerException
JDK-8237834: com/sun/jndi/ldap/LdapDnsProviderTest.java failing with LDAP response read timeout
JDK-8062947: Fix exception message to correctly represent LDAP connection failure
JDK-8223260: NamingManager should cache InitialContextFactory
JDK-7006496: Use modern Windows API to retrieve OS DNS servers
core-libs/javax.sql:
JDK-8235961: Default javax.sql.rowset.spi.SyncResolver impl returned by SyncProviderException throws unspecified NPE, UOE
core-libs/jdk.nashorn:
JDK-8247956: remove scripts under bin/nashorn and doc/nashorn/source
JDK-8241749: Remove the Nashorn JavaScript Engine
core-svc:
JDK-8238710: LingeredApp doesn't log stdout/stderr if exits with non-zero code
core-svc/debugger:
JDK-8244703: "platform encoding not initialized" exceptions with debugger, JNI
JDK-8239856: [ntintel] asserts about copying unaligned array element
JDK-8242241: add assert to ClassUnloadEventImpl::className
JDK-8247784: Bad link causes invalid documentation
JDK-8241530: com/sun/jdi tests fail due to network issues on OSX 10.15
JDK-8241080: Consolidate signature parsing code in serviceability tools
JDK-8236913: debug agent's jdwp command logging should include the command set name and command name
JDK-8196450: Deprecate JDWP/JDI canUnrestrictedlyRedefineClasses to match JVM TI capabilities
JDK-8240142: Fix copyright in ThreadGroupReferenceImpl.h
JDK-8240902: JDI shared memory connector can use already closed Handles
JDK-8241807: JDWP needs update for hidden classes
JDK-8234935: JdwpListenTest.java and JdwpAttachTest.java getting bind failures on Windows 2016 hosts
JDK-8247958: minor HTML errors in com.sun.jdi
JDK-8227269: Slow class loading when running with JDWP
JDK-8241958: Slow ClassLoaderReferenceImpl.findType
JDK-8241214: Test debugging of hidden classes using jdb
JDK-8243437: use reproducible random in :vmTestbase_nsk_jdi
JDK-8239055: Wrong implementation of VMState.hasListener
JDK-8241750: x86_32 build failure after JDK-8227269
core-svc/java.lang.instrument:
JDK-8234968: check calloc rv in libinstrument InvocationAdapter
JDK-8243012: Fix issues in j.l.i package info
JDK-8238602: remove obsolete functions from libinstrument/FileSystemSupport_md.c
core-svc/java.lang.management:
JDK-8248061: bad reference in @throws in HotSpotDiagnosticMXBean
JDK-8240957: Clarify BadAttributeValueExpException readObject method
JDK-8242430: Correct links in javadoc of OperatingSystemMXBean
JDK-8229829: java/lang/management/ThreadMXBean/Locks.java fails with java.lang.RuntimeException: Thread WaitingThread is at WAITING state but is expected to be in Thread.State = WAITING
JDK-8242480: Negative value may be returned by getFreeSwapSpaceSize() in the docker
JDK-8235681: Remove unnecessary workarounds in UnixOperatingSystem.c
JDK-8232622: Technical debt in BadAttributeValueExpException
JDK-8243436: use reproducible random in :vmTestbase_nsk_monitoring
core-svc/javax.management:
JDK-8242239: [Graal] javax/management/generified/GenericTest.java fails: FAILED: queryMBeans sets same
JDK-8234484: Add ability to configure third port for remote JMX
JDK-8247894: Invalid @see in java.management
JDK-8213222: remove RMIConnectorServer.CREDENTIAL_TYPES
core-svc/tools:
JDK-8240881: [BACKOUT] 8222489 jcmd VM.system_properties gives unusable paths on Windows
JDK-8196729: Add jstatd option to specify RMI connector port
JDK-8237354: Add option to jcmd to write a gzipped heap dump
JDK-8222489: jcmd VM.system_properties gives unusable paths on Windows
JDK-8236968: jmap -clstats fails to work after JDK-8232759
JDK-8237111: LingeredApp should be started with getTestJavaOpts
JDK-8232759: Remove GC.class_stats
JDK-8244973: serviceability/attach/RemovingUnixDomainSocketTest.java fails "stderr was not empty"
JDK-8235211: serviceability/attach/RemovingUnixDomainSocketTest.java fails with AttachNotSupportedException: Unable to open socket file
JDK-8242282: Test sun/tools/jps/TestJps.java fails after JDK-8237572
JDK-8236917: TestInstanceKlassSize.java fails with "The size computed by SA for java.lang.Object does not match"
JDK-8240711: TestJstatdPort.java failed due to "ExportException: Port already in use:"
deploy/packager:
JDK-8243648: Windows 32bit compile error src/jdk.incubator.jpackage/windows/native/libjpackage/VersionInfo.cpp
docs/guides:
JDK-8245656: Document jpackager options for user-defined jlink options
JDK-8245852: Document New System Properties to configure the TLS signature schemes
JDK-8245848: Document the certificate_authorities extension in JSSE Reference Guides
JDK-8242389: Enhance jpackage documentation of mac signing
JDK-8246035: java scripting guide's use nashorn scripts
JDK-8241328: Need to update security providers guide for SunJCE provider for new support
JDK-8242409: Update Kerberos GSS-API mechanism page to include the "canonicalize" setting
globalization/translation:
JDK-8238377: JDK 14 L10n resource file update - msg drop 20
JDK-8249086: JDK 15 L10n resource file update - msg drop 10
hotspot:
JDK-8244170: [aarch64] correct instruction typo for dcps1/2/3
JDK-8245986: AArch64: Provide information when hitting a HaltNode
JDK-8236856: AArch64: Spurious GCC warnings
JDK-8234599: PPC64: Add support on recent CPUs and Linux for JEP-352
hotspot/compiler:
JDK-8245714: "Bad graph detected in build_loop_late" when loads are pinned on loop limit check uncommon branch
JDK-8241232: -XX:+BootstrapJVMCI is not compatible with TieredStopAtLevel < CompLevel_full_optimization
JDK-8248822: 8 vm/classfmt/atr_ann/atr_rtm_annot007/atr_rtm_annot00709 tests fail w/ AOT
JDK-8247200: [aarch64] assert((unsigned)fpargs < 32)
JDK-8247350: [aarch64] assert(false) failed: wrong size of mach node
JDK-8246051: [aarch64] SIGBUS by unaligned Unsafe compare_and_swap
JDK-8240794: [BACKOUT] 8238384 CTW: C2 compilation fails with "assert(store != load->find_exact_control(load->in(0))) failed: dependence cycle found"
JDK-8240830: [BACKOUT] 8240195: some jaotc failures of fastdebug build with specific flags
JDK-8235673: [C1, C2] Split inlining control flags
JDK-8248597: [Graal] api/java_security/SignatureSpi/DelegationTests.html fails with Method "javasoft.sqe.tests.api.java.security.SignatureSpi.JCKSignatureSpi.clear" doesn't exist.
JDK-8241802: [Graal] compiler/loopopts/TestLogSum.java timed out
JDK-8191930: [Graal] emits unparseable XML into compile log
JDK-8247832: [Graal] Many Javafuzzer tests failures with Graal, due to unexpected results, after last update JDK-8243380
JDK-8248598: [Graal] Several testcases from applications/jcstress/acqrel.java fails with forbidden state
JDK-8227647: [Graal] Test8009761.java fails due to "RuntimeException: static java.lang.Object compiler.uncommontrap.Test8009761.m3(boolean,boolean) not compiled"
JDK-8230015: [instruction selector] generic vector operands support.
JDK-8193210: [JVMCI/Graal] add JFR compiler phase/inlining events
JDK-8247246: [JVMCI] `ResolvedJavaType.getDeclaredMethod()` can throw NoClassDefFoundError.
JDK-8241458: [JVMCI] add mark value to expose CodeOffsets::Frame_Complete
JDK-8240538: [JVMCI] add test for JVMCI ConstantPool class
JDK-8240831: [JVMCI] Export missing vmStructs entries used by JVMCI compilers
JDK-8240610: [JVMCI] Export VMVersion::_has_intel_jcc_erratum to JVMCI compiler
JDK-8238758: [JVMCI] fix JVMCI jtreg events tests to work with GraalVM
JDK-8238190: [JVMCI] Fix single implementor speculation for diamond shapes.
JDK-8247992: [JVMCI] HotSpotNmethod.executeVarargs can try execute a zombie nmethod
JDK-8236285: [JVMCI] improve TranslatedException traces
JDK-8242357: [JVMCI] Incorrect use of JVMCI_CHECK_ on return statement
JDK-8240976: [JVMCI] MethodProfileWidth flag is broken
JDK-8231756: [JVMCI] need support for deoptimizing virtual byte arrays encoding non-byte primitives
JDK-8230290: [JVMCI] Remove unused API entry points
JDK-8245047: [PPC64] C2: ReverseBytes + Load always match to unordered Load (acquire semantics missing)
JDK-8240795: [REDO] 8238384 CTW: C2 compilation fails with "assert(store != load->find_exact_control(load->in(0))) failed: dependence cycle found"
JDK-8240854: [REDO] some jaotc failures of fastdebug build with specific flags
JDK-8239456: [win][x86] vtable stub generation: assert failure (code size estimate)
JDK-8239931: [win][x86] vtable stub generation: assert failure (code size estimate) follow-up
JDK-8243620: a few compiler/jvmci tests can be run in driver mode
JDK-8241091: AArch64: "bad AD file" with VM option "-XX:-UsePopCountInstruction"
JDK-8241475: AArch64: Add missing support for PopCountVI node
JDK-8243597: AArch64: Add support for integer vector abs
JDK-8243240: AArch64: Add support for MulVB
JDK-8243155: AArch64: Add support for SqrtVF
JDK-8239549: AArch64: Backend support for MulAddVS2VI node
JDK-8242482: AArch64: Change parameter names of reduction operations to make code clear
JDK-8239914: AArch64: Combine add/sub with comparison against zero
JDK-8241911: AArch64: Fix a potential issue about register allocation effect rule in reduce_add2I
JDK-8241482: AArch64: Fix a potential issue after JDK-8239549
JDK-8242070: AArch64: Fix a typo introduced by JDK-8238690
JDK-8244164: AArch64: jaotc generates incorrect code for compressed OOPs with non-zero heap base
JDK-8233743: AArch64: Make r27 conditionally allocatable
JDK-8230591: AArch64: Missing intrinsics for Math.ceil, floor, rint
JDK-8240353: AArch64: missing support for -XX:+ExtendedDTraceProbes in C1
JDK-8243339: AArch64: Obsolete UseBarriersForVolatile option
JDK-8242449: AArch64: r27 can be allocated in CompressedOops mode
JDK-8241587: Aarch64: remove x86 specifics from os_linux.cpp/hpp/inline.hpp
JDK-8234228: AArch64: Some temp vars in string_compare intrinsics for processing the last 4 chars (LU/UL) are no use
JDK-8248845: AArch64: stack corruption after spilling vector register
JDK-8237524: AArch64: String.compareTo() may return incorrect result
JDK-8229351: AArch64: the const STUB_THRESHOLD in macroAssembler_aarch64.cpp needs to be tuned
JDK-8167065: Add intrinsic support for double precision shifting on x86_64
JDK-8237724: Add org.graalvm.compiler.asm.amd64 to the list of packages to be processed by the options annotation processor
JDK-8219607: Add support in Graal and AOT for hidden class
JDK-8243622: all actions in compiler/aot/fingerprint/SelfChangedCDS.java can be run in driver mode
JDK-8230402: Allocation of compile task fails with assert: "Leaking compilation tasks?"
JDK-8231118: ARM32: Math tests failures
JDK-8237086: assert(is_MachReturn()) running CTW with fix for JDK-8231291
JDK-8240905: assert(mem == (Node*)1 || mem == mem2) failed: multiple Memories being matched at once?
JDK-8247763: assert(outer->outcnt() == 2) failed: 'only phis' failure in LoopNode::verify_strip_mined()
JDK-8244186: assertion failure test/jdk/javax/net/ssl/DTLS/RespondToRetransmit.java
JDK-8242429: Better implementation for signed extract
JDK-8239878: Bug in PrintEliminateAllocations code causes TestClhsdbJstackLock.java to fail
JDK-8239083: C1 assert(known_holder == NULL || (known_holder->is_instance_klass() && (!known_holder->is_interface() || ((ciInstanceKlass*)known_holder)->has_nonstatic_concrete_methods())), "should be non-static concrete method");
JDK-8245051: c1 is broken if it is compiled by gcc without -fno-lifetime-dse
JDK-8236179: C1 register allocation failure with T_ADDRESS
JDK-8237950: C2 compilation fails with "Live Node limit exceeded limit" during ConvI2L::Ideal optimization
JDK-8250609: C2 crash in IfNode::fold_compares
JDK-8234605: C2 failed "assert(C->live_nodes() - live_at_begin <= 2 * _nodes_required) failed: Bad node estimate: actual = 208 >> request = 101"
JDK-8236721: C2 should better optimize not-equal integer comparisons
JDK-8239142: C2's UseUniqueSubclasses optimization is broken for array accesses
JDK-8241041: C2: "assert((Value(phase) == t) || (t != TypeInt::CC_GT && t != TypeInt::CC_EQ)) failed: missing Value() optimization" still happens after fix for 8239335
JDK-8238756: C2: assert(((n) == __null || !VerifyIterativeGVN || !((n)->is_dead()))) failed: can not use dead node
JDK-8239335: C2: assert((Value(phase) == t) || (t != TypeInt::CC_GT && t != TypeInt::CC_EQ)) failed: missing Value() optimization
JDK-8240335: C2: assert(found_sfpt) failed: no node in loop that's not input to safepoint
JDK-8238811: C2: assert(i >= req() || i == 0 || is_Region() || is_Phi()) with -XX:+VerifyGraphEdges
JDK-8242491: C2: assert(v2->bottom_type() == vt) failed: mismatch when creating MacroLogicV
JDK-8237859: C2: Crash when loads float above range check
JDK-8239009: C2: Don't use PSHUF to load scalars from memory on x86
JDK-8245158: C2: Enable SLP for some manually unrolled loops
JDK-8241436: C2: Factor out C2-specific code from MacroAssembler
JDK-8238690: C2: Handle vector shifts by constant and non-constant scalar uniformly
JDK-8231291: C2: loop opts before EA should maximally unroll loops
JDK-8235824: C2: Merge AD instructions for AddReductionV and MulReductionV nodes
JDK-8235825: C2: Merge AD instructions for Replicate nodes
JDK-8244504: C2: refactor counted loop code in preparation for long counted loop
JDK-8242492: C2: Remove Matcher::vector_shift_count_ideal_reg()
JDK-8238680: C2: Remove redundant AD instructions for Replicate nodes
JDK-8238683: C2: Remove Use24BitFP and Use24BitFPMode develop flags
JDK-8236181: C2: Remove useless step_over_gc_barrier() in int->bool conversion
JDK-8239069: C2: SIGSEGV in IdealGraphPrinter::walk_nodes due to C->root() being NULL
JDK-8239008: C2: Simplify Replicate support for sub-word types on x86
JDK-8242289: C2: Support platform-specific node cloning in Matcher
JDK-8238691: C2: turn subtype check into macro node
JDK-8236228: clean up BarrierSet headers in c1_LIRAssembler
JDK-8249019: clean up FileInstaller $test.src $cwd in vmTestbase_vm_compiler tests
JDK-8249018: clean up FileInstaller $test.src $cwd in vmTestbase_vm_mlvm tests
JDK-8238759: Clones should always keep the base pointer
JDK-8244660: Code cache sweeper heuristics is broken
JDK-8238356: CodeHeap::blob_count() overestimates the number of blobs
JDK-8248265: compiler/ciReplay tests fail with AOT compiled java.base
JDK-8243619: compiler/codecache/CheckSegmentedCodeCache.java test misses -version
JDK-8243932: compiler/codecache/cli/printcodecache/TestPrintCodeCacheOption.java test can use driver mode
JDK-8243617: compiler/onSpinWait/TestOnSpinWaitC1.java test uses wrong class
JDK-8243618: compiler/rtm/cli tests can be run w/o WhiteBox
JDK-8248410: Correct Fix for 8236647: java/lang/invoke/CallSiteTest.java failed with InvocationTargetException in Graal mode
JDK-8235385: Crash on aarch64 JDK due to long offset
JDK-8245512: CRC32 optimization using AVX512 instructions
JDK-8238366: CTW runner closes standard output on exit
JDK-8237949: CTW: C1 compilation fails with "too many stack slots used"
JDK-8238178: CTW: C1 compilation fails with assert(sux->loop_depth() != block->loop_depth() || sux->loop_index() == block->loop_index() || loop_through_xhandler) failed: Loop index has to be same
JDK-8237894: CTW: C1 compilation fails with assert(x->type()->tag() == f->type()->tag()) failed: should have same type
JDK-8238385: CTW: C2 (Shenandoah) compilation fails with "Range check dependent CastII node was not removed"
JDK-8244721: CTW: C2 (Shenandoah) compilation fails with "unexpected infinite loop graph shape"
JDK-8238153: CTW: C2 (Shenandoah) compilation fails with "Unknown node in get_load_addr: CreateEx"
JDK-8244719: CTW: C2 compilation fails with "assert(!VerifyHashTableKeys || _hash_lock == 0) failed: remove node from hash table before modifying it"
JDK-8238384: CTW: C2 compilation fails with "assert(store != load->find_exact_control(load->in(0))) failed: dependence cycle found"
JDK-8244724: CTW: C2 compilation fails with "Live Node limit exceeded limit"
JDK-8237951: CTW: C2 compilation fails with "malformed control flow"
JDK-8237945: CTW: C2 compilation fails with assert(just_allocated_object(alloc_ctl) == ptr) failed: most recent allo
JDK-8241365: Define Unique_Node_List::contains() to prevent usage by mistake
JDK-8240669: Devirtualize Relocation::type
JDK-7175279: Don't use x87 FPU on x86-64
JDK-8234160: Enable optimized mitigation for Intel jcc erratum in C2
JDK-8244278: Excessive code cache flushes and sweeps
JDK-8240248: Extend superword reduction optimizations for x86
JDK-8242895: failed: sanity at src/hotspot/share/opto/escape.cpp:2361
JDK-8242796: Fix client build failure
JDK-8241595: Fix missing debug_orig information in Ideal Graph Visualizer
JDK-8244086: Following 8241492, strip mined loop may run extra iterations
JDK-8244852: GraalVM native-image fails after JDK-8238048 change
JDK-8239001: Hotspot build broken on linux-sparc after 8238281
JDK-8244819: hsdis does not compile with binutils 2.34+
JDK-8240220: IdealLoopTree::dump_head predicate printing is broken
JDK-8237581: Improve allocation expansion
JDK-8246805: Incorrect copyright header in TestInvalidTieredStopAtLevel.java
JDK-8248570: Incorrect copyright header in TestUnsafeUnalignedSwap.java
JDK-8236647: java/lang/invoke/CallSiteTest.java failed with InvocationTargetException in Graal mode
JDK-8239852: java/util/concurrent tests fail with -XX:+VerifyGraphEdges: assert(!VerifyGraphEdges) failed: verification should have failed
JDK-8241074: JDK-8240363 broke the build on AArch64
JDK-8239477: jdk/jfr/jcmd/TestJcmdStartStopDefault.java fails -XX:+VerifyOops with "verify_oop: rsi: broken oop"
JDK-8239500: jittester shouldn't use non-deterministic System methods
JDK-8240576: JVM crashes after transformation in C2 IdealLoopTree::merge_many_backedges
JDK-8244407: JVM crashes after transformation in C2 IdealLoopTree::split_fall_in
JDK-8237045: JVM uses excessive memory with -XX:+EnableJVMCI -XX:JVMCICounterSize=2147483648
JDK-8249880: JVMCI calling register_nmethod without CodeCache lock
JDK-8245128: Kitchensink fails with: assert(destination == (address)-1 || destination == entry) failed: b) MT-unsafe modification of inline cache
JDK-8136414: Large performance penalty declaring a method strictfp on strict-only platforms
JDK-8240227: Loop predicates should be copied to unswitched loops
JDK-8241900: Loop unswitching may cause dependence on null check to be lost
JDK-8238681: Make -XX:UseSSE flag x86-specific
JDK-8168304: Make all of DependencyContext_test available in product mode
JDK-8238896: Massive x86_32 crashes after JDK-7175279 (Don't use x87 FPU on x86-64)
JDK-8240676: Meet not symmetric failure when running lucene on jdk8
JDK-8241556: Memory leak if -XX:CompileCommand is set
JDK-8246027: Minimal fastdebug build broken after JDK-8245801
JDK-8241438: Move IntelJccErratum mitigation code to platform-specific code
JDK-8245864: Obsolete BranchOnRegister
JDK-8246023: Obsolete LIRFillDelaySlot
JDK-8240528: OopMap cleanup
JDK-8242108: Performance regression after fix for JDK-8229496
JDK-8238765: PhaseCFG::schedule_pinned_nodes cannot handle precedence edges from unmatched CFG nodes correctly
JDK-8247502: PhaseStringOpts crashes while optimising effectively dead code
JDK-8151030: PPC64: AllocatePrefetchStyle=4 is out of range
JDK-8241874: PPC64: Improve performance of Long.reverseBytes() and Integer.reverseBytes() on Power9
JDK-8245505: Prelink j.l.ref.Reference when loading AOT library
JDK-8230552: Provide information when hitting a HaltNode for architectures other than x86
JDK-8240370: Provide Intel JCC Erratum opt-out
JDK-8239569: PublicMethodsTest.java failed due to NPE in java.base/java.nio.file.FileSystems.getFileSystem(FileSystems.java:230)
JDK-8240363: Refactor Compile::Output() to its own Phase
JDK-8238863: Refactor out static initialization from Dict constructors
JDK-8242090: Remove dead code from c1_LIR
JDK-8244658: Remove dead code in code cache sweeper
JDK-8022574: remove HaltNode code after uncommon trap calls
JDK-8244433: Remove saving of RSP in Assembler::pusha_uncached()
JDK-8235995: Remove src/jdk.internal.vm.compiler/.mx.graal directory
JDK-8203883: Remove State from InvocationCounters
JDK-8241122: Remove unimplemented InlineTree constructor definition from parse.hpp
JDK-8245957: Remove unused LIR_OpBranch::type after SPARC port removal
JDK-8241909: Remove useless code cache lookup in frame::patch_pc
JDK-8237800: rewrite vmTestbase/jit/escape/LockCoarsening from shell to java
JDK-8237798: rewrite vmTestbase/jit/tiered from shell to java
JDK-8237787: rewrite vmTestbase/vm/compiler/CodeCacheInfo* from shell to java
JDK-8239367: RunThese30M.java failed due to "assert(false) failed: graph should be schedulable"
JDK-8241997: Scalar replacement of cloned array is broken after JDK-8238759
JDK-8237007: Shenandoah: assert(_base == Tuple) failure during C2 compilation
JDK-8241675: Shenandoah: assert(n->outcnt() > 0) at shenandoahSupport.cpp:2858 with java/util/Collections/FindSubList.java
JDK-8240070: Shenandoah: remove obsolete ShenandoahCommonGCStateLoads
JDK-8241070: Shenandoah: remove unused local variables in C2 support
JDK-8236759: ShouldNotReachHere in PhaseIdealLoop::verify_strip_mined_scheduling
JDK-8229495: SIGILL in C2 generated OSR compilation
JDK-8237375: SimpleThresholdPolicy misses CounterDecay timestamp initialization
JDK-8244207: Simplify usage of Compile::print_method() when debugging with gdb and enable its use with rr
JDK-8240195: some jaotc failures of fastdebug build with specific flags
JDK-8245801: StressRecompilation triggers assert "redundunt OSR recompilation detected. memory leak in CodeCache!"
JDK-8241492: Strip mining not working for test/hotspot/jtreg/compiler/c2/Test6850611.java
JDK-8236709: struct SwitchRange in HS violates C++ One Definition Rule
JDK-8239072: subtype check macro node causes node budget to be exhausted
JDK-8238438: SuperWord::co_locate_pack picks memory state of first instead of last load
JDK-8241040: Support for AVX-512 Ternary Logic Instruction
JDK-8240693: Sweeper should not examine dying metadata in is_unloading() nmethod during static call stub cleaning
JDK-8246453: TestClone crashes with "all collected exceptions must come from the same place"
JDK-8246153: TestEliminateArrayCopy fails with -XX:+StressReflectiveCode
JDK-8235332: TestInstanceCloneAsLoadsStores.java fails with -XX:+StressGCM
JDK-8241986: The 'java' man page erroneously refers to XEND when it should refer XTEST
JDK-8243670: Unexpected test result caused by C2 MergeMemNode::Ideal
JDK-8242502: UnexpectedDeoptimizationTest.java failed "assert(phase->type(obj)->isa_oopptr()) failed: only for oop input"
JDK-8241234: Unify monitor enter/exit runtime entries.
JDK-8241231: Update Graal
JDK-8247798: Update man pages for inline flags
JDK-8249622: use 8249621 to ignore 8 jvmci tests
JDK-8240829: Use a fast O(1) algorithm for exact_log2
JDK-8240223: Use consistent predicate order in and with PhaseIdealLoop::find_predicate
JDK-8243428: use reproducible random in :vmTestbase_vm_compiler
JDK-8243427: use reproducible random in :vmTestbase_vm_mlvm
JDK-8242310: use reproducible random in hotspot compiler tests
JDK-8244182: Use root node as default for find_node when called from debugger
JDK-8243621: use SkippedException in compiler/jsr292/MHInlineTest.java test
JDK-8246381: VM crashes with "Current BasicObjectLock* below than low_mark"
JDK-8249000: vm.gc.X should take selected JIT into account
JDK-8237497: vmStructs_jvmci.cpp does not check that the correct field type is specified
JDK-8237953: vmTestbase/jit/tiered/Test.java failure after JDK-8237798
JDK-8238278: vmTestbase/vm/compiler/CodeCacheInfo/Test.java failure after JDK-8237787
JDK-8241319: WB_GetCodeBlob doesn't have ResourceMark
JDK-8241433: x86: Add VBMI CPU feature detection
JDK-8238696: x86: Enumerate all detected CPU features in VM_Version feature string
JDK-8241434: x86: Fix Assembler::emit_operand asserts for XMM registers
JDK-8241597: x86: Remove MMX support
JDK-8242073: x86_32 build failure after JDK-8241040
JDK-8238909: x86_32 fails gtest:power_of_2
JDK-8238723: yank_alloc_node must remove membar
JDK-8239110: Zero VM build fails after JDK-8203883
JDK-8240846: Zero VM is broken on x86 after JDK-8238681: UseSSE not defined
hotspot/gc:
JDK-8244384: @requires-related clean up in gc/metaspace/ tests
JDK-8246689: [aarch64] Enable independent compressed oops/class ptrs on Aarch64
JDK-8244813: [BACKOUT] 8244523: Shenandoah: Remove null-handling in LRB expansion
JDK-8240722: [BACKOUT] G1DirtyCardQueue destructor has useless flush
JDK-8244595: [REDO] 8244523: Shenandoah: Remove null-handling in LRB expansion
JDK-8245083: [REDO] Shenandoah: Remove null-handling in LRB expansion
JDK-8216557: Aarch64: Add support for Concurrent Class Unloading
JDK-8242029: AArch64: skip G1 array copy pre-barrier if marking not active
JDK-8244817: Add configuration logging similar to ZGCs to other GCs
JDK-8246405: Add GCLogPrecious functionality to log and report debug errors
JDK-8240590: Add MemRegion::destroy_array to complement introduced create_array
JDK-8241976: Add test for GCPhaseConcurrentLevel1 JFR event
JDK-8244815: Always log MMU information in G1
JDK-8245088: Always provide logs for G1 heap expansion calculations
JDK-8240246: Avoid cast_to_oop from char*
JDK-8228692: BitMap::reallocate might not clear some bits
JDK-8242448: Change HeapRegionManager::guarantee_contiguous_range to be assert_contiguous_range
JDK-8249037: clean up FileInstaller $test.src $cwd in vmTestbase_vm_g1classunloading tests
JDK-8249038: clean up FileInstaller $test.src $cwd in vmTestbase_vm_gc tests
JDK-8243325: Cleanup TaskQueueSuper<>::peek
JDK-8243326: Cleanup use of volatile in taskqueue code
JDK-8241160: Concurrent class unloading reports GCTraceTime events as JFR pause sub-phase events
JDK-8237261: Concurrent refinement activation threshold not updated for card counts
JDK-8231779: crash HeapWord*ParallelScavengeHeap::failed_mem_allocate
JDK-8247824: CTW: C2 (Shenandoah) compilation fails with SEGV in SBC2Support::pin_and_expand
JDK-8243628: Deprecate -XX:ForceNUMA option
JDK-8242901: Duplicate PSYoung/OldGen max size functions
JDK-8238272: Eliminate cast_from_oop to narrowOop*
JDK-8237143: Eliminate DirtyCardQ_cbl_mon
JDK-8246258: Enable hs_err heap printing earlier during initialization
JDK-8242370: Enable JFR TestGCPhaseConcurrent test for Shenandoah
JDK-8244752: Enable Linux support for multiple huge page sizes -XX:LargePageSizeInBytes
JDK-8241670: Enhance heap region size ergonomics to improve OOTB performance
JDK-8241666: Enhance log messages in ReferenceProcessor
JDK-8245718: Epsilon: improve configuration logging
JDK-8236226: fix merge error in src/hotspot/share/gc/z/zRootsIterator.cpp
JDK-8243961: ForceNUMA and only one available NUMA node fails assertion on Windows
JDK-8242459: ForceNUMA and only one available NUMA node hits a guarantee
JDK-8243146: Further cleanups after UseAdaptiveGCBoundary removal
JDK-8244684: G1 abuses StarTask to also include partial objarray scan tasks
JDK-8240668: G1 list of all PerRegionTable does not have to be a double linkedlist any more
JDK-8246274: G1 old gen allocation tracking is not in a separate class
JDK-8244714: G1 young gen sizer allows zero young gen with huge -XX:NewRatio
JDK-8233439: G1 zero_filled optimization when committing CardCountsTable does not work
JDK-8242078: G1: Improve concurrent refinement logging
JDK-8241920: G1: Lazily initialize OtherRegionsTable::_coarse_map
JDK-8242038: G1: Lazily initialize RSHashTables
JDK-8245086: G1: Rename measured pause time ratios
JDK-8239825: G1: Simplify threshold test for mutator refinement
JDK-8240133: G1DirtyCardQueue destructor has useless flush
JDK-8240591: G1HeapSizingPolicy attempts to compute expansion_amount even when at full capacity
JDK-8225216: gc/logging/TestMetaSpaceLog.java doesn't work for Shenandoah
JDK-8249681: gc/stress/TestJNIBlockFullGC/TestJNIBlockFullGC.java fails w/ UnsatisfiedLinkError
JDK-8240592: HeapRegionManager::rebuild_free_list logs 0s for the estimated free regions before
JDK-8240440: Implement get_safepoint_workers() for parallel GC
JDK-8240745: Implementation: JEP 377: ZGC: A Scalable Low-Latency Garbage Collector (Production)
JDK-8245478: Implementation: JEP 379: Shenandoah: A Low-Pause-Time Garbage Collector (Production)
JDK-8244307: Improve assertions against taskqueue underflow
JDK-8238979: Improve G1DirtyCardQueueSet handling of previously paused buffers
JDK-8238867: Improve G1DirtyCardQueueSet::Queue::pop
JDK-8241001: Improve logging in the ConcurrentGCBreakpoint mechanism
JDK-8237217: Incorrect G1StringDedupEntry type used in StringDedupTable destructor
JDK-8238705: jdk/jfr/event/gc/stacktrace/TestMetaspace* are unstable on arm64 with Xcomp
JDK-8241825: Make compressed oops and compressed class pointers independent (x86_64, PPC, S390)
JDK-8249787: Make TestGCLocker more resilient with concurrent GCs
JDK-8246272: Make use of GCLogPrecious for G1, Parallel and Serial
JDK-8246075: Missing logging in nmethod::oops_do_marking_epilogue() on early return path
JDK-8220503: Move definition of ShenandoahTerminatorTerminator::should_exit_termination() to .cpp file
JDK-8245724: Move g1 periodic gc logging to G1InitLogger
JDK-8238855: Move G1ConcurrentMark flag sanity checks to g1Arguments
JDK-8235996: Move obsolete flag G1RSetScanBlockSize in flags list
JDK-8139652: Mutator refinement processing should take the oldest dirty card buffer
JDK-8242216: ObjectSampler::weak_oops_do() should not trigger barrier
JDK-8228991: Obsolete -XX:UseAdaptiveGCBoundary
JDK-8235860: Obsolete the UseParallelOldGC option
JDK-8240589: OtherRegionsTable::_num_occupied not updated correctly
JDK-8209162: Page size selection does not always select optimal page size
JDK-8245022: ParallelGC abuses StarTask to also include partial objarray scan tasks
JDK-8246718: ParallelGC should not check for forward objects for copy task queue
JDK-8247201: Print potential pointer value of readable stack memory in hs_err file
JDK-8241153: Refactor HeapRegionManager::find_unavailable_from_idx to simplify expand_at
JDK-8246622: Remove CollectedHeap::print_gc_threads_on()
JDK-8241771: Remove dead code in SparsePRT
JDK-8237637: Remove dubious type conversions from oop
JDK-8231668: Remove ForceDynamicNumberOfGCThreads
JDK-8242597: Remove GenericTaskQueue<>::push_slow
JDK-8244416: Remove incorrect assert during inline cache cleaning
JDK-8238999: Remove MemRegion custom new/delete operator overloads
JDK-8245236: Remove MO_VOLATILE Access decorator
JDK-8237645: Remove OopsInGenClosure::par_do_barrier
JDK-8215297: Remove ParallelTaskTerminator
JDK-8232689: Remove ParCompactionManager::Action enum
JDK-8245723: Remove PrintCompressedOopsMode and change gc+heap+coops info log to debug level
JDK-8238854: Remove superfluous C heap allocation failure checks
JDK-8231670: Remove TaskExecutor abstraction used in preserved marks processing
JDK-8238229: Remove TRACESPINNING debug code
JDK-8238220: Rename OWSTTaskTerminator to TaskTerminator
JDK-8240239: Replace ConcurrentGCPhaseManager
JDK-8241141: Restructure humongous object allocation in G1
JDK-8246135: Save important GC log lines and print them when dumping hs_err files
JDK-8226797: serviceability/tmtools/jstat/GcCapacityTest.java fails with Exception: java.lang.RuntimeException: OGCMN > OGCMX (min generation capacity > max generation capacity)
JDK-8241765: Shenandoah: AARCH64 need to save/restore call clobbered registers before calling keepalive barrier
JDK-8242273: Shenandoah: accept either SATB or IU barriers, but not both
JDK-8237632: Shenandoah: accept NULL fwdptr to cooperate with JVMTI and JFR
JDK-8239904: Shenandoah: accumulated penalties should not be over 100% of capacity
JDK-8242041: Shenandoah: adaptive heuristics should account evac reserve in free target
JDK-8246612: Shenandoah: add timing tracking to ShenandoahStringDedupRoots
JDK-8241845: Shenandoah: align ShenandoahHeapRegions to cache lines
JDK-8245464: Shenandoah: allocate collection set bitmap at lower addresses
JDK-8243200: Shenandoah: Allow concurrent nmethod iteration
JDK-8242602: Shenandoah: allow earlier recycle of trashed regions during concurrent root processing
JDK-8245757: Shenandoah: AlwaysPreTouch should not disable heap resizing or uncommits
JDK-8237837: Shenandoah: assert(mem == __null) failed: only one safepoint
JDK-8238574: Shenandoah: Assertion failure due to missing null check
JDK-8241435: Shenandoah: avoid disabling pacing with "aggressive"
JDK-8243478: Shenandoah: avoid implicit worker_id = 0
JDK-8240917: Shenandoah: Avoid scanning thread code roots twice in all root scanner
JDK-8240872: Shenandoah: Avoid updating new regions from start of evacuation
JDK-8237874: Shenandoah: Backout JDK-8234399
JDK-8244739: Shenandoah: break superclass dependency on ShenandoahNormalMode
JDK-8244200: Shenandoah: build breakages after JDK-8241743
JDK-8237821: Shenandoah: build broken after JDK-8237637 (Remove dubious type conversions from oop)
JDK-8238851: Shenandoah: C1: Resolve into registers of correct type
JDK-8244663: Shenandoah: C2 assertion fails in Matcher::collect_null_checks
JDK-8244180: Shenandoah: carry Phase to ShWorkerTimingsTracker explicitly
JDK-8245880: Shenandoah: check class unloading flag early in concurrent code root scan
JDK-8248799: Shenandoah: Claim threads token in constructor of ShenandoahRootVerifier
JDK-8248725: Shenandoah: Claim verifier thread roots for parallel processing
JDK-8234399: Shenandoah: Cleanup native load barrier
JDK-8240948: Shenandoah: cleanup not-forwarded-objects paths after JDK-8240868
JDK-8245827: Shenandoah: Cleanup Shenandoah code root iterators and root scanner
JDK-8244243: Shenandoah: Cleanup Shenandoah phase timing tracking and JFR event supporting
JDK-8243578: Shenandoah: Cleanup ShenandoahStringDedup::parallel_oops_do()
JDK-8237570: Shenandoah: cleanup uses of allocation/free threshold in static heuristics
JDK-8242641: Shenandoah: clear live data and update TAMS optimistically
JDK-8242101: Shenandoah: coalesce and parallelise heap region walks during the pauses
JDK-8245812: Shenandoah: compute root phase parallelism
JDK-8239081: Shenandoah: Consolidate C1 LRB and native barriers
JDK-8247670: Shenandoah: deadlock during class unloading OOME
JDK-8243395: Shenandoah: demote guarantee in ShenandoahPhaseTimings::record_workers_end
JDK-8236681: Shenandoah: Disable concurrent class unloading flag if no class unloading for the GC cycle
JDK-8244821: Shenandoah: disarmed_value is initialized at wrong place
JDK-8241139: Shenandoah: distribute mark-compact work exactly to minimize fragmentation
JDK-8239868: Shenandoah: ditch C2 node limit adjustments
JDK-8240534: Shenandoah: ditch debug safepoint timeout adjustment
JDK-8244807: Shenandoah: ditch filter in ShenandoahUnload::unload
JDK-8241841: Shenandoah: ditch one of allocation type counters in ShenandoahHeapRegion
JDK-8243301: Shenandoah: ditch ShenandoahAllowMixedAllocs
JDK-8245754: Shenandoah: ditch ShenandoahAlwaysPreTouch
JDK-8243463: Shenandoah: ditch total_pause counters
JDK-8243465: Shenandoah: ditch unused pause_other, conc_other counters
JDK-8234974: Shenandoah: Do concurrent roots even when no evacuation is necessary
JDK-8241081: Shenandoah: Do not modify update-watermark concurrently
JDK-8241093: Shenandoah: editorial changes in flag descriptions
JDK-8241793: Shenandoah: Enable concurrent class unloading for aarch64
JDK-8242217: Shenandoah: Enable GC mode to be diagnostic/experimental and have a name
JDK-8241984: Shenandoah: enhance GCTimer and JFR support
JDK-8244420: Shenandoah: Ensure _disarmed_value offset < 128
JDK-8243238: Shenandoah: explicit GC request should wait for a complete GC cycle
JDK-8242107: Shenandoah: Fix aarch64 build after JDK-8242082
JDK-8249560: Shenandoah: Fix racy GC request handling
JDK-8244551: Shenandoah: Fix racy update of update_watermark
JDK-8236815: Shenandoah: Fix weak roots in final Traversal GC phase
JDK-8241700: Shenandoah: Fold ShenandoahKeepAliveBarrier flag into ShenandoahSATBBarrier
JDK-8241351: Shenandoah: fragmentation metrics overhaul
JDK-8246162: Shenandoah: full GC does not mark code roots when class unloading is off
JDK-8244730: Shenandoah: gc/shenandoah/options/TestHeuristicsUnlock.java should only verify the heuristics
JDK-8244953: Shenandoah: gc/shenandoah/TestStringInternCleanup fails with broken string table root
JDK-8244326: Shenandoah: global statistics should not accept bogus samples
JDK-8247560: Shenandoah: heap iteration holds root locks all the time
JDK-8237963: Shenandoah: Heap iteration should use concurrent version of string dedup roots
JDK-8235842: Shenandoah: Implement native LRB for narrow oop
JDK-8237223: Shenandoah: important flags should not be ergonomic for concurrent class unloading
JDK-8245720: Shenandoah: improve configuration logging
JDK-8241067: Shenandoah: improve ShenandoahNMethod::has_cset_oops arguments
JDK-8241068: Shenandoah: improve ShenandoahTraversalGC constructor arguments
JDK-8242212: Shenandoah: initialize ShenandoahHeuristics::_region_data eagerly
JDK-8242301: Shenandoah: Inline LRB runtime call
JDK-8241748: Shenandoah: inline MarkingContext TAMS methods
JDK-8242229: Shenandoah: inline ShenandoahHeapRegion liveness-related methods
JDK-8241842: Shenandoah: inline ShenandoahHeapRegion::region_number
JDK-8245823: Shenandoah: inline/optimize ShenandoahEvacOOMScope
JDK-8244510: Shenandoah: invert SHC2Support::is_in_cset condition
JDK-8245726: Shenandoah: lift/cleanup ShenandoahHeuristics names and properties
JDK-8246097: Shenandoah: limit parallelism in CLDG root handling
JDK-8250588: Shenandoah: LRB needs to save/restore fp registers for runtime call
JDK-8243487: Shenandoah: make _num_phases illegal phase type
JDK-8241668: Shenandoah: make ShenandoahHeapRegion not derive from ContiguousSpace
JDK-8242353: Shenandoah: micro-optimize region liveness handling
JDK-8239354: Shenandoah: minor enhancements to traversal GC
JDK-8245755: Shenandoah: missing logging for CWR Roots
JDK-8237543: Shenandoah: More asserts around code roots
JDK-8236851: Shenandoah: More details in Traversal GC event messages
JDK-8237780: Shenandoah: More reliable nmethod verification
JDK-8244732: Shenandoah: move heuristics code to gc/shenandoah/heuristics
JDK-8244737: Shenandoah: move mode code to gc/shenandoah/mode
JDK-8244328: Shenandoah: move ShenandoahThreadLocalData::_disarmed_value initialization
JDK-8245961: Shenandoah: move some root marking to concurrent phase
JDK-8236880: Shenandoah: Move string dedup cleanup into concurrent phase
JDK-8246591: Shenandoah: move string dedup roots scanning to concurrent phase
JDK-8245288: Shenandoah: move up ShenandoahEvacOOM scope for code root processing during concurrent class unloading
JDK-8242054: Shenandoah: New incremental-update mode
JDK-8243291: Shenandoah: no need to retire TLABs at Init Update Refs
JDK-8241838: Shenandoah: no need to trash cset during final mark
JDK-8241926: Shenandoah: only print heap changes for operations that directly affect it
JDK-8245124: Shenandoah: optimize code root evacuation/update during concurrent class unloading
JDK-8240076: Shenandoah: pacer should cover reset and preclean phases
JDK-8247310: Shenandoah: pacer should not affect interrupt status
JDK-8240511: Shenandoah: parallel safepoint workers count should be ParallelGCThreads
JDK-8244226: Shenandoah: per-cycle statistics contain worker data from previous cycles
JDK-8242089: Shenandoah: per-worker stats should be summed up, not averaged
JDK-8242040: Shenandoah: print allocation failure type
JDK-8239786: Shenandoah: print per-cycle statistics
JDK-8243495: Shenandoah: print root statistics for concurrent weak/strong root phases
JDK-8243464: Shenandoah: print statistic counters in time order
JDK-8244759: Shenandoah: print verbose class unloading counters
JDK-8228818: Shenandoah: Processing weak roots in concurrent phase when possible
JDK-8237586: Shenandoah: provide option to disable periodic GC
JDK-8243460: Shenandoah: purge init_update_refs_prepare counter
JDK-8241545: Shenandoah: purge root work overwrites counters after JDK-8228818
JDK-8242082: Shenandoah: Purge Traversal mode
JDK-8245814: Shenandoah: reconsider format specifiers for stats
JDK-8247358: Shenandoah: reconsider free budget slice for marking
JDK-8243323: Shenandoah: Recycle immediate garbage before concurrent class unloading
JDK-8241743: Shenandoah: refactor and inline ShenandoahHeap::heap()
JDK-8241673: Shenandoah: refactor anti-false-sharing padding
JDK-8244509: Shenandoah: refactor ShenandoahBarrierC2Support::test_* methods
JDK-8240671: Shenandoah: refactor ShenandoahPhaseTimings
JDK-8240749: Shenandoah: refactor ShenandoahUtils
JDK-8245461: Shenandoah: refine mode name()-s
JDK-8245463: Shenandoah: refine ShenandoahPhaseTimings constructor arguments
JDK-8241534: Shenandoah: region status should include update watermark
JDK-8242267: Shenandoah: regions space needs to be aligned by os::vm_allocation_granularity()
JDK-8240868: Shenandoah: remove CM-with-UR piggybacking cycles
JDK-8245825: Shenandoah: Remove diagnostic flag ShenandoahConcurrentScanCodeRoots
JDK-8240750: Shenandoah: remove leftover files and mentions of ShenandoahAllocTracker
JDK-8245955: Shenandoah: Remove LRB/is_redundant optimization
JDK-8244523: Shenandoah: Remove null-handling in LRB expansion
JDK-8237017: Shenandoah: Remove racy assertion
JDK-8244729: Shenandoah: remove resolve paths from SBSA::generate_shenandoah_lrb
JDK-8243307: Shenandoah: remove ShCollectionSet::live_data
JDK-8240215: Shenandoah: remove ShenandoahAllocationTrace
JDK-8240217: Shenandoah: remove ShenandoahEvacAssist
JDK-8241740: Shenandoah: remove ShenandoahHeapRegion::_heap
JDK-8241692: Shenandoah: remove ShenandoahHeapRegion::_reserved
JDK-8242114: Shenandoah: remove ShenandoahHeapRegion::reset_alloc_metadata_to_shared
JDK-8242375: Shenandoah: Remove ShenandoahHeuristic::record_gc_start/end methods
JDK-8242213: Shenandoah: remove ShenandoahHeuristics::_bytes_in_cset
JDK-8242211: Shenandoah: remove ShenandoahHeuristics::RegionData::_seqnum_last_alloc
JDK-8238162: Shenandoah: Remove ShenandoahTaskTerminator wrapper
JDK-8240216: Shenandoah: remove ShenandoahTerminationTrace
JDK-8236981: Shenandoah: Remove ShenandoahTraversalUpdateRefsClosure
JDK-8240915: Shenandoah: Remove unused fields in init mark tasks
JDK-8242228: Shenandoah: remove unused ShenandoahCollectionSet methods
JDK-8246342: Shenandoah: remove unused ShenandoahIsMarkedNextClosure
JDK-8243573: Shenandoah: rename GCParPhases and related code
JDK-8241844: Shenandoah: rename ShenandoahHeapRegion::region_number
JDK-8242075: Shenandoah: rename ShenandoahHeapRegionSize flag
JDK-8244740: Shenandoah: rename ShenandoahNormalMode to ShenandoahSATBMode
JDK-8240315: Shenandoah: Rename ShLBN::get_barrier_strength()
JDK-8230853: Shenandoah: replace leftover assert(is_in(...)) with rich asserts
JDK-8242625: Shenandoah: restore heap logging for Degenerated/Full cycles
JDK-8242638: Shenandoah: restore heap logging for uncommit
JDK-8242400: Shenandoah: Restore logging to pre-jdk8241984 format
JDK-8241062: Shenandoah: rich asserts trigger "empty statement" inspection
JDK-8244667: Shenandoah: SBC2Support::test_gc_state takes loop for wrong control
JDK-8243494: Shenandoah: set counters once per cycle
JDK-8239926: Shenandoah: Shenandoah needs to mark nmethod's metadata
JDK-8240873: Shenandoah: Short-cut arraycopy barriers
JDK-8241142: Shenandoah: should not use parallel reference processing with single GC thread
JDK-8242130: Shenandoah: Simplify arraycopy-barrier dispatching
JDK-8241985: Shenandoah: simplify collectable garbage logging
JDK-8241983: Shenandoah: simplify FreeSet logging
JDK-8241520: Shenandoah: simplify region sequence numbers handling
JDK-8242083: Shenandoah: split "Prepare Evacuation" tracking into cset/freeset counters
JDK-8242643: Shenandoah: split concurrent weak and strong root processing
JDK-8236732: Shenandoah: Stricter placement for oom-evac scopes
JDK-8246593: Shenandoah: string dedup roots should be processed during concurrent weak roots phase
JDK-8245240: Shenandoah: support nesting evacuation OOM scope
JDK-8245465: Shenandoah: test_in_cset can use more efficient encoding
JDK-8246458: Shenandoah: TestAllocObjects.java test fail with -XX:+ShenandoahVerify
JDK-8243008: Shenandoah: TestVolatilesShenandoah test failed on aarch64
JDK-8242227: Shenandoah: transit regions to cset state when adding to collection set
JDK-8242042: Shenandoah: tune down ShenandoahGarbageThreshold
JDK-8241583: Shenandoah: turn heap lock asserts into macros
JDK-8240069: Shenandoah: turn more flags diagnostic
JDK-8242316: Shenandoah: Turn NULL-check into assert in SATB slow-path entry
JDK-8242365: Shenandoah: use uint16_t instead of jushort for liveness cache
JDK-8246100: Shenandoah: walk roots in more efficient order
JDK-8246433: Shenandoah: walk roots in more efficient order in ShenandoahRootUpdater
JDK-8245773: Shenandoah: Windows assertion failure after JDK-8245464
JDK-8243848: Shenandoah: Windows build fails after JDK-8239786
JDK-8247474: Shenandoah: Windows build warning after JDK-8247310
JDK-8245942: Shenandoah: x86_32 builds fail after JDK-8245594
JDK-8241830: Simplify commit error messages in G1PageBasedVirtualSpace
JDK-8244010: Simplify usages of ProcessTools.createJavaProcessBuilder in our tests
JDK-8243565: some gc tests use 'test.java.opts' and not 'test.vm.opts'
JDK-8233220: Space::_par_seq_tasks is unused after CMS removal
JDK-8230349: Test jdk/jfr/event/gc/detailed/TestStressAllocationGCEventsWithParallel.java fails with GC overhead limit exceeded on several MacOS servers
JDK-8244291: Test: gc/z/TestGarbageCollectorMXBean.java failed: "unexpected cycles"
JDK-8246557: test_os_linux.cpp uses NULL instead of MAP_FAILED to check for failed mmap call
JDK-8242031: TestLookForUntestedEvents.java fails because newly added test tests experimental events
JDK-8246434: Threads::print_on_error assumes that the heap has been set up
JDK-8232686: Turn parallel gc develop tracing flags into unified logging
JDK-8238160: Uniformize Parallel GC task queue variable names
JDK-8183574: Unify the is_power_of_2 functions
JDK-8237182: Update copyright header for shenandoah and epsilon files
JDK-8236878: Use atomic instruction to update StringDedupTable's entries and entries_removed counters
JDK-8243933: Use driver mode in gc tests
JDK-8214277: Use merged G1ArchiveRegionMap for open and closed archive heap regions
JDK-8245087: Use ratios instead of percentages in G1HeapSizingPolicy::expansion_amount
JDK-8243434: use reproducible random in :vmTestbase_vm_g1classunloading
JDK-8243430: use reproducible random in :vmTestbase_vm_gc
JDK-8242312: use reproducible random in hotspot gc tests
JDK-8243942: Use SkippedException in gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java test
JDK-8216975: Using ForceNUMA does not disable adaptive sizing with parallel gc
JDK-8233822: VM_G1CollectForAllocation should always check for upgrade to full
JDK-8245000: Windows GDI functions don't support large pages
JDK-8245002: Windows GDI functions don't support NUMA interleaving
JDK-8240679: ZGC GarbageCollectorMXBean reports inaccurate post GC heap size for ZHeap pool
JDK-8248048: ZGC: AArch64: SIGILL in load barrier register spilling
JDK-8241881: ZGC: Add tests for JFR events
JDK-8243486: ZGC: Adjust "Allocated" statistics to take undone page allocations into account
JDK-8239129: ZGC: Allow -XX:AllocateHeapAt to use any filesystem
JDK-8245208: ZGC: Don't hold the ZPageAllocator lock while committing/uncommitting memory
JDK-8245203: ZGC: Don't track size in ZPhysicalMemoryBacking
JDK-8245106: ZGC: Fix incorrect setup when using -XX:+UseTransparentHugePages
JDK-8246045: ZGC: Fix ZDirector::rule_high_usage() calculation
JDK-8236153: ZGC: gc/z/TestUncommit.java fails with java.lang.Exception: Uncommitted too fast
JDK-8246406: ZGC: Generate crash reports in debug builds for a few important errors paths
JDK-8241361: ZGC: Implement memory related JFR events
JDK-8237649: ZGC: Improved NUMA support when using small pages
JDK-8246265: ZGC: Introduce ZConditionLock
JDK-8245204: ZGC: Introduce ZListRemoveIterator
JDK-8246220: ZGC: Introduce ZUnmapper to asynchronous unmap pages
JDK-8241603: ZGC: java/lang/management/MemoryMXBean/MemoryTestZGC.sh crashes on macOS
JDK-8248388: ZGC: Load barrier incorrectly elided in jdk/java/text/Format/DateFormat/SDFTCKZoneNamesTest.java
JDK-8245233: ZGC: Load volatile oops using Atomic::load()
JDK-8239533: ZGC: Make the ZProactive flag non-diagnostic
JDK-8237758: ZGC: Move get_mempolicy() syscall wrapper to ZSyscall
JDK-8245196: ZGC: No need to disable UseBiasedLocking by default
JDK-8234440: ZGC: Print relocation information on info level
JDK-8245450: ZGC: Remove unused ZArguments::initialize_platform()
JDK-8237201: ZGC: Remove unused ZRelocationSetSelector::fragmentation()
JDK-8237882: ZGC: Remove ZUtils::round_{up,down}_power_of_2() declarations
JDK-8237199: ZGC: Rename ZBackingFile to ZPhysicalMemoryBacking
JDK-8237200: ZGC: Rename ZBackingPath to ZMountPoint
JDK-8246044: ZGC: Rename ZDirector's max_capacity to soft_max_capacity
JDK-8237825: ZGC: Replace -XX:ZPath with -XX:AllocateHeapAt
JDK-8246134: ZGC: Restructure hs_err sections
JDK-8235905: ZGC: Rework how ZRootsIterator visits threads
JDK-8237198: ZGC: Share multi-mapping code in ZBackingFile
JDK-8240714: ZGC: TestSmallHeap.java failed due to OutOfMemoryError
JDK-8242527: ZGC: TestUncommit.java fails due to "Exception: Uncommitted too fast"
JDK-8237884: ZGC: Use clamp() instead of MIN2(MAX2())
JDK-8246404: ZGC: Use GCLogPrecious for important logging lines
JDK-8247214: ZGC: ZUncommit initialization should use precious logging
hotspot/jfr:
JDK-8223066: "jfr metadata" output the @Name annotation twice
JDK-8239793: 'jfr' tool should hide hidden frames
JDK-8244920: Access violation in frames::interpreter_frame_method
JDK-8237364: Add early validation to the jdk.jfr.Recording constructor
JDK-8238236: Add JFR class redefinition events
JDK-8238665: Add JFR event for direct memory statistics
JDK-8238959: Add missing classpath exception to FileAcess and ConstantLookup
JDK-8239350: Add tests for JFR class redefinition events
JDK-8241718: assert ((klass)->trace_id()) & ((JfrTraceIdEpoch::method_and_class_in_use_this_epoch_bits()))) != 0 in ObjectSampleCheckpoint::add_to_leakp_set
JDK-8240819: Assign a name to the JfrThreadSampler thread
JDK-8246770: Atomic::add() with 64 bit value fails to link on 32-bit platforms
JDK-8237887: CDSandJFR: assert(instance_klass->is_initialized())
JDK-8219904: ClassCastException when calling FlightRecorderMXBean#getRecordings()
JDK-8244777: ClassLoaderStats VM Op uses constant hash value
JDK-8238083: Crash: assert(is_object_aligned(v)) failed: address not aligned: 0xfffffffffffffff1
JDK-8243563: Doc comments cleanup
JDK-8242188: error in jtreg test jdk/jfr/api/consumer/TestRecordedFrame.java on linux-aarch64
JDK-8240634: event/runtime/TestMetaspaceAllocationFailure.java times out
JDK-8239584: EventStream::close should state that stream will be stopped
JDK-8239581: Improve javadoc example for @jdk.jfr.Category
JDK-8242792: interval < flushInterval is always false in jdk.jfr.internal.RequestEngine#setFlushInterval
JDK-8244149: jdk/jfr/api/consumer/recordingstream/TestOnEvent.java times out
JDK-8242933: jdk/jfr/api/consumer/TestHiddenMethod uses nashorn script engine
JDK-8237488: jdk/jfr/event/compiler/TestCompilerCompile.java failed due to "RuntimeException: No thread in event"
JDK-8235921: jdk/jfr/event/oldobject/TestLargeRootSet.java times out with debug bits
JDK-8210977: jdk/jfr/event/oldobject/TestThreadLocalLeak.java fails to find ThreadLocalObject
JDK-8219686: jdk/jfr/event/runtime/TestShutdownEvent.java recording file length is 0
JDK-8239423: jdk/jfr/jvm/TestJFRIntrinsic.java failed with -XX:-TieredCompilation
JDK-8233706: JFR emergency dump should be performed after error reporting
JDK-8222001: JFR event for heap dumps written
JDK-8245113: JFR Recorder Thread to run in thread state "_thread_in_native"
JDK-8241064: JFR related tests TestMetaspaceAllocationFailure.java and TestEventInstrumentation.java miss requires tag
JDK-8241695: JFR TestCrossProcessStreaming.java child process exited with SIGQUIT (131)
JDK-8232636: JFR TestDumpOnCrash.java crashed and failed to create emergency dump file
JDK-8247247: JFR tests fail due to JDK-8235521 missing doPrivileged block
JDK-8241803: JFR TestThreadStartEndEvents.java failed due to "RuntimeException: Wrong thread id"
JDK-8239376: JFR: assert(!cld->is_unsafe_anonymous()) failed: invariant
JDK-8241263: JFR: Bump native events limit
JDK-8245283: JFR: Can't handle constant dynamic used by Jacoco agent
JDK-8244463: JFR: Clean up jdk.jfr.internal.RepositoryChunk
JDK-8242844: JFR: Clean up typos and log format
JDK-8243452: JFR: Could not create chunk in repository with over 200 recordings
JDK-8238592: JFR: Crash when dumping paths to gc roots on deep heaps
JDK-8240778: JFR: Create timer task lazily
JDK-8246259: JFR: Fetch VM memory pools without using streams
JDK-8246128: JFR: Fix warnings
JDK-8244508: JFR: FlightRecorderOptions reset date format
JDK-8237499: JFR: Include stack trace in the ThreadStart event
JDK-8249713: JFR: java.base events have incomplete stacktraces
JDK-8239585: JFR: Native events should support empty payloads
JDK-8240773: JFR: Non-Java threads are not serialized
JDK-8245120: JFR: Parser unable to return typed version
JDK-8222000: JFR: Process start event
JDK-8247269: JFR: Reduce allocation when using AnnotationElement
JDK-8247320: JFR: Reduce logging overhead
JDK-8244661: JFR: Remove use of thread-locals for java.base events
JDK-8216303: JFR: Simplify generated files
JDK-8227559: JFR: Slow dump with path-to-gc-roots=true
JDK-8240783: JFR: TestClose could not finish chunk
JDK-8246130: JFR: TestInheritedAnnotations has incorrect validation
JDK-8246260: JFR: Write event size field without padding
JDK-8247530: JfrCheckpointManager failed "assert(!SafepointSynchronize::is_at_safepoint()) failed: invariant"
JDK-8242240: JfrStacktrace_lock rank not special enough
JDK-8239024: Kitchensink24HStress.java failed due to timeout
JDK-8233705: Let artifact iteration running time be a function of incrementally tagged artifacts
JDK-8215452: Logged repo location is wrong when using delayed recording start
JDK-8237014: Missing javadoc for jdk.jfr.Recording(Map)
JDK-8240360: NativeLibraryEvent has wrong library name on Linux
JDK-8240738: nested comment in JVM.java and other minor formatting errors
JDK-8248485: Poor scalability in JfrCheckpointManager when using many threads after JDK-8242008
JDK-8238634: Reduce log verbosity of the JFR thread sampler
JDK-8227610: Remove allocation when getting EventHandler
JDK-8240818: Remove colon from "JFR: Shutdown Hook" thread name
JDK-8242034: Remove JRE_HOME references
JDK-8244775: Remove unnecessary dependency to jfrEvents.hpp
JDK-8242088: Replace mutually exclusive lists with concurrent alternatives
JDK-8238180: RunThese30M failed "assert(t->jfr_thread_local()->shelved_buffer() == __null) failed: invariant"
JDK-8239497: SEGV in EdgeUtils::field_name_symbol(Edge const&)
JDK-8247967: SparkExamples24H.java SIGSEGV in various places
JDK-8248475: Suppress unconditional warning "JFR will be disabled during CDS dumping"
JDK-8244676: test/jdk/jdk/jfr/startupargs/TestOptionsWithLocale.java fails
JDK-8242934: test/jdk/jdk/jfr/tool/TestPrintJSON.java uses nashorn script engine
JDK-8238224: test\jdk\jdk\jfr\event\io\EvilInstrument.java should be removed
JDK-8219999: TestJFREvents container test should not use jdk.CPUInformation event for container CPU values
JDK-8243489: Thread CPU Load event may contain wrong data for CPU time under certain conditions
JDK-8248794: Transition JFR Periodic Task Thread to "_thread_in_native" before invoking performance counters
hotspot/jvmti:
JDK-8230502: Add support in JVM TI, JDI, and Instrumentation for hidden classes
JDK-8243941: build issue introduced with the push of 8242237
JDK-8222005: ClassRedefinition crashes with: guarantee(false) failed: OLD and/or OBSOLETE method(s) found
JDK-8242237: Improve JVM TI HiddenClasses tests
JDK-8247248: JVM TI Monitor queries might create JNI locals in another thread when using handshakes.
JDK-8245854: JVM TI Specification for sealed classes
JDK-8242425: JVMTI monitor operations should use Thread-Local Handshakes
JDK-8221306: JVMTI spec for FramePop(), MethodExit(), and MethodEnter() could use some cleanup
JDK-8235912: JvmtiBreakpoint remove oops_do and metadata_do
JDK-8238585: JvmtiEventControllerPrivate::enter_interp_only_mode() should not make compiled methods on stack not_entrant
JDK-8245126: Kitchensink fails with: assert(!method->is_old()) failed: Should not be installing old methods
JDK-8246442: nmethod::can_convert_to_zombie() asserts when not called by the sweeper
JDK-8245321: refactor the redefine check that an attribute consisting of a list of classes has not changed
JDK-8245392: Remove duplication in class redefinition and retransformation specs
JDK-8242896: typo #ifdef INCLUDE_JVMTI in codeCache.cpp
JDK-8236190: Unproblem list vmTestbase/nsk/jvmti/scenarios/hotswap/HS102/hs102t002/TestDescription.java
JDK-8243435: use reproducible random in :vmTestbase_nsk_jvmti
hotspot/runtime:
JDK-8237777: "Dumping core ..." is shown despite claiming that "# No core dump will be written."
JDK-8239014: -XX:-UseEmptySlotsInSupers sometime fails to reproduce the layout of the old code
JDK-8231612: 100% cpu on arm32 in Service Thread
JDK-8245703: 32-bit build failures after JDK-8243392
JDK-8237753: 32-bit builds are broken after JDK-8230594
JDK-8241018: 32-bit integer log2 functions return the wrong value for negative arguments on 64-bit machines
JDK-8237479: 8230305 causes slowdebug build failure
JDK-8236901: 8232759 missed a test case
JDK-8237756: [BACKOUT]: JDK-8230594: Allow direct handshakes without VMThread intervention
JDK-8238284: [macos] Zero VM build fails due to an obvious typo
JDK-8246377: [PPC64] Further improvements for assembler stop function
JDK-8244949: [PPC64] Reengineer assembler stop function
JDK-8240918: [REDO] Allow direct handshakes without VMThread intervention
JDK-8241101: [s390] jtreg test failure after JDK-8238696: not conformant features string
JDK-8239492: [x86] Turn MacroAssembler::verify_oop into macro recording file and line
JDK-8240588: _threadObj cannot be used on an exiting JavaThread.
JDK-8241124: Aarch64 build broken by JDK-8239593
JDK-8245137: aarch64 ICache flush depends on enabling gnu extensions
JDK-8237512: AArch64: aarch64TestHook leaks a BufferBlob
JDK-8242905: AArch64: Client build failed
JDK-8248219: aarch64: missing memory barrier in fast_storefield and fast_accessfield
JDK-8236992: AArch64: redundant load_klass in itable stub
JDK-8234794: AArch64: runtime/memory/ReadFromNoaccessArea.java crashes
JDK-8239787: AArch64: String.indexOf may incorrectly handle empty strings.
JDK-8236778: Add Atomic::fetch_and_add
JDK-8241581: Add BitMap::count_one_bits variant for arbitrary lengths
JDK-8187305: Add logging for shared library loads/unloads
JDK-8235931: add OM_CACHE_LINE_SIZE and use smaller size on SPARCv9 and X64
JDK-8244733: Add ResourceHashtable::xxx_if_absent
JDK-8241660: Add virtualization information output to hs_err file on macOS
JDK-8244196: adjust output in os_linux
JDK-8230594: Allow direct handshakes without VMThread intervention
JDK-8243045: AOTCompiledMethod::print_on triggers assertion after JDK-8210012
JDK-8238643: ARM32 build fails after JDK-8230199
JDK-8236242: Arm32: build broken after 8234794
JDK-8229971: Arm32: implementation for Thread-local handshakes
JDK-8248112: array index out of bound in FileMapInfo::check_paths
JDK-8246382: assert in MetaspaceShared::map_archives
JDK-8239895: assert(_stack_base != 0LL) failed: Sanity check
JDK-8247522: assert(is_aligned(class_space_rs.base(), class_space_alignment)) failed: Sanity
JDK-8236177: assert(status == 0) failed: error ETIMEDOUT(60), cond_wait
JDK-8238961: Assertion failure in new field layout code when ContendedPaddingWidth == 0.
JDK-8240263: Assertion-only call in Method::link_method affecting product builds
JDK-8240245: Avoid calling is_shared_class_visible() in SystemDictionary::load_shared_class()
JDK-8240244: Avoid calling resolve_super_or_fail in SystemDictionary::load_shared_class
JDK-8240205: Avoid PackageEntry lookup when loading shared classes
JDK-8238198: Avoid using @ tags in TestOptionsWithRanges_generate.sh
JDK-8235714: BitMap::count_one_bits may count bits beyond unaligned end
JDK-8239593: Bogus warning "Re-registering of platform native method" for a JVMTI agent
JDK-8237747: Build broken on macOS by JDK-8235741 - wrong format specifier
JDK-8241723: Build error after 8241581
JDK-8240231: Build failure on illumos after 8238988
JDK-8239514: Build for arm-linux-gnueabihf fails with undefined reference 'read_polling_page'
JDK-8240695: Build is broken when cds is disabled after JDK-8232081
JDK-8240254: Build is broken when cds is disabled after JDK-8236604
JDK-8242913: Bump the SPECIAL_FLAG_VALIDATION_BUILD to 25
JDK-8178349: Cache builtin class loader constraints to avoid re-initializing itable/vtable for shared classes
JDK-8240197: Cannot start JVM when $JAVA_HOME includes CJK characters
JDK-8241244: CDS dynamic dump asserts in ArchivePtrBitmapCleaner::do_bit
JDK-8244536: cds/DeterministicDump.java failed: File content different
JDK-8239537: cgroup MetricsTester testMemorySubsystem fails sometimes when testing memory.kmem.tcp.usage_in_bytes
JDK-8230305: Cgroups v2: Container awareness
JDK-8239785: Cgroups: Incorrect detection logic on old systems in hotspot
JDK-8234628: Change BasicHashTables::new_entry() to use clamp()
JDK-8233826: Change CDS dumping tty->print_cr() to unified logging
JDK-8240530: CheckUnhandledOops breaks BacktraceBuilder::set_has_hidden_top_frame
JDK-8240529: CheckUnhandledOops breaks NULL check in Modules::define_module
JDK-8186780: clang fastdebug assertion failure in os_linux_x86:os::verify_stack_alignment()
JDK-8246359: clarify confusing comment in ObjectMonitor::EnterI()'s race with async deflation
JDK-8249032: clean up FileInstaller $test.src $cwd in vmTestbase_nsk_sysdict tests
JDK-8249029: clean up FileInstaller $test.src $cwd in vmTestbase_vm_defmeth tests
JDK-8249033: clean up FileInstaller $test.src $cwd in vmTestbase_vm_metaspace tests
JDK-8242898: Clean up InstanceKlass::_array_klasses
JDK-8242027: Clean up LinkResolver::check_klass_accessability
JDK-8242000: clean up list of environment variables printed in hs_err file
JDK-8246926: Clean up newlines and whitespaces in hs_err files
JDK-8245289: Clean up offset code in JavaClasses
JDK-8245035: Clean up os::split_reserved_memory()
JDK-8238782: Cleanup Deoptimization::deoptimize(): remove unused RegisterMap argument and don't update RegisterMap in callers if UseBiasedLocking is enabled
JDK-8241852: Cleanup error message generation in LinkResolver::resolve_field
JDK-8223699: cleanup perfMemory_aix.cpp O_NOFOLLOW coding on aix
JDK-8241837: Cleanup stringStream usage in ObjectSynchronizer
JDK-8241006: Cleanup TemplateInterpreter initialization
JDK-8237382: Cleanup the OPT_SPEED_SRC file list in JvmFeatures.gmk
JDK-8238048: Close alignment gaps in InstanceKlass
JDK-8241427: Coarsen locking in Modules::add_module_exports
JDK-8241009: CommandLineFlagComboNegative.java fails after JDK-8240563
JDK-8241586: compiler/cpuflags/TestAESIntrinsicsOnUnsupportedConfig.java fails on aarch64
JDK-8241665: Configuring --with-jvm-features=-compiler2 fails to build on AArch64
JDK-8230199: consolidate signature parsing code in HotSpot sources
JDK-8242134: Consolidate the get_package_entry() in SystemDictionaryShared and ClassLoader
JDK-8245509: Crash handler itself crashes when reporting Unsafe.putInt(0) crash
JDK-8238000: Crash in ClassLoader::record_result while dynamic dumping netty
JDK-8245833: crash_with_sigfpe uses pthread_kill(SIGFPE) on macOS
JDK-8238175: CTW: Class.getDeclaredMethods fails with assert(k->is_subclass_of(SystemDictionary::Throwable_klass())) failed: invalid exception class
JDK-8242424: Deprecate InitialBootClassLoaderMetaspaceSize
JDK-8236844: Deprecate PrintVMQWaitTime to prepare for its removal
JDK-8243147: Deprecate UseLargePagesInMetaspace
JDK-8242452: During module definition, move conversion of packages from native to VM
JDK-8236236: Eliminate CDS md region and consolidate c++ vtable patching code
JDK-8232069: Enable CDS even when UseCompressedClassPointers and/or UseCompressedOops are false
JDK-8233014: Enable ShowCodeDetailsInExceptionMessages by default
JDK-8241948: enhance list of environment variables printed in hs_err file
JDK-8243389: enhance os::pd_print_cpu_info on linux
JDK-8242626: enhance posix print_rlimit_info
JDK-8240824: enhance print_full_memory_info on Linux by THP related information
JDK-8235671: enhance print_rlimit_info in os_posix
JDK-8237766: Enhance signature API to include ResolvingSignatureStream
JDK-8242504: Enhance the system clock to nanosecond precision
JDK-8239235: Examine SignatureStream performance after consolidation
JDK-8241043: Expand assertions to identify thread with errant _stack_base
JDK-8241395: Factor out platform independent code for os::xxx_memory_special()
JDK-8244946: fatal error: memory leak: allocating without ResourceMark with -XX:+Verbose -Xlog:methodhandles
JDK-8237080: fatal error: VM thread could block on lock that may be held by a JavaThread during safepoint: SharedDecoder_lock
JDK-8237767: Field layout computation overhaul
JDK-8247236: fieldDescriptor::print_on_for prints extra newline after NULL
JDK-8241071: Generation of classes.jsa with -Xshare:dump is not deterministic
JDK-8239000: handle ContendedPaddingWidth in vm_version_ppc
JDK-8244340: Handshake processing thread lacks yielding
JDK-8240532: heap inspection prints trailing @ after name of module without version
JDK-8240295: hs_err elapsed time in seconds is not accurate enough
JDK-8210012: Implement Unified Logging Option for -XX:+TraceMethodHandles and -XX:+TraceInvokeDynamic
JDK-8231264: Implementation of JEP 374: Disable biased-locking and deprecate all flags related to biased-locking
JDK-8240324: Improve is_boot_class_loader_data() by adding simple check
JDK-8243393: Improve ReservedSpace constructor resolution
JDK-8245042: Improve scalability of reading Windows Performance counters via PDH when using the Process object
JDK-8235741: Inappropriate uses of os::javaTimeMillis()
JDK-8240982: Incorrect copyright header in BCEL 6.4.1 sources
JDK-8240141: Incorrect copyright header in src/hotspot/os_cpu/linux_sparc/os_linux_sparc.cpp
JDK-8244107: Incorrect parameters in ReservedSpace constructor change
JDK-8245707: Increase Metaspace reserve alignment
JDK-8243503: InstanceKlass::_array_name is not needed and leaks
JDK-8240613: InstanceKlass::set_init_state failed with "assert(good_state || state == allocated): illegal state transition"
JDK-8234372: Investigate use of Thread::stack_base() and queries for "in stack"
JDK-8240615: is_power_of_2() has Undefined Behaviour and is inconsistent
JDK-8246648: issue with OperatingSystemImpl getFreeSwapSpaceSize in docker after 8242480
JDK-8236489: Java heap file on daxfs should be more secure
JDK-8241439: jdk.NativeLibraryEvent hooks all opened regular files
JDK-8235256: JEP 374: Disable and Deprecate Biased Locking
JDK-8238676: jni crashes on accessing it from process exit hook
JDK-8243997: Linux build failed after JDK-8242244
JDK-8237750: Load libzip.so only if necessary
JDK-8237857: LogDecorations::uptimenanos is implemented incorrectly
JDK-8239066: make LinkedList more generic
JDK-8247220: Make OopHandle constructor explicit
JDK-8244491: make runtime/cds/appcds/TestZGCWithCDS.java test more robust
JDK-8245098: Make SafeFetch32/N available earlier
JDK-8239070: Memory leak when unsuccessfully mapping in archive regions
JDK-8247388: Minimal build broken after JDK-8240245 (undefined reference to `MetaspaceShared::_use_optimized_module_handling')
JDK-8237752: Minimal VM build fails after JDK-8236236
JDK-8239886: Minimal VM build fails after JDK-8237499
JDK-8242631: Missing but used special functions for some classes
JDK-8245260: Missing file header for test/hotspot/jtreg/containers/docker/TEST.properties
JDK-8153224: Monitor deflation prolong safepoints
JDK-8246676: monitor list lock operations need more fencing
JDK-8247280: more fencing needed in async deflation for non-TSO machines
JDK-8233093: Move CDS heap oopmaps into new MetaspaceShared::bm region
JDK-8246340: Move SystemDictionary GC roots into OopStorage
JDK-8243572: Multiple tests fail with assert(cld->klasses() != 0LL) failed: unexpected NULL for cld->klasses()
JDK-8243535: NMT may show wrong numbers for CDS and CCS
JDK-8241004: NMT tests fail on unaligned thread size with debug build
JDK-8248476: No helpful NullPointerException message after calling fillInStackTrace.
JDK-8244606: Non-PCH build is broken after JDK-8244550
JDK-8239854: Non-PCH gtest build fails after JDK-8239235 due to a missing include
JDK-8243936: NonWriteable system properties are actually writeable
JDK-8242485: Null _file checking in fileStream::flush()
JDK-8230940: Obsolete MonitorBound
JDK-8236224: Obsolete the FieldsAllocationStyle and CompactFields options
JDK-8245850: Obsolete UseLWPSynchronization
JDK-8235908: omit ThreadPriorityPolicy warning when value is set from image
JDK-8225760: oop::raw_set_obj isn't needed
JDK-8240204: Optimize package handling for archived classes
JDK-8236604: Optimize SystemDictionary::resolve_well_known_classes for CDS
JDK-8238762: Optimized build is broken
JDK-8235962: os::current_thread_id() is not signal safe on macOS
JDK-8242290: Pointless verification in get_package_entry_by_name
JDK-8234691: Potential double-free in ParallelSPCleanupTask constructor
JDK-8245487: Potential double-free of interfaces array
JDK-8239363: PPC64: Wrong code generation after JDK-8183574
JDK-8235966: Process obsolete flags less aggressively
JDK-8238460: Provide warnings about the use of JNI RegisterNatives to rebind native methods for boot/platform classes in other classloaders
JDK-8241726: Re-enable gtest for BitMap::count_one_bits()
JDK-8166358: Re-enable String verification in java_lang_String::create_from_str()
JDK-8241371: Refactor and consolidate package_from_name
JDK-8236035: refactor ObjectMonitor::set_owner() and _owner field setting
JDK-8239347: Refactor Symbol to make _length a standalone field again
JDK-8243392: Remodel CDS/Metaspace storage reservation
JDK-8242003: Remove CallInfo::_selected_klass
JDK-8240481: Remove CDS usage of InstanceKlass::is_in_error_state
JDK-8231559: Remove expired flags in JDK 15
JDK-8220051: Remove global safepoint code
JDK-8243996: Remove hardcoded field offsets from HotSpot
JDK-8235956: Remove javaClasses offset tests
JDK-8232733: Remove need to grab Threads_lock while processing handshakes
JDK-8242244: Remove redundant ELF machine definitions
JDK-8238600: Remove runtime/fieldType.hpp and fieldType.cpp
JDK-8245521: Remove STACK_BIAS
JDK-8236766: Remove un-used oops do and drain list in VM thread.
JDK-8235678: Remove unnecessary calls to Thread::current() in MutexLocker calls
JDK-8246109: Remove unneeded undef CS
JDK-8241585: Remove unused _recursion_counter facility from PerfTraceTime
JDK-8241584: Remove unused classLoader perf counters
JDK-8241419: Remove unused InterfaceSupport::_number_of_calls
JDK-8245428: Remove unused oopFactory functions
JDK-8245594: Remove volatile-qualified member functions and parameters from oop class
JDK-8236625: Remove writeable macro from JVM flags declaration
JDK-8238988: Rename thread "in stack" methods and add is_in_stack_range
JDK-8246837: Rename WeakHandle to better reflect its OopStorage association
JDK-8235225: Replace CHECK_0 with CHECK_NULL for non-integer returning methods
JDK-8235795: replace monitor list mux{Acquire,Release}(&gListLock) with spin locks
JDK-8239357: Revert gcc implementation of offset_of
JDK-8242484: Rework thread deletion during VM termination
JDK-8240840: Rollback whitebox.cpp in push 8240691
JDK-8244485: runtime/cds/appcds/TestZGCWithCDS.java fails after 8244385
JDK-8240546: runtime/cds/appcds/TestZGCWithCDS.java fails with Graal
JDK-8232213: runtime/MemberName/MemberNameLeak.java fails intermittently
JDK-8237819: s390x - remove unused pd_zero_to_words_large
JDK-8241158: SA TestHeapDumpForInvokeDynamic.java fails when CDS archive is relocated
JDK-8235766: SafepointSynchronize::_end_of_last_safepoint is unused
JDK-8241296: Segfault in JNIHandleBlock::oops_do()
JDK-8243568: serviceability/logging/TestLogRotation.java uses 'test.java.opts' and not 'test.vm.opts'
JDK-8243506: SharedBaseAddress is ignored by -Xshare:dump
JDK-8241934: Simplify parse_stream() and remove has_class_mirror_holder_cld()
JDK-8244142: some hotspot/runtime tests don't check exit code of forked JVM
JDK-8244495: Some jlink tests crash on Windows after JDK-8237750
JDK-8198698: Support Lambda proxy classes in dynamic CDS archive
JDK-8237830: support O_CLOEXEC in os::open on other OS than Linux
JDK-8240258: SystemDictionary::quick_resolve need guarded by INCLUDE_CDS
JDK-8245264: Test runtime/cds/appcds/SignedJar.java fails
JDK-8242921: test/hotspot/jtreg/runtime/CompactStrings/TestMethodNames.java uses nashorn script engine
JDK-8247252: TestCombinedCompressedFlags.java failed src/hotspot/share/services/virtualMemoryTracker.cpp:388 Error: ShouldNotReachHere()
JDK-8235965: Tests using ThreadLocalHandshakes need to stop using it as it no longer exists
JDK-8235913: ThreadStop should be a handshake
JDK-8232081: Try to link all classes during dynamic CDS dump
JDK-8241705: Tune PerfData collections
JDK-8244173: Uncomment subtest in runtime/InvocationTests/invocationC1Tests.java
JDK-8241010: Unnecessarily resolving some well-known classes
JDK-8241815: Unnecessary calls to SystemDictionaryShared::define_shared_package
JDK-8244550: Unsafe::allocateInstance does redundant transitions
JDK-8234206: Update the java command manpage in relation to biased-locking options
JDK-8244141: use @requires and SkippedException in some hotspot/runtime tests
JDK-8238289: Use _byteswap_ functions to implement Bytes::swap_uX on Windows
JDK-8242524: Use different default CDS archives depending on UseCompressOops
JDK-8243945: use driver mode in runtime tests
JDK-8239461: Use jcod rather than jar files in runtime tests
JDK-8243433: use reproducible random in :vmTestbase_nsk_sysdict
JDK-8243432: use reproducible random in :vmTestbase_vm_defmeth
JDK-8243431: use reproducible random in :vmTestbase_vm_metaspace
JDK-8242311: use reproducible random in hotspot runtime tests
JDK-8243944: use SkippedException and @requires in runtime/memory/ReadFromNoaccessArea.java test
JDK-8244385: various clean-ups in runtime tests
JDK-8240267: VM fails to start with CDS enabled but JVMTI disabled
JDK-8245717: VM option "-XX:EnableJVMCIProduct" could not be repetitively enabled
JDK-8225056: VM support for sealed classes
JDK-8240603: Windows 32bit compile error after 8238676
JDK-8240302: x64: Assembler::reachable redundantly call Relocation::type() more than once
JDK-8241095: x86: Improve prefix handling in Assembler
JDK-8241128: x86_32 build failure after JDK-8241042
JDK-8241042: x86_64: Improve Assembler generation
JDK-8241077: x86_64: Minor Assembler improvements
JDK-8240772: x86_64: Pre-generate Assembler::popa, pusha and vzeroupper
JDK-8244276: Zero and minimal VM build failure after JDK-8178349 (use of undeclared identifier 'SystemDictionaryShared')
JDK-8244489: Zero and minimal VM build failure after JDK-8241071 (MetaspaceShared::symbol_space_alloc is undefined)
JDK-8247377: Zero and Minimal VMs are broken after JDK-8198698 ('SystemDictionaryShared' has not been declared)
JDK-8237847: Zero builds fail after JDK-8237637 (Remove dubious type conversions from oop)
JDK-8239915: Zero VM crashes when handling dynamic constant
JDK-8244971: Zero VM is broken after JDK-8241825 (COMPRESSED_CLASS_POINTERS_DEPENDS_ON_COMPRESSED_OOPS not defined)
JDK-8244625: Zero VM is broken after JDK-8244550 (java_lang_Class::as_Klass(oopDesc*) undefined)
JDK-8247284: Zero VM is broken after JDK-8244920 ('class JavaFrameAnchor' has no member named 'set_last_Java_sp')
hotspot/svc:
JDK-8244571: assert(!_thread->is_pending_jni_exception_check()) failed: Pending JNI Exception Check during class loading
JDK-8242295: Change ThreadMBean in vmTestbase/nsk/monitoring to ThreadMXBean
JDK-8249039: clean up FileInstaller $test.src $cwd in vmTestbase_nsk_aod tests
JDK-8249040: clean up FileInstaller $test.src $cwd in vmTestbase_nsk_jdb tests
JDK-8249035: clean up FileInstaller $test.src $cwd in vmTestbase_nsk_jdwp tests
JDK-8249034: clean up FileInstaller $test.src $cwd in vmTestbase_nsk_jvmti tests
JDK-8249028: clean up FileInstaller $test.src $cwd in vmTestbase_nsk_monitoring tests
JDK-8240691: ClhsdbCDSJstackPrintAll incorrectly thinks CDS is in use
JDK-8243210: ClhsdbScanOops fails with NullPointerException in FileMapHeader.inCopiedVtableSpace
JDK-8236552: Description of jmxremote.ssl.config.file in ManagementAgent.start is incorrect
JDK-8242471: remove "temporarily" restrictions of nsk/jdi/Argument/value/value004
JDK-8234510: Remove file seeking requirement for writing a heap dump
JDK-8244993: Revert changes to OutputAnalyzer stderrShouldBeEmptyIgnoreVMWarnings() that allow version strings
JDK-8243954: serviceability/logging/TestQuotedLogOutputs.java fails after 8243928
JDK-8243989: test/hotspot/jtreg/serviceability/jvmti/CanGenerateAllClassHook/CanGenerateAllClassHook.java needs to use othervm
JDK-8242313: use reproducible random in hotspot svc tests
hotspot/svc-agent:
JDK-8196751: Add jhsdb option to specify debug server RMI connector port
JDK-8243206: Cleanup error checking and handling in serviceability/sa/JhsdbThreadInfoTest.java
JDK-8242168: ClhsdbFindPC.java failed due to "RuntimeException: 'In code in NMethod for LingeredAppWithTrivialMain.main' missing from stdout/stderr"
JDK-8235220: ClhsdbScanOops.java fails with sun.jvm.hotspot.types.WrongTypeException
JDK-8242142: convert clhsdb "class" and "classes" commands from javascript to java
JDK-8240990: convert clhsdb "dumpclass" command from javascript to java
JDK-8240989: convert clhsdb "dumpheap" command from javascript to java
JDK-8242162: convert clhsdb "sysprops" command from javascript to java
JDK-8237008: Exclude serviceability/sa/TestInstanceKlassSizeForInterface.java on linuxppc64 and linuxppc64le
JDK-8217441: Failure of ::realloc() should be handled correctly in sawindbg.cpp
JDK-8242808: Fix all remaining deprecation warnings in jdk.hotspot.agent
JDK-8242943: Fix all remaining unchecked warnings in jdk.hotspot.agent
JDK-8242804: Fix trivial deprecation issues in jdk.hotspot.agent
JDK-8241618: Fix trivial unchecked warnings for jdk.hotspot.agent
JDK-8235846: Improve WindbgDebuggerLocal implementation
JDK-8239462: jdk.hotspot.agent misses some ReleaseStringUTFChars calls in case of early returns
JDK-8234624: jstack mixed mode should refer DWARF
JDK-8239224: libproc_impl.c previous_thr may be used uninitialized warning
JDK-8237250: pmap and pstack should do a better of making it clear that they are not supported on Mac OS X
JDK-8242629: Remove references to deprecated java.util.Observer and Observable
JDK-8244668: Remove SA's javascript support
JDK-8244622: Remove SA's memory/FreeChunk.java. It's no longer used.
JDK-8243450: Remove VMOps from jdk.hotspot.agent
JDK-8204994: SA might fail to attach to process with "Windbg Error: WaitForEvent failed"
JDK-8231634: SA stack walking fails with "illegal bci"
JDK-8242165: SA sysprops support fails to dump all system properties
JDK-8230731: SA tests fail with "Windbg Error: ReadVirtual failed"
JDK-8242384: sa/TestSysProps.java failed due to "RuntimeException: Could not find property in jinfo output: [0.058s][info][cds] Archive was created with UseCompressedOops"
JDK-8184249: SA: clhsdb 'intConstant' throws a NullPointerException when not attached to a VM
JDK-8193237: SA: ClhsdbLauncher should show the command being executed
JDK-8239916: SA: delete dead code in jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java
JDK-8243500: SA: Incorrect BCI and Line Number with jstack if the top frame is in the interpreter (BSD and Windows)
JDK-8194874: SA: Remove scripts with sa-jdi.jar dependencies.
JDK-8240956: SEGV in DwarfParser::process_dwarf after JDK-8234624
JDK-8243946: serviceability/sa and jvmti tests fail after JDK-8243928
JDK-8242265: serviceability/sa/ClhsdbScanOops.java fails due to bad @requires expression
JDK-7107012: sun.jvm.hostspot.code.CompressedReadStream readDouble() conversion to long mishandled
JDK-8242789: sun/tools/jhsdb/HeapDumpTestWithActiveProcess.java fails with 'JShellToolProvider' missing from stdout/stderr
JDK-8244203: sun/tools/jhsdb/HeapDumpTestWithActiveProcess.java fails with NullPointerException
JDK-8242787: sun/tools/jhsdb/HeapDumpTestWithActiveProcess.java fails with sun.jvm.hotspot.types.WrongTypeException
JDK-8237501: TestInstanceKlassSizeForInstance runs TestInstanceKlassSize instead
JDK-8214797: TestJmapCoreMetaspace.java timed out
JDK-8241320: The ClassLoaderData::_is_unsafe_anonymous field is unused in the SA
hotspot/test:
JDK-8236437: [BACKOUT] JDK-8236275 switch to jck14-b09
JDK-8249036: clean up FileInstaller $test.src $cwd in vmTestbase_nsk_stress tests
JDK-8244614: cleanup keywords used/available in hotspot testbase
JDK-8242931: Few more tests that use nashorn have been missed
JDK-8243154: Fix deprecation warnings in failure handler
JDK-8241707: introduce randomness k/w to hotspot test suite
JDK-8247716: JVM_RegisterWhiteBoxMethods checks wrong classloader
JDK-8240698: LingeredApp does not pass getTestJavaOpts() to the children process if vmArguments is already specified
JDK-8250688: missed open parenthesis for GTEST_FRAMEWORK_SRC var in Main.gmk
JDK-8247725: move two tests for whitebox from test/hotspot/jtreg/sanity to test/lib-test
JDK-8236111: narrow allowSmartActionArgs disabling
JDK-8244078: ProcessTools executeTestJvm and createJavaProcessBuilder have inconsistent handling of test.*.opts
JDK-8242463: ProcessTools.createNativeTestProcessBuilder() in testlib needs jdk/bin on PATH on Windows
JDK-8241123: Refactor vmTestbase stress framework to use j.u.c and make creation of threads more flexible
JDK-8243935: remove copying of s.h.WB$WhiteBoxPermission in hotspot tests
JDK-8245610: remove in-tree copy on gtest
JDK-8245874: requires.extraPropDefns.vmOpts doesn't need -Xbootclasspath/a:bootClasses
JDK-8240904: Screen flashes on test failures when running tests from make
JDK-8241456: ThreadRunner shouldn't use Wicket for threads starting synchronization
JDK-8243930: update copyright years
JDK-8243429: use reproducible random in :vmTestbase_nsk_stress
JDK-8241623: use reproducible random in hotspot tests
JDK-8242314: use reproducible random in vmTestbase shared code
infrastructure:
JDK-8238534: Deep sign macOS bundles before bundle archive is being created
JDK-8238943: switch to jtreg 5.0
JDK-8246387: switch to jtreg 5.1
JDK-8235960: Zero should not trigger the deprecation warning for ports
infrastructure/build:
JDK-8240228: "make hotspot-ide-project" on Windows creates a Visual Studio project with empty preprocessor defines
JDK-8245070: 32-bit builds are broken after JDK-8242524
JDK-8246094: [macos] Sound Recording and playback is not working
JDK-8243510: AbsPathsInImage.java fails on Windows
JDK-8245401: AbsPathsInImage.java fails on Windows on jdwp.dll
JDK-8244051: AbsPathsInImage.java still fails on Windows
JDK-8244966: Add .vscode to .hgignore and .gitignore
JDK-8236921: Add build target to produce a JDK image suitable for a Graal/SVM build
JDK-8243634: Add pandoc dependency when building linux-aarch64 at Oracle
JDK-8199138: Add RISC-V support to Zero
JDK-8240241: Add support for JCov DiffCoverage to make files
JDK-8239860: Add support for testing the configure script
JDK-8243988: Added flexibility in build system for unusal hotspot configurations
JDK-8246572: Always pass java.library.path when running micro benchmarks
JDK-8218480: Automatically add -Werror in FLAGS_COMPILER_CHECK_ARGUMENTS
JDK-8245096: Better windows environment output in configure
JDK-8244248: boot-jdk.m4 captures the version line using regex
JDK-8243109: Bootcycle build failures after Nashorn removal
JDK-8201349: build broken when configured with --with-zlib=bundled on gcc 7.3
JDK-8244756: Build broken with some awk version after JDK-8244248
JDK-8249255: Build fails if source code in cygwin home dir
JDK-8243059: Build fails when --with-vendor-name contains a comma
JDK-8244247: Build failures after sjavac cleanup
JDK-8244928: Build log output too verbose after JDK-8244844
JDK-8248135: Build microbenchmarks with --enable-preview
JDK-8244615: build-performance.m4 is not always parsing /proc/cpuinfo correctly
JDK-8244930: Building without test failure handler broken after JDK-8244844
JDK-8243590: Bump boot jdk to JDK 14 on aarch64 at Oracle
JDK-8242863: Bump minimum boot jdk to JDK 14
JDK-8240947: Change conflicting JVM features from warning to error
JDK-8243591: Change to GCC 9.2 for building Linux/aarch64 at Oracle
JDK-8241721: Change to GCC 9.2 for building on Linux at Oracle
JDK-8244214: Change to VS2019 for building on Windows at Oracle
JDK-8243973: Clarify difference between JAVA_OPTIONS and VM_OPTIONS
JDK-8241421: Cleanup handling of jtreg
JDK-8156967: configure --with-extra-cxxflags doesn't affect hotspot
JDK-8237374: configuring with --with-jvm-variants=minimal,server makes cds disappear in server
JDK-8239799: Cross-compilation ARM32/AARCH clientvm builds fails after JDK-8239450
JDK-8240259: Disable -Wshift-negative-value warnings
JDK-8244061: Disable jvmci/graal/aot when building linux-aarch64 at Oracle
JDK-8245281: Disabling hotspot gtest builds make it impossible to run tests
JDK-8246750: Docs bundle should be published to common dir
JDK-8236714: enable link-time section-gc for linux to remove unused code
JDK-8243665: exploded-image-optimize touches module-info.class in all modules
JDK-8237566: FindTests.gmk should only include existing TEST.ROOT files
JDK-8241034: Fix a configuring error with "-Xmx2048M: command not found"
JDK-8245119: Fix include path for hotspot-ide-project
JDK-8245041: Fix incorrect output order in configure
JDK-8243982: Fix testing documentation after JDK-8240241
JDK-8247936: Fix typos in man pages
JDK-8241310: Fix warnings in jdk buildtools
JDK-8245033: Fixes for building in WSL
JDK-8239789: Follow-up on JVM feature rewrite
JDK-8243477: FreeType library check should prefer 64-bit directory
JDK-8237192: Generate stripped/public pdbs on Windows for jdk images
JDK-8246256: GenerateLinkOptData should not mutate the interim or bootstrap JDK
JDK-8239566: gtest/GTestWrapper.java fails due to "libstlport.so.1: open failed: No such file or directory"
JDK-8245870: GTEST_FRAMEWORK_SRC should go through UTIL_FIXUP_PATH
JDK-8244021: Hide warning from jlink about incubating modules
JDK-8238918: idea.sh should work with both mercurial and git repos
JDK-8244224: Implementation of JEP 381: Remove the Solaris and SPARC Ports
JDK-8236272: Improve fidelity between contents of default CDS archive and classes loaded at runtime
JDK-8149110: Introduce DISABLED_WARNINGS for Java compilation
JDK-8149111: Introduce DISABLED_WARNINGS_doclint
JDK-8244757: Introduce SetupTarget in Main.gmk
JDK-8238225: Issues reported after replacing symlink at Contents/MacOS/libjli.dylib with binary
JDK-8244844: javac command line is not re-executable
JDK-8245832: JDK build make-static-libs should build all JDK libraries
JDK-8245168: jlink should not be treated as a "small" tool
JDK-8235997: JMH test runner should quote VM_OPTIONS and JAVA_OPTIONS sent to -jvmArgs
JDK-8246751: Mac OS build settings should use -O3
JDK-8240972: macOS codesign fail on macOS 10.13.5 or older
JDK-8236469: macOS devkit needs 64-bit SetFile for Catalina
JDK-8237879: make 4.3 breaks build
JDK-8244097: make bootcycle-images fails after JDK-8244036
JDK-8241271: Make hotspot build reproducible
JDK-8243985: Make source generation by generatecharacter reproducible
JDK-8218814: make test fails when configured with --with-extra-cflags="-Wformat -Werror=format-security"
JDK-8212986: Make Visual Studio compiler check less strict
JDK-8244945: Mark VS2019 as supported and default
JDK-8240950: Missing AC_SUBST after JDK-8240820
JDK-8244951: Missing entitlements for hardened runtime
JDK-8239794: Move -Os from JVM feature 'minimal' to new feature 'opt-size'
JDK-8244093: Move all IDE support into coherent structure in make directory
JDK-8241996: on linux set full relro in the linker flags
JDK-8238530: OPT_SPEED_SRC list misses some files with cpu-dependend file names
JDK-8239450: Overhaul JVM feature handling in configure
JDK-8213185: Properly handle run-test-prebuilt -> test-prebuilt migration
JDK-8238281: Raise minimum gcc version needed to 5.0
JDK-8244044: Refactor phase makefiles to be structured per module
JDK-8244036: Refresh SetupJavaCompilation, and remove support for sjavac
JDK-8219973: Remove "smart javac" (sjavac) support in build system
JDK-8243633: Remove cups dependency when building linux at Oracle
JDK-8245032: Remove exceptions from compare.sh
JDK-8236274: remove obsolete -d2Zi+ debug flag in MSVC builds
JDK-8243991: Remove obsolete -XX:ThreadStackSize from java command line
JDK-8243576: Remove residual reference to nashorn modules in make/CompileJavaModules.gmk
JDK-8246478: Remove src/utils/reorder
JDK-8240820: Replace AC_ARG_ENABLE with UTIL_ARG_ENABLE
JDK-8246435: Replace Javascript implementation of pandoc filters with Java
JDK-8244009: Separate -Xdoclint options in CompileJavaModules.gmk
JDK-8245046: SetupTarget incorrect for hotspot-ide-project
JDK-8243656: Shell built-in test in configure depends on help
JDK-8241254: Simplify usage of UTIL_DEPRECATED_ARG_ENABLE
JDK-8239708: Split basics.m4 into basic.m4 and util.m4
JDK-8244592: Start supporting SOURCE_DATE_EPOCH
JDK-8245287: Start using ModuleWrapper for gensrc as well
JDK-8236488: Support for configure option --with-native-debug-symbols=internal is impossible on Windows
JDK-8244653: Suppress gcc 9.1 ABI change notes on aarch64
JDK-8237042: Switch to JCov build which supports byte code version 59
JDK-8239019: testmake fails with FATAL: VCS_TYPE is empty
JDK-8244210: The javac server is never used
JDK-8250216: The README need not mention retrieving source code
JDK-8237914: The test-make target does not fail on test failure
JDK-8240866: Typo in JDK-8240820 messes up configure --help
JDK-8235532: Update --release 14 symbol information for JDK 14 b27
JDK-8237248: Update --release 14 symbol information for JDK 14 b32
JDK-8235926: Update @jls @jvms taglets to allow inline usage
JDK-8240777: Update all nroff manpages for JDK 15 release
JDK-8238912: Update devkit for linux-aarch64
JDK-8243567: Update download link of jtreg provided by Adoption Group
JDK-8196875: Update run-test instructions for TEST_MODE
JDK-8231572: Use -lobjc instead of -fobjc-link-runtime in libosxsecurity
JDK-8246484: Verify patch at start of COMPARE_BUILD=PATCH run
JDK-8242468: VS2019 build missing vcruntime140_1.dll
JDK-8238542: When warning about C/C++ compiler mismatch, be clear if this is about build compilers
JDK-8245093: WSL support broke cygwin toolchain detection
infrastructure/licensing:
JDK-8244094: Fix Amazon copyright in various test files
other-libs:
JDK-8235903: GCC default -fno-common exposes "multiple definition" link errors
other-libs/other:
JDK-8247274: (test) HexPrinter cleanup
JDK-8247521: (test) jdk/test/lib/hexdump/HexPrinterTest.java fails on windows
JDK-8244066: ClassFileInstaller should be run in driver mode
JDK-8211977: move testlibrary tests into one place
JDK-8244052: remove copying of s.h.WB$WhiteBoxPermission in test/jdk
JDK-8243010: Test support: Customizable Hex Printer
JDK-8183040: update jdk/test/lib/Platform.java to use NIO file API
performance:
JDK-8243156: Fix deprecation and unchecked warnings in microbenchmark
JDK-8236603: JDK 15 Start-up Performance Tracking
performance/hotspot:
JDK-8245043: Simplified contention benchmark
performance/libraries:
JDK-8234812: Add micros for DatagramChannel send/receive
JDK-8237480: Add micros for DatagramSocket send/receive
JDK-8246251: Adjust HelloClasslist after JDK-8230301
JDK-8238189: Cleanups to AES crypto micros
security-libs:
JDK-8241761: Typos: empty lines in javadoc, inconsistent indents, etc. (security-libs only)
security-libs/java.security:
JDK-8244087: 2020-04-24 public suffix list update v ff6fcea
JDK-8240686: 70 security tests are failing on Windows due to "Fetch artifact failed"
JDK-8244683: A TSA server used by tests
JDK-8244565: Accept PKCS #8 with version number 1
JDK-8225130: Add exception for expiring Comodo roots to VerifyCACerts test
JDK-8242060: Add revocation checking to jarsigner
JDK-8242811: AlgorithmId::getDefaultAlgorithmParameterSpec returns incompatible PSSParameterSpec for an RSASSA-PSS key
JDK-8236070: Backout fix for JDK-8234465
JDK-8242556: Cannot load RSASSA-PSS public key with non-null params from byte array
JDK-8246613: Choose the default SecureRandom algo based on registration ordering
JDK-8239264: Clearup the legacy ObjectIdentifier constructor from int array
JDK-8242184: Default signature algorithm for an RSASSA-PSS key
JDK-8237219: Disable native SunEC implementation by default
JDK-8244274: Document the new -revCheck option in jarsigner man page
JDK-8239928: ec/ECDSAJavaVerify.java failed due to timeout
JDK-8234465: Encoded elliptic curve private keys should include the public point
JDK-8234697: Generate sun.security.util.math.intpoly classes during build
JDK-8237962: give better error output for invalid OCSP response intervals in CertPathValidator checks
JDK-8242151: Improve OID mapping and reuse among JDK security providers for aliases registration
JDK-8240988: Incorrect copyright header in CertificateValidation.java
JDK-8246806: Incorrect copyright header in KeyAgreementTest.java, GroupName.java
JDK-8245151: jarsigner should not raise duplicate warnings on verification
JDK-8238566: java.security.Provider$Service.supportsParameter() is racy
JDK-8242897: KeyFactory.generatePublic( x509Spec ) failed with java.security.InvalidKeyException
JDK-8245679: KeyStore cannot probe PKCS12 keystore if BouncyCastle is the top security provider
JDK-8186143: keytool -ext option doesn't accept wildcards for DNS subject alternative names
JDK-8238452: Keytool generates wrong expiration date if validity is set to 2050/01/01
JDK-8238388: libj2gss/NativeFunc.o "multiple definition" link errors with GCC10
JDK-8239094: PKCS#9 ChallengePassword attribute does not allow for the UTF8String type
JDK-8242565: Policy initialization issues when the denyAfter constraint is enabled
JDK-8225069: Remove Comodo root certificate that is expiring in May 2020
JDK-8225068: Remove DocuSign root certificate that is expiring in May 2020
JDK-8238448: RSASSA-PSS signature verification fail when using certain odd key sizes
JDK-8237888: security/infra/java/security/cert/CertPathValidator/certification/LuxTrustCA.java fails when checking validity interval
JDK-8243424: Signature and SignatureSpi get parameter methods may return null when unsupported
JDK-8218482: sun/security/krb5/auto/ReplayCachePrecise.java failed - no KrbException thrown
JDK-8237804: sun/security/mscapi tests fail with "Key pair not generated, alias already exists"
JDK-8246709: sun/security/tools/jarsigner/TsacertOptionTest.java compilation failed after JDK-8244683
JDK-8239979: sun/security/tools/keytool/ExtOptionCamelCase.java is not run
JDK-8237218: Support NIST Curves verification in java implementation
JDK-8245665: Test WeakAlg.java should only make sure no warning for weak signature algorithms by keytool on root CA
JDK-8245134: test/lib/jdk/test/lib/security/KeyStoreUtils.java should allow to specify aliases
JDK-8241960: The SHA3 message digests impl of SUN provider are not thread safe after cloned
JDK-8244674: Third-party code version check
JDK-8172404: Tools should warn if weak algorithms are used before restricting them
JDK-8248505: Unexpected NoSuchAlgorithmException when using secure random impl from BCFIPS provider
JDK-8240552: Update jarsigner and keytool man pages for the legacy algorithms
JDK-8246397: Use KnownOIDs for known OIDs
JDK-8240261: Use make/templates/gpl-cp-header in FieldGen.java
security-libs/javax.crypto:
JDK-8087327: CipherStream produces new byte array on every update or doFinal operation
JDK-8246077: Cloneable test in HmacCore seems questionable
JDK-8166597: Crypto support for the EdDSA Signature Algorithm
JDK-8209632: Develop new tests for EdDSA API
JDK-8216012: Infinite loop in RSA KeyPairGenerator
JDK-8199231: JEP 339: Edwards-Curve Digital Signature Algorithm (EdDSA)
JDK-8238502: sunmscapi.dll causing EXCEPTION_ACCESS_VIOLATION
JDK-8172680: Support SHA-3 based Hmac algorithms
JDK-8239815: Update ECC legal file
security-libs/javax.crypto:pkcs11:
JDK-8238555: Allow initialization of SunPKCS11 with NSS when there are external FIPS modules in the NSSDB
JDK-8239457: call ReleaseStringUTFChars before early returns in Java_sun_security_pkcs11_wrapper_PKCS11_connect
JDK-8238898: Missing hash characters for header on license file
JDK-8236512: PKCS11 Connection closed after Cipher.doFinal and NoPadding
security-libs/javax.net.ssl:
JDK-8245691: Add EdDSA certificstes to SSLSocketTemplate and CertUtils
JDK-8238560: Cleanup and consolidate algorithms in the jdk.tls.legacyAlgorithms security property
JDK-8237474: Default SSLEngine should create in server role
JDK-8245686: Ed25519 and Ed448 present in handshake messages
JDK-8236039: JSSE Client does not accept status_request extension in CertificateRequest messages for TLS 1.3
JDK-8242294: JSSE Client does not throw SSLException when an alert occurs during handshaking
JDK-8240193: loadLibrary("osxsecurity") should not be removed
JDK-8215711: Missing key_share extension for (EC)DHE key exchange should alert missing_extension
JDK-8242141: New System Properties to configure the TLS signature schemes
JDK-8215712: Parsing extension failure may alert decode_error
JDK-8219989: Retire the com.sun.net.ssl.internal.ssl.Provider name
JDK-8241039: Retire the deprecated SSLSession.getPeerCertificateChain() method
JDK-8243029: Rewrite javax/net/ssl/compatibility/Compatibility.java with a flexible interop test framework
JDK-8236464: SO_LINGER option is ignored by SSLSocket in JDK 11
JDK-8233619: SSLEngine handshake status immediately after the handshake can be NOT_HANDSHAKING rather than FINISHED with TLSv1.3
JDK-8242008: SSLSession inconsistencies
JDK-8239798: SSLSocket closes socket both socket endpoints on a SocketTimeoutException
JDK-8243549: sun/security/ssl/CipherSuite/NamedGroupsWithCipherSuite.java failed with Unsupported signature algorithm: DSA
JDK-8206925: Support the certificate_authorities extension
JDK-8242929: The values of jdk.tls.namedGroups should not be case-sensitive
security-libs/javax.security:
JDK-8242335: Additional Tests for RSASSA-PSS
JDK-8242330: Arrays should be cloned in several JAAS Callback classes
JDK-8236405: Formatting issues in Kerberos debug output
JDK-8160818: GssKrb5Client violates RFC 4752
JDK-8191395: policy.allowSystemProperty and policy.expandProperties also apply to JAAS configurations
JDK-8231508: Remove vague spec from KeyTab::exist on fallback
JDK-8239385: Support the 'canonicalize' setting (krb5.conf) in the Kerberos client
security-libs/javax.smartcardio:
JDK-8163251: Hard coded loop limit prevents reading of smart card data greater than 8k
JDK-8244151: Update MUSCLE PC/SC-Lite headers to the latest release 1.8.26
security-libs/javax.xml.crypto:
JDK-8247964: All log0() in com/sun/org/slf4j/internal/Logger.java should be private
JDK-8247907: XMLDsig logging does not work
security-libs/jdk.security:
JDK-8242260: Add forRemoval=true to already deprecated ContentSigner
JDK-8240848: ArrayIndexOutOfBoundsException buf for TextCallbackHandler
JDK-8241888: Mirror jdk.security.allowNonCaAnchor system property with a security one
security-libs/org.ietf.jgss:
JDK-8246640: @systemproperty should be @systemProperty in java.security.jgss
security-libs/org.ietf.jgss:krb5:
JDK-8246193: Possible NPE in ENC-PA-REP search in AS-REQ
JDK-8005819: Support cross-realm MSSFU
specification/language:
JDK-8236893: (IGNORE) Changes to Records specification
JDK-8245674: 13.4.2: Discuss binary compatibility of sealed and non-sealed interfaces
JDK-8245546: 14.22: Completion of switch statement with switch rules but no default
JDK-8240465: 3.10.2: Improve information about min/max FP literals
JDK-7074799: 4.2: Adopt IEEE 754-2019 terminology in JLS
JDK-8245557: 4.8: Erasure of a type is not always a raw type
JDK-8247305: 7.5.1: Ignore single-type-import of only top level, not nested, types in same compilation unit
JDK-8231970: 8.4.8.2: Static methods of classes shouldn't hide static methods of interfaces
JDK-8245550: 9.7.4: Fix illegal examples of "admissible" type annotations
JDK-8227043: JEP 360: Sealed Classes (Preview)
JDK-8235186: JEP 375: Pattern Matching for instanceof (Second Preview)
JDK-8246156: JLS changes for Pattern Matching for instanceof (Second Preview)
JDK-8246157: JLS changes for Records (Second Preview)
JDK-8227048: JLS changes for Sealed Classes (Preview)
JDK-8242149: JLS changes for Text Blocks
JDK-8236622: Records: Clarify interaction between records and @SafeVarargs
JDK-8236623: Records: Clarify interaction between records and varargs
JDK-8236734: Records: Do not allow 'final' modifier to be redundantly applied to record components
JDK-8236599: Records: Names of formal parameters in canonical constructors must match the corresponding record component
JDK-8247628: Records: Specify permitted accessibility of canonical constructor of a private record class
specification/vm:
JDK-8240327: 2.8: Adopt IEEE 754-2019 terminology in JVMS
JDK-8236510: 4.1: Allow v59.0 class files for Java SE 15
JDK-8231313: 5.4.4: Enhance access control for dynamically-determined nest membership
JDK-8246158: JVMS changes for Records (Second Preview)
JDK-8227049: JVMS changes for Sealed Classes (Preview)
tools/jar:
JDK-8230117: remove dead code from jar tool
tools/javac:
JDK-8246199: 'permits' is a restricted identifier
JDK-8246704: --release => "unknown enum constant PreviewFeature$Feature.TEXT_BLOCKS"
JDK-8235528: Add source 15 and target 15 to javac
JDK-8241798: Allow enums to have more constants
JDK-8242293: allow for local interfaces and enums
JDK-8246257: Annotated record's vararg type component started to be uncompilable with JDK15b24
JDK-8210649: AssertionError @ jdk.compiler/com.sun.tools.javac.comp.Modules.enter(Modules.java:244)
JDK-8228963: Classes found with implicit permits should be listed in natural (source-file) order
JDK-8243417: Clean up com.sun.tools.javac.main.CommandLine
JDK-8242472: Comment for unused PreviewFeature.Feature.TEXT_BLOCKS enum
JDK-8240964: Compilation error thrown when long literal used with yield
JDK-8239447: compiler error for annotations applied to record components with target METHOD
JDK-8242478: compiler implementation for records (Second Preview)
JDK-8227046: compiler implementation for sealed classes
JDK-8241907: Error when cross compiling with JDK 13, release flag and JFR package
JDK-8237214: fix for JDK-8236597 reintroduced wrong subexpression
JDK-8236435: Fix typos in javac area
JDK-8241741: Implement Text Blocks as a standard feature in javac
JDK-8239884: implicitly generated SomeRecord::toString does not have the same modifiers as other generated methods
JDK-8243557: Inconvenient span for multi-catch error diagnostics
JDK-8240454: incorrect error message: as of release 13, 'record' is a restricted type name
JDK-8237528: Inefficient compilation of Pattern Matching for instanceof
JDK-8236597: issues inferring type annotations on records
JDK-8242802: javac crashes when checking equals and hashCode in unresolvable anonymous class
JDK-8235564: javac crashes while compiling incorrect method invocation with member reference
JDK-8241519: javac crashes with wrong module-info.class in module path
JDK-8242529: javac defines type annotations incorrectly for record members (constructor and property accessor)
JDK-8239544: Javac does not respect should-stop.ifNoError policy to stop after CompileState PARSE, ENTER and PROCESS
JDK-8246486: javac doesn't allow a subclass to be declared before a sealed superclass with no permits clause
JDK-8236682: Javac generates a redundant FieldRef constant for record fields
JDK-8236210: javac generates wrong annotation for fields generated from record components
JDK-8230827: javac gives inappropriate warning about potentially ambiguous methods
JDK-8243548: Javac incorrectly collects enum fields when verifying switch expression exhaustivness
JDK-8243047: javac may crash when processing exits in class initializers
JDK-8243000: javac only build fails after removal of Nashorn
JDK-8235149: javac parser is too aggressive on ambiguous expressions using identifier: record
JDK-8237450: JDK13 annotation processors not run when a supported annotation type specifies a module
JDK-8241950: JShell could support auto-indent
JDK-8247932: JShell crashes when typing text block
JDK-8245445: Langtools NetBeans ant build broken after JDK-8244093
JDK-8236598: make sure that the compiler issues an error for any modifier applied to record components
JDK-8243074: Misplaced and/or duplicate super or this constructor invocation not attributed
JDK-8241312: missing code coverage for records
JDK-8238735: NPE compiling lambda expression within conditional expression
JDK-8228451: NPE in Attr.java when -XDshould-stop.ifError=FLOW
JDK-8242214: NullPointerException in JDK 14 javac compiling a method reference
JDK-8247849: permits clause of sealed interfaces should not allow parameterized types
JDK-8042742: possible error in Tokens.Token.checkKind() for javac
JDK-8245842: provide tests for binary compatibility assertions for sealed classes
JDK-8240826: records: mandated members should get the accessibility of the enclosing record type
JDK-8245147: Refactor and improve utility of test/langtools/tools/javac/versions/Versions.java
JDK-8245841: Remove unused com.sun.tools.javac.comp.Modules.XMODULES_PREFIX
JDK-8245786: Scope is wrong for ClassTree representing record
JDK-8240970: Some tests fail when run with JCov
JDK-8035787: SourcePositions are wrong for Strings concatenated with '+' operator
JDK-8238838: spurious error message for compact constructors with throws clause
JDK-8236697: Stack overflow with cyclic hierarchy in class file
JDK-8236824: subtypes of non-sealed types not handled correctly
JDK-8231911: Symbol.packge() NPEs on ModuleSymbols
JDK-8235339: test TargetAnnoCombo.java is failing after new target RECORD_COMPONENT was added
JDK-8237601: test/langtools/tools/javac/warnings/MaxDiagsRecompile.java fails after JDK-8237589
JDK-8241616: Timestamps on ct.sym entries lead to non-reproducible builds
JDK-8236997: tools/javac tests fail with --illegal-access=deny
JDK-8236108: tools/javac/lambda/LambdaParserTest.java timed out
JDK-8247334: Trees.getScope crashes for annotated local records
JDK-8235216: typo in test filename
JDK-8245153: Unicode encoded double-quoted empty string does not compile
JDK-8244763: Update --release 8 symbol information after JSR 337 MR3
JDK-8245847: Update Profile.java to not require per-release updates
tools/javadoc(tool):
JDK-8242607: -Xdoclint doesn't report missing/unexpected comments
JDK-8177280: @see {@link} syntax should allow generic types
JDK-8218161: [specification] inline tag brace balancing is not documented
JDK-8243396: Add a brief description of argfiles to the javadoc help output
JDK-8239378: Add Classpath Exception to license in source file.
JDK-8200363: Add javadoc command line setting to fail on warnings
JDK-8164408: Add module support for @see, @link and @linkplain javadoc tags.
JDK-8241780: Allow \n@ inside inline tags.
JDK-8239487: Better links generation for system properties found in HTML files
JDK-8238467: Clean up annotations on overridden/implemented methods
JDK-8236077: Clean up the use of modifiers and semicolons
JDK-8240138: Cleanup HtmlTree
JDK-8238646: Cleanup signature and use of CommentHelper
JDK-8236030: Cleanup use of String.toCharArray
JDK-8240136: Cleanup/simplify HTML/CSS for definition lists
JDK-8239804: Cleanup/simplify HTML/CSS for general block tags
JDK-8235947: Cleanup/simplify Utils.getBlockTags
JDK-8240697: convert builders to high-level Content blocks
JDK-8242532: convert tests to use Text Blocks
JDK-8240916: Convert to using hyphenated naming for CSS classes
JDK-8239243: Create index structures only if required
JDK-8239485: Define behavior of the System Properties page when no system properties are available
JDK-8247788: DocCommentParser should not reject standalone '>'
JDK-8233293: Doclet examples are inconsistent with documentation
JDK-8247382: doclint errors (missing comments) in jdk.compiler and jdk.javadoc
JDK-8246712: doclint incorrectly reports some HTML elements as empty
JDK-8247235: doclint should permit "self-closing" tags for void elements in HTML5
JDK-8247955: doclint: don't complain about summary/caption when role=presentation
JDK-8247815: doclint: recategorize "no description for ..." as MISSING, not SYNTAX
JDK-8237826: DocTrees should provide getType(DocTreePath) method
JDK-8239817: Eliminate use of contentContainer and friends
JDK-8237845: Encapsulate doclet options
JDK-8236823: Ensure that API documentation uses minified libraries
JDK-8238291: Fix inconsistencies in the format of the index files
JDK-8241190: Fix name clash for constants-summary CSS class
JDK-8238506: fix obsolete comments and inconsistent exceptions in BaseTaglet
JDK-8237725: Fix signature of StandardDoclet.getSupportedOptions
JDK-8245062: HtmlStyle: group and document members for nav, header, summary, details
JDK-8241470: HtmlStyle: group and document members: description, flex, signature
JDK-8220002: Improve anchor definitions in generated files
JDK-8239876: Improve SearchIndexItem
JDK-8242649: improve the CSS class names used for summary and details tables
JDK-8236935: Improve UX of the search control
JDK-8238697: Incorrect Man pages of Javadocs tool
JDK-8241292: Interactive Search results are not highlighted as they used to be
JDK-8236949: javadoc -Xdoclint does not accumulate options correctly
JDK-8246429: Javadoc comparators are not module-aware
JDK-8245696: javadoc crashes when a doc-files directory contains a '#' file
JDK-8247913: Javadoc doc-comment-spec contains unintentional HTML char reference
JDK-8231484: Javadoc documentation includes unrecognized option -Xmodule:
JDK-8240169: javadoc fails to link to docs with non-matching modularity
JDK-8227047: Javadoc for sealed types
JDK-8246705: javadoc gives "misleading" and incomplete warning message.
JDK-8198705: Javadoc search needs a fix to handle duplicate package names in different modules
JDK-8246078: Javadoc Search specification link from Javadoc Help page points to JDK 13 spec
JDK-8224613: javadoc should better handle bad options
JDK-8224612: javadoc should better handle empty set of doclet options
JDK-8224266: Javadoc tool generates an error instead of a warning for missing references
JDK-8222793: Javadoc tool ignores "-locale" param and uses default locale for all messages and texts
JDK-8239575: javadoc triggers javac AssertionError for annos on modules
JDK-8243562: Make display of search results consistent with color scheme
JDK-8239816: Make handling of module / package / types consistent.
JDK-8241982: Make TestSearchScript.java run with GraalJS
JDK-8237383: Members inherited from non-public types are not included in index
JDK-8242056: Merge support for AnnotationType builders/writers into support for other types
JDK-8238969: Miscellaneous cleanup
JDK-8243388: Moving search result selection clears search input
JDK-8243318: New test jdk/javadoc/tool/8224612/OptionsTest.java is failing
JDK-8238259: new tests do not account for Windows file separators
JDK-8243533: Only one of several deprecated overloaded methods listed in the Deprecated list
JDK-8241631: PropertyGetterTaglet, PropertySetterTaglet may be removed
JDK-8247780: Refine the Help page for API Documentation
JDK-8236539: Relative link tags in record javadoc don't resolve
JDK-8235447: Remove (obsolete) @author info from javadoc tests
JDK-8232438: Remove ?is-external=true from external links
JDK-8238167: Remove stray files from jdk.javadoc
JDK-8238503: Remove unused field and accessor for docLocale from ToolOptions
JDK-8237909: Remove zipped index files feature
JDK-8238648: Rename and simplify Utils.WeakSoftHashMap
JDK-8241030: rename HtmlTag to TagName
JDK-8237492: Reorganize impl of doclet options
JDK-8237803: Reorganize impl of tool options
JDK-8248409: some jdk/javadoc/doclet tests fail (JDK 15)
JDK-8247577: Stamp the Javadoc Search Specification with the JDK version
JDK-8240137: Support chained use of Content.add
JDK-8235306: Support doc-comment tags that can be inline or block tags
JDK-8238437: Support separate locales for console messages and HTML content.
JDK-8240476: SystemPropertiesWriter does not conform to standard page layout
JDK-8241693: The paragraphs in the help page should not be in a
JDK-8241969: Type annotation is not shown for wildcard type in Javadoc
JDK-8241544: update stylesheet for *-page CSS class rename and hyphenated naming
JDK-8245981: Upgrade to jQuery 3.5.1
JDK-8236700: Upgrading JSZip from v3.1.5 to v3.2.2
JDK-8241895: use new "details-list" CSS class instead of general "block-list" for list of details sections
JDK-8241625: use new "member-list" CSS class instead of general "block-list" for list of members
JDK-8242326: use new "summary-list" CSS class instead of general "block-list" for list of summary sections
JDK-8240555: Using env of JAVA_TOOL_OPTIONS and _JAVA_OPTIONS breaks QuietOption.java test
tools/javap:
JDK-8244573: java.lang.ArrayIndexOutOfBoundsException thrown for malformed class file
JDK-8219475: javap man page needs to be updated
tools/jconsole:
JDK-8236873: Worker has a deadlock bug
tools/jlink:
JDK-8242846: Bring back test/jdk/tools/jlink/plugins/OrderResourcesPluginTest.java
JDK-8243117: Cleanups in Java code of module jdk.jlink
JDK-8242039: Improve jlink VersionPropsPlugin
JDK-8241602: jlink does not produce reproducible jimage files
JDK-8240333: jmod incorrectly updates .jar and .jmod files during hashing
JDK-8240910: jmod rejects duplicate entries in --class-path jars
JDK-8246034: Remove java.base/share/classes/jdk/internal/jrtfs/jrtfsviewer.js and java.base/share/classes/jdk/internal/jrtfs/jrtls.js
JDK-8241462: StripNativeDebugSymbols jlink plugin allocates huge arrays
JDK-8242859: test/jdk/tools/jlink/JLinkTest.java uses nashorn module
JDK-8242860: test/jdk/tools/jlink/ModuleNamesOrderTest.java uses nashorn module
tools/jpackage:
JDK-8247422: --runtime-image on Mac should work for runtime root
JDK-8235954: [dmg] Default DMG background tiff of jpackage not retina ready
JDK-8235955: [dmg] DMG creation fails without error message if previous DMG was not ejected
JDK-8237490: [macos] Add support notarizing jpackage app-image and dmg
JDK-8246706: [macos] Allow SigningPackageTest to be built with real certificates
JDK-8248501: [macos] App created with jpackage on Mac fails with error -10810
JDK-8248059: [macos] EmptyFolderPackageTest.java failed "hdiutil: create failed - No child processes"
JDK-8236282: [macos] Find permanent solution to macOS test timeout problem JDK-8235738
JDK-8241400: [macos] jpackageapplauncher/main.m built using CXXFLAGS_JDKEXE
JDK-8237769: [macos] Linking libapplauncher.dylib on Mac OS X fails
JDK-8242786: [macos] tools/jpackage/share/IconTest.java fails: ABORT trying to dequeue work
JDK-8244576: [macos] Volume icon deleted by osascript for background image
JDK-8246211: [TEST_BUG] JPKG001-007 instruction need to be updated.
JDK-8236132: Add missing properties to msi installers
JDK-8219536: Add Option for user defined jlink options
JDK-8231283: Add support to jpackage to create install Linux packages in /usr hierarchy
JDK-8233270: Add support to jtreg helpers to unpack packages
JDK-8236138: Add tests for jmod applications
JDK-8246010: AdditionalLaunchersTest is not enabled, and fails.
JDK-8246244: BasicShortcutHintTest shortcut can not be found
JDK-8244220: Compiler error in jpackage with VS2019
JDK-8246627: Consolidate app image bundlers
JDK-8237966: Creating runtime pkg requires --mac-package-identifier
JDK-8232077: Default behavior should allow downgrade scenario
JDK-8230933: Default icon is not set for additional launchers
JDK-8244758: Dmg bundler ignores --install-dir option.
JDK-8233578: Document configurable parameters of msi packages
JDK-8245788: EmptyFolderPackageTest fails on Windows 10
JDK-8242155: Enhance automated macos signing tests
JDK-8236129: Exe installers have wrong properties
JDK-8236134: files missing in putback to JDK-8233270
JDK-8235667: IOUtils.copyFile() problems.
JDK-8235915: jpackage associations fail when there are spaces in file name or path
JDK-8247424: jpackage BasicTest.java failed two sub-tests
JDK-8233215: jpackage doesn't allow enough flexibility for file type binding
JDK-8244981: jpackage error due to missing final newline in Debian control file
JDK-8232935: jpackage failed with NPE whenever --file-associations provided
JDK-8248254: jpackage fails if app module is in external runtime
JDK-8248427: jpackage jtreg BasicTest.testTemp() test fails on Windows
JDK-8247229: jpackage tests failed due to "semop(1): encountered an error: Invalid argument"
JDK-8233166: jpackage tool skips empty directories
JDK-8246212: JPKG001-012: application icon is missing in Control Panel Add/Remove
JDK-8247353: jtreg tests minor issues clean up
JDK-8244183: linker error jpackageapplauncher on Windows 32bit
JDK-8241713: Linux desktop shortcuts with spaces make postinst/prerm fail
JDK-8244634: LoadLibraryW failed from tools/jpackage tests after JDK-8242302
JDK-8243673: Mac signing process should not use --deep arg.
JDK-8246792: Mac signing tests failed (unsealed contents present in the bundle root)
JDK-8238692: MacOS runtime Installer issue
JDK-8243587: Missing comma in copyright header
JDK-8244018: No error message for non-existent icon path
JDK-8237967: No proper error message when --runtime-image points to non-existent path
JDK-8246042: Non-ASCII characters are not handled correctly in the native launcher
JDK-8247418: Only validate the certificates trust if using the default key user name.
JDK-8237971: Package type for runtime image on macosx
JDK-8235833: PosixPlatform.cpp should not include sysctl.h
JDK-8246624: Refactor JLinkBundlerHelper and StandardBundlerParam classes
JDK-8242302: Refactor jpackage native code
JDK-8238947: tools/jpackage tests fail with old rpmbuild versions
JDK-8245831: Unify code parsing version strings on Mac and Windows
JDK-8238206: Uninstall verification fails due to msiexec exiting before app is uninstall
JDK-8242865: Usability problems using mac signing in jpackage
JDK-8236125: Windows (MSVC 2013) build fails in jpackage: Need to include strsafe.h after tchar.h
JDK-8248264: WinUpgradeUUIDTest application is missing in downgrade scenario
JDK-8244618: WinUpgradeUUIDTest.java fails after JDK-8236518
tools/jshell:
JDK-8239536: Can't use `java.util.List` object after importing `java.awt.List`
JDK-8199646: JShell tests: jdk/jshell/FailOverDirectExecutionControlTest.java failed with java.lang.UnsupportedOperationException
JDK-8249367: JShell uses 100% of one core all the time
JDK-8247438: JShell: When FailOverExecutionControlProvider fails the proximal cause is not shown
JDK-8242919: Paste locks up jshell
JDK-8246353: Sealed types not supported by jshell
JDK-8234896: Tab completion does not work for method references in jshell.
JDK-8237743: test/langtools/jdk/jshell/FailOverExecutionControlTest.java fails No ExecutionControlProvider with name 'nonExistent' and parameter keys: []
JDK-8241598: Upgrade JLine to 3.14.0
JDK-8242030: Wrong package declarations in jline classes after JDK-8241598
tools/launcher:
JDK-8240629: argfiles parsing broken for argfiles with comment cross 4096 bytes chunk
JDK-8245600: Clean up libjli
JDK-8241445: Fix copyrights after JDK-8240629 change
JDK-8243453: java --describe-module failed with non-ASCII module name under non-UTF8 environment
JDK-8241638: launcher time metrics always report 1 on Linux when _JAVA_LAUNCHER_DEBUG set
xml:
JDK-8248060: small HTML issues in java.xml package-info.java files
xml/javax.xml.transform:
JDK-8238183: SAX2StAXStreamWriter cannot deal with comments prior to the root element
JDK-8237456: Transform filtered through SAX filter mishandles character entities
xml/javax.xml.xpath:
JDK-8244342: Compilation warnings about unexpected serialization related method signatures.
xml/jaxp:
JDK-8245231: Javadoc for the readObject methods needs to be updated
JDK-8237187: Obsolete references to java.sun.com
JDK-8209774: Refactor shell test javax/xml/jaxp/common/8035437/run.sh to java
JDK-8248348: Regression caused by the update to BCEL 6.0
JDK-8235368: Update BCEL to Version 6.4.1
JDK-8242470: Update Xerces to Version 2.12.1
CARRIED OVER FROM PREVIOUS RELEASES:
JDK-8230665: (bf spec) ByteBuffer::alignmentOffset spec misleading when address is misaligned
JDK-8215361: (doc) Cleanup package-info markup - smartcardio, java.sql, java.sql.rowset
JDK-8236582: (fc) FileChannel.map fails with InternalError when security manager enabled
JDK-8235819: -Wformat-overflow is reported from GCC 9
JDK-8235998: [C2] Memory leaks during tracing after "8224193: stringStream should not use Resource Area".
JDK-8234284: [dmg] Change DMG background image to TIFF
JDK-8231515: [Graal] Crash during exception throwing in InterpreterRuntime::resolve_invoke
JDK-8236139: [Graal] java/lang/RuntimeTests/exec/LotsOfOutput.java fails with JVMCI enabled
JDK-8235750: [jpackage] Cleanup imports in WinMsiBundler.java
JDK-8229377: [JVMCI] Improve InstalledCode.invalidate for large code caches
JDK-8234522: [macos] Crash with use of native file dialog
JDK-8236953: [macos] JavaFX SwingNode is not rendered on macOS
JDK-8237607: [macos] Signing app bundle with jpackage fails if runtime is already signed
JDK-8235738: [macos] tools/jpackage tests timeout on macOS
JDK-8236555: [s390] Fix VerifyOops
JDK-8235982: AArch64: Insufficient memory barriers in shadow region algorithm
JDK-8235789: AC_REQUIRE: `PLATFORM_EXTRACT_TARGET_AND_BUILD' was expanded before it was required
JDK-8236877: Add "record" to descriptions in java.lang.{annotation, reflect}
JDK-8235814: Add --enable-deprecated-ports=yes to all solaris and SPARC build profiles
JDK-8215038: Add a page that lists all system properties
JDK-8235849: Add back deprecation warning in jcmd man page
JDK-8235686: Add more custom hooks in Bundles.gmk
JDK-8236098: AlgorithmConstraints:permits method not throwing IAEx when primitives are empty
JDK-8229961: Assert failure in compiler/graalunit/HotspotTest.java
JDK-8236140: assert(!VerifyHashTableKeys || _hash_lock == 0) failed: remove node from hash table before modifying it
JDK-8230185: assert(is_Loop()) failed: invalid node class
JDK-8234173: assert(loader != __null && oopDesc::is_oop(loader)) failed: loader must be oop
JDK-8235751: Assertion when triggering concurrent cycle during shutdown
JDK-8229847: AttachProvider javadoc page needs an update
JDK-8238596: AVX enabled by default for Skylake even when unsupported
JDK-8237918: Bad copyright line in a hotspot test
JDK-8237916: Bad copyright line in a jshell source file
JDK-8235551: BitMap::count_one_bits should use population_count
JDK-8236441: Bound MulticastSocket fails when setting outbound interface on Windows
JDK-8227607: Broken external links in java.desktop
JDK-8235620: Broken merge between JDK-8006406 and JDK-8003559
JDK-8237183: Bug ID missing for test in patch which fixed JDK-8230665
JDK-8235815: Build fails with error: no "alt" attribute for image
JDK-8235866: bump jtreg requiredVersion to 4.2b16
JDK-8235870: C2 crashes in IdealLoopTree::est_loop_flow_merge_sz()
JDK-8229855: C2 fails with assert(false) failed: bad AD file
JDK-8233164: C2 fails with assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr)) failed: correct memory chain
JDK-8233033: C2 produces wrong result while unswitching a loop due to lost control dependencies
JDK-8235984: C2: assert(out->in(PhiNode::Region) == head || out->in(PhiNode::Region) == slow_head) failed: phi must be either part of the slow or the fast loop
JDK-8234392: C2: Extend Matcher::match_rule_supported_vector() with element type information
JDK-8235688: C2: Merge AD instructions for AddV, SubV, and MulV nodes
JDK-8235405: C2: Merge AD instructions for different vector operations
JDK-8235756: C2: Merge AD instructions for DivV, SqrtV, and FmaV nodes
JDK-8235719: C2: Merge AD instructions for ShiftV, AbsV, and NegV nodes
JDK-8236266: change error message for the case when a class extends j.l.Record
JDK-8235788: Changeset for JDK-8235252 pushed with wrong bug ID
JDK-8237651: Clarify initialization of jdk.serialFilter
JDK-8236769: Clarify javadoc of memory access API
JDK-8235653: Clean-up BarrierSetC2
JDK-8234277: ClhsdbLauncher should enable verbose exceptions and do a better job of detecting SA failures
JDK-8236841: compact constructor parameters are always final
JDK-8236545: Compilation error in mach5 java/awt/FileDialog/MacOSGoToFolderCrash.java
JDK-8234101: Compilation error thrown when repeating annotation is used on record component
JDK-8235767: Compilation failure caused by JDK-8212780: Packaging Tool Implementation
JDK-8236670: Conflicting bindings accepted in some cases
JDK-8236544: confusing error message: return type of accessor method is not compatible with type of record component
JDK-8235687: Contents/MacOS/libjli.dylib cannot be a symlink
JDK-8238605: Correct the CLDR version number in cldr.md files
JDK-8235305: Corrupted oops embedded in nmethods due to parallel modification during optional evacuation
JDK-8235457: Crash when reporting a message about an annotation on a module
JDK-8236044: Create jdk_accessibility test group
JDK-8236470: Deal with ECDSA using ecdsa-with-SHA2 plus hash algorithm as AlgorithmId
JDK-8230392: Define AArch64 as MULTI_COPY_ATOMIC
JDK-8234870: Deprecate the OracleUcrypto JCE Provider for removal
JDK-8235976: Directives in WWW-Authenticate should be comma separated
JDK-8236062: Disable clhsdb initialization of SA javascript support since it will always fail, and will likely be removed soon
JDK-8233228: Disable weak named curves by default in TLS, CertPath, and Signed JAR
JDK-8234782: Discuss evolution of records in serialization spec
JDK-8235410: Enable handshakes on Linux x86 (32-bit)
JDK-8235585: Enable macOS codesigning for all libraries and executables
JDK-8233111: Epoch shift synchronization point for Compiler threads
JDK-8233112: Exclude SVG files from build comparison
JDK-8235759: Extend GCConfig::is_gc_supported to mean supported not only included in build
JDK-8235541: Extend javax.lang.model to cover binding variables
JDK-8235597: Extend support for -XDaccessInternalAPI to plugin modules
JDK-8236772: Fix build for windows 32-bit after 8212160 and 8234331.
JDK-8236897: Fix the copyright header for pkcs11gcm2.h
JDK-8237186: Fix typo in copyright header of java/io/Reader/TransferTo.java
JDK-8235669: G1: Stack walking API can expose AS_NO_KEEPALIVE oops
JDK-8237079: gc/g1/mixedgc/TestLogging.java fails with "Pause Young (Mixed) (G1 Evacuation Pause) not found"
JDK-8235934: gc/g1/TestGCLogMessages.java fails with 'DerivedPointerTable Update' found
JDK-8235636: gc/shenandoah/compiler/TestUnsafeOffheapSwap.java fails after JDK-8226411
JDK-8235829: graal crashes with Zombie.java test
JDK-8235489: handle return values of sscanf calls in hotspot
JDK-8234049: Implementation of Memory Access API (Incubator)
JDK-8234746: Improve indexing of system properties
JDK-8234783: Improve wording of spec of Record.equals
JDK-8235119: Incomplete initialization of scan_top values results in out-of-bounds scanning of regions
JDK-8235730: Incorrect javadoc in MatchKind
JDK-8236145: Incorrect spec on ECDSA P1363 signature format
JDK-8236443: Issues with specializing vector register type for phi operand with generic operands
JDK-8236695: java.lang.Record should be declared with an explicit constructor
JDK-8233452: java.math.BigDecimal.sqrt() with RoundingMode.FLOOR results in incorrect result
JDK-8233680: JavacFileManager.close() doesn't clear some cache instance variables
JDK-8224052: Javadoc doesn't handle non-public intermediate types well
JDK-8237370: Javadoc of memory access API still refers to old MemoryAddress::offset method
JDK-8237348: Javadoc of MemorySegment::allocateNative should state that memory is zero-initialized
JDK-8235670: Javadoc pages not printing correctly in some browsers
JDK-8225773: jdeps --check produces NPE if there is any missing module dependence
JDK-8229396: jdeps ignores multi-release when generate-module-info used on command line
JDK-8237465: JDK 14 L10n resource file update - msg drop 10
JDK-8235728: JDK-8212780 breaks builds with a custom X11 include path
JDK-8235654: JFR leak profiler should not trace through the StringTable
JDK-8236487: JFR Recorder Thread crashed due to "assert(_chunkwriter.is_valid()) failed: invariant"
JDK-8236743: JFR: assert(klass != __null) failed: invariant in ObjectSampleCheckpoint::add_to_leakp_set
JDK-8236691: JFR: assert((((((klass)->trace_id()) & ((JfrTraceIdEpoch::method_and_class_in_use_this_epoch_bits()))) != 0))) failed: invariant
JDK-8235390: JfrEmergencyDump::on_vm_shutdown crashes
JDK-8235637: jhsdb jmap from OpenJDK 11.0.5 doesn't work if prelink is enabled
JDK-8225561: jlink --help doesn't state that ALL-MODULE-PATH is accepted for --add-modules
JDK-8235474: JShell does not handle records properly
JDK-8232855: jshell missing word in /help help
JDK-8210527: JShell: NullPointerException in jdk.jshell.Eval.translateExceptionStack
JDK-8236715: JShell: Records with errors are not properly corraled
JDK-8235762: JVM crash in SWPointer during C2 compilation
JDK-8234076: JVM crashes on Windows 10 using --module=NAME
JDK-8237396: JvmtiTagMap::weak_oops_do() should not trigger barriers
JDK-8236661: Launcher test PatchSystemModules.java fails frequently after JDK-8234049
JDK-8235668: LineNumberReader#getLineNumber() returns wrong line number (one fewer) in Lucene test
JDK-8236005: local records shouldn't capture any non-static state from any enclosing type
JDK-8235837: Memory access API refinements
JDK-8236634: Memory Access API tests fail on 32-bit
JDK-8236124: Minimal VM slowdebug build failed after JDK-8212160
JDK-8234423: Modifying ArrayList.subList().subList() resets modCount of subList
JDK-8235414: Module level doc-files show "unnamed package" as holder
JDK-8235778: No compilation error reported when a record is declared in a local class
JDK-8221485: Not all options for JFR.dump are documented
JDK-8233655: NPE at jdk.compiler/com.sun.tools.javac.comp.Flow$FlowAnalyzer.visitApply
JDK-8220049: Obsolete ThreadLocalHandshakes
JDK-8236957: Obvious typo in java/security/spec/RSAMultiPrimePrivateCrtKeySpec.java
JDK-8236495: open/test/jdk/java/util/Locale/LocaleProvidersRun.java failed on mac 10.14 with de_DE locale.
JDK-8226575: OperatingSystemMXBean should be made container aware
JDK-8235744: PIT: test/jdk/javax/swing/text/html/TestJLabelWithHTMLText.java times out in linux-x64
JDK-8235458: Problem caused by imports in a module-info.java file
JDK-8237368: Problem with NullPointerException in RMI TCPEndpoint.read
JDK-8236679: Records: Local records shouldn't capture any non-static state from any enclosing type
JDK-8237062: Refine JSR 269 API ahead of Java SE 14 MR
JDK-8238168: Remove Copyright from WinLauncher.template
JDK-8236263: Remove experimental streaming events
JDK-8235808: Remove graalunit from tier1_compiler_not_xcomp
JDK-8232231: Remove invalid JFR thread CPU load test case
JDK-8236264: Remove jdk.jfr.Recording::setFlushInterval and jdk.jfr.Recording::getFlushInterval
JDK-8237185: Remove Pack200 spec and references from documentation
JDK-8235629: Remove unnecessary calls to Thread::current
JDK-8235427: Remove unnecessary parameters from G1CollectedHeap::free_region and HeapRegion::hr_clear
JDK-8235757: Rename SupportedGC to IncludedGC
JDK-8235252: Repair run_tests.sh by locating jtreg locally
JDK-8235621: Replace use of Function with ToIntFunction
JDK-8237019: Serialization Specification changes for Records
JDK-8237369: Shenandoah: failed vmTestbase/nsk/jvmti/AttachOnDemand/attach021/TestDescription.java test
JDK-8236902: Shenandoah: Missing string dedup roots in all root scanner
JDK-8237038: Shenandoah: Reduce thread pool size in TestEvilSyncBug.java test
JDK-8237392: Shenandoah: Remove unreliable assertion
JDK-8235729: Shenandoah: Remove useless casting to non-constant
JDK-8235776: Shenandoah: Shenandoah root updater not always uses right code blob closure
JDK-8237776: Shenandoah: Wrong result with Lucene test
JDK-8236050: Some compiler tests fail when executed with custom TieredLevel
JDK-8234728: Some security tests should support TLSv1.3
JDK-8214916: SourceLauncherTest fails on exploded image
JDK-8237514: Spec Clarification - ByteBuffer::alignmentOffset Spec
JDK-8234445: spurious error message for record constructors with receiver parameters
JDK-8236779: static field in implementation class erroneously leaking in memory access javadoc
JDK-8236692: static final fields without initializer are accepted by javac
JDK-8234059: Stress test fails with "Unexpected Exception in thread JFR Event Stream"
JDK-8233751: StringBuilder / StringBuffer capacity() doc is misleading
JDK-8235452: Strip mined loop verification fails with assert(is_OuterStripMinedLoop()) failed: invalid node class
JDK-8234727: sun/security/ssl/X509TrustManagerImpl tests support TLSv1.3
JDK-8235813: System property fullCipherSuites is not used by javax/net/ssl/compatibility/Compatibility.java
JDK-8236364: TEMP vector registers could be incorrectly assigned upper bank xmm registers after Generic Operands (JDK-8234391)
JDK-8235338: test jdk/jshell/CompletenessTest.java fails for records
JDK-8225471: Test utility jdk.test.lib.util.FileUtils.areAllMountPointsAccessible needs to tolerate duplicates
JDK-8233866: Text in table cells has inconsistent alignment
JDK-8236944: The legVecZ operand should be limited to zmm0-zmm15 registers
JDK-8235874: The ordering of Cipher Suites is not maintained provided through “jdk.tls.client.cipherSuites” and “jdk.tls.server.cipherSuites” system property.
JDK-8235773: Tier3 fails because graalunit tests started to run with ZGC
JDK-8222100: tools/jimage/JImageTest.java time out
JDK-8222098: tools/jlink/plugins/IncludeLocalesPluginTest.java time out
JDK-8236945: typo "the the" in Lookup::in javadoc
JDK-8235959: Update --release 14 symbol information up to JDK 14 b31
JDK-8237058: Update all nroff manpages for JDK 14 release
JDK-8235634: Update Graal
JDK-8235869: Update Java manpage for JDK 14
JDK-8235514: Update record serialization tests to not use hard coded source versions
JDK-8235584: UseProfiledLoopPredicate fails with assert(_phase->get_loop(c) == loop) failed: have to be in the same loop
JDK-8234328: VectorSet::clear can cause fragmentation
JDK-8236000: VM build without C2 fails
JDK-8231501: VM crash in MethodData::clean_extra_data(CleanExtraDataClosure*): fatal error: unexpected tag 99
JDK-8236110: Windows (MSVC 2013) build failures after JDK-8233299
JDK-8236936: x86_32 Minimal VM build failure after JDK-8230765
JDK-8236546: Yield with boolean expression and Object target type crashes javac.
JDK-8235696: ZGC: assert(ZNMethod::is_armed(nm) == _should_disarm_nmethods) failed: Invalid state
JDK-8235760: ZGC: Implement precise check for @require vm.gc.Z for Windows
JDK-8235748: ZGC: Remove ZAddress::address()