/*
|
* 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 Test1939 {
|
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 String SafeToString(Object o) {
|
if (o instanceof Method && Proxy.isProxyClass(((Method)o).getDeclaringClass())) {
|
// TODO This currently only really works on ART. It would be good if we could make it work for
|
// the RI as well.
|
return o.toString().replaceFirst("Proxy[0-9]+", "__PROXY__");
|
} else {
|
return o.toString();
|
}
|
}
|
|
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: " + SafeToString(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(
|
Test1939.class.getClassLoader(),
|
k,
|
(p, m, a) -> {
|
if (m.getName().equals("toString")) {
|
return "Proxy for " + Arrays.toString(k);
|
} else {
|
((Runnable)a[0]).run();
|
return null;
|
}
|
});
|
}
|
|
public static void run() throws Exception {
|
Locals.EnableLocalVariableAccess();
|
TestCase test = new TestCase(
|
getProxyObject(Foo.class), getMethod(Foo.class, "InterfaceProxyMethod"));
|
test.exec(NamedGet("This", Locals::GetLocalInstance));
|
test.exec(NamedGet("LocalReference0", (t, d) -> Locals.GetLocalVariableObject(t, d, 0)));
|
test.exec(NamedGet("ProxyFrameLocation", (t, d) -> Long.valueOf(GetFrameLocation(t, d))));
|
test.exec(NamedGet("ProxyFrameMethod", Test1939::GetFrameMethod));
|
}
|
|
public static native long GetFrameLocation(Thread thr, int depth);
|
public static native Executable GetFrameMethod(Thread thr, int depth);
|
}
|
