test/1915-get-set-local-current-thread/src/art/Test1915.java

/*
 * 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.Method;
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 Test1915 {
    public static final int SET_VALUE = 1337;
    public static final String TARGET_VAR = "TARGET";

    public static void reportValue(Object val) {
        System.out.println("\tValue is '" + val + "'");
    }
    public static interface ThrowRunnable {
        public void run() throws Exception;
    }

    public static void IntMethod(ThrowRunnable safepoint) throws Exception {
        int TARGET = 42;
        safepoint.run();
        reportValue(TARGET);
    }

    public static void run() throws Exception {
        Locals.EnableLocalVariableAccess();
        final Method target = Test1915.class.getDeclaredMethod("IntMethod", ThrowRunnable.class);
        // Get Variable.
        System.out.println("GetLocalInt on current thread!");
        IntMethod(() -> {
            StackTrace.StackFrameData frame = FindStackFrame(target);
            int depth = FindExpectedFrameDepth(frame);
            int slot = FindSlot(frame);
            int value = Locals.GetLocalVariableInt(Thread.currentThread(), depth, slot);
            System.out.println("From GetLocalInt(), value is " + value);
        });
        // Set Variable.
        System.out.println("SetLocalInt on current thread!");
        IntMethod(() -> {
            StackTrace.StackFrameData frame = FindStackFrame(target);
            int depth = FindExpectedFrameDepth(frame);
            int slot = FindSlot(frame);
            Locals.SetLocalVariableInt(Thread.currentThread(), depth, slot, SET_VALUE);
        });
    }

    public static int FindSlot(StackTrace.StackFrameData frame) throws Exception {
        long loc = frame.current_location;
        for (Locals.VariableDescription var : Locals.GetLocalVariableTable(frame.method)) {
            if (var.start_location <= loc &&
                    var.length + var.start_location > loc &&
                    var.name.equals(TARGET_VAR)) {
                return var.slot;
            }
        }
        throw new Error(
                "Unable to find variable " + TARGET_VAR + " in " + frame.method + " at loc " + loc);
    }

    public static int FindExpectedFrameDepth(StackTrace.StackFrameData frame) throws Exception {
        // Adjust the 'frame' depth since it is modified by:
        // +1 for Get/SetLocalVariableInt in future.
        // -1 for FindStackFrame
        // -1 for GetStackTrace
        // -1 for GetStackTraceNative
        // ------------------------------
        // -2
        return frame.depth - 2;
    }

    private static StackTrace.StackFrameData FindStackFrame(Method target) {
        for (StackTrace.StackFrameData frame : StackTrace.GetStackTrace(Thread.currentThread())) {
            if (frame.method.equals(target)) {
                return frame;
            }
        }
        throw new Error("Unable to find stack frame in method " + target);
    }
}