/*
|
* 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.lang.reflect.Constructor;
|
import java.lang.reflect.Executable;
|
import java.lang.reflect.InvocationHandler;
|
import java.lang.reflect.Method;
|
import java.lang.reflect.Proxy;
|
import java.nio.ByteBuffer;
|
import java.util.concurrent.Semaphore;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.function.Function;
|
import java.util.function.Predicate;
|
import java.util.function.Supplier;
|
import java.util.function.Consumer;
|
|
public class Test1914 {
|
public static final String TARGET_VAR = "TARGET";
|
|
public static void reportValue(Object val) {
|
System.out.println("\tValue is '" + val + "' (class: "
|
+ (val != null ? (val instanceof Proxy ? "PROXY CLASS" : val.getClass()) : "NULL") + ")");
|
}
|
|
public static void StaticMethod(Runnable safepoint) {
|
safepoint.run();
|
reportValue(null);
|
}
|
|
public static native void NativeStaticMethod(Runnable safepoint);
|
|
public static class TargetClass {
|
public String id;
|
public String toString() { return String.format("TargetClass(\"%s\")", id); }
|
public TargetClass(String id) { this.id = id; }
|
|
public void InstanceMethod(Runnable safepoint) {
|
safepoint.run();
|
reportValue(this);
|
}
|
|
public native void NativeInstanceMethod(Runnable safepoint);
|
}
|
|
public static interface SafepointFunction {
|
public void invoke(
|
Thread thread,
|
Method target,
|
int depth) throws Exception;
|
}
|
|
public static interface GetterFunction {
|
public Object GetVar(Thread t, int depth);
|
}
|
|
public static SafepointFunction NamedGet(final String type, final GetterFunction get) {
|
return new SafepointFunction() {
|
public void invoke(Thread t, Method method, int depth) {
|
try {
|
Object res = get.GetVar(t, depth);
|
System.out.println(this + " on " + method + " got value: " + res);
|
} catch (Exception e) {
|
System.out.println(this + " on " + method + " failed due to " + e.getMessage());
|
}
|
}
|
public String toString() {
|
return "\"Get" + type + "\"";
|
}
|
};
|
}
|
|
public static class TestCase {
|
public final Object thiz;
|
public final Method target;
|
|
public TestCase(Method target) {
|
this(null, target);
|
}
|
public TestCase(Object thiz, Method target) {
|
this.thiz = thiz;
|
this.target = target;
|
}
|
|
public static class ThreadPauser implements Runnable {
|
public final Semaphore sem_wakeup_main;
|
public final Semaphore sem_wait;
|
|
public ThreadPauser() {
|
sem_wakeup_main = new Semaphore(0);
|
sem_wait = new Semaphore(0);
|
}
|
|
public void run() {
|
try {
|
sem_wakeup_main.release();
|
sem_wait.acquire();
|
} catch (Exception e) {
|
throw new Error("Error with semaphores!", e);
|
}
|
}
|
|
public void waitForOtherThreadToPause() throws Exception {
|
sem_wakeup_main.acquire();
|
}
|
|
public void wakeupOtherThread() throws Exception {
|
sem_wait.release();
|
}
|
}
|
|
public void exec(final SafepointFunction safepoint) throws Exception {
|
System.out.println("Running " + target + " with " + safepoint + " on remote thread.");
|
final ThreadPauser pause = new ThreadPauser();
|
Thread remote = new Thread(
|
() -> {
|
try {
|
target.invoke(thiz, pause);
|
} catch (Exception e) {
|
throw new Error("Error invoking remote thread " + Thread.currentThread(), e);
|
}
|
},
|
"remote thread for " + target + " with " + safepoint);
|
remote.start();
|
pause.waitForOtherThreadToPause();
|
try {
|
Suspension.suspend(remote);
|
StackTrace.StackFrameData frame = findStackFrame(remote);
|
safepoint.invoke(remote, target, frame.depth);
|
} finally {
|
Suspension.resume(remote);
|
pause.wakeupOtherThread();
|
remote.join();
|
}
|
}
|
|
private StackTrace.StackFrameData findStackFrame(Thread thr) {
|
for (StackTrace.StackFrameData frame : StackTrace.GetStackTrace(thr)) {
|
if (frame.method.equals(target) ||
|
(frame.method.getName().equals(target.getName()) &&
|
Arrays.deepEquals(frame.method.getParameterTypes(), target.getParameterTypes()) &&
|
((Method)frame.method).getReturnType().equals(target.getReturnType()))) {
|
return frame;
|
}
|
}
|
throw new Error("Unable to find stack frame in method " + target + " on thread " + thr);
|
}
|
}
|
|
public static Method getMethod(Class<?> klass, String name) throws Exception {
|
return klass.getDeclaredMethod(name, Runnable.class);
|
}
|
|
public static interface Foo {
|
public void InterfaceProxyMethod(Runnable r);
|
}
|
|
public static Object getProxyObject(final Class... k) {
|
return Proxy.newProxyInstance(
|
Test1914.class.getClassLoader(),
|
k,
|
(p, m, a) -> {
|
if (m.getName().equals("toString")) {
|
return "Proxy for " + Arrays.toString(k);
|
} else {
|
((Runnable)a[0]).run();
|
reportValue(p);
|
return null;
|
}
|
});
|
}
|
|
public static void run() throws Exception {
|
Locals.EnableLocalVariableAccess();
|
final TestCase[] MAIN_TEST_CASES = new TestCase[] {
|
new TestCase(null, getMethod(Test1914.class, "StaticMethod")),
|
new TestCase(null, getMethod(Test1914.class, "NativeStaticMethod")),
|
new TestCase(new TargetClass("InstanceMethodObject"),
|
getMethod(TargetClass.class, "InstanceMethod")),
|
new TestCase(new TargetClass("NativeInstanceMethodObject"),
|
getMethod(TargetClass.class, "NativeInstanceMethod")),
|
new TestCase(getProxyObject(Foo.class),
|
getMethod(Foo.class, "InterfaceProxyMethod")),
|
};
|
|
for (TestCase t: MAIN_TEST_CASES) {
|
t.exec(NamedGet("This", Locals::GetLocalInstance));
|
}
|
}
|
}
|
