Revert "Revert "JVMTI Exception and ExceptionCatch events""
Fixed error where we were incorrectly not updating a ShadowFrame
dex_pc causing deoptimization errors.
Bug: 62821960
Bug: 65049545
Test: ./test.py --host -j50
Test: ./art/tools/run-libcore-tests.sh \
--mode=host --variant-X32 --debug
This reverts commit 959742483885779f106e000df6dd422fc8657931.
Change-Id: I91ab2bc3e645ddf0359c189b19a59a3ecf0d8921
diff --git a/test/1929-exception-catch-exception/src/art/Test1929.java b/test/1929-exception-catch-exception/src/art/Test1929.java
new file mode 100644
index 0000000..07d2087
--- /dev/null
+++ b/test/1929-exception-catch-exception/src/art/Test1929.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package art;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Objects;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+
+public class Test1929 {
+ public static boolean PRINT_FULL_EXCEPTION = false;
+ public static ExceptionHandler HANDLER = null;
+ public static Collection<Executable> TEST_METHODS;
+
+ public static void doNothing() {};
+ static {
+ try {
+ TEST_METHODS = Arrays.asList(
+ Test1929.class.getDeclaredMethod("doThrow"),
+ Test1929.class.getDeclaredMethod("throwCatchBaseTestException"),
+ Test1929.class.getDeclaredMethod("throwCatchBaseTestExceptionTwice"),
+ Test1929.class.getDeclaredMethod("throwCatchTestException"),
+ Test1929.class.getDeclaredMethod("throwCatchTestExceptionTwice"),
+ Test1929.class.getDeclaredMethod("throwCatchTestExceptionNoRethrow"));
+ } catch (Exception e) {
+ throw new Error("Unable to list test methods!", e);
+ }
+ }
+
+ public static interface ExceptionHandler {
+ public void exceptionOccurred(
+ Executable m, long loc, Throwable exception);
+ }
+
+ private static void PrintStack() {
+ System.out.println("\tCurrent Stack:");
+ for (StackTrace.StackFrameData e : StackTrace.GetStackTrace(Thread.currentThread())) {
+ if (Objects.equals(e.method.getDeclaringClass().getPackage(), Test1929.class.getPackage())) {
+ System.out.println("\t\t" + e.method + " @ line = " +
+ Breakpoint.locationToLine(e.method, e.current_location));
+ }
+ }
+ }
+
+ public static void ExceptionCatchEvent(
+ Thread thr, Executable method, long location, Throwable exception) {
+ System.out.println(thr.getName() + ": " + method + " @ line = " +
+ Breakpoint.locationToLine(method, location) + " caught " +
+ exception.getClass() + ": " + exception.getMessage());
+ PrintStack();
+ if (PRINT_FULL_EXCEPTION) {
+ System.out.print("exception is: ");
+ exception.printStackTrace(System.out);
+ }
+ if (HANDLER != null && TEST_METHODS.contains(method)) {
+ HANDLER.exceptionOccurred(method, location, exception);
+ }
+ }
+
+ public static class BaseTestException extends Error {
+ public BaseTestException(String e) { super(e); }
+ public BaseTestException(String e, Throwable t) { super(e, t); }
+ }
+ public static class TestException extends BaseTestException {
+ public TestException(String e) { super(e); }
+ public TestException(String e, Throwable t) { super(e, t); }
+ }
+
+ public static class TestExceptionNoRethrow extends TestException {
+ public TestExceptionNoRethrow(String e) { super(e); }
+ public TestExceptionNoRethrow(String e, Throwable t) { super(e, t); }
+ }
+
+ public static class DoNothingHandler implements ExceptionHandler {
+ public void exceptionOccurred(Executable m, long loc, Throwable exception) {
+ System.out.println("\tDoing nothing!");
+ return;
+ }
+ }
+
+ public static class ThrowCatchBase implements ExceptionHandler {
+ public void exceptionOccurred(Executable m, long loc, Throwable exception) {
+ System.out.println("\tThrowing BaseTestException and catching it!");
+ try {
+ throw new BaseTestException("ThrowBaseHandler during throw from " + m + " @ line = " +
+ Breakpoint.locationToLine(m, loc), exception);
+ } catch (BaseTestException t) {
+ System.out.println("Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ }
+ }
+ public static class ThrowBaseTestExceptionHandler implements ExceptionHandler {
+ public void exceptionOccurred(Executable m, long loc, Throwable exception) {
+ System.out.println("\tThrowing BaseTestException!");
+ throw new BaseTestException("ThrowBaseHandler during throw from " + m + " @ line = " +
+ Breakpoint.locationToLine(m, loc), exception);
+ }
+ }
+
+ public static class ThrowTestExceptionNoRethrowHandler implements ExceptionHandler {
+ public void exceptionOccurred(Executable m, long loc, Throwable exception) {
+ if (exception instanceof TestExceptionNoRethrow) {
+ System.out.println("\tInstance of TestExceptionNoRethrow was thrown. Not throwing again.");
+ } else {
+ System.out.println("\tThrowing TestExceptionNoRethrow!");
+ throw new TestExceptionNoRethrow("ThrowTestExceptionNoRethrowHandler during throw from " +
+ m + " @ line = " + Breakpoint.locationToLine(m, loc), exception);
+ }
+ }
+ }
+ public static void doThrow() {
+ throw new TestException("doThrow");
+ }
+
+ public static class DoThrowClass implements Runnable {
+ public void run() { doThrow(); }
+ }
+
+ public static void throwCatchBaseTestException() {
+ try {
+ throw new TestException("throwCatchBaseTestException");
+ } catch (BaseTestException t) {
+ System.out.println("Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ }
+
+ public static class DoThrowCatchBaseTestException implements Runnable {
+ public void run() { throwCatchBaseTestException(); }
+ }
+
+ // dx/d8/jack all do an optimization around catch blocks that (while legal) breaks assumptions
+ // this test relies on so we have the actual implementation be corrected smali. This does work
+ // for RI however.
+ public static final class Impl {
+ private Impl() {}
+ public static void throwCatchBaseTestExceptionTwiceImpl() {
+ try {
+ try {
+ throw new TestException("throwCatchBaseTestExceptionTwice");
+ } catch (BaseTestException t) {
+ System.out.println("Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ } catch (BaseTestException t) {
+ System.out.println("2nd Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ }
+
+ public static void throwCatchTestExceptionTwiceImpl() {
+ try {
+ try {
+ throw new TestException("throwCatchTestExceptionTwice");
+ } catch (TestException t) {
+ System.out.println("Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ } catch (TestException t) {
+ System.out.println("2nd Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ }
+ }
+
+ public static void throwCatchBaseTestExceptionTwice() {
+ // The implementation of this has to change depending upon the runtime slightly due to compiler
+ // optimizations present in DX/D8/Jack.
+ Impl.throwCatchBaseTestExceptionTwiceImpl();
+ }
+
+ public static class DoThrowCatchBaseTestExceptionTwice implements Runnable {
+ public void run() { throwCatchBaseTestExceptionTwice(); }
+ }
+
+ public static void throwCatchTestException() {
+ try {
+ throw new TestException("throwCatchTestException");
+ } catch (TestException t) {
+ System.out.println("Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ }
+
+ public static class DoThrowCatchTestException implements Runnable {
+ public void run() { throwCatchTestException(); }
+ }
+
+ public static void throwCatchTestExceptionTwice() {
+ // The implementation of this has to change depending upon the runtime slightly due to compiler
+ // optimizations present in DX/D8/Jack.
+ Impl.throwCatchTestExceptionTwiceImpl();
+ }
+
+ public static class DoThrowCatchTestExceptionTwice implements Runnable {
+ public void run() { throwCatchTestExceptionTwice(); }
+ }
+
+ public static void throwCatchTestExceptionNoRethrow() {
+ try {
+ throw new TestException("throwCatchTestExceptionNoRethrow");
+ } catch (TestExceptionNoRethrow t) {
+ System.out.println("Caught " + t.getClass().getName() + ": \"" + t.getMessage() + "\"");
+ if (PRINT_FULL_EXCEPTION) {
+ t.printStackTrace(System.out);
+ }
+ }
+ }
+
+ public static class DoThrowCatchTestExceptionNoRethrow implements Runnable {
+ public void run() { throwCatchTestExceptionNoRethrow(); }
+ }
+
+ public static void run() throws Exception {
+ // Set up breakpoints
+ Exceptions.setupExceptionTracing(
+ Test1929.class,
+ TestException.class,
+ null,
+ Test1929.class.getDeclaredMethod(
+ "ExceptionCatchEvent",
+ Thread.class,
+ Executable.class,
+ Long.TYPE,
+ Throwable.class));
+ Exceptions.enableExceptionCatchEvent(Thread.currentThread());
+
+ ExceptionHandler[] handlers = new ExceptionHandler[] {
+ new DoNothingHandler(),
+ new ThrowCatchBase(),
+ new ThrowBaseTestExceptionHandler(),
+ new ThrowTestExceptionNoRethrowHandler(),
+ };
+
+ Runnable[] tests = new Runnable[] {
+ new DoThrowClass(),
+ new DoThrowCatchBaseTestException(),
+ new DoThrowCatchBaseTestExceptionTwice(),
+ new DoThrowCatchTestException(),
+ new DoThrowCatchTestExceptionTwice(),
+ new DoThrowCatchTestExceptionNoRethrow(),
+ };
+
+ for (ExceptionHandler handler : handlers) {
+ for (Runnable test : tests) {
+ try {
+ HANDLER = handler;
+ System.out.printf("Test \"%s\": Running breakpoint with handler \"%s\"\n",
+ test.getClass().getName(), handler.getClass().getName());
+ test.run();
+ System.out.printf("Test \"%s\": No error caught with handler \"%s\"\n",
+ test.getClass().getName(), handler.getClass().getName());
+ } catch (Throwable e) {
+ System.out.printf("Test \"%s\": Caught error %s:\"%s\" with handler \"%s\"\n",
+ test.getClass().getName(),
+ e.getClass().getName(),
+ e.getMessage(),
+ handler.getClass().getName());
+ if (PRINT_FULL_EXCEPTION) {
+ e.printStackTrace(System.out);
+ }
+ }
+ System.out.printf("Test \"%s\": Finished running with handler \"%s\"\n",
+ test.getClass().getName(), handler.getClass().getName());
+ HANDLER = null;
+ }
+ }
+ Exceptions.disableExceptionCatchEvent(Thread.currentThread());
+ }
+}