--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/c2/Test8004741.java Tue Jul 12 18:24:48 2016 +0300
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2012, 2013, 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.
+ */
+
+/*
+ * @test Test8004741.java
+ * @bug 8004741
+ * @summary Missing compiled exception handle table entry for multidimensional array allocation
+ *
+ * @run main/othervm -Xmx64m -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
+ * -XX:-TieredCompilation -XX:+StressCompiledExceptionHandlers
+ * -XX:+SafepointALot -XX:GuaranteedSafepointInterval=100
+ * compiler.c2.Test8004741
+ * @run main/othervm -Xmx64m -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
+ * -XX:-TieredCompilation -XX:+StressCompiledExceptionHandlers
+ * compiler.c2.Test8004741
+ */
+
+package compiler.c2;
+
+public class Test8004741 extends Thread {
+
+ static int passed = 0;
+
+ /**
+ * Loop forever allocating 2-d arrays.
+ * Catches and rethrows all exceptions; in the case of ThreadDeath, increments passed.
+ * Note that passed is incremented here because this is the exception handler with
+ * the smallest scope; we only want to declare success in the case where it is highly
+ * likely that the test condition
+ * (exception in 2-d array alloc interrupted by ThreadDeath)
+ * actually occurs.
+ */
+ static int[][] test(int a, int b) throws Exception {
+ int[][] ar;
+ try {
+ ar = new int[a][b];
+ } catch (ThreadDeath e) {
+ System.out.println("test got ThreadDeath");
+ passed++;
+ throw(e);
+ }
+ return ar;
+ }
+
+ /* Cookbook wait-notify to track progress of test thread. */
+ Object progressLock = new Object();
+ private static final int NOT_STARTED = 0;
+ private static final int RUNNING = 1;
+ private static final int STOPPING = 2;
+
+ int progressState = NOT_STARTED;
+
+ void toState(int state) {
+ synchronized (progressLock) {
+ progressState = state;
+ progressLock.notify();
+ }
+ }
+
+ void waitFor(int state) {
+ synchronized (progressLock) {
+ while (progressState < state) {
+ try {
+ progressLock.wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ System.out.println("unexpected InterruptedException");
+ fail();
+ }
+ }
+ if (progressState > state) {
+ System.out.println("unexpected test state change, expected " +
+ state + " but saw " + progressState);
+ fail();
+ }
+ }
+ }
+
+ /**
+ * Loops running test until some sort of an exception or error,
+ * expects to see ThreadDeath.
+ */
+ public void run() {
+ try {
+ // Print before state change, so that other thread is most likely
+ // to see this thread executing calls to test() in a loop.
+ System.out.println("thread running");
+ toState(RUNNING);
+ while (true) {
+ // (2,2) (2,10) (2,100) were observed to tickle the bug;
+ test(2, 100);
+ }
+ } catch (ThreadDeath e) {
+ // nothing to say, passing was incremented by the test.
+ } catch (Throwable e) {
+ e.printStackTrace();
+ System.out.println("unexpected Throwable " + e);
+ fail();
+ }
+ toState(STOPPING);
+ }
+
+ /**
+ * Runs a single trial of the test in a thread.
+ * No single trial is definitive, since the ThreadDeath
+ * exception might not land in the tested region of code.
+ */
+ public static void threadTest() throws InterruptedException {
+ Test8004741 t = new Test8004741();
+ t.start();
+ t.waitFor(RUNNING);
+ Thread.sleep(100);
+ System.out.println("stopping thread");
+ t.stop();
+ t.waitFor(STOPPING);
+ t.join();
+ }
+
+ public static void main(String[] args) throws Exception {
+ // Warm up "test"
+ // t will never be started.
+ for (int n = 0; n < 11000; n++) {
+ test(2, 100);
+ }
+
+ // Will this sleep help ensure that the compiler is run?
+ Thread.sleep(500);
+ passed = 0;
+
+ try {
+ test(-1, 100);
+ System.out.println("Missing NegativeArraySizeException #1");
+ fail();
+ } catch ( java.lang.NegativeArraySizeException e ) {
+ System.out.println("Saw expected NegativeArraySizeException #1");
+ }
+
+ try {
+ test(100, -1);
+ fail();
+ System.out.println("Missing NegativeArraySizeException #2");
+ fail();
+ } catch ( java.lang.NegativeArraySizeException e ) {
+ System.out.println("Saw expected NegativeArraySizeException #2");
+ }
+
+ /* Test repetitions. If the test succeeds-mostly, it succeeds,
+ * as long as it does not crash (the outcome if the exception range
+ * table entry for the array allocation is missing).
+ */
+ int N = 12;
+ for (int n = 0; n < N; n++) {
+ threadTest();
+ }
+
+ if (passed > N/2) {
+ System.out.println("Saw " + passed + " out of " + N + " possible ThreadDeath hits");
+ System.out.println("PASSED");
+ } else {
+ System.out.println("Too few ThreadDeath hits; expected at least " + N/2 +
+ " but saw only " + passed);
+ fail();
+ }
+ }
+
+ static void fail() {
+ System.out.println("FAILED");
+ System.exit(97);
+ }
+};