OpenJDK / jdk / hs
changeset 44609:cf81fa72eb18
Merge
| author | duke |
|---|---|
| date | Wed, 05 Jul 2017 23:12:51 +0200 |
| parents | af711e46e07d adab7bc02f2a |
| children | a34001e206f9 |
| files | hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.test/src/org/graalvm/compiler/test/JLRModule.java hotspot/test/runtime/modules/java.base/java/lang/reflect/ModuleHelper.java jdk/src/java.base/share/classes/java/lang/reflect/Layer.java jdk/src/java.base/share/classes/java/lang/reflect/LayerInstantiationException.java jdk/src/java.base/share/classes/java/lang/reflect/Module.java jdk/src/java.base/share/classes/java/lang/reflect/WeakPairMap.java jdk/src/java.base/share/classes/jdk/internal/misc/JavaLangReflectModuleAccess.java jdk/test/java/lang/reflect/Layer/BasicLayerTest.java jdk/test/java/lang/reflect/Layer/LayerAndLoadersTest.java jdk/test/java/lang/reflect/Layer/LayerControllerTest.java jdk/test/java/lang/reflect/Layer/layertest/Test.java jdk/test/java/lang/reflect/Layer/src/m1/module-info.java jdk/test/java/lang/reflect/Layer/src/m1/p/Main.java jdk/test/java/lang/reflect/Layer/src/m1/p/Service.java jdk/test/java/lang/reflect/Layer/src/m2/module-info.java jdk/test/java/lang/reflect/Layer/src/m2/q/Hello.java jdk/test/java/lang/reflect/Layer/src/m3/module-info.java jdk/test/java/lang/reflect/Layer/src/m3/w/Hello.java jdk/test/java/lang/reflect/Layer/src/m4/impl/ServiceImpl.java jdk/test/java/lang/reflect/Layer/src/m4/module-info.java jdk/test/java/lang/reflect/Module/AddExportsTest.java jdk/test/java/lang/reflect/Module/AnnotationsTest.java jdk/test/java/lang/reflect/Module/BasicModuleTest.java jdk/test/java/lang/reflect/Module/WithSecurityManager.java jdk/test/java/lang/reflect/Module/access/AccessTest.java jdk/test/java/lang/reflect/Module/access/src/target/module-info.java jdk/test/java/lang/reflect/Module/access/src/target/p1/Helper.java jdk/test/java/lang/reflect/Module/access/src/target/p1/Public.java jdk/test/java/lang/reflect/Module/access/src/target/p2/NonPublic.java jdk/test/java/lang/reflect/Module/access/src/target/q1/Public.java jdk/test/java/lang/reflect/Module/access/src/target/q2/NonPublic.java jdk/test/java/lang/reflect/Module/access/src/test/module-info.java jdk/test/java/lang/reflect/Module/access/src/test/test/Main.java jdk/test/java/lang/reflect/Module/addXXX/Driver.java jdk/test/java/lang/reflect/Module/addXXX/m1/module-info.java jdk/test/java/lang/reflect/Module/addXXX/m1/p1/C.java jdk/test/java/lang/reflect/Module/addXXX/m2/module-info.java jdk/test/java/lang/reflect/Module/addXXX/m2/p2/C.java jdk/test/java/lang/reflect/Module/addXXX/m2/p2/internal/C.java jdk/test/java/lang/reflect/Module/addXXX/m3/module-info.java jdk/test/java/lang/reflect/Module/addXXX/m3/p3/C.java jdk/test/java/lang/reflect/Module/addXXX/m4/module-info.java jdk/test/java/lang/reflect/Module/addXXX/m4/p4/C.java jdk/test/java/lang/reflect/Module/addXXX/test/module-info.java jdk/test/java/lang/reflect/Module/addXXX/test/test/C.java jdk/test/java/lang/reflect/Module/addXXX/test/test/Main.java jdk/test/java/lang/reflect/Module/addXXX/test/test/Service.java jdk/test/java/lang/reflect/Module/allow.policy jdk/test/java/lang/reflect/Module/annotation/Basic.java jdk/test/java/lang/reflect/Module/annotation/src/m/module-info.java jdk/test/java/lang/reflect/Module/annotation/src/m/p/annotation/Bar.java jdk/test/java/lang/reflect/Module/annotation/src/m/p/annotation/Baz.java jdk/test/java/lang/reflect/Module/annotation/src/m/p/annotation/Foo.java jdk/test/java/lang/reflect/WeakPairMap/Driver.java jdk/test/java/lang/reflect/WeakPairMap/java.base/java/lang/reflect/WeakPairMapTest.java |
| diffstat | 616 files changed, 14001 insertions(+), 10408 deletions(-) [+] |
line wrap: on
line diff
--- a/.hgtags-top-repo Thu Apr 13 20:36:02 2017 +0000 +++ b/.hgtags-top-repo Wed Jul 05 23:12:51 2017 +0200 @@ -408,3 +408,4 @@ 21b063d75b3edbffb9bebc8872d990920c4ae1e5 jdk-9+162 c38c6b270ccc8e2b86d1631bcf42248241b54d2c jdk-9+163 7810f75d016a52e32295c4233009de5ca90e31af jdk-9+164 +aff4f339acd40942d3dab499846b52acd87b3af1 jdk-9+165
--- a/common/conf/jib-profiles.js Thu Apr 13 20:36:02 2017 +0000 +++ b/common/conf/jib-profiles.js Wed Jul 05 23:12:51 2017 +0200 @@ -882,7 +882,7 @@ jtreg: { server: "javare", revision: "4.2", - build_number: "b05", + build_number: "b07", checksum_file: "MD5_VALUES", file: "jtreg_bin-4.2.zip", environment_name: "JT_HOME",
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/doc/testing.html Wed Jul 05 23:12:51 2017 +0200 @@ -0,0 +1,112 @@ +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml"> +<head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Content-Style-Type" content="text/css" /> + <meta name="generator" content="pandoc" /> + <title>Testing OpenJDK</title> + <style type="text/css">code{white-space: pre;}</style> + <link rel="stylesheet" href="http://openjdk.java.net/page.css" type="text/css" /> + <style type="text/css">pre, code, tt { color: #1d6ae5; }</style> + <style type="text/css">pre { font-size: 10pt; }</style> +</head> +<body> +<div id="header"> +<h1 class="title">Testing OpenJDK</h1> +</div> +<div id="TOC"> +<ul> +<li><a href="#using-the-run-test-framework">Using the run-test framework</a></li> +<li><a href="#test-selection">Test selection</a><ul> +<li><a href="#jtreg">JTreg</a></li> +<li><a href="#gtest">Gtest</a></li> +</ul></li> +<li><a href="#test-results-and-summary">Test results and summary</a></li> +<li><a href="#test-suite-control">Test suite control</a><ul> +<li><a href="#jtreg-keywords">JTreg keywords</a></li> +<li><a href="#gtest-keywords">Gtest keywords</a></li> +</ul></li> +</ul> +</div> +<h2 id="using-the-run-test-framework">Using the run-test framework</h2> +<p>This new way of running tests is developer-centric. It assumes that you have built a jdk locally and want to test it. Running common test targets is simple, and more complex ad-hoc combination of tests is possible. The user interface is forgiving, and clearly report errors it cannot resolve.</p> +<p>Some example command-lines:</p> +<pre><code>$ make run-test-tier1 +$ make run-test-jdk_lang JTREG="JOBS=8" +$ make run-test TEST=jdk_lang +$ make run-test-only TEST="gtest:LogTagSet gtest:LogTagSetDescriptions" GTEST="REPEAT=-1" +$ make run-test TEST="hotspot/test:hotspot_gc" JTREG="JOBS=1;TIMEOUT=8;VM_OTIONS=-XshowSettings -Xlog:gc+ref=debug" +$ make run-test TEST="jtreg:hotspot/test:hotspot_gc hotspot/test/native_sanity/JniVersion.java"</code></pre> +<h2 id="test-selection">Test selection</h2> +<p>All functionality is available using the run-test make target. In this use case, the test or tests to be executed is controlled using the <code>TEST</code> variable. To speed up subsequent test runs with no source code changes, run-test-only can be used instead, which do not depend on the source and test image build.</p> +<p>For some common top-level tests, direct make targets have been generated. This includes all JTreg test groups, the hotspot gtest, and custom tests (if present). This means that <code>make run-test-tier1</code> is equivalent to <code>make run-test TEST="tier1"</code>, but the latter is more tab-completion friendly. For more complex test runs, the <code>run-test TEST="x"</code> solution needs to be used.</p> +<p>The test specifications given in <code>TEST</code> is parsed into fully qualified test descriptors, which clearly and unambigously show which tests will be run. As an example, <code>:tier1</code> will expand to <code>jtreg:jdk/test:tier1 jtreg:langtools/test:tier1 jtreg:nashorn/test:tier1 jtreg:jaxp/test:tier1</code>. You can always submit a list of fully qualified test descriptors in the <code>TEST</code> variable if you want to shortcut the parser.</p> +<h3 id="jtreg">JTreg</h3> +<p>JTreg test groups can be specified either without a test root, e.g. <code>:tier1</code> (or <code>tier1</code>, the initial colon is optional), or with, e.g. <code>hotspot/test:tier1</code>, <code>jdk/test:jdk_util</code>.</p> +<p>When specified without a test root, all matching groups from all tests roots will be added. Otherwise, only the group from the specified test root will be added.</p> +<p>Individual JTreg tests or directories containing JTreg tests can also be specified, like <code>hotspot/test/native_sanity/JniVersion.java</code> or <code>hotspot/test/native_sanity</code>. You can also specify an absolute path, to point to a JTreg test outside the source tree.</p> +<p>As long as the test groups or test paths can be uniquely resolved, you do not need to enter the <code>jtreg:</code> prefix. If this is not possible, or if you want to use a fully qualified test descriptor, add <code>jtreg:</code>, e.g. <code>jtreg:hotspot/test/native_sanity</code>.</p> +<h3 id="gtest">Gtest</h3> +<p>Since the Hotspot Gtest suite is so quick, the default is to run all tests. This is specified by just <code>gtest</code>, or as a fully qualified test descriptor <code>gtest:all</code>.</p> +<p>If you want, you can single out an individual test or a group of tests, for instance <code>gtest:LogDecorations</code> or <code>gtest:LogDecorations.level_test_vm</code>. This can be particularly useful if you want to run a shaky test repeatedly.</p> +<h2 id="test-results-and-summary">Test results and summary</h2> +<p>At the end of the test run, a summary of all tests run will be presented. This will have a consistent look, regardless of what test suites were used. This is a sample summary:</p> +<pre><code>============================== +Test summary +============================== + TEST TOTAL PASS FAIL ERROR +>> jtreg:jdk/test:tier1 1867 1865 2 0 << + jtreg:langtools/test:tier1 4711 4711 0 0 + jtreg:nashorn/test:tier1 133 133 0 0 +============================== +TEST FAILURE</code></pre> +<p>Tests where the number of TOTAL tests does not equal the number of PASSed tests will be considered a test failure. These are marked with the <code>>> ... <<</code> marker for easy identification.</p> +<p>The classification of non-passed tests differs a bit between test suites. In the summary, ERROR is used as a catch-all for tests that neither passed nor are classified as failed by the framework. This might indicate test framework error, timeout or other problems.</p> +<p>In case of test failures, <code>make run-test</code> will exit with a non-zero exit value.</p> +<p>All tests have their result stored in <code>build/$BUILD/test-result/$TEST_ID</code>, where TEST_ID is a path-safe conversion from the fully qualified test descriptor, e.g. for <code>jtreg:jdk/test:tier1</code> the TEST_ID is <code>jtreg_jdk_test_tier1</code>. This path is also printed in the log at the end of the test run.</p> +<p>Additional work data is stored in <code>build/$BUILD/test-support/$TEST_ID</code>. For some frameworks, this directory might contain information that is useful in determining the cause of a failed test.</p> +<h2 id="test-suite-control">Test suite control</h2> +<p>It is possible to control various aspects of the test suites using make control variables.</p> +<p>These variables use a keyword=value approach to allow multiple values to be set. So, for instance, <code>JTREG="JOBS=1;TIMEOUT=8"</code> will set the JTreg concurrency level to 1 and the timeout factor to 8. This is equivalent to setting <code>JTREG_JOBS=1 JTREG_TIMEOUT=8</code>, but using the keyword format means that the <code>JTREG</code> variable is parsed and verified for correctness, so <code>JTREG="TMIEOUT=8"</code> would give an error, while <code>JTREG_TMIEOUT=8</code> would just pass unnoticed.</p> +<p>To separate multiple keyword=value pairs, use <code>;</code> (semicolon). Since the shell normally eats <code>;</code>, the recommended usage is to write the assignment inside qoutes, e.g. <code>JTREG="...;..."</code>. This will also make sure spaces are preserved, as in <code>JTREG="VM_OTIONS=-XshowSettings -Xlog:gc+ref=debug"</code>.</p> +<p>(Other ways are possible, e.g. using backslash: <code>JTREG=JOBS=1\;TIMEOUT=8</code>. Also, as a special technique, the string <code>%20</code> will be replaced with space for certain options, e.g. <code>JTREG=VM_OTIONS=-XshowSettings%20-Xlog:gc+ref=debug</code>. This can be useful if you have layers of scripts and have trouble getting proper quoting of command line arguments through.)</p> +<p>As far as possible, the names of the keywords have been standardized between test suites.</p> +<h3 id="jtreg-keywords">JTreg keywords</h3> +<h4 id="jobs">JOBS</h4> +<p>The test concurrency (<code>-concurrency</code>).</p> +<p>Defaults to TEST_JOBS (if set by <code>--with-test-jobs=</code>), otherwise it defaults to JOBS, except for Hotspot, where the default is <em>number of CPU cores/2</em>, but never more than 12.</p> +<h4 id="timeout">TIMEOUT</h4> +<p>The timeout factor (<code>-timeoutFactor</code>).</p> +<p>Defaults to 4.</p> +<h4 id="test_mode">TEST_MODE</h4> +<p>The test mode (<code>-agentvm</code>, <code>-samevm</code> or <code>-othervm</code>).</p> +<p>Defaults to <code>-agentvm</code>.</p> +<h4 id="assert">ASSERT</h4> +<p>Enable asserts (<code>-ea -esa</code>, or none).</p> +<p>Set to <code>true</code> or <code>false</code>. If true, adds <code>-ea -esa</code>. Defaults to true, except for hotspot.</p> +<h4 id="verbose">VERBOSE</h4> +<p>The verbosity level (<code>-verbose</code>).</p> +<p>Defaults to <code>fail,error,summary</code>.</p> +<h4 id="retain">RETAIN</h4> +<p>What test data to retain (<code>-retain</code>).</p> +<p>Defaults to <code>fail,error</code>.</p> +<h4 id="max_mem">MAX_MEM</h4> +<p>Limit memory consumption (<code>-Xmx</code> and <code>-vmoption:-Xmx</code>, or none).</p> +<p>Limit memory consumption for JTreg test framework and VM under test. Set to 0 to disable the limits.</p> +<p>Defaults to 512m, except for hotspot, where it defaults to 0 (no limit).</p> +<h4 id="options">OPTIONS</h4> +<p>Additional options to the JTreg test framework.</p> +<p>Use <code>JTREG="OPTIONS=--help all"</code> to see all available JTreg options.</p> +<h4 id="java_options">JAVA_OPTIONS</h4> +<p>Additional Java options to JTreg (<code>-javaoption</code>).</p> +<h4 id="vm_options">VM_OPTIONS</h4> +<p>Additional VM options to JTreg (<code>-vmoption</code>).</p> +<h3 id="gtest-keywords">Gtest keywords</h3> +<h4 id="repeat">REPEAT</h4> +<p>The number of times to repeat the tests (<code>--gtest_repeat</code>).</p> +<p>Default is 1. Set to -1 to repeat indefinitely. This can be especially useful combined with <code>OPTIONS=--gtest_break_on_failure</code> to reproduce an intermittent problem.</p> +<h4 id="options-1">OPTIONS</h4> +<p>Additional options to the Gtest test framework.</p> +<p>Use <code>GTEST="OPTIONS=--help"</code> to see all available Gtest options.</p> +</body> +</html>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/doc/testing.md Wed Jul 05 23:12:51 2017 +0200 @@ -0,0 +1,207 @@ +% Testing OpenJDK + +## Using the run-test framework + +This new way of running tests is developer-centric. It assumes that you have +built a jdk locally and want to test it. Running common test targets is simple, +and more complex ad-hoc combination of tests is possible. The user interface is +forgiving, and clearly report errors it cannot resolve. + +Some example command-lines: + + $ make run-test-tier1 + $ make run-test-jdk_lang JTREG="JOBS=8" + $ make run-test TEST=jdk_lang + $ make run-test-only TEST="gtest:LogTagSet gtest:LogTagSetDescriptions" GTEST="REPEAT=-1" + $ make run-test TEST="hotspot/test:hotspot_gc" JTREG="JOBS=1;TIMEOUT=8;VM_OTIONS=-XshowSettings -Xlog:gc+ref=debug" + $ make run-test TEST="jtreg:hotspot/test:hotspot_gc hotspot/test/native_sanity/JniVersion.java" + +## Test selection + +All functionality is available using the run-test make target. In this use +case, the test or tests to be executed is controlled using the `TEST` variable. +To speed up subsequent test runs with no source code changes, run-test-only can +be used instead, which do not depend on the source and test image build. + +For some common top-level tests, direct make targets have been generated. This +includes all JTreg test groups, the hotspot gtest, and custom tests (if +present). This means that `make run-test-tier1` is equivalent to `make run-test +TEST="tier1"`, but the latter is more tab-completion friendly. For more complex +test runs, the `run-test TEST="x"` solution needs to be used. + +The test specifications given in `TEST` is parsed into fully qualified test +descriptors, which clearly and unambigously show which tests will be run. As an +example, `:tier1` will expand to `jtreg:jdk/test:tier1 +jtreg:langtools/test:tier1 jtreg:nashorn/test:tier1 jtreg:jaxp/test:tier1`. You +can always submit a list of fully qualified test descriptors in the `TEST` +variable if you want to shortcut the parser. + +### JTreg + +JTreg test groups can be specified either without a test root, e.g. `:tier1` +(or `tier1`, the initial colon is optional), or with, e.g. +`hotspot/test:tier1`, `jdk/test:jdk_util`. + +When specified without a test root, all matching groups from all tests roots +will be added. Otherwise, only the group from the specified test root will be +added. + +Individual JTreg tests or directories containing JTreg tests can also be +specified, like `hotspot/test/native_sanity/JniVersion.java` or +`hotspot/test/native_sanity`. You can also specify an absolute path, to point +to a JTreg test outside the source tree. + +As long as the test groups or test paths can be uniquely resolved, you do not +need to enter the `jtreg:` prefix. If this is not possible, or if you want to +use a fully qualified test descriptor, add `jtreg:`, e.g. +`jtreg:hotspot/test/native_sanity`. + +### Gtest + +Since the Hotspot Gtest suite is so quick, the default is to run all tests. +This is specified by just `gtest`, or as a fully qualified test descriptor +`gtest:all`. + +If you want, you can single out an individual test or a group of tests, for +instance `gtest:LogDecorations` or `gtest:LogDecorations.level_test_vm`. This +can be particularly useful if you want to run a shaky test repeatedly. + +## Test results and summary + +At the end of the test run, a summary of all tests run will be presented. This +will have a consistent look, regardless of what test suites were used. This is +a sample summary: + + ============================== + Test summary + ============================== + TEST TOTAL PASS FAIL ERROR + >> jtreg:jdk/test:tier1 1867 1865 2 0 << + jtreg:langtools/test:tier1 4711 4711 0 0 + jtreg:nashorn/test:tier1 133 133 0 0 + ============================== + TEST FAILURE + +Tests where the number of TOTAL tests does not equal the number of PASSed tests +will be considered a test failure. These are marked with the `>> ... <<` marker +for easy identification. + +The classification of non-passed tests differs a bit between test suites. In +the summary, ERROR is used as a catch-all for tests that neither passed nor are +classified as failed by the framework. This might indicate test framework +error, timeout or other problems. + +In case of test failures, `make run-test` will exit with a non-zero exit value. + +All tests have their result stored in `build/$BUILD/test-result/$TEST_ID`, +where TEST_ID is a path-safe conversion from the fully qualified test +descriptor, e.g. for `jtreg:jdk/test:tier1` the TEST_ID is +`jtreg_jdk_test_tier1`. This path is also printed in the log at the end of the +test run. + +Additional work data is stored in `build/$BUILD/test-support/$TEST_ID`. For +some frameworks, this directory might contain information that is useful in +determining the cause of a failed test. + +## Test suite control + +It is possible to control various aspects of the test suites using make control +variables. + +These variables use a keyword=value approach to allow multiple values to be +set. So, for instance, `JTREG="JOBS=1;TIMEOUT=8"` will set the JTreg +concurrency level to 1 and the timeout factor to 8. This is equivalent to +setting `JTREG_JOBS=1 JTREG_TIMEOUT=8`, but using the keyword format means that +the `JTREG` variable is parsed and verified for correctness, so +`JTREG="TMIEOUT=8"` would give an error, while `JTREG_TMIEOUT=8` would just +pass unnoticed. + +To separate multiple keyword=value pairs, use `;` (semicolon). Since the shell +normally eats `;`, the recommended usage is to write the assignment inside +qoutes, e.g. `JTREG="...;..."`. This will also make sure spaces are preserved, +as in `JTREG="VM_OTIONS=-XshowSettings -Xlog:gc+ref=debug"`. + +(Other ways are possible, e.g. using backslash: `JTREG=JOBS=1\;TIMEOUT=8`. +Also, as a special technique, the string `%20` will be replaced with space for +certain options, e.g. `JTREG=VM_OTIONS=-XshowSettings%20-Xlog:gc+ref=debug`. +This can be useful if you have layers of scripts and have trouble getting +proper quoting of command line arguments through.) + +As far as possible, the names of the keywords have been standardized between +test suites. + +### JTreg keywords + +#### JOBS +The test concurrency (`-concurrency`). + +Defaults to TEST_JOBS (if set by `--with-test-jobs=`), otherwise it defaults to +JOBS, except for Hotspot, where the default is *number of CPU cores/2*, but +never more than 12. + +#### TIMEOUT +The timeout factor (`-timeoutFactor`). + +Defaults to 4. + +#### TEST_MODE +The test mode (`-agentvm`, `-samevm` or `-othervm`). + +Defaults to `-agentvm`. + +#### ASSERT +Enable asserts (`-ea -esa`, or none). + +Set to `true` or `false`. If true, adds `-ea -esa`. Defaults to true, except +for hotspot. + +#### VERBOSE +The verbosity level (`-verbose`). + +Defaults to `fail,error,summary`. + +#### RETAIN +What test data to retain (`-retain`). + +Defaults to `fail,error`. + +#### MAX_MEM +Limit memory consumption (`-Xmx` and `-vmoption:-Xmx`, or none). + +Limit memory consumption for JTreg test framework and VM under test. Set to 0 +to disable the limits. + +Defaults to 512m, except for hotspot, where it defaults to 0 (no limit). + +#### OPTIONS +Additional options to the JTreg test framework. + +Use `JTREG="OPTIONS=--help all"` to see all available JTreg options. + +#### JAVA_OPTIONS +Additional Java options to JTreg (`-javaoption`). + +#### VM_OPTIONS +Additional VM options to JTreg (`-vmoption`). + +### Gtest keywords + +#### REPEAT +The number of times to repeat the tests (`--gtest_repeat`). + +Default is 1. Set to -1 to repeat indefinitely. This can be especially useful +combined with `OPTIONS=--gtest_break_on_failure` to reproduce an intermittent +problem. + +#### OPTIONS +Additional options to the Gtest test framework. + +Use `GTEST="OPTIONS=--help"` to see all available Gtest options. + +--- +# Override some definitions in http://openjdk.java.net/page.css that are +# unsuitable for this document. +header-includes: + - '<style type="text/css">pre, code, tt { color: #1d6ae5; }</style>' + - '<style type="text/css">pre { font-size: 10pt; }</style>' +---
--- a/corba/.hgtags Thu Apr 13 20:36:02 2017 +0000 +++ b/corba/.hgtags Wed Jul 05 23:12:51 2017 +0200 @@ -408,3 +408,4 @@ 18ffcf99a3b4a10457853d94190e825bdf07e39b jdk-9+162 493011dee80e51c2a2b064d049183c047df36d80 jdk-9+163 965bbae3072702f7c0d95c240523b65e6bb19261 jdk-9+164 +a510b2201154abdd12ede42788086b5283bfb9a6 jdk-9+165
--- a/hotspot/.hgtags Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/.hgtags Wed Jul 05 23:12:51 2017 +0200 @@ -568,3 +568,4 @@ b01c519b715ef6f785d0631adee0a6537cf6c12e jdk-9+162 983fe207555724d98f4876991e1cbafbcf2733e8 jdk-9+163 0af429be8bbaeaaf0cb838e9af28c953dda6a9c8 jdk-9+164 +c92c6416ca03b1464d5ed99cf6201e52b5ba0a70 jdk-9+165
--- a/hotspot/src/cpu/x86/vm/assembler_x86.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/cpu/x86/vm/assembler_x86.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -917,7 +917,7 @@ break; case 0x62: // EVEX_4bytes - assert((UseAVX > 0), "shouldn't have EVEX prefix"); + assert(VM_Version::supports_evex(), "shouldn't have EVEX prefix"); assert(ip == inst+1, "no prefixes allowed"); // no EVEX collisions, all instructions that have 0x62 opcodes // have EVEX versions and are subopcodes of 0x66
--- a/hotspot/src/cpu/x86/vm/nativeInst_x86.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/cpu/x86/vm/nativeInst_x86.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -365,6 +365,10 @@ NOT_LP64(assert((0xC0 & ubyte_at(1)) == 0xC0, "shouldn't have LDS and LES instructions")); return 3; } + if (instr_0 == instruction_EVEX_prefix_4bytes) { + assert(VM_Version::supports_evex(), "shouldn't have EVEX prefix"); + return 4; + } // First check to see if we have a (prefixed or not) xor if (instr_0 >= instruction_prefix_wide_lo && // 0x40
--- a/hotspot/src/cpu/x86/vm/nativeInst_x86.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/cpu/x86/vm/nativeInst_x86.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -356,6 +356,7 @@ instruction_VEX_prefix_2bytes = Assembler::VEX_2bytes, instruction_VEX_prefix_3bytes = Assembler::VEX_3bytes, + instruction_EVEX_prefix_4bytes = Assembler::EVEX_4bytes, instruction_size = 4, instruction_offset = 0,
--- a/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotConstantReflectionProvider.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotConstantReflectionProvider.java Wed Jul 05 23:12:51 2017 +0200 @@ -179,11 +179,14 @@ if (hotspotField.isStatic()) { HotSpotResolvedJavaType holder = (HotSpotResolvedJavaType) hotspotField.getDeclaringClass(); if (holder.isInitialized()) { - return memoryAccess.readUnsafeConstant(hotspotField.getJavaKind(), HotSpotObjectConstantImpl.forObject(holder.mirror()), hotspotField.offset()); + return memoryAccess.readFieldValue(hotspotField, holder.mirror()); } } else { - if (receiver.isNonNull() && hotspotField.isInObject(((HotSpotObjectConstantImpl) receiver).object())) { - return memoryAccess.readUnsafeConstant(hotspotField.getJavaKind(), receiver, hotspotField.offset()); + if (receiver.isNonNull()) { + Object object = ((HotSpotObjectConstantImpl) receiver).object(); + if (hotspotField.isInObject(object)) { + return memoryAccess.readFieldValue(hotspotField, object); + } } } return null;
--- a/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMemoryAccessProvider.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMemoryAccessProvider.java Wed Jul 05 23:12:51 2017 +0200 @@ -31,6 +31,10 @@ */ public interface HotSpotMemoryAccessProvider extends MemoryAccessProvider { + /** + * @throws IllegalArgumentException if the address computed from {@code base} and + * {@code displacement} does not denote a location holding a narrow oop + */ JavaConstant readNarrowOopConstant(Constant base, long displacement); Constant readKlassPointerConstant(Constant base, long displacement);
--- a/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMemoryAccessProviderImpl.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMemoryAccessProviderImpl.java Wed Jul 05 23:12:51 2017 +0200 @@ -22,13 +22,21 @@ */ package jdk.vm.ci.hotspot; +import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntimeProvider.getArrayBaseOffset; +import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntimeProvider.getArrayIndexScale; import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE; +import java.lang.reflect.Array; + +import jdk.vm.ci.common.JVMCIError; import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.MemoryAccessProvider; +import jdk.vm.ci.meta.MetaAccessProvider; import jdk.vm.ci.meta.PrimitiveConstant; +import jdk.vm.ci.meta.ResolvedJavaField; +import jdk.vm.ci.meta.ResolvedJavaType; /** * HotSpot implementation of {@link MemoryAccessProvider}. @@ -41,12 +49,93 @@ this.runtime = runtime; } - private static Object asObject(Constant base) { + /** + * Gets the object boxed by {@code base} that is about to have a value of kind {@code kind} read + * from it at the offset {@code displacement}. + * + * @param base constant value containing the base address for a pending read + * @return {@code null} if {@code base} does not box an object otherwise the object boxed in + * {@code base} + */ + private Object asObject(Constant base, JavaKind kind, long displacement) { if (base instanceof HotSpotObjectConstantImpl) { - return ((HotSpotObjectConstantImpl) base).object(); + HotSpotObjectConstantImpl constant = (HotSpotObjectConstantImpl) base; + HotSpotResolvedObjectType type = constant.getType(); + Object object = constant.object(); + checkRead(kind, displacement, type, object); + return object; + } + return null; + } + + /** + * Offset of injected {@code java.lang.Class::oop_size} field. No need to make {@code volatile} + * as initialization is idempotent. + */ + private long oopSizeOffset; + + private static int computeOopSizeOffset(HotSpotJVMCIRuntimeProvider runtime) { + MetaAccessProvider metaAccess = runtime.getHostJVMCIBackend().getMetaAccess(); + ResolvedJavaType staticType = metaAccess.lookupJavaType(Class.class); + for (ResolvedJavaField f : staticType.getInstanceFields(false)) { + if (f.getName().equals("oop_size")) { + int offset = ((HotSpotResolvedJavaField) f).offset(); + assert offset != 0 : "not expecting offset of java.lang.Class::oop_size to be 0"; + return offset; + } + } + throw new JVMCIError("Could not find injected java.lang.Class::oop_size field"); + } + + private boolean checkRead(JavaKind kind, long displacement, HotSpotResolvedObjectType type, Object object) { + if (type.isArray()) { + ResolvedJavaType componentType = type.getComponentType(); + JavaKind componentKind = componentType.getJavaKind(); + final int headerSize = getArrayBaseOffset(componentKind); + int sizeOfElement = getArrayIndexScale(componentKind); + int length = Array.getLength(object); + long arrayEnd = headerSize + (sizeOfElement * length); + boolean aligned = ((displacement - headerSize) % sizeOfElement) == 0; + if (displacement < 0 || displacement > (arrayEnd - sizeOfElement) || (kind == JavaKind.Object && !aligned)) { + int index = (int) ((displacement - headerSize) / sizeOfElement); + throw new AssertionError("Unsafe array access: reading element of kind " + kind + + " at offset " + displacement + " (index ~ " + index + ") in " + + type.toJavaName() + " object of length " + length); + } + } else if (kind != JavaKind.Object) { + long size; + if (object instanceof Class) { + if (oopSizeOffset == 0) { + oopSizeOffset = computeOopSizeOffset(runtime); + } + int wordSize = runtime.getHostJVMCIBackend().getCodeCache().getTarget().wordSize; + size = UNSAFE.getInt(object, oopSizeOffset) * wordSize; + } else { + size = Math.abs(type.instanceSize()); + } + int bytesToRead = kind.getByteCount(); + if (displacement + bytesToRead > size || displacement < 0) { + throw new IllegalArgumentException("Unsafe access: reading " + bytesToRead + " bytes at offset " + displacement + " in " + + type.toJavaName() + " object of size " + size); + } } else { - return null; + ResolvedJavaField field = type.findInstanceFieldWithOffset(displacement, JavaKind.Object); + if (field == null && object instanceof Class) { + // Read of a static field + MetaAccessProvider metaAccess = runtime.getHostJVMCIBackend().getMetaAccess(); + HotSpotResolvedObjectTypeImpl staticFieldsHolder = (HotSpotResolvedObjectTypeImpl) metaAccess.lookupJavaType((Class<?>) object); + field = staticFieldsHolder.findStaticFieldWithOffset(displacement, JavaKind.Object); + } + if (field == null) { + throw new IllegalArgumentException("Unsafe object access: field not found for read of kind Object" + + " at offset " + displacement + " in " + type.toJavaName() + " object"); + } + if (field.getJavaKind() != JavaKind.Object) { + throw new IllegalArgumentException("Unsafe object access: field " + field.format("%H.%n:%T") + " not of expected kind Object" + + " at offset " + displacement + " in " + type.toJavaName() + " object"); + } } + return true; } private boolean isValidObjectFieldDisplacement(Constant base, long displacement) { @@ -77,8 +166,8 @@ throw new IllegalArgumentException(String.valueOf(base)); } - private static long readRawValue(Constant baseConstant, long displacement, int bits) { - Object base = asObject(baseConstant); + private long readRawValue(Constant baseConstant, long displacement, JavaKind kind, int bits) { + Object base = asObject(baseConstant, kind, displacement); if (base != null) { switch (bits) { case Byte.SIZE: @@ -123,9 +212,8 @@ private Object readRawObject(Constant baseConstant, long initialDisplacement, boolean compressed) { long displacement = initialDisplacement; - Object ret; - Object base = asObject(baseConstant); + Object base = asObject(baseConstant, JavaKind.Object, displacement); if (base == null) { assert !compressed; displacement += asRawPointer(baseConstant); @@ -138,34 +226,43 @@ return ret; } - /** - * Reads a value of this kind using a base address and a displacement. No bounds checking or - * type checking is performed. Returns {@code null} if the value is not available at this point. - * - * @param baseConstant the base address from which the value is read. - * @param displacement the displacement within the object in bytes - * @return the read value encapsulated in a {@link JavaConstant} object, or {@code null} if the - * value cannot be read. - * @throws IllegalArgumentException if {@code kind} is {@code null}, {@link JavaKind#Void}, not - * {@link JavaKind#Object} or not {@linkplain JavaKind#isPrimitive() primitive} kind - */ - JavaConstant readUnsafeConstant(JavaKind kind, JavaConstant baseConstant, long displacement) { - if (kind == null) { - throw new IllegalArgumentException("null JavaKind"); - } - if (kind == JavaKind.Object) { - Object o = readRawObject(baseConstant, displacement, runtime.getConfig().useCompressedOops); + JavaConstant readFieldValue(HotSpotResolvedJavaField field, Object obj) { + assert obj != null; + assert !field.isStatic() || obj instanceof Class; + long displacement = field.offset(); + assert checkRead(field.getJavaKind(), displacement, (HotSpotResolvedObjectType) runtime.getHostJVMCIBackend().getMetaAccess().lookupJavaType(obj.getClass()), obj); + if (field.getJavaKind() == JavaKind.Object) { + Object o = UNSAFE.getObject(obj, displacement); return HotSpotObjectConstantImpl.forObject(o); } else { - int bits = kind.getByteCount() * Byte.SIZE; - return readPrimitiveConstant(kind, baseConstant, displacement, bits); + JavaKind kind = field.getJavaKind(); + switch (kind) { + case Boolean: + return JavaConstant.forBoolean(UNSAFE.getBoolean(obj, displacement)); + case Byte: + return JavaConstant.forByte(UNSAFE.getByte(obj, displacement)); + case Char: + return JavaConstant.forChar(UNSAFE.getChar(obj, displacement)); + case Short: + return JavaConstant.forShort(UNSAFE.getShort(obj, displacement)); + case Int: + return JavaConstant.forInt(UNSAFE.getInt(obj, displacement)); + case Long: + return JavaConstant.forLong(UNSAFE.getLong(obj, displacement)); + case Float: + return JavaConstant.forFloat(UNSAFE.getFloat(obj, displacement)); + case Double: + return JavaConstant.forDouble(UNSAFE.getDouble(obj, displacement)); + default: + throw new IllegalArgumentException("Unsupported kind: " + kind); + } } } @Override public JavaConstant readPrimitiveConstant(JavaKind kind, Constant baseConstant, long initialDisplacement, int bits) { try { - long rawValue = readRawValue(baseConstant, initialDisplacement, bits); + long rawValue = readRawValue(baseConstant, initialDisplacement, kind, bits); switch (kind) { case Boolean: return JavaConstant.forBoolean(rawValue != 0); @@ -193,6 +290,10 @@ @Override public JavaConstant readObjectConstant(Constant base, long displacement) { + if (base instanceof HotSpotObjectConstantImpl) { + Object o = readRawObject(base, displacement, runtime.getConfig().useCompressedOops); + return HotSpotObjectConstantImpl.forObject(o); + } if (!isValidObjectFieldDisplacement(base, displacement)) { return null; }
--- a/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java Wed Jul 05 23:12:51 2017 +0200 @@ -847,6 +847,15 @@ @Override public ResolvedJavaField findInstanceFieldWithOffset(long offset, JavaKind expectedEntryKind) { ResolvedJavaField[] declaredFields = getInstanceFields(true); + return findFieldWithOffset(offset, expectedEntryKind, declaredFields); + } + + public ResolvedJavaField findStaticFieldWithOffset(long offset, JavaKind expectedEntryKind) { + ResolvedJavaField[] declaredFields = getStaticFields(); + return findFieldWithOffset(offset, expectedEntryKind, declaredFields); + } + + private static ResolvedJavaField findFieldWithOffset(long offset, JavaKind expectedEntryKind, ResolvedJavaField[] declaredFields) { for (ResolvedJavaField field : declaredFields) { HotSpotResolvedJavaField resolvedField = (HotSpotResolvedJavaField) field; long resolvedFieldOffset = resolvedField.offset();
--- a/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/MemoryAccessProvider.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/MemoryAccessProvider.java Wed Jul 05 23:12:51 2017 +0200 @@ -35,9 +35,9 @@ * @param displacement the displacement within the object in bytes * @param bits the number of bits to read from memory * @return the read value encapsulated in a {@link JavaConstant} object of {@link JavaKind} kind - * @throws IllegalArgumentException if {@code kind} is {@link JavaKind#Void} or not - * {@linkplain JavaKind#isPrimitive() primitive} kind or {@code bits} is not 8, 16, - * 32 or 64 + * @throws IllegalArgumentException if the read is out of bounds of the object or {@code kind} + * is {@link JavaKind#Void} or not {@linkplain JavaKind#isPrimitive() primitive} + * kind or {@code bits} is not 8, 16, 32 or 64 */ JavaConstant readPrimitiveConstant(JavaKind kind, Constant base, long displacement, int bits) throws IllegalArgumentException; @@ -46,9 +46,9 @@ * * @param base the base address from which the value is read * @param displacement the displacement within the object in bytes - * @return the read value encapsulated in a {@link Constant} object or {@code null} if the - * address computed from {@code base} and {@code displacement} does not denote a - * location holding an {@code Object} value + * @return the read value encapsulated in a {@link Constant} object + * @throws IllegalArgumentException if the address computed from {@code base} and + * {@code displacement} does not denote a location holding an {@code Object} value */ JavaConstant readObjectConstant(Constant base, long displacement); }
--- a/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.services/src/jdk/vm/ci/services/Services.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.services/src/jdk/vm/ci/services/Services.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,6 +28,7 @@ import java.util.Iterator; import java.util.ServiceConfigurationError; import java.util.ServiceLoader; +import java.util.Set; /** * A mechanism for accessing service providers via JVMCI. @@ -108,7 +109,7 @@ Object jvmci = invoke(getModule, Services.class); Object requestorModule = invoke(getModule, requestor); if (jvmci != requestorModule) { - String[] packages = invoke(getPackages, jvmci); + Set<String> packages = invoke(getPackages, jvmci); for (String pkg : packages) { // Export all JVMCI packages dynamically instead // of requiring a long list of --add-exports
--- a/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/util/ModuleAPI.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/util/ModuleAPI.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -58,22 +58,22 @@ public static final ModuleAPI addExports; /** - * {@code java.lang.reflect.Module.getResourceAsStream(String)}. + * {@code java.lang.Module.getResourceAsStream(String)}. */ public static final ModuleAPI getResourceAsStream; /** - * {@code java.lang.reflect.Module.canRead(Module)}. + * {@code java.lang.Module.canRead(Module)}. */ public static final ModuleAPI canRead; /** - * {@code java.lang.reflect.Module.isExported(String)}. + * {@code java.lang.Module.isExported(String)}. */ public static final ModuleAPI isExported; /** - * {@code java.lang.reflect.Module.isExported(String, Module)}. + * {@code java.lang.Module.isExported(String, Module)}. */ public static final ModuleAPI isExportedTo;
--- a/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/phases/aot/EliminateRedundantInitializationPhase.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/phases/aot/EliminateRedundantInitializationPhase.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,9 +28,6 @@ import java.util.HashMap; import java.util.Map.Entry; -import jdk.vm.ci.hotspot.HotSpotMetaspaceConstant; -import jdk.vm.ci.meta.JavaConstant; - import org.graalvm.compiler.graph.Node; import org.graalvm.compiler.graph.iterators.NodeIterable; import org.graalvm.compiler.hotspot.nodes.aot.InitializeKlassNode; @@ -43,6 +40,9 @@ import org.graalvm.compiler.phases.BasePhase; import org.graalvm.compiler.phases.tiers.PhaseContext; +import jdk.vm.ci.hotspot.HotSpotMetaspaceConstant; +import jdk.vm.ci.meta.Constant; + public class EliminateRedundantInitializationPhase extends BasePhase<PhaseContext> { /** * Find blocks with class initializing nodes for the class identified the by the constant node. @@ -202,7 +202,7 @@ ControlFlowGraph cfg = ControlFlowGraph.compute(graph, true, false, true, false); ArrayList<Node> redundantInits = new ArrayList<>(); for (ConstantNode node : getConstantNodes(graph)) { - JavaConstant constant = node.asJavaConstant(); + Constant constant = node.asConstant(); if (constant instanceof HotSpotMetaspaceConstant) { redundantInits.addAll(processConstantNode(cfg, node)); }
--- a/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.test/src/org/graalvm/compiler/test/ExportingClassLoader.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.test/src/org/graalvm/compiler/test/ExportingClassLoader.java Wed Jul 05 23:12:51 2017 +0200 @@ -29,14 +29,14 @@ public class ExportingClassLoader extends ClassLoader { public ExportingClassLoader() { if (!GraalTest.Java8OrEarlier) { - JLRModule.fromClass(getClass()).exportAllPackagesTo(JLRModule.getUnnamedModuleFor(this)); + JLModule.fromClass(getClass()).exportAllPackagesTo(JLModule.getUnnamedModuleFor(this)); } } public ExportingClassLoader(ClassLoader parent) { super(parent); if (!GraalTest.Java8OrEarlier) { - JLRModule.fromClass(getClass()).exportAllPackagesTo(JLRModule.getUnnamedModuleFor(this)); + JLModule.fromClass(getClass()).exportAllPackagesTo(JLModule.getUnnamedModuleFor(this)); } } }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.test/src/org/graalvm/compiler/test/JLModule.java Wed Jul 05 23:12:51 2017 +0200 @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package org.graalvm.compiler.test; + +import java.lang.reflect.Method; +import java.util.Set; + +/** + * Facade for the {@code java.lang.Module} class introduced in JDK9 that allows tests to be + * developed against JDK8 but use module logic if deployed on JDK9. + */ +public class JLModule { + + static { + if (GraalTest.Java8OrEarlier) { + throw new AssertionError("Use of " + JLModule.class + " only allowed if " + GraalTest.class.getName() + ".JDK8OrEarlier is false"); + } + } + + private final Object realModule; + + public JLModule(Object module) { + this.realModule = module; + } + + private static final Class<?> moduleClass; + private static final Method getModuleMethod; + private static final Method getUnnamedModuleMethod; + private static final Method getPackagesMethod; + private static final Method isExportedMethod; + private static final Method isExported2Method; + private static final Method addExportsMethod; + static { + try { + moduleClass = Class.forName("java.lang.Module"); + getModuleMethod = Class.class.getMethod("getModule"); + getUnnamedModuleMethod = ClassLoader.class.getMethod("getUnnamedModule"); + getPackagesMethod = moduleClass.getMethod("getPackages"); + isExportedMethod = moduleClass.getMethod("isExported", String.class); + isExported2Method = moduleClass.getMethod("isExported", String.class, moduleClass); + addExportsMethod = moduleClass.getMethod("addExports", String.class, moduleClass); + } catch (Exception e) { + throw new AssertionError(e); + } + } + + public static JLModule fromClass(Class<?> cls) { + try { + return new JLModule(getModuleMethod.invoke(cls)); + } catch (Exception e) { + throw new AssertionError(e); + } + } + + public static JLModule getUnnamedModuleFor(ClassLoader cl) { + try { + return new JLModule(getUnnamedModuleMethod.invoke(cl)); + } catch (Exception e) { + throw new AssertionError(e); + } + } + + /** + * Exports all packages in this module to a given module. + */ + public void exportAllPackagesTo(JLModule module) { + if (this != module) { + for (String pkg : getPackages()) { + // Export all JVMCI packages dynamically instead + // of requiring a long list of -XaddExports + // options on the JVM command line. + if (!isExported(pkg, module)) { + addExports(pkg, module); + } + } + } + } + + public Set<String> getPackages() { + try { + return (Set<String>) getPackagesMethod.invoke(realModule); + } catch (Exception e) { + throw new AssertionError(e); + } + } + + public boolean isExported(String pn) { + try { + return (Boolean) isExportedMethod.invoke(realModule, pn); + } catch (Exception e) { + throw new AssertionError(e); + } + } + + public boolean isExported(String pn, JLModule other) { + try { + return (Boolean) isExported2Method.invoke(realModule, pn, other.realModule); + } catch (Exception e) { + throw new AssertionError(e); + } + } + + public void addExports(String pn, JLModule other) { + try { + addExportsMethod.invoke(realModule, pn, other.realModule); + } catch (Exception e) { + throw new AssertionError(e); + } + } +}
--- a/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.test/src/org/graalvm/compiler/test/JLRModule.java Thu Apr 13 20:36:02 2017 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,129 +0,0 @@ -/* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package org.graalvm.compiler.test; - -import java.lang.reflect.Method; - -/** - * Facade for the {@code java.lang.reflect.Module} class introduced in JDK9 that allows tests to be - * developed against JDK8 but use module logic if deployed on JDK9. - */ -public class JLRModule { - - static { - if (GraalTest.Java8OrEarlier) { - throw new AssertionError("Use of " + JLRModule.class + " only allowed if " + GraalTest.class.getName() + ".JDK8OrEarlier is false"); - } - } - - private final Object realModule; - - public JLRModule(Object module) { - this.realModule = module; - } - - private static final Class<?> moduleClass; - private static final Method getModuleMethod; - private static final Method getUnnamedModuleMethod; - private static final Method getPackagesMethod; - private static final Method isExportedMethod; - private static final Method isExported2Method; - private static final Method addExportsMethod; - static { - try { - moduleClass = Class.forName("java.lang.reflect.Module"); - getModuleMethod = Class.class.getMethod("getModule"); - getUnnamedModuleMethod = ClassLoader.class.getMethod("getUnnamedModule"); - getPackagesMethod = moduleClass.getMethod("getPackages"); - isExportedMethod = moduleClass.getMethod("isExported", String.class); - isExported2Method = moduleClass.getMethod("isExported", String.class, moduleClass); - addExportsMethod = moduleClass.getMethod("addExports", String.class, moduleClass); - } catch (Exception e) { - throw new AssertionError(e); - } - } - - public static JLRModule fromClass(Class<?> cls) { - try { - return new JLRModule(getModuleMethod.invoke(cls)); - } catch (Exception e) { - throw new AssertionError(e); - } - } - - public static JLRModule getUnnamedModuleFor(ClassLoader cl) { - try { - return new JLRModule(getUnnamedModuleMethod.invoke(cl)); - } catch (Exception e) { - throw new AssertionError(e); - } - } - - /** - * Exports all packages in this module to a given module. - */ - public void exportAllPackagesTo(JLRModule module) { - if (this != module) { - for (String pkg : getPackages()) { - // Export all JVMCI packages dynamically instead - // of requiring a long list of -XaddExports - // options on the JVM command line. - if (!isExported(pkg, module)) { - addExports(pkg, module); - } - } - } - } - - public String[] getPackages() { - try { - return (String[]) getPackagesMethod.invoke(realModule); - } catch (Exception e) { - throw new AssertionError(e); - } - } - - public boolean isExported(String pn) { - try { - return (Boolean) isExportedMethod.invoke(realModule, pn); - } catch (Exception e) { - throw new AssertionError(e); - } - } - - public boolean isExported(String pn, JLRModule other) { - try { - return (Boolean) isExported2Method.invoke(realModule, pn, other.realModule); - } catch (Exception e) { - throw new AssertionError(e); - } - } - - public void addExports(String pn, JLRModule other) { - try { - addExportsMethod.invoke(realModule, pn, other.realModule); - } catch (Exception e) { - throw new AssertionError(e); - } - } -}
--- a/hotspot/src/share/vm/classfile/classFileParser.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/classFileParser.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -5406,7 +5406,7 @@ ModuleEntry* module_entry = ik->module(); assert(module_entry != NULL, "module_entry should always be set"); - // Obtain java.lang.reflect.Module + // Obtain java.lang.Module Handle module_handle(THREAD, JNIHandles::resolve(module_entry->module())); // Allocate mirror and initialize static fields
--- a/hotspot/src/share/vm/classfile/javaClasses.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/javaClasses.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -773,13 +773,13 @@ InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, mirror, CHECK); } -// Set the java.lang.reflect.Module module field in the java_lang_Class mirror +// Set the java.lang.Module module field in the java_lang_Class mirror void java_lang_Class::set_mirror_module_field(KlassHandle k, Handle mirror, Handle module, TRAPS) { if (module.is_null()) { // During startup, the module may be NULL only if java.base has not been defined yet. - // Put the class on the fixup_module_list to patch later when the java.lang.reflect.Module + // Put the class on the fixup_module_list to patch later when the java.lang.Module // for java.base is known. - assert(!Universe::is_module_initialized(), "Incorrect java.lang.reflect.Module pre module system initialization"); + assert(!Universe::is_module_initialized(), "Incorrect java.lang.Module pre module system initialization"); bool javabase_was_defined = false; { @@ -810,7 +810,7 @@ assert(Universe::is_module_initialized() || (ModuleEntryTable::javabase_defined() && (module() == JNIHandles::resolve(ModuleEntryTable::javabase_moduleEntry()->module()))), - "Incorrect java.lang.reflect.Module specification while creating mirror"); + "Incorrect java.lang.Module specification while creating mirror"); set_module(mirror(), module()); } } @@ -2804,28 +2804,28 @@ } -int java_lang_reflect_Module::loader_offset; -int java_lang_reflect_Module::name_offset; -int java_lang_reflect_Module::_module_entry_offset = -1; - -Handle java_lang_reflect_Module::create(Handle loader, Handle module_name, TRAPS) { +int java_lang_Module::loader_offset; +int java_lang_Module::name_offset; +int java_lang_Module::_module_entry_offset = -1; + +Handle java_lang_Module::create(Handle loader, Handle module_name, TRAPS) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); - Symbol* name = vmSymbols::java_lang_reflect_Module(); + Symbol* name = vmSymbols::java_lang_Module(); Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); instanceKlassHandle klass (THREAD, k); - Handle jlrmh = klass->allocate_instance_handle(CHECK_NH); + Handle jlmh = klass->allocate_instance_handle(CHECK_NH); JavaValue result(T_VOID); - JavaCalls::call_special(&result, jlrmh, KlassHandle(THREAD, klass()), + JavaCalls::call_special(&result, jlmh, KlassHandle(THREAD, klass()), vmSymbols::object_initializer_name(), - vmSymbols::java_lang_reflect_module_init_signature(), + vmSymbols::java_lang_module_init_signature(), loader, module_name, CHECK_NH); - return jlrmh; -} - -void java_lang_reflect_Module::compute_offsets() { - Klass* k = SystemDictionary::reflect_Module_klass(); + return jlmh; +} + +void java_lang_Module::compute_offsets() { + Klass* k = SystemDictionary::Module_klass(); if(NULL != k) { compute_offset(loader_offset, k, vmSymbols::loader_name(), vmSymbols::classloader_signature()); compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); @@ -2834,27 +2834,27 @@ } -oop java_lang_reflect_Module::loader(oop module) { +oop java_lang_Module::loader(oop module) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); return module->obj_field(loader_offset); } -void java_lang_reflect_Module::set_loader(oop module, oop value) { +void java_lang_Module::set_loader(oop module, oop value) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); module->obj_field_put(loader_offset, value); } -oop java_lang_reflect_Module::name(oop module) { +oop java_lang_Module::name(oop module) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); return module->obj_field(name_offset); } -void java_lang_reflect_Module::set_name(oop module, oop value) { +void java_lang_Module::set_name(oop module, oop value) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); module->obj_field_put(name_offset, value); } -ModuleEntry* java_lang_reflect_Module::module_entry(oop module, TRAPS) { +ModuleEntry* java_lang_Module::module_entry(oop module, TRAPS) { assert(_module_entry_offset != -1, "Uninitialized module_entry_offset"); assert(module != NULL, "module can't be null"); assert(module->is_oop(), "module must be oop"); @@ -2863,7 +2863,7 @@ if (module_entry == NULL) { // If the inject field containing the ModuleEntry* is null then return the // class loader's unnamed module. - oop loader = java_lang_reflect_Module::loader(module); + oop loader = java_lang_Module::loader(module); Handle h_loader = Handle(THREAD, loader); ClassLoaderData* loader_cld = SystemDictionary::register_loader(h_loader, CHECK_NULL); return loader_cld->modules()->unnamed_module(); @@ -2871,7 +2871,7 @@ return module_entry; } -void java_lang_reflect_Module::set_module_entry(oop module, ModuleEntry* module_entry) { +void java_lang_Module::set_module_entry(oop module, ModuleEntry* module_entry) { assert(_module_entry_offset != -1, "Uninitialized module_entry_offset"); assert(module != NULL, "module can't be null"); assert(module->is_oop(), "module must be oop"); @@ -3877,7 +3877,7 @@ reflect_ConstantPool::compute_offsets(); reflect_UnsafeStaticFieldAccessorImpl::compute_offsets(); java_lang_reflect_Parameter::compute_offsets(); - java_lang_reflect_Module::compute_offsets(); + java_lang_Module::compute_offsets(); java_lang_StackFrameInfo::compute_offsets(); java_lang_LiveStackFrameInfo::compute_offsets();
--- a/hotspot/src/share/vm/classfile/javaClasses.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/javaClasses.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -755,9 +755,9 @@ }; #define MODULE_INJECTED_FIELDS(macro) \ - macro(java_lang_reflect_Module, module_entry, intptr_signature, false) + macro(java_lang_Module, module_entry, intptr_signature, false) -class java_lang_reflect_Module { +class java_lang_Module { private: static int loader_offset; static int name_offset;
--- a/hotspot/src/share/vm/classfile/javaClasses.inline.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/javaClasses.inline.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -162,8 +162,8 @@ return obj != NULL && is_subclass(obj->klass()); } -inline bool java_lang_reflect_Module::is_instance(oop obj) { - return obj != NULL && obj->klass() == SystemDictionary::reflect_Module_klass(); +inline bool java_lang_Module::is_instance(oop obj) { + return obj != NULL && obj->klass() == SystemDictionary::Module_klass(); } inline int Backtrace::merge_bci_and_version(int bci, int version) {
--- a/hotspot/src/share/vm/classfile/moduleEntry.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/moduleEntry.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -266,19 +266,19 @@ // Each ModuleEntryTable has exactly one unnamed module if (loader_data->is_the_null_class_loader_data()) { - // For the boot loader, the java.lang.reflect.Module for the unnamed module + // For the boot loader, the java.lang.Module for the unnamed module // is not known until a call to JVM_SetBootLoaderUnnamedModule is made. At // this point initially create the ModuleEntry for the unnamed module. _unnamed_module = new_entry(0, Handle(NULL), NULL, NULL, NULL, loader_data); } else { - // For all other class loaders the java.lang.reflect.Module for their + // For all other class loaders the java.lang.Module for their // corresponding unnamed module can be found in the java.lang.ClassLoader object. oop module = java_lang_ClassLoader::unnamedModule(loader_data->class_loader()); _unnamed_module = new_entry(0, Handle(module), NULL, NULL, NULL, loader_data); - // Store pointer to the ModuleEntry in the unnamed module's java.lang.reflect.Module + // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module // object. - java_lang_reflect_Module::set_module_entry(module, _unnamed_module); + java_lang_Module::set_module_entry(module, _unnamed_module); } // Add to bucket 0, no name to hash on @@ -388,27 +388,27 @@ fatal("Unable to finalize module definition for " JAVA_BASE_NAME); } - // Set java.lang.reflect.Module, version and location for java.base + // Set java.lang.Module, version and location for java.base ModuleEntry* jb_module = javabase_moduleEntry(); assert(jb_module != NULL, JAVA_BASE_NAME " ModuleEntry not defined"); jb_module->set_version(version); jb_module->set_location(location); // Once java.base's ModuleEntry _module field is set with the known - // java.lang.reflect.Module, java.base is considered "defined" to the VM. + // java.lang.Module, java.base is considered "defined" to the VM. jb_module->set_module(boot_loader_data->add_handle(module_handle)); - // Store pointer to the ModuleEntry for java.base in the java.lang.reflect.Module object. - java_lang_reflect_Module::set_module_entry(module_handle(), jb_module); + // Store pointer to the ModuleEntry for java.base in the java.lang.Module object. + java_lang_Module::set_module_entry(module_handle(), jb_module); } -// Within java.lang.Class instances there is a java.lang.reflect.Module field -// that must be set with the defining module. During startup, prior to java.base's -// definition, classes needing their module field set are added to the fixup_module_list. -// Their module field is set once java.base's java.lang.reflect.Module is known to the VM. +// Within java.lang.Class instances there is a java.lang.Module field that must +// be set with the defining module. During startup, prior to java.base's definition, +// classes needing their module field set are added to the fixup_module_list. +// Their module field is set once java.base's java.lang.Module is known to the VM. void ModuleEntryTable::patch_javabase_entries(Handle module_handle) { if (module_handle.is_null()) { fatal("Unable to patch the module field of classes loaded prior to " - JAVA_BASE_NAME "'s definition, invalid java.lang.reflect.Module"); + JAVA_BASE_NAME "'s definition, invalid java.lang.Module"); } // Do the fixups for the basic primitive types
--- a/hotspot/src/share/vm/classfile/moduleEntry.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/moduleEntry.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -45,7 +45,7 @@ // A ModuleEntry describes a module that has been defined by a call to JVM_DefineModule. // It contains: // - Symbol* containing the module's name. -// - pointer to the java.lang.reflect.Module for this module. +// - pointer to the java.lang.Module for this module. // - pointer to the java.security.ProtectionDomain shared by classes defined to this module. // - ClassLoaderData*, class loader of this module. // - a growable array containg other module entries that this module can read. @@ -55,7 +55,7 @@ // data structure. class ModuleEntry : public HashtableEntry<Symbol*, mtModule> { private: - jobject _module; // java.lang.reflect.Module + jobject _module; // java.lang.Module jobject _pd; // java.security.ProtectionDomain, cached // for shared classes from this module ClassLoaderData* _loader_data;
--- a/hotspot/src/share/vm/classfile/modules.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/modules.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -62,7 +62,7 @@ } static char* get_module_name(oop module, TRAPS) { - oop name_oop = java_lang_reflect_Module::name(module); + oop name_oop = java_lang_Module::name(module); if (name_oop == NULL) { THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), "Null module name"); } @@ -98,11 +98,11 @@ static ModuleEntry* get_module_entry(jobject module, TRAPS) { Handle module_h(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(module_h())) { + if (!java_lang_Module::is_instance(module_h())) { THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), - "module is not an instance of type java.lang.reflect.Module"); + "module is not an instance of type java.lang.Module"); } - return java_lang_reflect_Module::module_entry(module_h(), CHECK_NULL); + return java_lang_Module::module_entry(module_h(), CHECK_NULL); } static PackageEntry* get_package_entry(ModuleEntry* module_entry, const char* package_name, TRAPS) { @@ -181,7 +181,7 @@ } // Validate java_base's loader is the boot loader. - oop loader = java_lang_reflect_Module::loader(module_handle()); + oop loader = java_lang_Module::loader(module_handle()); if (loader != NULL) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Class loader must be the boot class loader"); @@ -234,7 +234,7 @@ // Only the thread that actually defined the base module will get here, // so no locking is needed. - // Patch any previously loaded class's module field with java.base's java.lang.reflect.Module. + // Patch any previously loaded class's module field with java.base's java.lang.Module. ModuleEntryTable::patch_javabase_entries(module_handle); log_debug(modules)("define_javabase_module(): Definition of module: " @@ -284,9 +284,9 @@ } Handle module_handle(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(module_handle())) { + if (!java_lang_Module::is_instance(module_handle())) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), - "module is not an instance of type java.lang.reflect.Module"); + "module is not an instance of type java.lang.Module"); } char* module_name = get_module_name(module_handle(), CHECK); @@ -303,7 +303,7 @@ const char* module_version = get_module_version(version); - oop loader = java_lang_reflect_Module::loader(module_handle()); + oop loader = java_lang_Module::loader(module_handle()); // Make sure loader is not the jdk.internal.reflect.DelegatingClassLoader. if (loader != java_lang_ClassLoader::non_reflection_class_loader(loader)) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), @@ -424,8 +424,8 @@ pkg_list->at(y)->decrement_refcount(); } - // Store pointer to ModuleEntry record in java.lang.reflect.Module object. - java_lang_reflect_Module::set_module_entry(module_handle(), module_entry); + // Store pointer to ModuleEntry record in java.lang.Module object. + java_lang_Module::set_module_entry(module_handle(), module_entry); } } } // Release the lock @@ -467,20 +467,20 @@ THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object"); } Handle module_handle(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(module_handle())) { + if (!java_lang_Module::is_instance(module_handle())) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), - "module is not an instance of type java.lang.reflect.Module"); + "module is not an instance of type java.lang.Module"); } // Ensure that this is an unnamed module - oop name = java_lang_reflect_Module::name(module_handle()); + oop name = java_lang_Module::name(module_handle()); if (name != NULL) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), - "boot loader's unnamed module's java.lang.reflect.Module has a name"); + "boot loader's unnamed module's java.lang.Module has a name"); } // Validate java_base's loader is the boot loader. - oop loader = java_lang_reflect_Module::loader(module_handle()); + oop loader = java_lang_Module::loader(module_handle()); if (loader != NULL) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Class loader must be the boot class loader"); @@ -492,12 +492,12 @@ // Ensure the boot loader's PackageEntryTable has been created ModuleEntryTable* module_table = get_module_entry_table(h_loader, CHECK); - // Set java.lang.reflect.Module for the boot loader's unnamed module + // Set java.lang.Module for the boot loader's unnamed module ModuleEntry* unnamed_module = module_table->unnamed_module(); assert(unnamed_module != NULL, "boot loader's unnamed ModuleEntry not defined"); unnamed_module->set_module(ClassLoaderData::the_null_class_loader_data()->add_handle(module_handle)); - // Store pointer to the ModuleEntry in the unnamed module's java.lang.reflect.Module object. - java_lang_reflect_Module::set_module_entry(module_handle(), unnamed_module); + // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object. + java_lang_Module::set_module_entry(module_handle(), unnamed_module); } void Modules::add_module_exports(jobject from_module, const char* package_name, jobject to_module, TRAPS) { @@ -627,13 +627,13 @@ oop module = java_lang_Class::module(mirror); assert(module != NULL, "java.lang.Class module field not set"); - assert(java_lang_reflect_Module::is_instance(module), "module is not an instance of type java.lang.reflect.Module"); + assert(java_lang_Module::is_instance(module), "module is not an instance of type java.lang.Module"); if (log_is_enabled(Debug, modules)) { ResourceMark rm(THREAD); outputStream* logst = Log(modules)::debug_stream(); Klass* klass = java_lang_Class::as_Klass(mirror); - oop module_name = java_lang_reflect_Module::name(module); + oop module_name = java_lang_Module::name(module); if (module_name != NULL) { logst->print("get_module(): module "); java_lang_String::print(module_name, tty);
--- a/hotspot/src/share/vm/classfile/modules.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/modules.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* -* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. +* Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -55,12 +55,12 @@ jstring location, const char* const* packages, jsize num_packages, TRAPS); - // Provides the java.lang.reflect.Module for the unnamed module defined + // Provides the java.lang.Module for the unnamed module defined // to the boot loader. // // IllegalArgumentExceptions are thrown for the following : // * Module has a name - // * Module is not a subclass of java.lang.reflect.Module + // * Module is not a subclass of java.lang.Module // * Module's class loader is not the boot loader // NullPointerExceptions are thrown if module is null. static void set_bootloader_unnamed_module(jobject module, TRAPS); @@ -96,10 +96,10 @@ // module does not exist. static void add_reads_module(jobject from_module, jobject to_module, TRAPS); - // Return the java.lang.reflect.Module object for this class object. + // Return the java.lang.Module object for this class object. static jobject get_module(jclass clazz, TRAPS); - // Return the java.lang.reflect.Module object for this class loader and package. + // Return the java.lang.Module object for this class loader and package. // Returns NULL if the class loader has not loaded any classes in the package. // The package should contain /'s, not .'s, as in java/lang, not java.lang. // NullPointerException is thrown if package is null. @@ -109,7 +109,7 @@ static jobject get_named_module(Handle h_loader, const char* package, TRAPS); // If package is defined by loader, return the - // java.lang.reflect.Module object for the module in which the package is defined. + // java.lang.Module object for the module in which the package is defined. // Returns NULL if package is invalid or not defined by loader. static jobject get_module(Symbol* package_name, Handle h_loader, TRAPS);
--- a/hotspot/src/share/vm/classfile/systemDictionary.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/systemDictionary.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -133,9 +133,9 @@ do_klass(Thread_klass, java_lang_Thread, Pre ) \ do_klass(ThreadGroup_klass, java_lang_ThreadGroup, Pre ) \ do_klass(Properties_klass, java_util_Properties, Pre ) \ + do_klass(Module_klass, java_lang_Module, Pre ) \ do_klass(reflect_AccessibleObject_klass, java_lang_reflect_AccessibleObject, Pre ) \ do_klass(reflect_Field_klass, java_lang_reflect_Field, Pre ) \ - do_klass(reflect_Module_klass, java_lang_reflect_Module, Pre ) \ do_klass(reflect_Parameter_klass, java_lang_reflect_Parameter, Opt ) \ do_klass(reflect_Method_klass, java_lang_reflect_Method, Pre ) \ do_klass(reflect_Constructor_klass, java_lang_reflect_Constructor, Pre ) \
--- a/hotspot/src/share/vm/classfile/vmSymbols.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -56,6 +56,7 @@ template(java_lang_Object, "java/lang/Object") \ template(java_lang_Class, "java/lang/Class") \ template(java_lang_Package, "java/lang/Package") \ + template(java_lang_Module, "java/lang/Module") \ template(java_lang_String, "java/lang/String") \ template(java_lang_StringLatin1, "java/lang/StringLatin1") \ template(java_lang_StringUTF16, "java/lang/StringUTF16") \ @@ -90,7 +91,6 @@ template(java_lang_reflect_Method, "java/lang/reflect/Method") \ template(java_lang_reflect_Constructor, "java/lang/reflect/Constructor") \ template(java_lang_reflect_Field, "java/lang/reflect/Field") \ - template(java_lang_reflect_Module, "java/lang/reflect/Module") \ template(java_lang_reflect_Parameter, "java/lang/reflect/Parameter") \ template(java_lang_reflect_Array, "java/lang/reflect/Array") \ template(java_lang_StringBuffer, "java/lang/StringBuffer") \ @@ -136,7 +136,7 @@ template(initPhase1_name, "initPhase1") \ template(initPhase2_name, "initPhase2") \ template(initPhase3_name, "initPhase3") \ - template(java_lang_reflect_module_init_signature, "(Ljava/lang/ClassLoader;Ljava/lang/String;)V") \ + template(java_lang_module_init_signature, "(Ljava/lang/ClassLoader;Ljava/lang/String;)V") \ \ /* class file format tags */ \ template(tag_source_file, "SourceFile") \ @@ -450,7 +450,7 @@ template(getModule_name, "getModule") \ template(input_stream_void_signature, "(Ljava/io/InputStream;)V") \ template(definePackage_name, "definePackage") \ - template(definePackage_signature, "(Ljava/lang/String;Ljava/lang/reflect/Module;)Ljava/lang/Package;") \ + template(definePackage_signature, "(Ljava/lang/String;Ljava/lang/Module;)Ljava/lang/Package;") \ template(defineOrCheckPackage_name, "defineOrCheckPackage") \ template(defineOrCheckPackage_signature, "(Ljava/lang/String;Ljava/util/jar/Manifest;Ljava/net/URL;)Ljava/lang/Package;") \ template(fileToEncodedURL_name, "fileToEncodedURL") \ @@ -532,7 +532,7 @@ template(void_class_signature, "()Ljava/lang/Class;") \ template(void_class_array_signature, "()[Ljava/lang/Class;") \ template(void_string_signature, "()Ljava/lang/String;") \ - template(void_module_signature, "()Ljava/lang/reflect/Module;") \ + template(void_module_signature, "()Ljava/lang/Module;") \ template(object_array_object_signature, "([Ljava/lang/Object;)Ljava/lang/Object;") \ template(object_object_array_object_signature, "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;")\ template(exception_void_signature, "(Ljava/lang/Exception;)V") \ @@ -552,7 +552,7 @@ template(reference_signature, "Ljava/lang/ref/Reference;") \ template(sun_misc_Cleaner_signature, "Lsun/misc/Cleaner;") \ template(executable_signature, "Ljava/lang/reflect/Executable;") \ - template(module_signature, "Ljava/lang/reflect/Module;") \ + template(module_signature, "Ljava/lang/Module;") \ template(concurrenthashmap_signature, "Ljava/util/concurrent/ConcurrentHashMap;") \ template(String_StringBuilder_signature, "(Ljava/lang/String;)Ljava/lang/StringBuilder;") \ template(int_StringBuilder_signature, "(I)Ljava/lang/StringBuilder;") \ @@ -642,16 +642,16 @@ template(jdk_internal_module_Modules, "jdk/internal/module/Modules") \ template(jdk_internal_vm_VMSupport, "jdk/internal/vm/VMSupport") \ template(addReads_name, "addReads") \ - template(addReads_signature, "(Ljava/lang/reflect/Module;Ljava/lang/reflect/Module;)V") \ + template(addReads_signature, "(Ljava/lang/Module;Ljava/lang/Module;)V") \ template(addExports_name, "addExports") \ template(addOpens_name, "addOpens") \ - template(addExports_signature, "(Ljava/lang/reflect/Module;Ljava/lang/String;Ljava/lang/reflect/Module;)V") \ + template(addExports_signature, "(Ljava/lang/Module;Ljava/lang/String;Ljava/lang/Module;)V") \ template(addUses_name, "addUses") \ - template(addUses_signature, "(Ljava/lang/reflect/Module;Ljava/lang/Class;)V") \ + template(addUses_signature, "(Ljava/lang/Module;Ljava/lang/Class;)V") \ template(addProvides_name, "addProvides") \ - template(addProvides_signature, "(Ljava/lang/reflect/Module;Ljava/lang/Class;Ljava/lang/Class;)V") \ + template(addProvides_signature, "(Ljava/lang/Module;Ljava/lang/Class;Ljava/lang/Class;)V") \ template(transformedByAgent_name, "transformedByAgent") \ - template(transformedByAgent_signature, "(Ljava/lang/reflect/Module;)V") \ + template(transformedByAgent_signature, "(Ljava/lang/Module;)V") \ template(appendToClassPathForInstrumentation_name, "appendToClassPathForInstrumentation") \ do_alias(appendToClassPathForInstrumentation_signature, string_void_signature) \ template(serializePropertiesToByteArray_name, "serializePropertiesToByteArray") \
--- a/hotspot/src/share/vm/gc/parallel/gcTaskThread.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/gc/parallel/gcTaskThread.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -54,8 +54,26 @@ } } +void GCTaskThread::add_task_timestamp(const char* name, jlong t_entry, jlong t_exit) { + if (_time_stamp_index < GCTaskTimeStampEntries) { + GCTaskTimeStamp* time_stamp = time_stamp_at(_time_stamp_index); + time_stamp->set_name(name); + time_stamp->set_entry_time(t_entry); + time_stamp->set_exit_time(t_exit); + } else { + if (_time_stamp_index == GCTaskTimeStampEntries) { + log_warning(gc, task, time)("GC-thread %u: Too many timestamps, ignoring future ones. " + "Increase GCTaskTimeStampEntries to get more info.", + id()); + } + // Let _time_stamp_index keep counting to give the user an idea about how many + // are needed. + } + _time_stamp_index++; +} + GCTaskTimeStamp* GCTaskThread::time_stamp_at(uint index) { - guarantee(index < GCTaskTimeStampEntries, "increase GCTaskTimeStampEntries"); + assert(index < GCTaskTimeStampEntries, "Precondition"); if (_time_stamps == NULL) { // We allocate the _time_stamps array lazily since logging can be enabled dynamically GCTaskTimeStamp* time_stamps = NEW_C_HEAP_ARRAY(GCTaskTimeStamp, GCTaskTimeStampEntries, mtGC); @@ -65,7 +83,6 @@ FREE_C_HEAP_ARRAY(GCTaskTimeStamp, time_stamps); } } - return &(_time_stamps[index]); } @@ -75,8 +92,11 @@ // Since _time_stamps is now lazily allocated we need to check that it // has in fact been allocated when calling this function. if (_time_stamps != NULL) { - log_debug(gc, task, time)("GC-Thread %u entries: %d", id(), _time_stamp_index); - for(uint i=0; i<_time_stamp_index; i++) { + log_debug(gc, task, time)("GC-Thread %u entries: %d%s", id(), + _time_stamp_index, + _time_stamp_index >= GCTaskTimeStampEntries ? " (overflow)" : ""); + const uint max_index = MIN2(_time_stamp_index, GCTaskTimeStampEntries); + for (uint i = 0; i < max_index; i++) { GCTaskTimeStamp* time_stamp = time_stamp_at(i); log_debug(gc, task, time)("\t[ %s " JLONG_FORMAT " " JLONG_FORMAT " ]", time_stamp->name(), @@ -144,16 +164,7 @@ if (log_is_enabled(Debug, gc, task, time)) { timer.update(); - - GCTaskTimeStamp* time_stamp = time_stamp_at(_time_stamp_index); - - time_stamp->set_name(name); - time_stamp->set_entry_time(entry_time); - time_stamp->set_exit_time(timer.ticks()); - - // Update the index after we have set up the entry correctly since - // GCTaskThread::print_task_time_stamps() may read this value concurrently. - _time_stamp_index++; + add_task_timestamp(name, entry_time, timer.ticks()); } } else { // idle tasks complete outside the normal accounting
--- a/hotspot/src/share/vm/gc/parallel/gcTaskThread.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/gc/parallel/gcTaskThread.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -45,6 +45,7 @@ uint _time_stamp_index; GCTaskTimeStamp* time_stamp_at(uint index); + void add_task_timestamp(const char* name, jlong t_entry, jlong t_exit); bool _is_working; // True if participating in GC tasks @@ -92,16 +93,16 @@ private: jlong _entry_time; jlong _exit_time; - char* _name; + const char* _name; public: jlong entry_time() { return _entry_time; } jlong exit_time() { return _exit_time; } - const char* name() const { return (const char*)_name; } + const char* name() const { return _name; } void set_entry_time(jlong time) { _entry_time = time; } void set_exit_time(jlong time) { _exit_time = time; } - void set_name(char* name) { _name = name; } + void set_name(const char* name) { _name = name; } }; #endif // SHARE_VM_GC_PARALLEL_GCTASKTHREAD_HPP
--- a/hotspot/src/share/vm/oops/constMethod.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/oops/constMethod.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -359,7 +359,9 @@ } // Sizing - static int header_size() { return sizeof(ConstMethod)/wordSize; } + static int header_size() { + return align_size_up(sizeof(ConstMethod), wordSize) / wordSize; + } // Size needed static int size(int code_size, InlineTableSizes* sizes);
--- a/hotspot/src/share/vm/oops/constantPool.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/oops/constantPool.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -705,7 +705,9 @@ } // Sizing (in words) - static int header_size() { return sizeof(ConstantPool)/wordSize; } + static int header_size() { + return align_size_up(sizeof(ConstantPool), wordSize) / wordSize; + } static int size(int length) { return align_metadata_size(header_size() + length); } int size() const { return size(length()); } #if INCLUDE_SERVICES
--- a/hotspot/src/share/vm/oops/cpCache.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/oops/cpCache.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -359,7 +359,9 @@ return (TosState)((_flags >> tos_state_shift) & tos_state_mask); } // Code generation support - static WordSize size() { return in_WordSize(sizeof(ConstantPoolCacheEntry) / wordSize); } + static WordSize size() { + return in_WordSize(align_size_up(sizeof(ConstantPoolCacheEntry), wordSize) / wordSize); + } static ByteSize size_in_bytes() { return in_ByteSize(sizeof(ConstantPoolCacheEntry)); } static ByteSize indices_offset() { return byte_offset_of(ConstantPoolCacheEntry, _indices); } static ByteSize f1_offset() { return byte_offset_of(ConstantPoolCacheEntry, _f1); }
--- a/hotspot/src/share/vm/oops/klass.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/oops/klass.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -532,7 +532,7 @@ } else { module_entry = ModuleEntryTable::javabase_moduleEntry(); } - // Obtain java.lang.reflect.Module, if available + // Obtain java.lang.Module, if available Handle module_handle(THREAD, ((module_entry != NULL) ? JNIHandles::resolve(module_entry->module()) : (oop)NULL)); java_lang_Class::create_mirror(this, loader, module_handle, protection_domain, CHECK); }
--- a/hotspot/src/share/vm/oops/method.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/oops/method.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -671,7 +671,9 @@ #endif // sizing - static int header_size() { return sizeof(Method)/wordSize; } + static int header_size() { + return align_size_up(sizeof(Method), wordSize) / wordSize; + } static int size(bool is_native); int size() const { return method_size(); } #if INCLUDE_SERVICES
--- a/hotspot/src/share/vm/oops/methodCounters.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/oops/methodCounters.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -116,7 +116,9 @@ AOT_ONLY(Method* method() const { return _method; }) - static int size() { return sizeof(MethodCounters) / wordSize; } + static int size() { + return align_size_up(sizeof(MethodCounters), wordSize) / wordSize; + } bool is_klass() const { return false; }
--- a/hotspot/src/share/vm/prims/jvmti.xml Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/prims/jvmti.xml Wed Jul 05 23:12:51 2017 +0200 @@ -6516,7 +6516,7 @@ <function id="GetNamedModule" num="40" since="9"> <synopsis>Get Named Module</synopsis> <description> - Return the <code>java.lang.reflect.Module</code> object for a named + Return the <code>java.lang.Module</code> object for a named module defined to a class loader that contains a given package. The module is returned via <code>module_ptr</code>. <p/> @@ -6554,7 +6554,7 @@ <param id="module_ptr"> <outptr><jobject/></outptr> <description> - On return, points to a <code>java.lang.reflect.Module</code> object + On return, points to a <code>java.lang.Module</code> object or points to <code>NULL</code>. </description> </param> @@ -6599,6 +6599,10 @@ <error id="JVMTI_ERROR_INVALID_MODULE"> If <paramlink id="to_module"></paramlink> is not a module object. </error> + <error id="JVMTI_ERROR_UNMODIFIABLE_MODULE"> + if the module cannot be modified. + See <functionlink id="IsModifiableModule"/>. + </error> </errors> </function> @@ -6633,7 +6637,7 @@ <description> The module the package is exported to. If the <code>to_module</code> is not a subclass of - <code>java.lang.reflect.Module</code> this function returns + <code>java.lang.Module</code> this function returns <errorlink id="JVMTI_ERROR_INVALID_MODULE"></errorlink>. </description> </param> @@ -6649,6 +6653,10 @@ If the package <paramlink id="pkg_name"></paramlink> does not belong to the module. </error> + <error id="JVMTI_ERROR_UNMODIFIABLE_MODULE"> + if the module cannot be modified. + See <functionlink id="IsModifiableModule"/>. + </error> </errors> </function> @@ -6684,7 +6692,7 @@ <description> The module with the package to open. If the <code>to_module</code> is not a subclass of - <code>java.lang.reflect.Module</code> this function returns + <code>java.lang.Module</code> this function returns <errorlink id="JVMTI_ERROR_INVALID_MODULE"></errorlink>. </description> </param> @@ -6700,6 +6708,10 @@ If the package <paramlink id="pkg_name"></paramlink> does not belong to the module. </error> + <error id="JVMTI_ERROR_UNMODIFIABLE_MODULE"> + if the module cannot be modified. + See <functionlink id="IsModifiableModule"/>. + </error> </errors> </function> @@ -6737,6 +6749,10 @@ <error id="JVMTI_ERROR_INVALID_CLASS"> If <paramlink id="service"></paramlink> is not a class object. </error> + <error id="JVMTI_ERROR_UNMODIFIABLE_MODULE"> + if the module cannot be modified. + See <functionlink id="IsModifiableModule"/>. + </error> </errors> </function> @@ -6783,6 +6799,44 @@ <error id="JVMTI_ERROR_INVALID_CLASS"> If <paramlink id="impl_class"></paramlink> is not a class object. </error> + <error id="JVMTI_ERROR_UNMODIFIABLE_MODULE"> + if the module cannot be modified. + See <functionlink id="IsModifiableModule"/>. + </error> + </errors> + </function> + + <function id="IsModifiableModule" num="99" since="9"> + <synopsis>Is Modifiable Module</synopsis> + <description> + Determines whether a module is modifiable. + If a module is modifiable then this module can be updated with + <functionlink id="AddModuleReads"/>, <functionlink id="AddModuleExports"/>, + <functionlink id="AddModuleOpens"/>, <functionlink id="AddModuleUses"/>, + and <functionlink id="AddModuleProvides"/>. If a module is not modifiable + then the module can not be updated with these functions. + </description> + <origin>new</origin> + <capabilities> + </capabilities> + <parameters> + <param id="module"> + <ptrtype><jobject/></ptrtype> + <description> + The module to query. + </description> + </param> + <param id="is_modifiable_module_ptr"> + <outptr><jboolean/></outptr> + <description> + On return, points to the boolean result of this function. + </description> + </param> + </parameters> + <errors> + <error id="JVMTI_ERROR_INVALID_MODULE"> + If <paramlink id="module"></paramlink> is not a module object. + </error> </errors> </function> @@ -7803,6 +7857,10 @@ A method in the new class version has different modifiers than its counterpart in the old class version. </error> + <error id="JVMTI_ERROR_UNMODIFIABLE_MODULE"> + A module cannot be modified. + See <functionlink id="IsModifiableModule"/>. + </error> </errors> </function> @@ -11567,6 +11625,9 @@ <errorid id="JVMTI_ERROR_UNMODIFIABLE_CLASS" num="79"> The class cannot be modified. </errorid> + <errorid id="JVMTI_ERROR_UNMODIFIABLE_MODULE" num="80"> + The module cannot be modified. + </errorid> <errorid id="JVMTI_ERROR_NOT_AVAILABLE" num="98"> The functionality is not available in this virtual machine. </errorid> @@ -14736,6 +14797,7 @@ - Add new functions: - GetAllModules - AddModuleReads, AddModuleExports, AddModuleOpens, AddModuleUses, AddModuleProvides + - IsModifiableModule Clarified can_redefine_any_classes, can_retransform_any_classes and IsModifiableClass API to disallow some implementation defined classes. </change>
--- a/hotspot/src/share/vm/prims/jvmtiEnv.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/prims/jvmtiEnv.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -235,12 +235,12 @@ // check module Handle h_module(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(h_module())) { + if (!java_lang_Module::is_instance(h_module())) { return JVMTI_ERROR_INVALID_MODULE; } // check to_module Handle h_to_module(THREAD, JNIHandles::resolve(to_module)); - if (!java_lang_reflect_Module::is_instance(h_to_module())) { + if (!java_lang_Module::is_instance(h_to_module())) { return JVMTI_ERROR_INVALID_MODULE; } return JvmtiExport::add_module_reads(h_module, h_to_module, THREAD); @@ -257,12 +257,12 @@ // check module Handle h_module(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(h_module())) { + if (!java_lang_Module::is_instance(h_module())) { return JVMTI_ERROR_INVALID_MODULE; } // check to_module Handle h_to_module(THREAD, JNIHandles::resolve(to_module)); - if (!java_lang_reflect_Module::is_instance(h_to_module())) { + if (!java_lang_Module::is_instance(h_to_module())) { return JVMTI_ERROR_INVALID_MODULE; } return JvmtiExport::add_module_exports(h_module, h_pkg, h_to_module, THREAD); @@ -279,12 +279,12 @@ // check module Handle h_module(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(h_module())) { + if (!java_lang_Module::is_instance(h_module())) { return JVMTI_ERROR_INVALID_MODULE; } // check to_module Handle h_to_module(THREAD, JNIHandles::resolve(to_module)); - if (!java_lang_reflect_Module::is_instance(h_to_module())) { + if (!java_lang_Module::is_instance(h_to_module())) { return JVMTI_ERROR_INVALID_MODULE; } return JvmtiExport::add_module_opens(h_module, h_pkg, h_to_module, THREAD); @@ -299,7 +299,7 @@ // check module Handle h_module(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(h_module())) { + if (!java_lang_Module::is_instance(h_module())) { return JVMTI_ERROR_INVALID_MODULE; } // check service @@ -321,7 +321,7 @@ // check module Handle h_module(THREAD, JNIHandles::resolve(module)); - if (!java_lang_reflect_Module::is_instance(h_module())) { + if (!java_lang_Module::is_instance(h_module())) { return JVMTI_ERROR_INVALID_MODULE; } // check service @@ -339,6 +339,22 @@ return JvmtiExport::add_module_provides(h_module, h_service, h_impl_class, THREAD); } /* end AddModuleProvides */ +// module - pre-checked for NULL +// is_modifiable_class_ptr - pre-checked for NULL +jvmtiError +JvmtiEnv::IsModifiableModule(jobject module, jboolean* is_modifiable_module_ptr) { + JavaThread* THREAD = JavaThread::current(); + + // check module + Handle h_module(THREAD, JNIHandles::resolve(module)); + if (!java_lang_Module::is_instance(h_module())) { + return JVMTI_ERROR_INVALID_MODULE; + } + + *is_modifiable_module_ptr = JNI_TRUE; + return JVMTI_ERROR_NONE; +} /* end IsModifiableModule */ + // // Class functions
--- a/hotspot/src/share/vm/runtime/globals.hpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/runtime/globals.hpp Wed Jul 05 23:12:51 2017 +0200 @@ -1450,9 +1450,9 @@ "Number of threads concurrent gc will use") \ constraint(ConcGCThreadsConstraintFunc,AfterErgo) \ \ - product(uintx, GCTaskTimeStampEntries, 200, \ + product(uint, GCTaskTimeStampEntries, 200, \ "Number of time stamp entries per gc worker thread") \ - range(1, max_uintx) \ + range(1, max_jint) \ \ product(bool, AlwaysTenure, false, \ "Always tenure objects in eden (ParallelGC only)") \
--- a/hotspot/src/share/vm/runtime/reflection.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/runtime/reflection.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -594,9 +594,9 @@ current_class_name, module_from_name, new_class_name, module_to_name, module_from_name, module_to_name); } else { - jobject jlrm = module_to->module(); - assert(jlrm != NULL, "Null jlrm in module_to ModuleEntry"); - intptr_t identity_hash = JNIHandles::resolve(jlrm)->identity_hash(); + jobject jlm = module_to->module(); + assert(jlm != NULL, "Null jlm in module_to ModuleEntry"); + intptr_t identity_hash = JNIHandles::resolve(jlm)->identity_hash(); size_t len = 160 + strlen(current_class_name) + 2*strlen(module_from_name) + strlen(new_class_name) + 2*sizeof(uintx); msg = NEW_RESOURCE_ARRAY(char, len); @@ -621,9 +621,9 @@ current_class_name, module_from_name, new_class_name, module_to_name, module_to_name, package_name, module_from_name); } else { - jobject jlrm = module_from->module(); - assert(jlrm != NULL, "Null jlrm in module_from ModuleEntry"); - intptr_t identity_hash = JNIHandles::resolve(jlrm)->identity_hash(); + jobject jlm = module_from->module(); + assert(jlm != NULL, "Null jlm in module_from ModuleEntry"); + intptr_t identity_hash = JNIHandles::resolve(jlm)->identity_hash(); size_t len = 170 + strlen(current_class_name) + strlen(new_class_name) + 2*strlen(module_to_name) + strlen(package_name) + 2*sizeof(uintx); msg = NEW_RESOURCE_ARRAY(char, len);
--- a/hotspot/src/share/vm/runtime/thread.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/src/share/vm/runtime/thread.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -3465,7 +3465,7 @@ java_lang_Thread::RUNNABLE); // The VM creates objects of this class. - initialize_class(vmSymbols::java_lang_reflect_Module(), CHECK); + initialize_class(vmSymbols::java_lang_Module(), CHECK); // The VM preresolves methods to these classes. Make sure that they get initialized initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK);
--- a/hotspot/test/TEST.ROOT Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/TEST.ROOT Wed Jul 05 23:12:51 2017 +0200 @@ -50,8 +50,8 @@ vm.cpu.features \ vm.debug -# Tests using jtreg 4.2 b04 features -requiredVersion=4.2 b04 +# Tests using jtreg 4.2 b07 features +requiredVersion=4.2 b07 # Path to libraries in the topmost test directory. This is needed so @library # does not need ../../ notation to reach them
--- a/hotspot/test/compiler/c2/cr7200264/TestDriver.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/compiler/c2/cr7200264/TestDriver.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,7 +26,6 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.regex.Pattern; import jdk.test.lib.Asserts; import jdk.test.lib.process.OutputAnalyzer; @@ -45,7 +44,7 @@ } private List<String> executeApplication() throws Throwable { - OutputAnalyzer outputAnalyzer = ProcessTools.executeTestJvmAllArgs( + OutputAnalyzer outputAnalyzer = ProcessTools.executeTestJvm( "-Xbatch", "-XX:-TieredCompilation", "-XX:+PrintCompilation",
--- a/hotspot/test/compiler/compilercontrol/share/scenario/Executor.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/compiler/compilercontrol/share/scenario/Executor.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,7 @@ import compiler.compilercontrol.share.actions.BaseAction; import jdk.test.lib.Asserts; +import jdk.test.lib.management.InputArguments; import jdk.test.lib.process.OutputAnalyzer; import jdk.test.lib.process.ProcessTools; import jdk.test.lib.dcmd.CommandExecutor; @@ -38,6 +39,7 @@ import java.net.ServerSocket; import java.net.Socket; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Map; @@ -97,9 +99,13 @@ // Start separate thread to connect with test VM new Thread(() -> connectTestVM(serverSocket)).start(); } - // Start test VM - output = ProcessTools.executeTestJvmAllArgs( - vmOptions.toArray(new String[vmOptions.size()])); + // Start a test VM using vm flags from @run and from vm options + String[] vmInputArgs = InputArguments.getVmInputArgs(); + String[] cmds = Arrays.copyOf(vmInputArgs, + vmInputArgs.length + vmOptions.size()); + System.arraycopy(vmOptions.toArray(), 0, cmds, vmInputArgs.length, + vmOptions.size()); + output = ProcessTools.executeTestJvm(cmds); } catch (Throwable thr) { throw new Error("Execution failed: " + thr.getMessage(), thr); }
--- a/hotspot/test/compiler/jvmci/common/CTVMUtilities.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/compiler/jvmci/common/CTVMUtilities.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -41,7 +41,6 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; -import java.lang.reflect.Module; import java.lang.reflect.Parameter; import java.util.HashMap; import java.util.Map;
--- a/hotspot/test/compiler/jvmci/compilerToVM/DebugOutputTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/compiler/jvmci/compilerToVM/DebugOutputTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -30,11 +30,9 @@ * @modules java.base/jdk.internal.misc * @modules jdk.internal.vm.ci/jdk.vm.ci.hotspot * @build jdk.internal.vm.ci/jdk.vm.ci.hotspot.CompilerToVMHelper - * @run main/othervm compiler.jvmci.compilerToVM.DebugOutputTest + * @run driver compiler.jvmci.compilerToVM.DebugOutputTest */ - // as soon as CODETOOLS-7901589 fixed, '@run main/othervm' should be replaced w/ '@run driver' - package compiler.jvmci.compilerToVM; import jdk.test.lib.process.OutputAnalyzer; @@ -42,8 +40,11 @@ import jdk.vm.ci.hotspot.CompilerToVMHelper; import java.util.Arrays; +import java.nio.file.Path; +import java.nio.file.Paths; public class DebugOutputTest { + private static final String VM_CI_MODULE = "jdk.internal.vm.ci"; public static void main(String[] args) { new DebugOutputTest().test(); } @@ -53,10 +54,18 @@ System.out.println(testCase); OutputAnalyzer oa; try { - oa = ProcessTools.executeTestJvmAllArgs( + Path patch = Paths.get(System.getProperty("test.patch.path")); + Path jvmciPath = patch.resolve(VM_CI_MODULE).toAbsolutePath(); + if (!jvmciPath.toFile().exists()) { + throw new Error("TESTBUG: patch for " + VM_CI_MODULE + " : " + + jvmciPath.toString() + " does not exist"); + } + oa = ProcessTools.executeTestJvm( "-XX:+UnlockExperimentalVMOptions", "-XX:+EnableJVMCI", - "-Xbootclasspath/a:.", + "--add-exports", "java.base/jdk.internal.misc=ALL-UNNAMED", + "--add-exports", "jdk.internal.vm.ci/jdk.vm.ci.hotspot=ALL-UNNAMED", + "--patch-module", VM_CI_MODULE + "=" + jvmciPath.toString(), DebugOutputTest.Worker.class.getName(), testCase.name()); } catch (Throwable e) {
--- a/hotspot/test/compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MemoryAccessProviderData.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MemoryAccessProviderData.java Wed Jul 05 23:12:51 2017 +0200 @@ -27,6 +27,7 @@ import org.testng.annotations.DataProvider; +import sun.hotspot.WhiteBox; import jdk.internal.misc.Unsafe; import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider; import jdk.vm.ci.hotspot.HotSpotJVMCIRuntimeProvider; @@ -36,6 +37,10 @@ import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.runtime.JVMCI; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; public class MemoryAccessProviderData { private static final Unsafe UNSAFE = Unsafe.getUnsafe(); @@ -43,6 +48,18 @@ private static final TestClass TEST_OBJECT = new TestClass(); private static final JavaConstant TEST_CONSTANT = CONSTANT_REFLECTION.forObject(TEST_OBJECT); private static final JavaConstant TEST_CLASS_CONSTANT = CONSTANT_REFLECTION.forObject(TestClass.class); + private static KindData[] PRIMITIVE_KIND_DATA = { + new KindData(JavaKind.Boolean, TEST_OBJECT), + new KindData(JavaKind.Byte, TEST_OBJECT), + new KindData(JavaKind.Char, TEST_OBJECT), + new KindData(JavaKind.Short, TEST_OBJECT), + new KindData(JavaKind.Int, TEST_OBJECT), + new KindData(JavaKind.Float, TEST_OBJECT), + new KindData(JavaKind.Long, TEST_OBJECT), + new KindData(JavaKind.Double, TEST_OBJECT) + }; + private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox(); + @DataProvider(name = "positiveObject") public static Object[][] getPositiveObjectJavaKind() { @@ -54,51 +71,40 @@ @DataProvider(name = "positivePrimitive") public static Object[][] getPositivePrimitiveJavaKinds() { - Field booleanField; - Field byteField; - Field shortField; - Field intField; - Field longField; - Field floatField; - Field doubleField; - Field charField; - try { - booleanField = MemoryAccessProviderData.TestClass.class.getDeclaredField("booleanField"); - byteField = MemoryAccessProviderData.TestClass.class.getDeclaredField("byteField"); - shortField = MemoryAccessProviderData.TestClass.class.getDeclaredField("shortField"); - intField = MemoryAccessProviderData.TestClass.class.getDeclaredField("intField"); - longField = MemoryAccessProviderData.TestClass.class.getDeclaredField("longField"); - floatField = MemoryAccessProviderData.TestClass.class.getDeclaredField("floatField"); - doubleField = MemoryAccessProviderData.TestClass.class.getDeclaredField("doubleField"); - charField = MemoryAccessProviderData.TestClass.class.getDeclaredField("charField"); - } catch (NoSuchFieldException e) { - throw new Error("TESTBUG: can't find test field " + e, e); + List<Object[]> result = new ArrayList<>(); + for (KindData k : PRIMITIVE_KIND_DATA) { + result.add(new Object[] {k.kind, TEST_CONSTANT, k.instanceFieldOffset, k.instanceFieldValue, Math.max(8, k.kind.getBitCount())}); + result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, k.staticFieldOffset, k.staticFieldValue, Math.max(8, k.kind.getBitCount())}); } - long booleanFieldOffset = UNSAFE.objectFieldOffset(booleanField); - long byteFieldOffset = UNSAFE.objectFieldOffset(byteField); - long shortFieldOffset = UNSAFE.objectFieldOffset(shortField); - long intFieldOffset = UNSAFE.objectFieldOffset(intField); - long longFieldOffset = UNSAFE.objectFieldOffset(longField); - long floatFieldOffset = UNSAFE.objectFieldOffset(floatField); - long doubleFieldOffset = UNSAFE.objectFieldOffset(doubleField); - long charFieldOffset = UNSAFE.objectFieldOffset(charField); - return new Object[][]{ - new Object[]{JavaKind.Boolean, TEST_CONSTANT, booleanFieldOffset, - JavaConstant.forBoolean(TEST_OBJECT.booleanField), 8}, - new Object[]{JavaKind.Byte, TEST_CONSTANT, byteFieldOffset, - JavaConstant.forByte(TEST_OBJECT.byteField), 8}, - new Object[]{JavaKind.Short, TEST_CONSTANT, shortFieldOffset, - JavaConstant.forShort(TEST_OBJECT.shortField), 16}, - new Object[]{JavaKind.Int, TEST_CONSTANT, intFieldOffset, - JavaConstant.forInt(TEST_OBJECT.intField), 32}, - new Object[]{JavaKind.Long, TEST_CONSTANT, longFieldOffset, - JavaConstant.forLong(TEST_OBJECT.longField), 64}, - new Object[]{JavaKind.Float, TEST_CONSTANT, floatFieldOffset, - JavaConstant.forFloat(TEST_OBJECT.floatField), 32}, - new Object[]{JavaKind.Double, TEST_CONSTANT, doubleFieldOffset, - JavaConstant.forDouble(TEST_OBJECT.doubleField), 64}, - new Object[]{JavaKind.Char, TEST_CONSTANT, charFieldOffset, - JavaConstant.forChar(TEST_OBJECT.charField), 16}}; + return result.toArray(new Object[result.size()][]); + } + + @DataProvider(name = "outOfBoundsInstanceFields") + public static Object[][] getOutOfBoundsStaticFieldReads() { + long instanceSize = WHITE_BOX.getObjectSize(TEST_OBJECT); + List<Object[]> result = new ArrayList<>(); + for (KindData k : PRIMITIVE_KIND_DATA) { + long lastValidOffset = instanceSize - (k.kind.getByteCount()); + result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset, false}); + result.add(new Object[] {k.kind, TEST_CONSTANT, (long) -1, true}); + result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset + 1, true}); + result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset + 100, true}); + } + return result.toArray(new Object[result.size()][]); + } + + @DataProvider(name = "outOfBoundsStaticFields") + public static Object[][] getOutOfBoundsInstanceFieldReads() { + long staticsSize = WHITE_BOX.getObjectSize(TEST_OBJECT.getClass()); + List<Object[]> result = new ArrayList<>(); + for (KindData k : PRIMITIVE_KIND_DATA) { + long lastValidOffset = staticsSize - (k.kind.getByteCount()); + result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset, false}); + result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, (long) -1, true}); + result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset + 1, true}); + result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset + 100, true}); + } + return result.toArray(new Object[result.size()][]); } @DataProvider(name = "negative") @@ -108,6 +114,7 @@ new Object[]{JavaKind.Illegal, JavaConstant.INT_1}}; } + private static class TestClass { public final boolean booleanField = true; public final byte byteField = 2; @@ -117,6 +124,43 @@ public final double doubleField = 6.0d; public final float floatField = 7.0f; public final char charField = 'a'; - public final String stringField = "abc"; + public final String objectField = "abc"; + + public static final boolean booleanStaticField = true; + public static final byte byteStaticField = 2; + public static final short shortStaticField = 3; + public static final int intStaticField = 4; + public static final long longStaticField = 5L; + public static final double doubleStaticField = 6.0d; + public static final float floatStaticField = 7.0f; + public static final char charStaticField = 'a'; + public static final String objectStaticField = "abc"; + } + + + static class KindData { + final JavaKind kind; + final Field instanceField; + final Field staticField; + final long instanceFieldOffset; + final long staticFieldOffset; + final JavaConstant instanceFieldValue; + final JavaConstant staticFieldValue; + KindData(JavaKind kind, Object testObject) { + this.kind = kind; + try { + Class<?> c = testObject.getClass(); + instanceField = c.getDeclaredField(kind.getJavaName() + "Field"); + staticField = c.getDeclaredField(kind.getJavaName() + "StaticField"); + instanceField.setAccessible(true); + staticField.setAccessible(true); + instanceFieldOffset = UNSAFE.objectFieldOffset(instanceField); + staticFieldOffset = UNSAFE.staticFieldOffset(staticField); + instanceFieldValue = JavaConstant.forBoxedPrimitive(instanceField.get(testObject)); + staticFieldValue = JavaConstant.forBoxedPrimitive(staticField.get(null)); + } catch (Exception e) { + throw new Error("TESTBUG for kind " + kind, e); + } + } } }
--- a/hotspot/test/compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MemoryAccessProviderTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MemoryAccessProviderTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -31,12 +31,19 @@ * jdk.internal.vm.ci/jdk.vm.ci.runtime * jdk.internal.vm.ci/jdk.vm.ci.hotspot * java.base/jdk.internal.misc - * @run testng/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI + * @build sun.hotspot.WhiteBox + * @run driver ClassFileInstaller sun.hotspot.WhiteBox + * sun.hotspot.WhiteBox$WhiteBoxPermission + * @run testng/othervm -Xbootclasspath/a:. + * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI + * -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI * jdk.vm.ci.hotspot.test.MemoryAccessProviderTest */ package jdk.vm.ci.hotspot.test; +import sun.hotspot.WhiteBox; + import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.MemoryAccessProvider; @@ -59,7 +66,27 @@ @Test(dataProvider = "negative", dataProviderClass = MemoryAccessProviderData.class, expectedExceptions = {IllegalArgumentException.class}) public void testNegativeReadPrimitiveConstant(JavaKind kind, Constant base) { - PROVIDER.readPrimitiveConstant(kind, base, 0L, kind == null ? 0 : kind.getBitCount()); + PROVIDER.readPrimitiveConstant(kind, base, 0L, kind == null ? 0 : kind.getByteCount() / 8); + } + + @Test(dataProvider = "outOfBoundsInstanceFields", dataProviderClass = MemoryAccessProviderData.class) + public void testReadPrimitiveInstanceFieldOutOfBounds(JavaKind kind, Constant base, Long offset, boolean isOutOfBounds) { + try { + PROVIDER.readPrimitiveConstant(kind, base, offset, kind.getByteCount() * 8); + Assert.assertFalse(isOutOfBounds); + } catch (IllegalArgumentException iae) { + Assert.assertTrue(isOutOfBounds); + } + } + + @Test(dataProvider = "outOfBoundsStaticFields", dataProviderClass = MemoryAccessProviderData.class) + public void testReadPrimitiveStaticFieldOutOFBounds(JavaKind kind, Constant base, Long offset, boolean isOutOfBounds) { + try { + PROVIDER.readPrimitiveConstant(kind, base, offset, kind.getByteCount() * 8); + Assert.assertFalse(isOutOfBounds); + } catch (IllegalArgumentException iae) { + Assert.assertTrue(isOutOfBounds); + } } @Test(dataProvider = "positiveObject", dataProviderClass = MemoryAccessProviderData.class, expectedExceptions = {IllegalArgumentException.class}) @@ -87,7 +114,7 @@ Assert.assertNull(PROVIDER.readObjectConstant(base, offset + 1), "Expected null"); } - @Test(dataProvider = "positivePrimitive", dataProviderClass = MemoryAccessProviderData.class) + @Test(dataProvider = "positivePrimitive", dataProviderClass = MemoryAccessProviderData.class, expectedExceptions = {IllegalArgumentException.class}) public void testNegativeReadObjectConstantPrimitiveBase(JavaKind kind, Constant base, Long offset, Object expected, int bitsCount) { Assert.assertNull(PROVIDER.readObjectConstant(base, offset), "Expected null"); }
--- a/hotspot/test/gc/parallel/TestPrintGCDetailsVerbose.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/gc/parallel/TestPrintGCDetailsVerbose.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,12 +23,13 @@ /* * @test TestPrintGCDetailsVerbose - * @bug 8016740 + * @bug 8016740 8177963 * @summary Tests that jvm with maximally verbose GC logging does not crash when ParOldGC has no memory * @key gc * @requires vm.gc.Parallel * @modules java.base/jdk.internal.misc * @run main/othervm -Xmx50m -XX:+UseParallelGC -Xlog:gc*=trace TestPrintGCDetailsVerbose + * @run main/othervm -Xmx50m -XX:+UseParallelGC -XX:GCTaskTimeStampEntries=1 -Xlog:gc*=trace TestPrintGCDetailsVerbose */ public class TestPrintGCDetailsVerbose {
--- a/hotspot/test/native/runtime/test_globals.cpp Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/native/runtime/test_globals.cpp Wed Jul 05 23:12:51 2017 +0200 @@ -53,7 +53,7 @@ } TEST_VM(FlagGuard, uintx_flag) { - TEST_FLAG(GCTaskTimeStampEntries, uintx, 1337); + TEST_FLAG(GCTaskTimeStampEntries, uint, 1337); } TEST_VM(FlagGuard, size_t_flag) {
--- a/hotspot/test/runtime/classFileParserBug/fakeMethodAccessor.jasm Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/classFileParserBug/fakeMethodAccessor.jasm Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,7 +26,6 @@ // to create a sub-type of jdk.internal.reflect.MethodAccessorImpl in order // to bypass Reflection.getCallerClass. That should fail with an IAE. // - import java.lang.reflect.Module; class fakeMethodAccessor extends jdk.internal.reflect.MethodAccessorImpl { public static void main(String[] a) throws Exception { fakeMethodAccessor f = new fakeMethodAccessor(); @@ -60,11 +59,11 @@ astore_1; getstatic Field java/lang/System.out:"Ljava/io/PrintStream;"; ldc class java/lang/String; - invokevirtual Method java/lang/Class.getModule:"()Ljava/lang/reflect/Module;"; + invokevirtual Method java/lang/Class.getModule:"()Ljava/lang/Module;"; ldc String "jdk.internal.misc"; ldc class FakeMethodAccessor; - invokevirtual Method java/lang/Class.getModule:"()Ljava/lang/reflect/Module;"; - invokevirtual Method java/lang/reflect/Module.isExported:"(Ljava/lang/String;Ljava/lang/reflect/Module;)Z"; + invokevirtual Method java/lang/Class.getModule:"()Ljava/lang/Module;"; + invokevirtual Method java/lang/Module.isExported:"(Ljava/lang/String;Ljava/lang/Module;)Z"; invokevirtual Method java/io/PrintStream.println:"(Z)V"; return; }
--- a/hotspot/test/runtime/getSysPackage/GetSysPkgTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/getSysPackage/GetSysPkgTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -55,7 +55,7 @@ return m; } } - throw new RuntimeException("Failed to find method " + name + " in java.lang.reflect.Module"); + throw new RuntimeException("Failed to find method " + name + " in java.lang.Module"); } // Throw RuntimeException if getSystemPackageLocation() does not return
--- a/hotspot/test/runtime/modules/AccModuleTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccModuleTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,8 +28,6 @@ * @run main AccModuleTest */ -import java.io.File; - public class AccModuleTest { public static void main(String args[]) throws Throwable {
--- a/hotspot/test/runtime/modules/AccessCheck/AccessExportTwice.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/AccessExportTwice.java Wed Jul 05 23:12:51 2017 +0200 @@ -39,8 +39,6 @@ import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; -import java.lang.reflect.Layer; -import java.lang.reflect.Module; import java.util.HashMap; import java.util.Map; import java.util.Set; @@ -58,7 +56,7 @@ public class AccessExportTwice { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publicly defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -87,7 +85,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_first_mod, descriptor_second_mod); // Resolves "first_mod" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("first_mod")); @@ -96,8 +94,8 @@ map.put("first_mod", MySameClassLoader.loader1); map.put("second_mod", MySameClassLoader.loader1); - // Create Layer that contains first_mod & second_mod - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains first_mod & second_mod + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("first_mod") == MySameClassLoader.loader1); assertTrue(layer.findLoader("second_mod") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/AccessReadTwice.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/AccessReadTwice.java Wed Jul 05 23:12:51 2017 +0200 @@ -39,8 +39,6 @@ import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; -import java.lang.reflect.Layer; -import java.lang.reflect.Module; import java.util.HashMap; import java.util.Map; import java.util.Set; @@ -56,7 +54,7 @@ public class AccessReadTwice { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publicly defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -85,7 +83,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_first_mod, descriptor_second_mod); // Resolves "first_mod" and "second_mod" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("first_mod", "second_mod")); @@ -95,8 +93,8 @@ map.put("first_mod", loader); map.put("second_mod", loader); - // Create Layer that contains first_mod & second_mod - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains first_mod & second_mod + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("first_mod") == loader); assertTrue(layer.findLoader("second_mod") == loader);
--- a/hotspot/test/runtime/modules/AccessCheck/CheckRead.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/CheckRead.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,7 +58,7 @@ // public class CheckRead { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publicly defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -100,7 +99,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x, descriptor_m3x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -110,8 +109,8 @@ map.put("m2x", MySameClassLoader.loader1); map.put("m3x", MySameClassLoader.loader1); - // Create Layer that contains m1x, m2x and m3x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x, m2x and m3x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/DiffCL_CheckRead.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/DiffCL_CheckRead.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,7 +58,7 @@ // public class DiffCL_CheckRead { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publicly defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -100,7 +99,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x, descriptor_m3x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -110,8 +109,8 @@ map.put("m2x", MyDiffClassLoader.loader2); map.put("m3x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x, m2x and m3x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x, m2x and m3x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/DiffCL_ExpQualOther.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/DiffCL_ExpQualOther.java Wed Jul 05 23:12:51 2017 +0200 @@ -38,7 +38,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -60,7 +59,7 @@ // public class DiffCL_ExpQualOther { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -102,7 +101,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x, descriptor_m3x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -112,8 +111,8 @@ map.put("m2x", MyDiffClassLoader.loader2); map.put("m3x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/DiffCL_ExpQualToM1.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/DiffCL_ExpQualToM1.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -58,7 +57,7 @@ // public class DiffCL_ExpQualToM1 { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -88,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -97,8 +96,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/DiffCL_ExpUnqual.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/DiffCL_ExpUnqual.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,7 +58,7 @@ // public class DiffCL_ExpUnqual { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -89,7 +88,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -98,8 +97,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/DiffCL_PkgNotExp.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/DiffCL_PkgNotExp.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -58,7 +57,7 @@ // public class DiffCL_PkgNotExp { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -88,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -97,8 +96,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/DiffCL_Umod.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/DiffCL_Umod.java Wed Jul 05 23:12:51 2017 +0200 @@ -42,8 +42,6 @@ import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; -import java.lang.reflect.Layer; -import java.lang.reflect.Module; import java.util.HashMap; import java.util.Map; import java.util.Set; @@ -68,7 +66,7 @@ // public class DiffCL_Umod { - // Create Layers over the boot layer to test different + // Create layers over the boot layer to test different // accessing scenarios of a named module to an unnamed module. // Module m1x is a strict module and has not established @@ -89,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -102,8 +100,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", MyDiffClassLoader.loader1); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("java.base") == null); @@ -138,7 +136,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -151,8 +149,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", MyDiffClassLoader.loader1); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("java.base") == null); @@ -187,7 +185,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -200,8 +198,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", MyDiffClassLoader.loader1); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("java.base") == null);
--- a/hotspot/test/runtime/modules/AccessCheck/DiffCL_UmodUpkg.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/DiffCL_UmodUpkg.java Wed Jul 05 23:12:51 2017 +0200 @@ -38,7 +38,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -63,7 +62,7 @@ // public class DiffCL_UmodUpkg { - // Create Layers over the boot layer to test different + // Create layers over the boot layer to test different // accessing scenarios of a named module to an unnamed module. // Module m1x is a strict module and has not established @@ -84,7 +83,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -97,8 +96,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", MyDiffClassLoader.loader1); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("java.base") == null); @@ -133,7 +132,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -146,8 +145,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", MyDiffClassLoader.loader1); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("java.base") == null);
--- a/hotspot/test/runtime/modules/AccessCheck/ExpQualOther.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/ExpQualOther.java Wed Jul 05 23:12:51 2017 +0200 @@ -38,7 +38,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -60,7 +59,7 @@ // public class ExpQualOther { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -102,7 +101,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x, descriptor_m3x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -112,8 +111,8 @@ map.put("m2x", MySameClassLoader.loader1); map.put("m3x", MySameClassLoader.loader1); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/ExpQualToM1.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/ExpQualToM1.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -48,7 +47,7 @@ public class ExpQualToM1 { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -78,7 +77,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -87,8 +86,8 @@ map.put("m1x", MySameClassLoader.loader1); map.put("m2x", MySameClassLoader.loader1); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/ExpUnqual.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/ExpUnqual.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -48,7 +47,7 @@ public class ExpUnqual { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -78,7 +77,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -87,8 +86,8 @@ map.put("m1x", MySameClassLoader.loader1); map.put("m2x", MySameClassLoader.loader1); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/ExportAllUnnamed.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/ExportAllUnnamed.java Wed Jul 05 23:12:51 2017 +0200 @@ -41,8 +41,6 @@ import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; -import java.lang.reflect.Layer; -import java.lang.reflect.Module; import java.util.HashMap; import java.util.Map; import java.util.Set; @@ -61,7 +59,7 @@ public class ExportAllUnnamed { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -90,7 +88,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -99,8 +97,8 @@ map.put("m1x", MySameClassLoader.loader1); map.put("m2x", MySameClassLoader.loader1); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/PkgNotExp.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/PkgNotExp.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -58,7 +57,7 @@ // public class PkgNotExp { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -88,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -97,8 +96,8 @@ map.put("m1x", MySameClassLoader.loader1); map.put("m2x", MySameClassLoader.loader1); - // Create Layer that contains m1x and m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x and m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/Umod.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/Umod.java Wed Jul 05 23:12:51 2017 +0200 @@ -39,11 +39,9 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; -import java.lang.reflect.Module; import java.util.HashMap; import java.util.Map; import java.util.Set; @@ -68,7 +66,7 @@ // public class Umod { - // Create Layers over the boot layer to test different + // Create layers over the boot layer to test different // accessing scenarios of a named module to an unnamed module. // Module m1x is a strict module and has not established @@ -89,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -99,8 +97,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", loader); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == loader); assertTrue(layer.findLoader("java.base") == null); @@ -135,7 +133,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -145,8 +143,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", loader); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == loader); assertTrue(layer.findLoader("java.base") == null); @@ -181,7 +179,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -191,8 +189,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", loader); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == loader); assertTrue(layer.findLoader("java.base") == null);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodDiffCL_ExpQualOther.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodDiffCL_ExpQualOther.java Wed Jul 05 23:12:51 2017 +0200 @@ -38,7 +38,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -60,7 +59,7 @@ // public class UmodDiffCL_ExpQualOther { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -89,7 +88,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -98,8 +97,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodDiffCL_ExpUnqual.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodDiffCL_ExpUnqual.java Wed Jul 05 23:12:51 2017 +0200 @@ -38,7 +38,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -60,7 +59,7 @@ // public class UmodDiffCL_ExpUnqual { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -89,7 +88,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -98,8 +97,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodDiffCL_PkgNotExp.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodDiffCL_PkgNotExp.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,7 +58,7 @@ // public class UmodDiffCL_PkgNotExp { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -88,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -97,8 +96,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodUPkg.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodUPkg.java Wed Jul 05 23:12:51 2017 +0200 @@ -40,8 +40,6 @@ import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; -import java.lang.reflect.Layer; -import java.lang.reflect.Module; import java.util.HashMap; import java.util.Map; import java.util.Set; @@ -63,7 +61,7 @@ // public class UmodUPkg { - // Create Layers over the boot layer to test different + // Create layers over the boot layer to test different // accessing scenarios of a named module to an unnamed module. // Module m1x is a strict module and has not established @@ -84,7 +82,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -94,8 +92,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", loader); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == loader); assertTrue(layer.findLoader("java.base") == null); @@ -130,7 +128,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -140,8 +138,8 @@ Map<String, ClassLoader> map = new HashMap<>(); map.put("m1x", loader); - // Create Layer that contains m1x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == loader); assertTrue(layer.findLoader("java.base") == null);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodUpkgDiffCL_ExpQualOther.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodUpkgDiffCL_ExpQualOther.java Wed Jul 05 23:12:51 2017 +0200 @@ -38,7 +38,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -60,7 +59,7 @@ // public class UmodUpkgDiffCL_ExpQualOther { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -89,7 +88,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -98,8 +97,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodUpkgDiffCL_NotExp.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodUpkgDiffCL_NotExp.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,7 +58,7 @@ // public class UmodUpkgDiffCL_NotExp { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -88,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -97,8 +96,8 @@ map.put("m1x", MyDiffClassLoader.loader1); map.put("m2x", MyDiffClassLoader.loader2); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MyDiffClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MyDiffClassLoader.loader2);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodUpkg_ExpQualOther.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodUpkg_ExpQualOther.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,12 +58,12 @@ // public class UmodUpkg_ExpQualOther { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { - // Define module: m1x (need to define m1x to establish the Layer successfully) + // Define module: m1x (need to define m1x to establish the layer successfully) // Can read: java.base, m2x, m3x // Packages: none // Packages exported: none @@ -98,7 +97,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x, descriptor_m3x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -108,8 +107,8 @@ map.put("m2x", MySameClassLoader.loader1); map.put("m3x", MySameClassLoader.loader1); - // Create Layer that contains m1x, m2x and m3x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x, m2x and m3x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/UmodUpkg_NotExp.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/UmodUpkg_NotExp.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -57,7 +56,7 @@ // public class UmodUpkg_NotExp { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -86,7 +85,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -95,8 +94,8 @@ map.put("m1x", MySameClassLoader.loader1); map.put("m2x", MySameClassLoader.loader1); - // Create Layer that contains m1x and m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x and m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/Umod_ExpQualOther.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/Umod_ExpQualOther.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,12 +58,12 @@ // public class Umod_ExpQualOther { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { - // Define module: m1x (need to define m1x to establish the Layer successfully) + // Define module: m1x (need to define m1x to establish the layer successfully) // Can read: java.base, m2x, m3x // Packages: none // Packages exported: none @@ -98,7 +97,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x, descriptor_m3x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -108,8 +107,8 @@ map.put("m2x", MySameClassLoader.loader1); map.put("m3x", MySameClassLoader.loader1); - // Create Layer that contains m1x, m2x and m3x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x, m2x and m3x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/Umod_ExpUnqual.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/Umod_ExpUnqual.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -59,7 +58,7 @@ public class Umod_ExpUnqual { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -88,7 +87,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -97,8 +96,8 @@ map.put("m1x", MySameClassLoader.loader1); map.put("m2x", MySameClassLoader.loader1); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/Umod_PkgNotExp.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/Umod_PkgNotExp.java Wed Jul 05 23:12:51 2017 +0200 @@ -37,7 +37,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -57,7 +56,7 @@ // public class Umod_PkgNotExp { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -86,7 +85,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -95,8 +94,8 @@ map.put("m1x", MySameClassLoader.loader1); map.put("m2x", MySameClassLoader.loader1); - // Create Layer that contains m1x and m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x and m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == MySameClassLoader.loader1); assertTrue(layer.findLoader("m2x") == MySameClassLoader.loader1);
--- a/hotspot/test/runtime/modules/AccessCheck/p1/c1ReadEdge.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/p1/c1ReadEdge.java Wed Jul 05 23:12:51 2017 +0200 @@ -22,7 +22,6 @@ */ package p1; -import java.lang.reflect.*; import p2.c2; public class c1ReadEdge {
--- a/hotspot/test/runtime/modules/AccessCheck/p1/c1ReadEdgeDiffLoader.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/p1/c1ReadEdgeDiffLoader.java Wed Jul 05 23:12:51 2017 +0200 @@ -22,7 +22,6 @@ */ package p1; -import java.lang.reflect.*; import myloaders.MyDiffClassLoader; import p2.c2;
--- a/hotspot/test/runtime/modules/AccessCheck/p3/c3ReadEdge.jcod Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/p3/c3ReadEdge.jcod Wed Jul 05 23:12:51 2017 +0200 @@ -23,7 +23,6 @@ /* * package p3; - * import java.lang.reflect.*; * public class c3ReadEdge { * public c3ReadEdge() { * // Establish read edge from module m1x, where c3ReadEdge is defined, @@ -75,14 +74,14 @@ Utf8 "java/lang/Object"; // #28 at 0xBC Utf8 "java/lang/Class"; // #29 at 0xCF Utf8 "getModule"; // #30 at 0xE1 - Utf8 "()Ljava/lang/reflect/Module;"; // #31 at 0xED + Utf8 "()Ljava/lang/Module;"; // #31 at 0xED Utf8 "getClassLoader"; // #32 at 0x010C Utf8 "()Ljava/lang/ClassLoader;"; // #33 at 0x011D Utf8 "java/lang/ClassLoader"; // #34 at 0x0139 Utf8 "getUnnamedModule"; // #35 at 0x0151 - Utf8 "java/lang/reflect/Module"; // #36 at 0x0164 + Utf8 "java/lang/Module"; // #36 at 0x0164 Utf8 "addReads"; // #37 at 0x017F - Utf8 "(Ljava/lang/reflect/Module;)Ljava/lang/reflect/Module;"; // #38 at 0x018A + Utf8 "(Ljava/lang/Module;)Ljava/lang/Module;"; // #38 at 0x018A Utf8 "method4"; // #39 at 0x01C3 } // Constant Pool
--- a/hotspot/test/runtime/modules/AccessCheck/p3/c3ReadEdgeDiffLoader.jcod Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/p3/c3ReadEdgeDiffLoader.jcod Wed Jul 05 23:12:51 2017 +0200 @@ -23,7 +23,6 @@ /* * package p3; - * import java.lang.reflect.*; * import myloaders.MyDiffClassLoader; * * public class c3ReadEdgeDiffLoader { @@ -100,14 +99,14 @@ Utf8 "java/lang/Object"; // #31 at 0xDD Utf8 "java/lang/Class"; // #32 at 0xF0 Utf8 "getModule"; // #33 at 0x0102 - Utf8 "()Ljava/lang/reflect/Module;"; // #34 at 0x010E + Utf8 "()Ljava/lang/Module;"; // #34 at 0x010E Utf8 "java/lang/ClassLoader"; // #35 at 0x012D Utf8 "getSystemClassLoader"; // #36 at 0x0145 Utf8 "()Ljava/lang/ClassLoader;"; // #37 at 0x015C Utf8 "getUnnamedModule"; // #38 at 0x0178 - Utf8 "java/lang/reflect/Module"; // #39 at 0x018B + Utf8 "java/lang/Module"; // #39 at 0x018B Utf8 "addReads"; // #40 at 0x01A6 - Utf8 "(Ljava/lang/reflect/Module;)Ljava/lang/reflect/Module;"; // #41 at 0x01B1 + Utf8 "(Ljava/lang/Module;)Ljava/lang/Module;"; // #41 at 0x01B1 Utf8 "myloaders/MyDiffClassLoader"; // #42 at 0x01EA Utf8 "loader2"; // #43 at 0x0208 Utf8 "Lmyloaders/MyDiffClassLoader;"; // #44 at 0x0212
--- a/hotspot/test/runtime/modules/AccessCheck/p4/c4.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheck/p4/c4.java Wed Jul 05 23:12:51 2017 +0200 @@ -25,8 +25,6 @@ package p4; -import java.lang.reflect.Module; - public class c4 { // Add a read edge from c4's module to given module m public void addReads(Module m) {
--- a/hotspot/test/runtime/modules/AccessCheckAllUnnamed.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheckAllUnnamed.java Wed Jul 05 23:12:51 2017 +0200 @@ -21,7 +21,6 @@ * questions. */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; /* @@ -31,7 +30,7 @@ * @compile p2/c2.java * @compile p1/c1.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AccessCheckAllUnnamed @@ -45,10 +44,10 @@ public static void main(String args[]) throws Throwable { Object m1x, m2x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlM = jlObject.getModule(); + assertNotNull(jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for AccessCheckWorks and assume it's also used to // load class p2.c2. @@ -58,13 +57,13 @@ m1x = ModuleHelper.ModuleObject("module_one", this_cldr, new String[] { "p3" }); assertNotNull(m1x, "Module should not be null"); ModuleHelper.DefineModule(m1x, "9.0", "m1x/there", new String[] { "p3" }); - ModuleHelper.AddReadsModule(m1x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m1x, jlM); // Define a module for p2. m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlM); try { ModuleHelper.AddModuleExportsToAllUnnamed((Module)null, "p2");
--- a/hotspot/test/runtime/modules/AccessCheckExp.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheckExp.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,13 +28,12 @@ * @compile p2/c2.java * @compile p1/c1.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AccessCheckExp */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class AccessCheckExp { @@ -44,10 +43,10 @@ public static void main(String args[]) throws Throwable { Object m1x, m2x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for AccessCheckExp and assume it's also used to // load classes p1.c1 and p2.c2. @@ -57,13 +56,13 @@ m1x = ModuleHelper.ModuleObject("module_one", this_cldr, new String[] { "p1" }); assertNotNull(m1x, "Module should not be null"); ModuleHelper.DefineModule(m1x, "9.0", "m1x/here", new String[] { "p1" }); - ModuleHelper.AddReadsModule(m1x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m1x, jlObject_jlM); // Define a module for p2. m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlObject_jlM); // Make package p1 in m1x visible to everyone. ModuleHelper.AddModuleExportsToAll(m1x, "p1");
--- a/hotspot/test/runtime/modules/AccessCheckJavaBase.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheckJavaBase.java Wed Jul 05 23:12:51 2017 +0200 @@ -27,13 +27,12 @@ * @library /test/lib .. * @compile p2/c2.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AccessCheckJavaBase */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class AccessCheckJavaBase {
--- a/hotspot/test/runtime/modules/AccessCheckRead.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheckRead.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,13 +28,12 @@ * @compile p2/c2.java * @compile p1/c1.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AccessCheckRead */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class AccessCheckRead { @@ -44,10 +43,10 @@ public static void main(String args[]) throws Throwable { Object m1x, m2x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for AccessCheckRead and assume it's also used to // load classes p1.c1 and p2.c2. @@ -57,13 +56,13 @@ m1x = ModuleHelper.ModuleObject("module_one", this_cldr, new String[] { "p1" }); assertNotNull(m1x, "Module should not be null"); ModuleHelper.DefineModule(m1x, "9.0", "m1x/here", new String[] { "p1" }); - ModuleHelper.AddReadsModule(m1x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m1x, jlObject_jlM); // Define a module for p2. m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlObject_jlM); // Make package p1 in m1x visible to everyone. ModuleHelper.AddModuleExportsToAll(m1x, "p1");
--- a/hotspot/test/runtime/modules/AccessCheckSuper.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheckSuper.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,13 +28,12 @@ * @compile p2/c2.java * @compile p3/c3.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AccessCheckSuper */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class AccessCheckSuper {
--- a/hotspot/test/runtime/modules/AccessCheckUnnamed.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheckUnnamed.java Wed Jul 05 23:12:51 2017 +0200 @@ -21,7 +21,6 @@ * questions. */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; /* @@ -31,7 +30,7 @@ * @compile p2/c2.java * @compile p1/c1.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AccessCheckUnnamed @@ -44,10 +43,10 @@ public static void main(String args[]) throws Throwable { Object m1x, m2x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for AccessCheckWorks and assume it's also used to // load class p2.c2. @@ -57,7 +56,7 @@ m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlObject_jlM); // p1.c1's ctor tries to call a method in p2.c2. This should fail because // p1 is in the unnamed module and p2.c2 is not unqualifiedly exported.
--- a/hotspot/test/runtime/modules/AccessCheckWorks.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/AccessCheckWorks.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,13 +28,12 @@ * @compile p2/c2.java * @compile p1/c1.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AccessCheckWorks */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class AccessCheckWorks { @@ -45,10 +44,10 @@ public static void main(String args[]) throws Throwable { Object m1x, m2x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for AccessCheckWorks and assume it's also used to // load classes p1.c1 and p2.c2. @@ -58,13 +57,13 @@ m1x = ModuleHelper.ModuleObject("module_one", this_cldr, new String[] { "p1" }); assertNotNull(m1x, "Module should not be null"); ModuleHelper.DefineModule(m1x, "9.0", "m1x/here", new String[] { "p1" }); - ModuleHelper.AddReadsModule(m1x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m1x, jlObject_jlM); // Define a module for p2. m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlObject_jlM); // Make package p1 in m1x visible to everyone. ModuleHelper.AddModuleExportsToAll(m1x, "p1");
--- a/hotspot/test/runtime/modules/CCE_module_msg.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/CCE_module_msg.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,14 +28,13 @@ * @compile p2/c2.java * @compile p4/c4.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI CCE_module_msg */ import java.io.*; -import java.lang.reflect.Module; import java.net.URL; import java.net.URLClassLoader; import java.nio.file.Path; @@ -73,10 +72,10 @@ } public static void invalidClassToString() throws Throwable { - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for CCE_module_msg and assume it's also used to // load classes p1.c1 and p2.c2. @@ -86,7 +85,7 @@ Object m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlObject_jlM); try { ModuleHelper.AddModuleExportsToAll(m2x, "p2"); @@ -105,10 +104,10 @@ } public static void invalidClassToStringCustomLoader() throws Throwable { - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Create a customer class loader to load class p4/c4. URL[] urls = new URL[] { CLASSES_DIR.toUri().toURL() };
--- a/hotspot/test/runtime/modules/ExportTwice.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/ExportTwice.java Wed Jul 05 23:12:51 2017 +0200 @@ -28,13 +28,12 @@ * @compile p2/c2.java * @compile p1/c1.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ExportTwice */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class ExportTwice { @@ -46,10 +45,10 @@ public static void main(String args[]) throws Throwable { Object m1x, m2x, m3x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for ExportTwice and assume it's also used to // load classes p1.c1 and p2.c2. @@ -59,19 +58,19 @@ m1x = ModuleHelper.ModuleObject("module_one", this_cldr, new String[] { "p1" }); assertNotNull(m1x, "Module should not be null"); ModuleHelper.DefineModule(m1x, "9.0", "m1x/here", new String[] { "p1" }); - ModuleHelper.AddReadsModule(m1x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m1x, jlObject_jlM); // Define a module for p2. m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlObject_jlM); // Define a module for p3. m3x = ModuleHelper.ModuleObject("module_three", this_cldr, new String[] { "p3" }); assertNotNull(m3x, "Module should not be null"); ModuleHelper.DefineModule(m3x, "9.0", "m3x/there", new String[] { "p3" }); - ModuleHelper.AddReadsModule(m3x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m3x, jlObject_jlM); // Make package p1 in m1x visible to everyone. ModuleHelper.AddModuleExportsToAll(m1x, "p1");
--- a/hotspot/test/runtime/modules/JVMAddModuleExportToAllUnnamed.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/JVMAddModuleExportToAllUnnamed.java Wed Jul 05 23:12:51 2017 +0200 @@ -30,11 +30,10 @@ * @build sun.hotspot.WhiteBox * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI JVMAddModuleExportToAllUnnamed */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class JVMAddModuleExportToAllUnnamed { @@ -44,10 +43,10 @@ public static void main(String args[]) throws Throwable { Object m1x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for JVMAddModuleExportToAllUnnamed and assume it's also used to // load class p1.c1. @@ -57,7 +56,7 @@ m1x = ModuleHelper.ModuleObject("module_one", this_cldr, new String[] { "p1" }); assertNotNull(m1x, "Module should not be null"); ModuleHelper.DefineModule(m1x, "9.0", "m1x/here", new String[] { "p1" }); - ModuleHelper.AddReadsModule(m1x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m1x, jlObject_jlM); // Make package p1 in m1x visible to everyone. ModuleHelper.AddModuleExportsToAll(m1x, "p1");
--- a/hotspot/test/runtime/modules/JVMAddModuleExports.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/JVMAddModuleExports.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,13 +26,12 @@ * @modules java.base/jdk.internal.misc * @library /test/lib .. * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI JVMAddModuleExports */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; public class JVMAddModuleExports {
--- a/hotspot/test/runtime/modules/JVMAddModuleExportsToAll.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/JVMAddModuleExportsToAll.java Wed Jul 05 23:12:51 2017 +0200 @@ -21,7 +21,6 @@ * questions. */ -import java.lang.reflect.Module; import static jdk.test.lib.Asserts.*; /* @@ -31,7 +30,7 @@ * @compile p2/c2.java * @compile p1/c1.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI JVMAddModuleExportsToAll @@ -45,10 +44,10 @@ public static void main(String args[]) throws Throwable { Object m1x, m2x, m3x; - // Get the java.lang.reflect.Module object for module java.base. + // Get the java.lang.Module object for module java.base. Class jlObject = Class.forName("java.lang.Object"); - Object jlObject_jlrM = jlObject.getModule(); - assertNotNull(jlObject_jlrM, "jlrModule object of java.lang.Object should not be null"); + Object jlObject_jlM = jlObject.getModule(); + assertNotNull(jlObject_jlM, "jlModule object of java.lang.Object should not be null"); // Get the class loader for JVMAddModuleExportsToAll and assume it's also used to // load class p2.c2. @@ -58,13 +57,13 @@ m1x = ModuleHelper.ModuleObject("module_one", this_cldr, new String[] { "p3" }); assertNotNull(m1x, "Module should not be null"); ModuleHelper.DefineModule(m1x, "9.0", "m1x/there", new String[] { "p3" }); - ModuleHelper.AddReadsModule(m1x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m1x, jlObject_jlM); // Define a module for p2. m2x = ModuleHelper.ModuleObject("module_two", this_cldr, new String[] { "p2" }); assertNotNull(m2x, "Module should not be null"); ModuleHelper.DefineModule(m2x, "9.0", "m2x/there", new String[] { "p2" }); - ModuleHelper.AddReadsModule(m2x, jlObject_jlrM); + ModuleHelper.AddReadsModule(m2x, jlObject_jlM); try { ModuleHelper.AddModuleExportsToAll((Module)null, "p2"); @@ -80,7 +79,7 @@ // Expected } - try { // Expect IAE when passing a ClassLoader object instead of a java.lang.reflect.Module object. + try { // Expect IAE when passing a ClassLoader object instead of a java.lang.Module object. ModuleHelper.AddModuleExportsToAll(this_cldr, "p2"); throw new RuntimeException("Failed to get the expected IAE for bad module"); } catch(IllegalArgumentException e) {
--- a/hotspot/test/runtime/modules/JVMAddModulePackage.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/JVMAddModulePackage.java Wed Jul 05 23:12:51 2017 +0200 @@ -26,7 +26,7 @@ * @modules java.base/jdk.internal.misc * @library /test/lib .. * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI JVMAddModulePackage
--- a/hotspot/test/runtime/modules/JVMAddReadsModule.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/JVMAddReadsModule.java Wed Jul 05 23:12:51 2017 +0200 @@ -26,7 +26,7 @@ * @modules java.base/jdk.internal.misc * @library /test/lib .. * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI JVMAddReadsModule
--- a/hotspot/test/runtime/modules/JVMDefineModule.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/JVMDefineModule.java Wed Jul 05 23:12:51 2017 +0200 @@ -26,7 +26,7 @@ * @modules java.base/jdk.internal.misc * @library /test/lib .. * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI JVMDefineModule @@ -78,7 +78,7 @@ ModuleHelper.DefineModule(new Object(), "9.0", "mymodule/here", new String[] { "mypackage1" }); throw new RuntimeException("Failed to get expected IAE or NPE for bad module"); } catch(IllegalArgumentException e) { - if (!e.getMessage().contains("module is not an instance of type java.lang.reflect.Module")) { + if (!e.getMessage().contains("module is not an instance of type java.lang.Module")) { throw new RuntimeException("Failed to get expected IAE message for bad module: " + e.getMessage()); } }
--- a/hotspot/test/runtime/modules/JVMGetModuleByPkgName.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/JVMGetModuleByPkgName.java Wed Jul 05 23:12:51 2017 +0200 @@ -27,7 +27,7 @@ * @library /test/lib .. * @compile p2/c2.java * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI JVMGetModuleByPkgName @@ -35,7 +35,6 @@ import static jdk.test.lib.Asserts.*; import java.lang.ClassLoader; -import java.lang.reflect.Module; public class JVMGetModuleByPkgName {
--- a/hotspot/test/runtime/modules/LoadUnloadModuleStress.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/LoadUnloadModuleStress.java Wed Jul 05 23:12:51 2017 +0200 @@ -27,7 +27,7 @@ * @modules java.base/jdk.internal.misc * @library /test/lib .. * @build sun.hotspot.WhiteBox - * @compile/module=java.base java/lang/reflect/ModuleHelper.java + * @compile/module=java.base java/lang/ModuleHelper.java * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xmx64m -Xmx64m LoadUnloadModuleStress 15000
--- a/hotspot/test/runtime/modules/ModuleHelper.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/ModuleHelper.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,7 +23,6 @@ import java.net.URI; import java.lang.module.ModuleDescriptor; -import java.lang.reflect.Module; import java.util.Collections; import java.util.HashSet; import java.util.Set; @@ -41,19 +40,19 @@ public static void AddModuleExports(Object from, String pkg, Object to) throws Throwable { WhiteBox wb = WhiteBox.getWhiteBox(); wb.AddModuleExports(from, pkg, to); - java.lang.reflect.ModuleHelper.addExportsNoSync((Module)from, pkg, (Module)to); + java.lang.ModuleHelper.addExportsNoSync((Module)from, pkg, (Module)to); } public static void AddReadsModule(Object from, Object to) throws Throwable { WhiteBox wb = WhiteBox.getWhiteBox(); wb.AddReadsModule(from, to); - java.lang.reflect.ModuleHelper.addReadsNoSync((Module)from, (Module)to); + java.lang.ModuleHelper.addReadsNoSync((Module)from, (Module)to); } public static void AddModulePackage(Object m, String pkg) throws Throwable { WhiteBox wb = WhiteBox.getWhiteBox(); wb.AddModulePackage(m, pkg); - java.lang.reflect.ModuleHelper.addPackageNoSync((Module)m, pkg); + java.lang.ModuleHelper.addPackageNoSync((Module)m, pkg); } public static Module GetModuleByPackageName(Object ldr, String pkg) throws Throwable { @@ -64,13 +63,13 @@ public static void AddModuleExportsToAllUnnamed(Object m, String pkg) throws Throwable { WhiteBox wb = WhiteBox.getWhiteBox(); wb.AddModuleExportsToAllUnnamed(m, pkg); - //java.lang.reflect.ModuleHelper.addExportsToAllUnnamedNoSync((Module)m, pkg); + //java.lang.ModuleHelper.addExportsToAllUnnamedNoSync((Module)m, pkg); } public static void AddModuleExportsToAll(Object m, String pkg) throws Throwable { WhiteBox wb = WhiteBox.getWhiteBox(); wb.AddModuleExportsToAll(m, pkg); - java.lang.reflect.ModuleHelper.addExportsNoSync((Module)m, pkg, (Module)null); + java.lang.ModuleHelper.addExportsNoSync((Module)m, pkg, (Module)null); } public static Module ModuleObject(String name, ClassLoader loader, String[] pkgs) throws Throwable { @@ -87,7 +86,7 @@ ModuleDescriptor.newModule(name).packages(pkg_set).build(); URI uri = URI.create("module:/" + name); - return java.lang.reflect.ModuleHelper.newModule(loader, descriptor); + return java.lang.ModuleHelper.newModule(loader, descriptor); } }
--- a/hotspot/test/runtime/modules/ModuleStress/ModuleNonBuiltinCLMain.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/ModuleStress/ModuleNonBuiltinCLMain.java Wed Jul 05 23:12:51 2017 +0200 @@ -25,7 +25,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -47,7 +46,7 @@ // public class ModuleNonBuiltinCLMain { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -90,7 +89,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x, descriptor_m3x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -103,8 +102,8 @@ map.put("m2x", cl2); map.put("m3x", cl3); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == cl1); assertTrue(layer.findLoader("m2x") == cl2); assertTrue(layer.findLoader("m3x") == cl3);
--- a/hotspot/test/runtime/modules/ModuleStress/ModuleSameCLMain.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/ModuleStress/ModuleSameCLMain.java Wed Jul 05 23:12:51 2017 +0200 @@ -25,7 +25,6 @@ import static jdk.test.lib.Asserts.*; -import java.lang.reflect.Layer; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; @@ -45,7 +44,7 @@ // public class ModuleSameCLMain { - // Create a Layer over the boot layer. + // Create a layer over the boot layer. // Define modules within this layer to test access between // publically defined classes within packages of those modules. public void createLayerOnBoot() throws Throwable { @@ -75,7 +74,7 @@ ModuleFinder finder = ModuleLibrary.of(descriptor_m1x, descriptor_m2x); // Resolves "m1x" - Configuration cf = Layer.boot() + Configuration cf = ModuleLayer.boot() .configuration() .resolve(finder, ModuleFinder.of(), Set.of("m1x")); @@ -85,8 +84,8 @@ map.put("m1x", cl1); map.put("m2x", cl1); - // Create Layer that contains m1x & m2x - Layer layer = Layer.boot().defineModules(cf, map::get); + // Create layer that contains m1x & m2x + ModuleLayer layer = ModuleLayer.boot().defineModules(cf, map::get); assertTrue(layer.findLoader("m1x") == cl1); assertTrue(layer.findLoader("m2x") == cl1); assertTrue(layer.findLoader("java.base") == null);
--- a/hotspot/test/runtime/modules/ModuleStress/src/jdk.test/test/Main.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/ModuleStress/src/jdk.test/test/Main.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,9 +25,7 @@ import java.lang.module.Configuration; import java.lang.module.ModuleFinder; -import java.lang.reflect.Layer; import java.lang.reflect.Method; -import java.lang.reflect.Module; import java.nio.file.Path; import java.nio.file.Paths; import java.util.*; @@ -44,7 +42,7 @@ public static void main(String[] args) throws Exception { ModuleFinder finder = ModuleFinder.of(MODS_DIR); - Layer layerBoot = Layer.boot(); + ModuleLayer layerBoot = ModuleLayer.boot(); Configuration cf = layerBoot .configuration() @@ -58,7 +56,7 @@ Callable<Void> task = new Callable<Void>() { @Override public Void call() throws Exception { - Layer layer = Layer.boot().defineModulesWithOneLoader(cf, scl); + ModuleLayer layer = ModuleLayer.boot().defineModulesWithOneLoader(cf, scl); Module transletModule = layer.findModule(MODULE_NAME).get(); testModule.addExports("test", transletModule); Class<?> c = layer.findLoader(MODULE_NAME).loadClass("translet.Main");
--- a/hotspot/test/runtime/modules/ModuleStress/src/jdk.test/test/MainGC.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/ModuleStress/src/jdk.test/test/MainGC.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,9 +25,7 @@ import java.lang.module.Configuration; import java.lang.module.ModuleFinder; -import java.lang.reflect.Layer; import java.lang.reflect.Method; -import java.lang.reflect.Module; import java.nio.file.Path; import java.nio.file.Paths; import java.util.*; @@ -44,7 +42,7 @@ public static void main(String[] args) throws Exception { ModuleFinder finder = ModuleFinder.of(MODS_DIR); - Layer layerBoot = Layer.boot(); + ModuleLayer layerBoot = ModuleLayer.boot(); Configuration cf = layerBoot .configuration() @@ -59,7 +57,7 @@ Callable<Void> task = new Callable<Void>() { @Override public Void call() throws Exception { - Layer layer = Layer.boot().defineModulesWithOneLoader(cf, scl); + ModuleLayer layer = ModuleLayer.boot().defineModulesWithOneLoader(cf, scl); Module transletModule = layer.findModule(MODULE_NAME).get(); testModule.addExports("test", transletModule); testModule.addReads(transletModule);
--- a/hotspot/test/runtime/modules/getModuleJNI/GetModule.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/runtime/modules/getModuleJNI/GetModule.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,7 +26,6 @@ * @run main/native GetModule */ -import java.lang.reflect.Module; import java.lang.management.LockInfo; public class GetModule {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hotspot/test/runtime/modules/java.base/java/lang/ModuleHelper.java Wed Jul 05 23:12:51 2017 +0200 @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +import java.lang.module.ModuleDescriptor; + +/** + * A helper class intended to be injected into java.lang using the + * java --patch-module option. The helper class provides access to package private + * methods in java.lang.Module. + */ + +public final class ModuleHelper { + + private ModuleHelper() { } + + /** + * Creates a named module but without defining the module to the VM. + */ + public static Module newModule(ClassLoader loader, ModuleDescriptor descriptor) { + return new Module(loader, descriptor); + } + + /** + * Updates module {@code from} to that it reads module {@code to} without + * notifying the VM. + */ + public static void addReadsNoSync(Module from, Module to) { + from.implAddReadsNoSync(to); + } + + /** + * Updates module {@code from} so that it exports package {@code pkg} + * to module {@code to} but without notifying the VM. If {@code to} is + * {@code null} then the package is exported unconditionally. + */ + public static void addExportsNoSync(Module from, String pkg, Module to) { + if (to == null) { + from.implAddExportsNoSync(pkg); + } else { + from.implAddExportsNoSync(pkg, to); + } + } + + /** + * Adds a package to a module without notifying the VM. + */ + public static void addPackageNoSync(Module m, String pkg) { + m.implAddPackageNoSync(pkg); + } + +}
--- a/hotspot/test/runtime/modules/java.base/java/lang/reflect/ModuleHelper.java Thu Apr 13 20:36:02 2017 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,69 +0,0 @@ -/* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package java.lang.reflect; - -import java.lang.module.ModuleDescriptor; - -/** - * A helper class intended to be injected into java.lang.reflect using the - * java --patch-module option. The helper class provides access to package private - * methods in java.lang.reflect.Module. - */ - -public final class ModuleHelper { - - private ModuleHelper() { } - - /** - * Creates a named module but without defining the module to the VM. - */ - public static Module newModule(ClassLoader loader, ModuleDescriptor descriptor) { - return new Module(loader, descriptor); - } - - /** - * Updates module {@code from} to that it reads module {@code to} without - * notifying the VM. - */ - public static void addReadsNoSync(Module from, Module to) { - from.implAddReadsNoSync(to); - } - - /** - * Updates module {@code from} so that it exports package {@code pkg} - * to module {@code to} but without notifying the VM. If {@code to} is - * {@code null} then the package is exported unconditionally. - */ - public static void addExportsNoSync(Module from, String pkg, Module to) { - from.implAddExportsNoSync(pkg, to); - } - - /** - * Adds a package to a module without notifying the VM. - */ - public static void addPackageNoSync(Module m, String pkg) { - m.implAddPackageNoSync(pkg); - } - -}
--- a/hotspot/test/serviceability/jdwp/AllModulesCommandTestDebuggee.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jdwp/AllModulesCommandTestDebuggee.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,8 +21,6 @@ * questions. */ -import java.lang.reflect.Module; -import java.lang.reflect.Layer; import java.util.Set; import java.util.HashSet; @@ -35,10 +33,10 @@ public static void main(String[] args) throws InterruptedException { - int modCount = Layer.boot().modules().size(); + int modCount = ModuleLayer.boot().modules().size(); // Send all modules names via the process output - for (Module mod : Layer.boot().modules()) { + for (Module mod : ModuleLayer.boot().modules()) { String info = String.format("module %s", mod.getName()); write(info); }
--- a/hotspot/test/serviceability/jvmti/AddModuleExportsAndOpens/MyPackage/AddModuleExportsAndOpensTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/AddModuleExportsAndOpens/MyPackage/AddModuleExportsAndOpensTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -31,7 +31,6 @@ */ import java.io.PrintStream; -import java.lang.reflect.Module; public class AddModuleExportsAndOpensTest {
--- a/hotspot/test/serviceability/jvmti/AddModuleExportsAndOpens/libAddModuleExportsAndOpensTest.c Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/AddModuleExportsAndOpens/libAddModuleExportsAndOpensTest.c Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -47,7 +47,7 @@ #define FAILED 2 static const char *EXC_CNAME = "java/lang/Exception"; -static const char* MOD_CNAME = "Ljava/lang/reflect/Module;"; +static const char* MOD_CNAME = "Ljava/lang/Module;"; static jvmtiEnv *jvmti = NULL; static jint result = PASSED; @@ -97,7 +97,7 @@ } static -jclass jlrM(JNIEnv *env) { +jclass jlM(JNIEnv *env) { jclass cls = NULL; cls = JNI_ENV_PTR(env)->FindClass(JNI_ENV_ARG(env, MOD_CNAME)); @@ -127,7 +127,7 @@ if (mIsExported == NULL) { const char* sign = "(Ljava/lang/String;)Z"; const char* name = open ? "isOpen" : "isExported"; - mIsExported = get_method(env, jlrM(env), name, sign); + mIsExported = get_method(env, jlM(env), name, sign); } jstr = JNI_ENV_PTR(env)->NewStringUTF(JNI_ENV_ARG(env, pkg)); res = JNI_ENV_PTR(env)->CallBooleanMethod(JNI_ENV_ARG(env, module), @@ -143,9 +143,9 @@ jboolean res = JNI_FALSE; if (mIsExportedTo == NULL) { - const char* sign = "(Ljava/lang/String;Ljava/lang/reflect/Module;)Z"; + const char* sign = "(Ljava/lang/String;Ljava/lang/Module;)Z"; const char* name = open ? "isOpen" : "isExported"; - mIsExportedTo = get_method(env, jlrM(env), name, sign); + mIsExportedTo = get_method(env, jlM(env), name, sign); } jstr = JNI_ENV_PTR(env)->NewStringUTF(JNI_ENV_ARG(env, pkg)); res = JNI_ENV_PTR(env)->CallBooleanMethod(JNI_ENV_ARG(env, module),
--- a/hotspot/test/serviceability/jvmti/AddModuleReads/MyPackage/AddModuleReadsTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/AddModuleReads/MyPackage/AddModuleReadsTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -32,7 +32,6 @@ import java.io.PrintStream; import java.lang.instrument.Instrumentation; -import java.lang.reflect.Module; public class AddModuleReadsTest {
--- a/hotspot/test/serviceability/jvmti/AddModuleReads/libAddModuleReadsTest.c Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/AddModuleReads/libAddModuleReadsTest.c Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -47,7 +47,7 @@ #define FAILED 2 static const char *EXC_CNAME = "java/lang/Exception"; -static const char* MOD_CNAME = "Ljava/lang/reflect/Module;"; +static const char* MOD_CNAME = "Ljava/lang/Module;"; static jvmtiEnv *jvmti = NULL; static jint result = PASSED; @@ -96,7 +96,7 @@ } static -jclass jlrM(JNIEnv *env) { +jclass jlM(JNIEnv *env) { jclass cls = NULL; cls = JNI_ENV_PTR(env)->FindClass(JNI_ENV_ARG(env, MOD_CNAME)); @@ -123,8 +123,8 @@ jboolean res = JNI_FALSE; if (mCanRead == NULL) { - const char* sign = "(Ljava/lang/reflect/Module;)Z"; - mCanRead = get_method(env, jlrM(env), "canRead", sign); + const char* sign = "(Ljava/lang/Module;)Z"; + mCanRead = get_method(env, jlM(env), "canRead", sign); } res = JNI_ENV_PTR(env)->CallBooleanMethod(JNI_ENV_ARG(env, module), mCanRead, to_module);
--- a/hotspot/test/serviceability/jvmti/AddModuleUsesAndProvides/MyPackage/AddModuleUsesAndProvidesTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/AddModuleUsesAndProvides/MyPackage/AddModuleUsesAndProvidesTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -34,7 +34,6 @@ import java.io.PrintStream; import java.lang.TestProvider; -import java.lang.reflect.Module; public class AddModuleUsesAndProvidesTest {
--- a/hotspot/test/serviceability/jvmti/AddModuleUsesAndProvides/libAddModuleUsesAndProvidesTest.c Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/AddModuleUsesAndProvides/libAddModuleUsesAndProvidesTest.c Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -47,7 +47,7 @@ #define FAILED 2 static const char *EXC_CNAME = "java/lang/Exception"; -static const char* MOD_CNAME = "Ljava/lang/reflect/Module;"; +static const char* MOD_CNAME = "Ljava/lang/Module;"; static jvmtiEnv *jvmti = NULL; static jint result = PASSED; @@ -97,7 +97,7 @@ } static -jclass jlrM(JNIEnv *env) { +jclass jlM(JNIEnv *env) { jclass cls = NULL; cls = JNI_ENV_PTR(env)->FindClass(JNI_ENV_ARG(env, MOD_CNAME)); @@ -125,7 +125,7 @@ if (mCanUse == NULL) { const char* sign = "(Ljava/lang/Class;)Z"; - mCanUse = get_method(env, jlrM(env), "canUse", sign); + mCanUse = get_method(env, jlM(env), "canUse", sign); } res = JNI_ENV_PTR(env)->CallBooleanMethod(JNI_ENV_ARG(env, module), mCanUse, service);
--- a/hotspot/test/serviceability/jvmti/GetModulesInfo/JvmtiGetAllModulesTest.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/GetModulesInfo/JvmtiGetAllModulesTest.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,8 +28,6 @@ * @run main/othervm -agentlib:JvmtiGetAllModulesTest JvmtiGetAllModulesTest * */ -import java.lang.reflect.Layer; -import java.lang.reflect.Module; import java.lang.module.ModuleReference; import java.lang.module.ModuleFinder; import java.lang.module.ModuleReader; @@ -79,15 +77,15 @@ final String MY_MODULE_NAME = "myModule"; // Verify that JVMTI reports exactly the same info as Java regarding the named modules - Asserts.assertEquals(Layer.boot().modules(), getModulesJVMTI()); + Asserts.assertEquals(ModuleLayer.boot().modules(), getModulesJVMTI()); // Load a new named module ModuleDescriptor descriptor = ModuleDescriptor.newModule(MY_MODULE_NAME).build(); ModuleFinder finder = finderOf(descriptor); ClassLoader loader = new ClassLoader() {}; - Configuration parent = Layer.boot().configuration(); + Configuration parent = ModuleLayer.boot().configuration(); Configuration cf = parent.resolve(finder, ModuleFinder.of(), Set.of(MY_MODULE_NAME)); - Layer my = Layer.boot().defineModules(cf, m -> loader); + ModuleLayer my = ModuleLayer.boot().defineModules(cf, m -> loader); // Verify that the loaded module is indeed reported by JVMTI Set<Module> jvmtiModules = getModulesJVMTI();
--- a/hotspot/test/serviceability/jvmti/GetModulesInfo/libJvmtiGetAllModulesTest.c Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/GetModulesInfo/libJvmtiGetAllModulesTest.c Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -53,7 +53,7 @@ return NULL; } - array = (*env)->NewObjectArray(env, modules_count, (*env)->FindClass(env, "java/lang/reflect/Module"), NULL); + array = (*env)->NewObjectArray(env, modules_count, (*env)->FindClass(env, "java/lang/Module"), NULL); for (i = 0; i < modules_count; ++i) { (*env)->SetObjectArrayElement(env, array, i, modules_ptr[i]);
--- a/hotspot/test/serviceability/jvmti/GetNamedModule/libGetNamedModuleTest.c Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/serviceability/jvmti/GetNamedModule/libGetNamedModuleTest.c Wed Jul 05 23:12:51 2017 +0200 @@ -47,7 +47,7 @@ #define FAILED 2 static const char *EXC_CNAME = "java/lang/Exception"; -static const char* MOD_CNAME = "Ljava/lang/reflect/Module;"; +static const char* MOD_CNAME = "Ljava/lang/Module;"; static jvmtiEnv *jvmti = NULL; static jint result = PASSED; @@ -115,7 +115,7 @@ } static -jclass jlrM(JNIEnv *env) { +jclass jlM(JNIEnv *env) { jclass cls = NULL; cls = JNI_ENV_PTR(env)->FindClass(JNI_ENV_ARG(env, MOD_CNAME)); @@ -142,7 +142,7 @@ jobject loader = NULL; if (cl_method == NULL) { - cl_method = get_method(env, jlrM(env), "getClassLoader", "()Ljava/lang/ClassLoader;"); + cl_method = get_method(env, jlM(env), "getClassLoader", "()Ljava/lang/ClassLoader;"); } loader = (jobject)JNI_ENV_PTR(env)->CallObjectMethod(JNI_ENV_ARG(env, module), cl_method); return loader; @@ -157,7 +157,7 @@ const char *nstr = NULL; if (method == NULL) { - method = get_method(env, jlrM(env), "getName", "()Ljava/lang/String;"); + method = get_method(env, jlM(env), "getName", "()Ljava/lang/String;"); } jstr = (jstring)JNI_ENV_PTR(env)->CallObjectMethod(JNI_ENV_ARG(env, module), method); if (jstr != NULL) {
--- a/hotspot/test/testlibrary/ctw/src/sun/hotspot/tools/ctw/PathHandler.java Thu Apr 13 20:36:02 2017 +0000 +++ b/hotspot/test/testlibrary/ctw/src/sun/hotspot/tools/ctw/PathHandler.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -151,8 +151,9 @@ if (id >= Utils.COMPILE_THE_WORLD_START_AT) { try { Class<?> aClass = loader.loadClass(name); - if (name != "sun.reflect.misc.Trampoline" - && name != "sun.tools.jconsole.OutputViewer") { // workaround for JDK-8159155 + if (!"sun.reflect.misc.Trampoline".equals(name) + // workaround for JDK-8159155 + && !"sun.tools.jconsole.OutputViewer".equals(name)) { UNSAFE.ensureClassInitialized(aClass); } CompileTheWorld.OUT.printf("[%d]\t%s%n", id, name);
--- a/jdk/.hgtags Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/.hgtags Wed Jul 05 23:12:51 2017 +0200 @@ -408,3 +408,4 @@ f6bf027e88e9a4dd19f721001a7af00157af42c4 jdk-9+162 50171f8c47961710cbf87aead6f03fa431d8d240 jdk-9+163 6dea581453d7c0e767e3169cfec8b423a381e71d jdk-9+164 +a7942c3b1e59495dbf51dc7c41aab355fcd253d7 jdk-9+165
--- a/jdk/make/data/tzdata/VERSION Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/make/data/tzdata/VERSION Wed Jul 05 23:12:51 2017 +0200 @@ -21,4 +21,4 @@ # or visit www.oracle.com if you need additional information or have any # questions. # -tzdata2017a +tzdata2017b
--- a/jdk/make/data/tzdata/africa Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/make/data/tzdata/africa Wed Jul 05 23:12:51 2017 +0200 @@ -443,18 +443,25 @@ # See Africa/Johannesburg. # Liberia -# From Paul Eggert (2006-03-22): -# In 1972 Liberia was the last country to switch -# from a UTC offset that was not a multiple of 15 or 20 minutes. -# Howse reports that it was in honor of their president's birthday. -# Shank & Pottenger report the date as May 1, whereas Howse reports Jan; -# go with Shanks & Pottenger. -# For Liberia before 1972, Shanks & Pottenger report -0:44, whereas Howse and -# Whitman each report -0:44:30; go with the more precise figure. +# +# From Paul Eggert (2017-03-02): +# +# The Nautical Almanac for the Year 1970, p 264, is the source for -0:44:30. +# +# In 1972 Liberia was the last country to switch from a UTC offset +# that was not a multiple of 15 or 20 minutes. The 1972 change was on +# 1972-01-07, according to an entry dated 1972-01-04 on p 330 of: +# Presidential Papers: First year of the administration of +# President William R. Tolbert, Jr., July 23, 1971-July 31, 1972. +# Monrovia: Executive Mansion. +# +# Use the abbreviation "MMT" before 1972, as the more-accurate numeric +# abbreviation "-004430" would be one byte over the POSIX limit. +# # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Africa/Monrovia -0:43:08 - LMT 1882 -0:43:08 - MMT 1919 Mar # Monrovia Mean Time - -0:44:30 - -004430 1972 May + -0:44:30 - MMT 1972 Jan 7 # approximately MMT 0:00 - GMT ###############################################################################
--- a/jdk/make/data/tzdata/iso3166.tab Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/make/data/tzdata/iso3166.tab Wed Jul 05 23:12:51 2017 +0200 @@ -32,8 +32,8 @@ # All text uses UTF-8 encoding. The columns of the table are as follows: # # 1. ISO 3166-1 alpha-2 country code, current as of -# ISO 3166-1 Newsletter VI-16 (2013-07-11). See: Updates on ISO 3166 -# http://www.iso.org/iso/home/standards/country_codes/updates_on_iso_3166.htm +# ISO 3166-1 N905 (2016-11-15). See: Updates on ISO 3166-1 +# http://isotc.iso.org/livelink/livelink/Open/16944257 # 2. The usual English name for the coded region, # chosen so that alphabetic sorting of subsets produces helpful lists. # This is not the same as the English name in the ISO 3166 tables.
--- a/jdk/make/data/tzdata/northamerica Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/make/data/tzdata/northamerica Wed Jul 05 23:12:51 2017 +0200 @@ -3162,6 +3162,12 @@ # http://www.vantbefinfo.com/changement-dheure-pas-pour-haiti/ # http://news.anmwe.com/haiti-lheure-nationale-ne-sera-ni-avancee-ni-reculee-cette-annee/ +# From Steffen Thorsen (2017-03-12): +# We have received 4 mails from different people telling that Haiti +# has started DST again today, and this source seems to confirm that, +# I have not been able to find a more authoritative source: +# https://www.haitilibre.com/en/news-20319-haiti-notices-time-change-in-haiti.html + # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S Rule Haiti 1983 only - May 8 0:00 1:00 D Rule Haiti 1984 1987 - Apr lastSun 0:00 1:00 D @@ -3174,6 +3180,8 @@ Rule Haiti 2005 2006 - Oct lastSun 0:00 0 S Rule Haiti 2012 2015 - Mar Sun>=8 2:00 1:00 D Rule Haiti 2012 2015 - Nov Sun>=1 2:00 0 S +Rule Haiti 2017 max - Mar Sun>=8 2:00 1:00 D +Rule Haiti 2017 max - Nov Sun>=1 2:00 0 S # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone America/Port-au-Prince -4:49:20 - LMT 1890 -4:49 - PPMT 1917 Jan 24 12:00 # P-a-P MT
--- a/jdk/make/mapfiles/libjava/mapfile-vers Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/make/mapfiles/libjava/mapfile-vers Wed Jul 05 23:12:51 2017 +0200 @@ -273,12 +273,12 @@ Java_jdk_internal_misc_VM_getRuntimeArguments; Java_jdk_internal_misc_VM_initialize; - Java_java_lang_reflect_Module_defineModule0; - Java_java_lang_reflect_Module_addReads0; - Java_java_lang_reflect_Module_addExports0; - Java_java_lang_reflect_Module_addExportsToAll0; - Java_java_lang_reflect_Module_addExportsToAllUnnamed0; - Java_java_lang_reflect_Module_addPackage0; + Java_java_lang_Module_defineModule0; + Java_java_lang_Module_addReads0; + Java_java_lang_Module_addExports0; + Java_java_lang_Module_addExportsToAll0; + Java_java_lang_Module_addExportsToAllUnnamed0; + Java_java_lang_Module_addPackage0; Java_jdk_internal_loader_BootLoader_getSystemPackageLocation; Java_jdk_internal_loader_BootLoader_getSystemPackageNames;
--- a/jdk/src/java.base/macosx/classes/java/net/DefaultInterface.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/macosx/classes/java/net/DefaultInterface.java Wed Jul 05 23:12:51 2017 +0200 @@ -50,10 +50,11 @@ } /** - * Choose a default interface. This method returns an interface that is - * both "up" and supports multicast. This method choses an interface in + * Choose a default interface. This method returns the first interface that + * is both "up" and supports multicast. This method chooses an interface in * order of preference: * 1. neither loopback nor point to point + * ( prefer interfaces with dual IP support ) * 2. point to point * 3. loopback * @@ -66,32 +67,56 @@ try { nifs = NetworkInterface.getNetworkInterfaces(); } catch (IOException ignore) { - // unable to enumate network interfaces + // unable to enumerate network interfaces return null; } + NetworkInterface preferred = null; NetworkInterface ppp = null; NetworkInterface loopback = null; while (nifs.hasMoreElements()) { NetworkInterface ni = nifs.nextElement(); try { - if (ni.isUp() && ni.supportsMulticast()) { - boolean isLoopback = ni.isLoopback(); - boolean isPPP = ni.isPointToPoint(); - if (!isLoopback && !isPPP) { - // found an interface that is not the loopback or a - // point-to-point interface + if (!ni.isUp() || !ni.supportsMulticast()) + continue; + + boolean ip4 = false, ip6 = false; + Enumeration<InetAddress> addrs = ni.getInetAddresses(); + while (addrs.hasMoreElements()) { + InetAddress addr = addrs.nextElement(); + if (!addr.isAnyLocalAddress()) { + if (addr instanceof Inet4Address) { + ip4 = true; + } else if (addr instanceof Inet6Address) { + ip6 = true; + } + } + } + + boolean isLoopback = ni.isLoopback(); + boolean isPPP = ni.isPointToPoint(); + if (!isLoopback && !isPPP) { + // found an interface that is not the loopback or a + // point-to-point interface + if (preferred == null) { + preferred = ni; + } else if (ip4 && ip6){ return ni; } - if (ppp == null && isPPP) - ppp = ni; - if (loopback == null && isLoopback) - loopback = ni; } + if (ppp == null && isPPP) + ppp = ni; + if (loopback == null && isLoopback) + loopback = ni; + } catch (IOException skip) { } } - return (ppp != null) ? ppp : loopback; + if (preferred != null) { + return preferred; + } else { + return (ppp != null) ? ppp : loopback; + } } }
--- a/jdk/src/java.base/share/classes/com/sun/crypto/provider/DESKey.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/com/sun/crypto/provider/DESKey.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -149,6 +149,7 @@ * Ensures that the bytes of this key are * set to zero when there are no more references to it. */ + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { try { if (this.key != null) {
--- a/jdk/src/java.base/share/classes/com/sun/crypto/provider/DESedeKey.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/com/sun/crypto/provider/DESedeKey.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -150,6 +150,7 @@ * Ensures that the bytes of this key are * set to zero when there are no more references to it. */ + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { try { if (this.key != null) {
--- a/jdk/src/java.base/share/classes/com/sun/crypto/provider/PBEKey.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/com/sun/crypto/provider/PBEKey.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -145,6 +145,7 @@ * Ensures that the password bytes of this key are * set to zero when there are no more references to it. */ + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { try { if (this.key != null) {
--- a/jdk/src/java.base/share/classes/com/sun/crypto/provider/PBKDF2KeyImpl.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/com/sun/crypto/provider/PBKDF2KeyImpl.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -267,6 +267,7 @@ * Ensures that the password bytes of this key are * erased when there are no more references to it. */ + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { try { if (this.passwd != null) {
--- a/jdk/src/java.base/share/classes/java/io/BufferedReader.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/io/BufferedReader.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -297,14 +297,15 @@ /** * Reads a line of text. A line is considered to be terminated by any one - * of a line feed ('\n'), a carriage return ('\r'), or a carriage return - * followed immediately by a linefeed. + * of a line feed ('\n'), a carriage return ('\r'), a carriage return + * followed immediately by a line feed, or by reaching the end-of-file + * (EOF). * * @param ignoreLF If true, the next '\n' will be skipped * * @return A String containing the contents of the line, not including * any line-termination characters, or null if the end of the - * stream has been reached + * stream has been reached without reading any characters * * @see java.io.LineNumberReader#readLine() * @@ -375,12 +376,13 @@ /** * Reads a line of text. A line is considered to be terminated by any one - * of a line feed ('\n'), a carriage return ('\r'), or a carriage return - * followed immediately by a linefeed. + * of a line feed ('\n'), a carriage return ('\r'), a carriage return + * followed immediately by a line feed, or by reaching the end-of-file + * (EOF). * * @return A String containing the contents of the line, not including * any line-termination characters, or null if the end of the - * stream has been reached + * stream has been reached without reading any characters * * @exception IOException If an I/O error occurs *
--- a/jdk/src/java.base/share/classes/java/io/FileInputStream.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/io/FileInputStream.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -413,9 +413,19 @@ * Ensures that the <code>close</code> method of this file input stream is * called when there are no more references to it. * + * @deprecated The {@code finalize} method has been deprecated. + * Subclasses that override {@code finalize} in order to perform cleanup + * should be modified to use alternative cleanup mechanisms and + * to remove the overriding {@code finalize} method. + * When overriding the {@code finalize} method, its implementation must explicitly + * ensure that {@code super.finalize()} is invoked as described in {@link Object#finalize}. + * See the specification for {@link Object#finalize()} for further + * information about migration options. + * * @exception IOException if an I/O error occurs. * @see java.io.FileInputStream#close() */ + @Deprecated(since="9") protected void finalize() throws IOException { if ((fd != null) && (fd != FileDescriptor.in)) { /* if fd is shared, the references in FileDescriptor
--- a/jdk/src/java.base/share/classes/java/io/FileOutputStream.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/io/FileOutputStream.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -427,9 +427,18 @@ * <code>close</code> method of this file output stream is * called when there are no more references to this stream. * + * @deprecated The {@code finalize} method has been deprecated. + * Subclasses that override {@code finalize} in order to perform cleanup + * should be modified to use alternative cleanup mechanisms and + * to remove the overriding {@code finalize} method. + * When overriding the {@code finalize} method, its implementation must explicitly + * ensure that {@code super.finalize()} is invoked as described in {@link Object#finalize}. + * See the specification for {@link Object#finalize()} for further + * information about migration options. * @exception IOException if an I/O error occurs. * @see java.io.FileInputStream#close() */ + @Deprecated(since="9") protected void finalize() throws IOException { if (fd != null) { if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
--- a/jdk/src/java.base/share/classes/java/io/ObjectInputFilter.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/io/ObjectInputFilter.java Wed Jul 05 23:12:51 2017 +0200 @@ -322,7 +322,7 @@ * Other patterns match or reject class or package name * as returned from {@link Class#getName() Class.getName()} and * if an optional module name is present - * {@link java.lang.reflect.Module#getName() class.getModule().getName()}. + * {@link Module#getName() class.getModule().getName()}. * Note that for arrays the element type is used in the pattern, * not the array type. * <ul>
--- a/jdk/src/java.base/share/classes/java/lang/Class.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/lang/Class.java Wed Jul 05 23:12:51 2017 +0200 @@ -43,7 +43,6 @@ import java.lang.reflect.Member; import java.lang.reflect.Method; import java.lang.reflect.Modifier; -import java.lang.reflect.Module; import java.lang.reflect.Proxy; import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; @@ -2561,21 +2560,16 @@ public InputStream getResourceAsStream(String name) { name = resolveName(name); - Module module = getModule(); - if (module.isNamed()) { - if (Resources.canEncapsulate(name)) { - Module caller = Reflection.getCallerClass().getModule(); - if (caller != module) { - Set<String> packages = module.getDescriptor().packages(); - String pn = Resources.toPackageName(name); - if (packages.contains(pn) && !module.isOpen(pn, caller)) { - // resource is in package not open to caller - return null; - } - } + Module thisModule = getModule(); + if (thisModule.isNamed()) { + // check if resource can be located by caller + if (Resources.canEncapsulate(name) + && !isOpenToCaller(name, Reflection.getCallerClass())) { + return null; } - String mn = module.getName(); + // resource not encapsulated or in package open to caller + String mn = thisModule.getName(); ClassLoader cl = getClassLoader0(); try { @@ -2663,20 +2657,16 @@ public URL getResource(String name) { name = resolveName(name); - Module module = getModule(); - if (module.isNamed()) { - if (Resources.canEncapsulate(name)) { - Module caller = Reflection.getCallerClass().getModule(); - if (caller != module) { - Set<String> packages = module.getDescriptor().packages(); - String pn = Resources.toPackageName(name); - if (packages.contains(pn) && !module.isOpen(pn, caller)) { - // resource is in package not open to caller - return null; - } - } + Module thisModule = getModule(); + if (thisModule.isNamed()) { + // check if resource can be located by caller + if (Resources.canEncapsulate(name) + && !isOpenToCaller(name, Reflection.getCallerClass())) { + return null; } - String mn = getModule().getName(); + + // resource not encapsulated or in package open to caller + String mn = thisModule.getName(); ClassLoader cl = getClassLoader0(); try { if (cl == null) { @@ -2698,10 +2688,36 @@ } } + /** + * Returns true if a resource with the given name can be located by the + * given caller. All resources in a module can be located by code in + * the module. For other callers, then the package needs to be open to + * the caller. + */ + private boolean isOpenToCaller(String name, Class<?> caller) { + // assert getModule().isNamed(); + Module thisModule = getModule(); + Module callerModule = (caller != null) ? caller.getModule() : null; + if (callerModule != thisModule) { + String pn = Resources.toPackageName(name); + if (thisModule.getDescriptor().packages().contains(pn)) { + if (callerModule == null && !thisModule.isOpen(pn)) { + // no caller, package not open + return false; + } + if (!thisModule.isOpen(pn, callerModule)) { + // package not open to caller + return false; + } + } + } + return true; + } + + /** protection domain returned when the internal domain is null */ private static java.security.ProtectionDomain allPermDomain; - /** * Returns the {@code ProtectionDomain} of this class. If there is a * security manager installed, this method first calls the security
--- a/jdk/src/java.base/share/classes/java/lang/ClassLoader.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/lang/ClassLoader.java Wed Jul 05 23:12:51 2017 +0200 @@ -31,7 +31,6 @@ import java.io.File; import java.lang.reflect.Constructor; import java.lang.reflect.Field; -import java.lang.reflect.Module; import java.net.URL; import java.security.AccessController; import java.security.AccessControlContext; @@ -352,9 +351,7 @@ private ClassLoader(Void unused, String name, ClassLoader parent) { this.name = name; this.parent = parent; - this.unnamedModule - = SharedSecrets.getJavaLangReflectModuleAccess() - .defineUnnamedModule(this); + this.unnamedModule = new Module(this); if (ParallelLoaders.isRegistered(this.getClass())) { parallelLockMap = new ConcurrentHashMap<>(); package2certs = new ConcurrentHashMap<>(); @@ -2348,6 +2345,7 @@ this.isBuiltin = isBuiltin; } + @SuppressWarnings("deprecation") protected void finalize() { synchronized (loadedLibraryNames) { if (fromClass.getClassLoader() != null && loaded) {
--- a/jdk/src/java.base/share/classes/java/lang/Comparable.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/lang/Comparable.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -124,7 +124,7 @@ * {@code sgn(}<i>expression</i>{@code )} designates the mathematical * <i>signum</i> function, which is defined to return one of {@code -1}, * {@code 0}, or {@code 1} according to whether the value of - * <i>expression</i> is negative, zero or positive. + * <i>expression</i> is negative, zero, or positive, respectively. * * @param o the object to be compared. * @return a negative integer, zero, or a positive integer as this object
--- a/jdk/src/java.base/share/classes/java/lang/Enum.java Thu Apr 13 20:36:02 2017 +0000 +++ b/jdk/src/java.base/share/classes/java/lang/Enum.java Wed Jul 05 23:12:51 2017 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -243,6 +243,7 @@ /** * enum classes cannot have finalize methods. */ + @SuppressWarnings("deprecation") protected final void finalize() { } /**
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/src/java.base/share/classes/java/lang/LayerInstantiationException.java Wed Jul 05 23:12:51 2017 +0200 @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +/** + * Thrown when creating a {@linkplain ModuleLayer module layer} fails. + * + * @see ModuleLayer + * @since 9 + * @spec JPMS + */ +public class LayerInstantiationException extends RuntimeException { + private static final long serialVersionUID = -906239691613568347L; + + /** + * Constructs a {@code LayerInstantiationException} with no detail message. + */ + public LayerInstantiationException() { + } + + /** + * Constructs a {@code LayerInstantiationException} with the given detail + * message. + * + * @param msg + * The detail message; can be {@code null} + */ + public LayerInstantiationException(String msg) { + super(msg); + } + + /** + * Constructs a {@code LayerInstantiationException} with the given cause. + * + * @param cause + * The cause; can be {@code null} + */ + public LayerInstantiationException(Throwable cause) { + super(cause); + } + + /** + * Constructs a {@code FindException} with the given detail message + * and cause. + * + * @param msg + * The detail message; can be {@code null} + * @param cause + * The cause; can be {@code null} + */ + public LayerInstantiationException(String msg, Throwable cause) { + super(msg, cause); + } + +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/src/java.base/share/classes/java/lang/Module.java Wed Jul 05 23:12:51 2017 +0200 @@ -0,0 +1,1586 @@ +/* + * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +import java.io.IOException; +import java.io.InputStream; +import java.lang.annotation.Annotation; +import java.lang.module.Configuration; +import java.lang.module.ModuleReference; +import java.lang.module.ModuleDescriptor; +import java.lang.module.ModuleDescriptor.Exports; +import java.lang.module.ModuleDescriptor.Opens; +import java.lang.module.ModuleDescriptor.Version; +import java.lang.module.ResolvedModule; +import java.lang.reflect.AnnotatedElement; +import java.net.URI; +import java.net.URL; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import jdk.internal.loader.BuiltinClassLoader; +import jdk.internal.loader.BootLoader; +import jdk.internal.misc.JavaLangAccess; +import jdk.internal.misc.SharedSecrets; +import jdk.internal.module.ServicesCatalog; +import jdk.internal.module.Resources; +import jdk.internal.org.objectweb.asm.AnnotationVisitor; +import jdk.internal.org.objectweb.asm.Attribute; +import jdk.internal.org.objectweb.asm.ClassReader; +import jdk.internal.org.objectweb.asm.ClassVisitor; +import jdk.internal.org.objectweb.asm.ClassWriter; +import jdk.internal.org.objectweb.asm.Opcodes; +import jdk.internal.reflect.CallerSensitive; +import jdk.internal.reflect.Reflection; +import sun.security.util.SecurityConstants; + +/** + * Represents a run-time module, either {@link #isNamed() named} or unnamed. + * + * <p> Named modules have a {@link #getName() name} and are constructed by the + * Java Virtual Machine when a graph of modules is defined to the Java virtual + * machine to create a {@linkplain ModuleLayer module layer}. </p> + * + * <p> An unnamed module does not have a name. There is an unnamed module for + * each {@link ClassLoader ClassLoader}, obtained by invoking its {@link + * ClassLoader#getUnnamedModule() getUnnamedModule} method. All types that are + * not in a named module are members of their defining class loader's unnamed + * module. </p> + * + * <p> The package names that are parameters or returned by methods defined in + * this class are the fully-qualified names of the packages as defined in + * section 6.5.3 of <cite>The Java™ Language Specification</cite>, for + * example, {@code "java.lang"}. </p> + * + * <p> Unless otherwise specified, passing a {@code null} argument to a method + * in this class causes a {@link NullPointerException NullPointerException} to + * be thrown. </p> + * + * @since 9 + * @spec JPMS + * @see Class#getModule() + */ + +public final class Module implements AnnotatedElement { + + // the layer that contains this module, can be null + private final ModuleLayer layer; + + // module name and loader, these fields are read by VM + private final String name; + private final ClassLoader loader; + + // the module descriptor + private final ModuleDescriptor descriptor; + + + /** + * Creates a new named Module. The resulting Module will be defined to the + * VM but will not read any other modules, will not have any exports setup + * and will not be registered in the service catalog. + */ + Module(ModuleLayer layer, + ClassLoader loader, + ModuleDescriptor descriptor, + URI uri) + { + this.layer = layer; + this.name = descriptor.name(); + this.loader = loader; + this.descriptor = descriptor; + + // define module to VM + + boolean isOpen = descriptor.isOpen(); + Version version = descriptor.version().orElse(null); + String vs = Objects.toString(version, null); + String loc = Objects.toString(uri, null); + String[] packages = descriptor.packages().toArray(new String[0]); + defineModule0(this, isOpen, vs, loc, packages); + } + + + /** + * Create the unnamed Module for the given ClassLoader. + * + * @see ClassLoader#getUnnamedModule + */ + Module(ClassLoader loader) { + this.layer = null; + this.name = null; + this.loader = loader; + this.descriptor = null; + } + + + /** + * Creates a named module but without defining the module to the VM. + * + * @apiNote This constructor is for VM white-box testing. + */ + Module(ClassLoader loader, ModuleDescriptor descriptor) { + this.layer = null; + this.name = descriptor.name(); + this.loader = loader; + this.descriptor = descriptor; + } + + + + /** + * Returns {@code true} if this module is a named module. + * + * @return {@code true} if this is a named module + * + * @see ClassLoader#getUnnamedModule() + */ + public boolean isNamed() { + return name != null; + } + + /** + * Returns the module name or {@code null} if this module is an unnamed + * module. + * + * @return The module name + */ + public String getName() { + return name; + } + + /** + * Returns the {@code ClassLoader} for this module. + * + * <p> If there is a security manager then its {@code checkPermission} + * method if first called with a {@code RuntimePermission("getClassLoader")} + * permission to check that the caller is allowed to get access to the + * class loader. </p> + * + * @return The class loader for this module + * + * @throws SecurityException + * If denied by the security manager + */ + public ClassLoader getClassLoader() { + SecurityManager sm = System.getSecurityManager(); + if (sm != null) { + sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION); + } + return loader; + } + + /** + * Returns the module descriptor for this module or {@code null} if this + * module is an unnamed module. + * + * @return The module descriptor for this module + */ + public ModuleDescriptor getDescriptor() { + return descriptor; + } + + /** + * Returns the layer that contains this module or {@code null} if this + * module is not in a layer. + * + * A module layer contains named modules and therefore this method always + * returns {@code null} when invoked on an unnamed module. + * + * <p> <a href="reflect/Proxy.html#dynamicmodule">Dynamic modules</a> are + * named modules that are generated at runtime. A dynamic module may or may + * not be in a module layer. </p> + * + * @return The module layer that contains this module + * + * @see java.lang.reflect.Proxy + */ + public ModuleLayer getLayer() { + if (isNamed()) { + ModuleLayer layer = this.layer; + if (layer != null) + return layer; + + // special-case java.base as it is created before the boot layer + if (loader == null && name.equals("java.base")) { + return ModuleLayer.boot(); + } + } + return null; + } + + + // -- + + // special Module to mean "all unnamed modules" + private static final Module ALL_UNNAMED_MODULE = new Module(null); + + // special Module to mean "everyone" + private static final Module EVERYONE_MODULE = new Module(null); + + // set contains EVERYONE_MODULE, used when a package is opened or + // exported unconditionally + private static final Set<Module> EVERYONE_SET = Set.of(EVERYONE_MODULE); + + + // -- readability -- + + // the modules that this module reads + private volatile Set<Module> reads; + + // additional module (2nd key) that some module (1st key) reflectively reads + private static final WeakPairMap<Module, Module, Boolean> reflectivelyReads + = new WeakPairMap<>(); + + + /** + * Indicates if this module reads the given module. This method returns + * {@code true} if invoked to test if this module reads itself. It also + * returns {@code true} if invoked on an unnamed module (as unnamed + * modules read all modules). + * + * @param other + * The other module + * + * @return {@code true} if this module reads {@code other} + * + * @see #addReads(Module) + */ + public boolean canRead(Module other) { + Objects.requireNonNull(other); + + // an unnamed module reads all modules + if (!this.isNamed()) + return true; + + // all modules read themselves + if (other == this) + return true; + + // check if this module reads other + if (other.isNamed()) { + Set<Module> reads = this.reads; // volatile read + if (reads != null && reads.contains(other)) + return true; + } + + // check if this module reads the other module reflectively + if (reflectivelyReads.containsKeyPair(this, other)) + return true; + + // if other is an unnamed module then check if this module reads + // all unnamed modules + if (!other.isNamed() + && reflectivelyReads.containsKeyPair(this, ALL_UNNAMED_MODULE)) + return true; + + return false; + } + + /** + * If the caller's module is this module then update this module to read + * the given module. + * + * This method is a no-op if {@code other} is this module (all modules read + * themselves), this module is an unnamed module (as unnamed modules read + * all modules), or this module already reads {@code other}. + * + * @implNote <em>Read edges</em> added by this method are <em>weak</em> and + * do not prevent {@code other} from being GC'ed when this module is + * strongly reachable. + * + * @param other + * The other module + * + * @return this module + * + * @throws IllegalCallerException + * If this is a named module and the caller's module is not this + * module + * + * @see #canRead + */ + @CallerSensitive + public Module addReads(Module other) { + Objects.requireNonNull(other); + if (this.isNamed()) { + Module caller = getCallerModule(Reflection.getCallerClass()); + if (caller != this) { + throw new IllegalCallerException(caller + " != " + this); + } + implAddReads(other, true); + } + return this; + } + + /** + * Updates this module to read another module. + * + * @apiNote Used by the --add-reads command line option. + */ + void implAddReads(Module other) { + implAddReads(other, true); + } + + /** + * Updates this module to read all unnamed modules. + * + * @apiNote Used by the --add-reads command line option. + */ + void implAddReadsAllUnnamed() { + implAddReads(Module.ALL_UNNAMED_MODULE, true); + } + + /** + * Updates this module to read another module without notifying the VM. + * + * @apiNote This method is for VM white-box testing. + */ + void implAddReadsNoSync(Module other) { + implAddReads(other, false); + } + + /** + * Makes the given {@code Module} readable to this module. + * + * If {@code syncVM} is {@code true} then the VM is notified. + */ + private void implAddReads(Module other, boolean syncVM) { + Objects.requireNonNull(other); + if (!canRead(other)) { + // update VM first, just in case it fails + if (syncVM) { + if (other == ALL_UNNAMED_MODULE) { + addReads0(this, null); + } else { + addReads0(this, other); + } + } + + // add reflective read + reflectivelyReads.putIfAbsent(this, other, Boolean.TRUE); + } + } + + + // -- exported and open packages -- + + // the packages are open to other modules, can be null + // if the value contains EVERYONE_MODULE then the package is open to all + private volatile Map<String, Set<Module>> openPackages; + + // the packages that are exported, can be null + // if the value contains EVERYONE_MODULE then the package is exported to all + private volatile Map<String, Set<Module>> exportedPackages; + + // additional exports or opens added at run-time + // this module (1st key), other module (2nd key) + // (package name, open?) (value) + private static final WeakPairMap<Module, Module, Map<String, Boolean>> + reflectivelyExports = new WeakPairMap<>(); + + + /** + * Returns {@code true} if this module exports the given package to at + * least the given module. + * + * <p> This method returns {@code true} if invoked to test if a package in + * this module is exported to itself. It always returns {@code true} when + * invoked on an unnamed module. A package that is {@link #isOpen open} to + * the given module is considered exported to that module at run-time and + * so this method returns {@code true} if the package is open to the given + * module. </p> + * + * <p> This method does not check if the given module reads this module. </p> + * + * @param pn + * The package name + * @param other + * The other module + * + * @return {@code true} if this module exports the package to at least the + * given module + * + * @see ModuleDescriptor#exports() + * @see #addExports(String,Module) + */ + public boolean isExported(String pn, Module other) { + Objects.requireNonNull(pn); + Objects.requireNonNull(other); + return implIsExportedOrOpen(pn, other, /*open*/false); + } + + /** + * Returns {@code true} if this module has <em>opened</em> a package to at + * least the given module. + * + * <p> This method returns {@code true} if invoked to test if a package in + * this module is open to itself. It returns {@code true} when invoked on an + * {@link ModuleDescriptor#isOpen open} module with a package in the module. + * It always returns {@code true} when invoked on an unnamed module. </p> + * + * <p> This method does not check if the given module reads this module. </p> + * + * @param pn + * The package name + * @param other + * The other module + * + * @return {@code true} if this module has <em>opened</em> the package + * to at least the given module + * + * @see ModuleDescriptor#opens() + * @see #addOpens(String,Module) + * @see AccessibleObject#setAccessible(boolean) + * @see java.lang.invoke.MethodHandles#privateLookupIn + */ + public boolean isOpen(String pn, Module other) { + Objects.requireNonNull(pn); + Objects.requireNonNull(other); + return implIsExportedOrOpen(pn, other, /*open*/true); + } + + /** + * Returns {@code true} if this module exports the given package + * unconditionally. + * + * <p> This method always returns {@code true} when invoked on an unnamed + * module. A package that is {@link #isOpen(String) opened} unconditionally + * is considered exported unconditionally at run-time and so this method + * returns {@code true} if the package is opened unconditionally. </p> + * + * <p> This method does not check if the given module reads this module. </p> + * + * @param pn + * The package name + * + * @return {@code true} if this module exports the package unconditionally + * + * @see ModuleDescriptor#exports() + */ + public boolean isExported(String pn) { + Objects.requireNonNull(pn); + return implIsExportedOrOpen(pn, EVERYONE_MODULE, /*open*/false); + } + + /** + * Returns {@code true} if this module has <em>opened</em> a package + * unconditionally. + * + * <p> This method always returns {@code true} when invoked on an unnamed + * module. Additionally, it always returns {@code true} when invoked on an + * {@link ModuleDescriptor#isOpen open} module with a package in the + * module. </p> + * + * <p> This method does not check if the given module reads this module. </p> + * + * @param pn + * The package name + * + * @return {@code true} if this module has <em>opened</em> the package + * unconditionally + * + * @see ModuleDescriptor#opens() + */ + public boolean isOpen(String pn) { + Objects.requireNonNull(pn); + return implIsExportedOrOpen(pn, EVERYONE_MODULE, /*open*/true); + } + + + /** + * Returns {@code true} if this module exports or opens the given package + * to the given module. If the other module is {@code EVERYONE_MODULE} then + * this method tests if the package is exported or opened unconditionally. + */ + private boolean implIsExportedOrOpen(String pn, Module other, boolean open) { + // all packages in unnamed modules are open + if (!isNamed()) + return true; + + // all packages are exported/open to self + if (other == this && containsPackage(pn)) + return true; + + // all packages in open and automatic modules are open + if (descriptor.isOpen() || descriptor.isAutomatic()) + return containsPackage(pn); + + // exported/opened via module declaration/descriptor + if (isStaticallyExportedOrOpen(pn, other, open)) + return true; + + // exported via addExports/addOpens + if (isReflectivelyExportedOrOpen(pn, other, open)) + return true; + + // not exported or open to other + return false; + } + + /** + * Returns {@code true} if this module exports or opens a package to + * the given module via its module declaration. + */ + private boolean isStaticallyExportedOrOpen(String pn, Module other, boolean open) { + // package is open to everyone or <other> + Map<String, Set<Module>> openPackages = this.openPackages; + if (openPackages != null) { + Set<Module> targets = openPackages.get(pn); + if (targets != null) { + if (targets.contains(EVERYONE_MODULE)) + return true; + if (other != EVERYONE_MODULE && targets.contains(other)) + return true; + } + } + + if (!open) { + // package is exported to everyone or <other> + Map<String, Set<Module>> exportedPackages = this.exportedPackages; + if (exportedPackages != null) { + Set<Module> targets = exportedPackages.get(pn); + if (targets != null) { + if (targets.contains(EVERYONE_MODULE)) + return true; + if (other != EVERYONE_MODULE && targets.contains(other)) + return true; + } + } + } + + return false; + } + + + /** + * Returns {@code true} if this module reflectively exports or opens given + * package package to the given module. + */ + private boolean isReflectivelyExportedOrOpen(String pn, Module other, boolean open) { + // exported or open to all modules + Map<String, Boolean> exports = reflectivelyExports.get(this, EVERYONE_MODULE); + if (exports != null) { + Boolean b = exports.get(pn); + if (b != null) { + boolean isOpen = b.booleanValue(); + if (!open || isOpen) return true; + } + } + + if (other != EVERYONE_MODULE) { + + // exported or open to other + exports = reflectivelyExports.get(this, other); + if (exports != null) { + Boolean b = exports.get(pn); + if (b != null) { + boolean isOpen = b.booleanValue(); + if (!open || isOpen) return true; + } + } + + // other is an unnamed module && exported or open to all unnamed + if (!other.isNamed()) { + exports = reflectivelyExports.get(this, ALL_UNNAMED_MODULE); + if (exports != null) { + Boolean b = exports.get(pn); + if (b != null) { + boolean isOpen = b.booleanValue(); + if (!open || isOpen) return true; + } + } + } + + } + + return false; + } + + + /** + * If the caller's module is this module then update this module to export + * the given package to the given module. + * + * <p> This method has no effect if the package is already exported (or + * <em>open</em>) to the given module. </p> + * + * @apiNote As specified in section 5.4.3 of the <cite>The Java™ + * Virtual Machine Specification </cite>, if an attempt to resolve a + * symbolic reference fails because of a linkage error, then subsequent + * attempts to resolve the reference always fail with the same error that + * was thrown as a result of the initial resolution attempt. + * + * @param pn + * The package name + * @param other + * The module + * + * @return this module + * + * @throws IllegalArgumentException + * If {@code pn} is {@code null}, or this is a named module and the + * package {@code pn} is not a package in this module + * @throws IllegalCallerException + * If this is a named module and the caller's module is not this + * module + * + * @jvms 5.4.3 Resolution + * @see #isExported(String,Module) + */ + @CallerSensitive + public Module addExports(String pn, Module other) { + if (pn == null) + throw new IllegalArgumentException("package is null"); + Objects.requireNonNull(other); + + if (isNamed()) { + Module caller = getCallerModule(Reflection.getCallerClass()); + if (caller != this) { + throw new IllegalCallerException(caller + " != " + this); + } + implAddExportsOrOpens(pn, other, /*open*/false, /*syncVM*/true); + } + + return this; + } + + /** + * If this module has <em>opened</em> a package to at least the caller + * module then update this module to open the package to the given module. + * Opening a package with this method allows all types in the package, + * and all their members, not just public types and their public members, + * to be reflected on by the given module when using APIs that support + * private access or a way to bypass or suppress default Java language + * access control checks. + * + * <p> This method has no effect if the package is already <em>open</em> + * to the given module. </p> + * + * @param pn + * The package name + * @param other + * The module + * + * @return this module + * + * @throws IllegalArgumentException + * If {@code pn} is {@code null}, or this is a named module and the + * package {@code pn} is not a package in this module + * @throws IllegalCallerException + * If this is a named module and this module has not opened the + * package to at least the caller's module + * + * @see #isOpen(String,Module) + * @see AccessibleObject#setAccessible(boolean) + * @see java.lang.invoke.MethodHandles#privateLookupIn + */ + @CallerSensitive + public Module addOpens(String pn, Module other) { + if (pn == null) + throw new IllegalArgumentException("package is null"); + Objects.requireNonNull(other); + + if (isNamed()) { + Module caller = getCallerModule(Reflection.getCallerClass()); + if (caller != this && (caller == null || !isOpen(pn, caller))) + throw new IllegalCallerException(pn + " is not open to " + caller); + implAddExportsOrOpens(pn, other, /*open*/true, /*syncVM*/true); + } + + return this; + } + + + /** + * Updates this module to export a package unconditionally. + * + * @apiNote This method is for JDK tests only. + */ + void implAddExports(String pn) { + implAddExportsOrOpens(pn, Module.EVERYONE_MODULE, false, true); + } + + /** + * Updates this module to export a package to another module. + * + * @apiNote Used by Instrumentation::redefineModule and --add-exports + */ + void implAddExports(String pn, Module other) { + implAddExportsOrOpens(pn, other, false, true); + } + + /** + * Updates this module to export a package to all unnamed modules. + * + * @apiNote Used by the --add-exports command line option. + */ + void implAddExportsToAllUnnamed(String pn) { + implAddExportsOrOpens(pn, Module.ALL_UNNAMED_MODULE, false, true); + } + + /** + * Updates this export to export a package unconditionally without + * notifying the VM. + * + * @apiNote This method is for VM white-box testing. + */ + void implAddExportsNoSync(String pn) { + implAddExportsOrOpens(pn.replace('/', '.'), Module.EVERYONE_MODULE, false, false); + } + + /** + * Updates a module to export a package to another module without + * notifying the VM. + * + * @apiNote This method is for VM white-box testing. + */ + void implAddExportsNoSync(String pn, Module other) { + implAddExportsOrOpens(pn.replace('/', '.'), other, false, false); + } + + /** + * Updates this module to open a package unconditionally. + * + * @apiNote This method is for JDK tests only. + */ + void implAddOpens(String pn) { + implAddExportsOrOpens(pn, Module.EVERYONE_MODULE, true, true); + } + + /** + * Updates this module to open a package to another module. + * + * @apiNote Used by Instrumentation::redefineModule and --add-opens + */ + void implAddOpens(String pn, Module other) { + implAddExportsOrOpens(pn, other, true, true); + } + + /** + * Updates this module to export a package to all unnamed modules. + * + * @apiNote Used by the --add-opens command line option. + */ + void implAddOpensToAllUnnamed(String pn) { + implAddExportsOrOpens(pn, Module.ALL_UNNAMED_MODULE, true, true); + } + + + /** + * Updates a module to export or open a module to another module. + * + * If {@code syncVM} is {@code true} then the VM is notified. + */ + private void implAddExportsOrOpens(String pn, + Module other, + boolean open, + boolean syncVM) { + Objects.requireNonNull(other); + Objects.requireNonNull(pn); + + // all packages are open in unnamed, open, and automatic modules + if (!isNamed() || descriptor.isOpen() || descriptor.isAutomatic()) + return; + + // nothing to do if already exported/open to other + if (implIsExportedOrOpen(pn, other, open)) + return; + + // can only export a package in the module + if (!containsPackage(pn)) { + throw new IllegalArgumentException("package " + pn + + " not in contents"); + } + + // update VM first, just in case it fails + if (syncVM) { + if (other == EVERYONE_MODULE) { + addExportsToAll0(this, pn); + } else if (other == ALL_UNNAMED_MODULE) { + addExportsToAllUnnamed0(this, pn); + } else { + addExports0(this, pn, other); + } + } + + // add package name to reflectivelyExports if absent + Map<String, Boolean> map = reflectivelyExports + .computeIfAbsent(this, other, + (m1, m2) -> new ConcurrentHashMap<>()); + + if (open) { + map.put(pn, Boolean.TRUE); // may need to promote from FALSE to TRUE + } else { + map.putIfAbsent(pn, Boolean.FALSE); + } + } + + + // -- services -- + + // additional service type (2nd key) that some module (1st key) uses + private static final WeakPairMap<Module, Class<?>, Boolean> reflectivelyUses + = new WeakPairMap<>(); + + /** + * If the caller's module is this module then update this module to add a + * service dependence on the given service type. This method is intended + * for use by frameworks that invoke {@link java.util.ServiceLoader + * ServiceLoader} on behalf of other modules or where the framework is + * passed a reference to the service type by other code. This method is + * a no-op when invoked on an unnamed module or an automatic module. + * + * <p> This method does not cause {@link Configuration#resolveAndBind + * resolveAndBind} to be re-run. </p> + * + * @param service + * The service type + * + * @return this module + * + * @throws IllegalCallerException + * If this is a named module and the caller's module is not this + * module + * + * @see #canUse(Class) + * @see ModuleDescriptor#uses() + */ + @CallerSensitive + public Module addUses(Class<?> service) { + Objects.requireNonNull(service); + + if (isNamed() && !descriptor.isAutomatic()) { + Module caller = getCallerModule(Reflection.getCallerClass()); + if (caller != this) { + throw new IllegalCallerException(caller + " != " + this); + } + implAddUses(service); + } + + return this; + } + + /** + * Update this module to add a service dependence on the given service + * type. + */ + void implAddUses(Class<?> service) { + if (!canUse(service)) { + reflectivelyUses.putIfAbsent(this, service, Boolean.TRUE); + } + } + + + /** + * Indicates if this module has a service dependence on the given service + * type. This method always returns {@code true} when invoked on an unnamed + * module or an automatic module. + * + * @param service + * The service type + * + * @return {@code true} if this module uses service type {@code st} + * + * @see #addUses(Class) + */ + public boolean canUse(Class<?> service) { + Objects.requireNonNull(service); + + if (!isNamed()) + return true; + + if (descriptor.isAutomatic()) + return true; + + // uses was declared + if (descriptor.uses().contains(service.getName())) + return true; + + // uses added via addUses + return reflectivelyUses.containsKeyPair(this, service); + } + + + + // -- packages -- + + // Additional packages that are added to the module at run-time. + private volatile Map<String, Boolean> extraPackages; + + private boolean containsPackage(String pn) { + if (descriptor.packages().contains(pn)) + return true; + Map<String, Boolean> extraPackages = this.extraPackages; + if (extraPackages != null && extraPackages.containsKey(pn)) + return true; + return false; + } + + + /** + * Returns the set of package names for the packages in this module. + * + * <p> For named modules, the returned set contains an element for each + * package in the module. </p> + * + * <p> For unnamed modules, this method is the equivalent to invoking the + * {@link ClassLoader#getDefinedPackages() getDefinedPackages} method of + * this module's class loader and returning the set of package names. </p> + * + * @return the set of the package names of the packages in this module + */ + public Set<String> getPackages() { + if (isNamed()) { + + Set<String> packages = descriptor.packages(); + Map<String, Boolean> extraPackages = this.extraPackages; + if (extraPackages == null) { + return packages; + } else { + return Stream.concat(packages.stream(), + extraPackages.keySet().stream()) + .collect(Collectors.toSet()); + } + + } else { + // unnamed module + Stream<Package> packages; + if (loader == null) { + packages = BootLoader.packages(); + } else { + packages = SharedSecrets.getJavaLangAccess().packages(loader); + } + return packages.map(Package::getName).collect(Collectors.toSet()); + } + } + + /** + * Add a package to this module without notifying the VM. + * + * @apiNote This method is VM white-box testing. + */ + void implAddPackageNoSync(String pn) { + implAddPackage(pn.replace('/', '.'), false); + } + + /** + * Add a package to this module. + * + * If {@code syncVM} is {@code true} then the VM is notified. This method is + * a no-op if this is an unnamed module or the module already contains the + * package. + * + * @throws IllegalArgumentException if the package name is not legal + * @throws IllegalStateException if the package is defined to another module + */ + private void implAddPackage(String pn, boolean syncVM) { + // no-op if unnamed module + if (!isNamed()) + return; + + // no-op if module contains the package + if (containsPackage(pn)) + return; + + // check package name is legal for named modules + if (pn.isEmpty()) + throw new IllegalArgumentException("Cannot add <unnamed> package"); + for (int i=0; i<pn.length(); i++) { + char c = pn.charAt(i); + if (c == '/' || c == ';' || c == '[') { + throw new IllegalArgumentException("Illegal character: " + c); + } + } + + // create extraPackages if needed + Map<String, Boolean> extraPackages = this.extraPackages; + if (extraPackages == null) { + synchronized (this) { + extraPackages = this.extraPackages; + if (extraPackages == null) + this.extraPackages = extraPackages = new ConcurrentHashMap<>(); + } + } + + // update VM first in case it fails. This is a no-op if another thread + // beats us to add the package first + if (syncVM) { + // throws IllegalStateException if defined to another module + addPackage0(this, pn); + if (descriptor.isOpen() || descriptor.isAutomatic()) { + addExportsToAll0(this, pn); + } + } + extraPackages.putIfAbsent(pn, Boolean.TRUE); + } + + + // -- creating Module objects -- + + /** + * Defines all module in a configuration to the runtime. + * + * @return a map of module name to runtime {@code Module} + * + * @throws IllegalArgumentException + * If defining any of the modules to the VM fails + */ + static Map<String, Module> defineModules(Configuration cf, + Function<String, ClassLoader> clf, + ModuleLayer layer) + { + Map<String, Module> nameToModule = new HashMap<>(); + Map<String, ClassLoader> moduleToLoader = new HashMap<>(); + + boolean isBootLayer = (ModuleLayer.boot() == null); + Set<ClassLoader> loaders = new HashSet<>(); + + // map each module to a class loader + for (ResolvedModule resolvedModule : cf.modules()) { + String name = resolvedModule.name(); + ClassLoader loader = clf.apply(name); + if (loader != null) { + moduleToLoader.put(name, loader); + loaders.add(loader); + } else if (!isBootLayer) { + throw new IllegalArgumentException("loader can't be 'null'"); + } + } + + // define each module in the configuration to the VM + for (ResolvedModule resolvedModule : cf.modules()) { + ModuleReference mref = resolvedModule.reference(); + ModuleDescriptor descriptor = mref.descriptor(); + String name = descriptor.name(); + URI uri = mref.location().orElse(null); + ClassLoader loader = moduleToLoader.get(resolvedModule.name()); + Module m; + if (loader == null && isBootLayer && name.equals("java.base")) { + // java.base is already defined to the VM + m = Object.class.getModule(); + } else { + m = new Module(layer, loader, descriptor, uri); + } + nameToModule.put(name, m); + moduleToLoader.put(name, loader); + } + + // setup readability and exports + for (ResolvedModule resolvedModule : cf.modules()) { + ModuleReference mref = resolvedModule.reference(); + ModuleDescriptor descriptor = mref.descriptor(); + + String mn = descriptor.name(); + Module m = nameToModule.get(mn); + assert m != null; + + // reads + Set<Module> reads = new HashSet<>(); + + // name -> source Module when in parent layer + Map<String, Module> nameToSource = Collections.emptyMap(); + + for (ResolvedModule other : resolvedModule.reads()) { + Module m2 = null; + if (other.configuration() == cf) { + // this configuration + m2 = nameToModule.get(other.name()); + assert m2 != null; + } else { + // parent layer + for (ModuleLayer parent: layer.parents()) { + m2 = findModule(parent, other); + if (m2 != null) + break; + } + assert m2 != null; + if (nameToSource.isEmpty()) + nameToSource = new HashMap<>(); + nameToSource.put(other.name(), m2); + } + reads.add(m2); + + // update VM view + addReads0(m, m2); + } + m.reads = reads; + + // automatic modules read all unnamed modules + if (descriptor.isAutomatic()) { + m.implAddReads(ALL_UNNAMED_MODULE, true); + } + + // exports and opens + initExportsAndOpens(m, nameToSource, nameToModule, layer.parents()); + } + + // register the modules in the boot layer + if (isBootLayer) { + for (ResolvedModule resolvedModule : cf.modules()) { + ModuleReference mref = resolvedModule.reference(); + ModuleDescriptor descriptor = mref.descriptor(); + if (!descriptor.provides().isEmpty()) { + String name = descriptor.name(); + Module m = nameToModule.get(name); + ClassLoader loader = moduleToLoader.get(name); + ServicesCatalog catalog; + if (loader == null) { + catalog = BootLoader.getServicesCatalog(); + } else { + catalog = ServicesCatalog.getServicesCatalog(loader); + } + catalog.register(m); + } + } + } + + // record that there is a layer with modules defined to the class loader + for (ClassLoader loader : loaders) { + layer.bindToLoader(loader); + } + + return nameToModule; + } + + + /** + * Find the runtime Module corresponding to the given ResolvedModule + * in the given parent layer (or its parents). + */ + private static Module findModule(ModuleLayer parent, + ResolvedModule resolvedModule) { + Configuration cf = resolvedModule.configuration(); + String dn = resolvedModule.name(); + return parent.layers() + .filter(l -> l.configuration() == cf) + .findAny() + .map(layer -> { + Optional<Module> om = layer.findModule(dn); + assert om.isPresent() : dn + " not found in layer"; + Module m = om.get(); + assert m.getLayer() == layer : m + " not in expected layer"; + return m; + }) + .orElse(null); + } + + + /** + * Initialize the maps of exported and open packages for module m. + */ + private static void initExportsAndOpens(Module m, + Map<String, Module> nameToSource, + Map<String, Module> nameToModule, + List<ModuleLayer> parents) { + // The VM doesn't special case open or automatic modules so need to + // export all packages + ModuleDescriptor descriptor = m.getDescriptor(); + if (descriptor.isOpen() || descriptor.isAutomatic()) { + assert descriptor.opens().isEmpty(); + for (String source : descriptor.packages()) { + addExportsToAll0(m, source); + } + return; + } + + Map<String, Set<Module>> openPackages = new HashMap<>(); + Map<String, Set<Module>> exportedPackages = new HashMap<>(); + + // process the open packages first + for (Opens opens : descriptor.opens()) { + String source = opens.source(); + + if (opens.isQualified()) { + // qualified opens + Set<Module> targets = new HashSet<>(); + for (String target : opens.targets()) { + Module m2 = findModule(target, nameToSource, nameToModule, parents); + if (m2 != null) { + addExports0(m, source, m2); + targets.add(m2); + } + } + if (!targets.isEmpty()) { + openPackages.put(source, targets); + } + } else { + // unqualified opens + addExportsToAll0(m, source); + openPackages.put(source, EVERYONE_SET); + } + } + + // next the exports, skipping exports when the package is open + for (Exports exports : descriptor.exports()) { + String source = exports.source(); + + // skip export if package is already open to everyone + Set<Module> openToTargets = openPackages.get(source); + if (openToTargets != null && openToTargets.contains(EVERYONE_MODULE)) + continue; + + if (exports.isQualified()) { + // qualified exports + Set<Module> targets = new HashSet<>(); + for (String target : exports.targets()) { + Module m2 = findModule(target, nameToSource, nameToModule, parents); + if (m2 != null) { + // skip qualified export if already open to m2 + if (openToTargets == null || !openToTargets.contains(m2)) { + addExports0(m, source, m2); + targets.add(m2); + } + } + } + if (!targets.isEmpty()) { + exportedPackages.put(source, targets); + } + + } else { + // unqualified exports + addExportsToAll0(m, source); + exportedPackages.put(source, EVERYONE_SET); + } + } + + if (!openPackages.isEmpty()) + m.openPackages = openPackages; + if (!exportedPackages.isEmpty()) + m.exportedPackages = exportedPackages; + } + + /** + * Find the runtime Module with the given name. The module name is the + * name of a target module in a qualified exports or opens directive. + * + * @param target The target module to find + * @param nameToSource The modules in parent layers that are read + * @param nameToModule The modules in the layer under construction + * @param parents The parent layers + */ + private static Module findModule(String target, + Map<String, Module> nameToSource, + Map<String, Module> nameToModule, + List<ModuleLayer> parents) { + Module m = nameToSource.get(target); + if (m == null) { + m = nameToModule.get(target); + if (m == null) { + for (ModuleLayer parent : parents) { + m = parent.findModule(target).orElse(null); + if (m != null) break; + } + } + } + return m; + } + + + // -- annotations -- + + /** + * {@inheritDoc} + * This method returns {@code null} when invoked on an unnamed module. + */ + @Override + public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { + return moduleInfoClass().getDeclaredAnnotation(annotationClass); + } + + /** + * {@inheritDoc} + * This method returns an empty array when invoked on an unnamed module. + */ + @Override + public Annotation[] getAnnotations() { + return moduleInfoClass().getAnnotations(); + } + + /** + * {@inheritDoc} + * This method returns an empty array when invoked on an unnamed module. + */ + @Override + public Annotation[] getDeclaredAnnotations() { + return moduleInfoClass().getDeclaredAnnotations(); + } + + // cached class file with annotations + private volatile Class<?> moduleInfoClass; + + private Class<?> moduleInfoClass() { + Class<?> clazz = this.moduleInfoClass; + if (clazz != null) + return clazz; + + synchronized (this) { + clazz = this.moduleInfoClass; + if (clazz == null) { + if (isNamed()) { + PrivilegedAction<Class<?>> pa = this::loadModuleInfoClass; + clazz = AccessController.doPrivileged(pa); + } + if (clazz == null) { + class DummyModuleInfo { } + clazz = DummyModuleInfo.class; + } + this.moduleInfoClass = clazz; + } + return clazz; + } + } + + private Class<?> loadModuleInfoClass() { + Class<?> clazz = null; + try (InputStream in = getResourceAsStream("module-info.class")) { + if (in != null) + clazz = loadModuleInfoClass(in); + } catch (Exception ignore) { } + return clazz; + } + + /** + * Loads module-info.class as a package-private interface in a class loader + * that is a child of this module's class loader. + */ + private Class<?> loadModuleInfoClass(InputStream in) throws IOException { + final String MODULE_INFO = "module-info"; + + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + + ClassWriter.COMPUTE_FRAMES); + + ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) { + @Override + public void visit(int version, + int access, + String name, + String signature, + String superName, + String[] interfaces) { + cw.visit(version, + Opcodes.ACC_INTERFACE + + Opcodes.ACC_ABSTRACT + + Opcodes.ACC_SYNTHETIC, + MODULE_INFO, + null, + "java/lang/Object", + null); + } + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + // keep annotations + return super.visitAnnotation(desc, visible); + } + @Override + public void visitAttribute(Attribute attr) { + // drop non-annotation attributes + } + }; + + ClassReader cr = new ClassReader(in); + cr.accept(cv, 0); + byte[] bytes = cw.toByteArray(); + + ClassLoader cl = new ClassLoader(loader) { + @Override + protected Class<?> findClass(String cn)throws ClassNotFoundException { + if (cn.equals(MODULE_INFO)) { + return super.defineClass(cn, bytes, 0, bytes.length); + } else { + throw new ClassNotFoundException(cn); + } + } + }; + + try { + return cl.loadClass(MODULE_INFO); + } catch (ClassNotFoundException e) { + throw new InternalError(e); + } + } + + + // -- misc -- + + + /** + * Returns an input stream for reading a resource in this module. + * The {@code name} parameter is a {@code '/'}-separated path name that + * identifies the resource. As with {@link Class#getResourceAsStream + * Class.getResourceAsStream}, this method delegates to the module's class + * loader {@link ClassLoader#findResource(String,String) + * findResource(String,String)} method, invoking it with the module name + * (or {@code null} when the module is unnamed) and the name of the + * resource. If the resource name has a leading slash then it is dropped + * before delegation. + * + * <p> A resource in a named module may be <em>encapsulated</em> so that + * it cannot be located by code in other modules. Whether a resource can be + * located or not is determined as follows: </p> + * + * <ul> + * <li> If the resource name ends with "{@code .class}" then it is not + * encapsulated. </li> + * + * <li> A <em>package name</em> is derived from the resource name. If + * the package name is a {@link #getPackages() package} in the module + * then the resource can only be located by the caller of this method + * when the package is {@link #isOpen(String,Module) open} to at least + * the caller's module. If the resource is not in a package in the module + * then the resource is not encapsulated. </li> + * </ul> + * + * <p> In the above, the <em>package name</em> for a resource is derived + * from the subsequence of characters that precedes the last {@code '/'} in + * the name and then replacing each {@code '/'} character in the subsequence + * with {@code '.'}. A leading slash is ignored when deriving the package + * name. As an example, the package name derived for a resource named + * "{@code a/b/c/foo.properties}" is "{@code a.b.c}". A resource name + * with the name "{@code META-INF/MANIFEST.MF}" is never encapsulated + * because "{@code META-INF}" is not a legal package name. </p> + * + * <p> This method returns {@code null} if the resource is not in this + * module, the resource is encapsulated and cannot be located by the caller, + * or access to the resource is denied by the security manager. </p> + * + * @param name + * The resource name + * + * @return An input stream for reading the resource or {@code null} + * + * @throws IOException + * If an I/O error occurs + * + * @see Class#getResourceAsStream(String) + */ + @CallerSensitive + public InputStream getResourceAsStream(String name) throws IOException { + if (name.startsWith("/")) { + name = name.substring(1); + } + + if (isNamed() && Resources.canEncapsulate(name)) { + Module caller = getCallerModule(Reflection.getCallerClass()); + if (caller != this && caller != Object.class.getModule()) { + String pn = Resources.toPackageName(name); + if (getPackages().contains(pn)) { + if (caller == null && !isOpen(pn)) { + // no caller, package not open + return null; + } + if (!isOpen(pn, caller)) { + // package not open to caller + return null; + } + } + } + } + + String mn = this.name; + + // special-case built-in class loaders to avoid URL connection + if (loader == null) { + return BootLoader.findResourceAsStream(mn, name); + } else if (loader instanceof BuiltinClassLoader) { + return ((BuiltinClassLoader) loader).findResourceAsStream(mn, name); + } + + // locate resource in module + JavaLangAccess jla = SharedSecrets.getJavaLangAccess(); + URL url = jla.findResource(loader, mn, name); + if (url != null) { + try { + return url.openStream(); + } catch (SecurityException e) { } + } + + return null; + } + + /** + * Returns the string representation of this module. For a named module, + * the representation is the string {@code "module"}, followed by a space, + * and then the module name. For an unnamed module, the representation is + * the string {@code "unnamed module"}, followed by a space, and then an + * implementation specific string that identifies the unnamed module. + * + * @return The string representation of this module + */ + @Override + public String toString() { + if (isNamed()) { + return "module " + name; + } else { + String id = Integer.toHexString(System.identityHashCode(this)); + return "unnamed module @" + id; + } + } + + /** + * Returns the module that a given caller class is a member of. Returns + * {@code null} if the caller is {@code null}. + */ + private Module getCallerModule(Class<?> caller) { + return (caller != null) ? caller.getModule() : null; + } + + + // -- native methods -- + + // JVM_DefineModule + private static native void defineModule0(Module module, + boolean isOpen, + String version, + String location, + String[] pns); + + // JVM_AddReadsModule + private static native void addReads0(Module from, Module to); + + // JVM_AddModuleExports + private static native void addExports0(Module from, String pn, Module to); + + // JVM_AddModuleExportsToAll + private static native void addExportsToAll0(Module from, String pn); + + // JVM_AddModuleExportsToAllUnnamed + private static native void addExportsToAllUnnamed0(Module from, String pn); + + // JVM_AddModulePackage + private static native void addPackage0(Module m, String pn); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/src/java.base/share/classes/java/lang/ModuleLayer.java Wed Jul 05 23:12:51 2017 +0200 @@ -0,0 +1,944 @@ +/* + * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang; + +import java.lang.module.Configuration; +import java.lang.module.ModuleDescriptor; +import java.lang.module.ResolvedModule; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Deque; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import jdk.internal.loader.ClassLoaderValue; +import jdk.internal.loader.Loader; +import jdk.internal.loader.LoaderPool; +import jdk.internal.module.ServicesCatalog; +import sun.security.util.SecurityConstants; + + +/** + * A layer of modules in the Java virtual machine. + * + * <p> A layer is created from a graph of modules in a {@link Configuration} + * and a function that maps each module to a {@link ClassLoader}. + * Creating a layer informs the Java virtual machine about the classes that + * may be loaded from the modules so that the Java virtual machine knows which + * module that each class is a member of. </p> + * + * <p> Creating a layer creates a {@link Module} object for each {@link + * ResolvedModule} in the configuration. For each resolved module that is + * {@link ResolvedModule#reads() read}, the {@code Module} {@link + * Module#canRead reads} the corresponding run-time {@code Module}, which may + * be in the same layer or a {@link #parents() parent} layer. </p> + * + * <p> The {@link #defineModulesWithOneLoader defineModulesWithOneLoader} and + * {@link #defineModulesWithManyLoaders defineModulesWithManyLoaders} methods + * provide convenient ways to create a module layer where all modules are + * mapped to a single class loader or where each module is mapped to its own + * class loader. The {@link #defineModules defineModules} method is for more + * advanced cases where modules are mapped to custom class loaders by means of + * a function specified to the method. Each of these methods has an instance + * and static variant. The instance methods create a layer with the receiver + * as the parent layer. The static methods are for more advanced cases where + * there can be more than one parent layer or where a {@link + * ModuleLayer.Controller Controller} is needed to control modules in the layer + * </p> + * + * <p> A Java virtual machine has at least one non-empty layer, the {@link + * #boot() boot} layer, that is created when the Java virtual machine is + * started. The boot layer contains module {@code java.base} and is the only + * layer in the Java virtual machine with a module named "{@code java.base}". + * The modules in the boot layer are mapped to the bootstrap class loader and + * other class loaders that are <a href="../ClassLoader.html#builtinLoaders"> + * built-in</a> into the Java virtual machine. The boot layer will often be + * the {@link #parents() parent} when creating additional layers. </p> + * + * <p> Each {@code Module} in a layer is created so that it {@link + * Module#isExported(String) exports} and {@link Module#isOpen(String) opens} + * the packages described by its {@link ModuleDescriptor}. Qualified exports + * (where a package is exported to a set of target modules rather than all + * modules) are reified when creating the layer as follows: </p> + * <ul> + * <li> If module {@code X} exports a package to {@code Y}, and if the + * runtime {@code Module} {@code X} reads {@code Module} {@code Y}, then + * the package is exported to {@code Module} {@code Y} (which may be in + * the same layer as {@code X} or a parent layer). </li> + * + * <li> If module {@code X} exports a package to {@code Y}, and if the + * runtime {@code Module} {@code X} does not read {@code Y} then target + * {@code Y} is located as if by invoking {@link #findModule(String) + * findModule} to find the module in the layer or its parent layers. If + * {@code Y} is found then the package is exported to the instance of + * {@code Y} that was found. If {@code Y} is not found then the qualified + * export is ignored. </li> + * </ul> + * + * <p> Qualified opens are handled in same way as qualified exports. </p> + * + * <p> As when creating a {@code Configuration}, + * {@link ModuleDescriptor#isAutomatic() automatic} modules receive special + * treatment when creating a layer. An automatic module is created in the + * Java virtual machine as a {@code Module} that reads every unnamed {@code + * Module} in the Java virtual machine. </p> + * + * <p> Unless otherwise specified, passing a {@code null} argument to a method + * in this class causes a {@link NullPointerException NullPointerException} to + * be thrown. </p> + * + * <h3> Example usage: </h3> + * + * <p> This example creates a configuration by resolving a module named + * "{@code myapp}" with the configuration for the boot layer as the parent. It + * then creates a new layer with the modules in this configuration. All modules + * are defined to the same class loader. </p> + * + * <pre>{@code + * ModuleFinder finder = ModuleFinder.of(dir1, dir2, dir3); + * + * ModuleLayer parent = ModuleLayer.boot(); + * + * Configuration cf = parent.configuration().resolve(finder, ModuleFinder.of(), Set.of("myapp")); + * + * ClassLoader scl = ClassLoader.getSystemClassLoader(); + * + * ModuleLayer layer = parent.defineModulesWithOneLoader(cf, scl); + * + * Class<?> c = layer.findLoader("myapp").loadClass("app.Main"); + * }</pre> + * + * @since 9 + * @spec JPMS + * @see Module#getLayer() + */ + +public final class ModuleLayer { + + // the empty layer + private static final ModuleLayer EMPTY_LAYER + = new ModuleLayer(Configuration.empty(), List.of(), null); + + // the configuration from which this ;ayer was created + private final Configuration cf; + + // parent layers, empty in the case of the empty layer + private final List<ModuleLayer> parents; + + // maps module name to jlr.Module + private final Map<String, Module> nameToModule; + + /** + * Creates a new module layer from the modules in the given configuration. + */ + private ModuleLayer(Configuration cf, + List<ModuleLayer> parents, + Function<String, ClassLoader> clf) + { + this.cf = cf; + this.parents = parents; // no need to do defensive copy + + Map<String, Module> map; + if (parents.isEmpty()) { + map = Collections.emptyMap(); + } else { + map = Module.defineModules(cf, clf, this); + } + this.nameToModule = map; // no need to do defensive copy + } + + /** + * Controls a module layer. The static methods defined by {@link ModuleLayer} + * to create module layers return a {@code Controller} that can be used to + * control modules in the layer. + * + * <p> Unless otherwise specified, passing a {@code null} argument to a + * method in this class causes a {@link NullPointerException + * NullPointerException} to be thrown. </p&