dalvik.system.VMStack Maven / Gradle / Ivy

/*
 * Copyright (C) 2007 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 dalvik.system;

import java.util.Arrays;

import org.robovm.rt.VM;

/**
 * Provides a limited interface to the Dalvik VM stack. This class is mostly
 * used for implementing security checks.
 *
 * @hide
 */
public final class VMStack {
    /**
     * Returns the defining class loader of the caller's caller.
     *
     * @return the requested class loader, or {@code null} if this is the
     *         bootstrap class loader.
     */
    public static ClassLoader getCallingClassLoader() {
        // RoboVM note: This is native in Android
        return VM.getStackClasses(1, 1)[0].getClassLoader();
    }

    /**
     * Returns the class of the caller's caller's caller.
     *
     * @return the requested class, or {@code null}.
     */
    public static Class getStackClass2() {
        // RoboVM note: This is native in Android
        Class[] classes = VM.getStackClasses(2, 1);
        return classes != null && classes.length > 0 ? classes[0] : null;
    }

    /**
     * Creates an array of classes from the methods at the top of the stack.
     * We continue until we reach the bottom of the stack or exceed the
     * specified maximum depth.
     * 
     * The topmost stack frame (this method) and the one above that (the
     * caller) are excluded from the array.  Frames with java.lang.reflect
     * classes are skipped over.
     * 

     * The classes in the array are the defining classes of the methods.
     * 
     * This is similar to Harmony's VMStack.getClasses, except that this
     * implementation doesn't have a concept of "privileged" frames.
     *
     * @param maxDepth
     *      maximum number of classes to return, or -1 for all
     * @return an array with classes for the most-recent methods on the stack
     */
    public static Class[] getClasses(int maxDepth) {
        // RoboVM note: This is native in Android
        // TODO: Skip over java.lang.reflect classes.
        return VM.getStackClasses(1, maxDepth);
    }

    /**
     * Returns the first ClassLoader on the call stack that isn't either of
     * the passed-in ClassLoaders.
     */
    public static ClassLoader getClosestUserClassLoader(ClassLoader bootstrap,
                                                        ClassLoader system) {
        Class[] stackClasses = VMStack.getClasses(-1);
        for (Class stackClass : stackClasses) {
            ClassLoader loader = stackClass.getClassLoader();
            if (loader != null && loader != bootstrap && loader != system) {
                return loader;
            }
        }
        return null;
    }

    /**
     * Retrieves the stack trace from the specified thread.
     *
     * @param t
     *      thread of interest
     * @return an array of stack trace elements, or null if the thread
     *      doesn't have a stack trace (e.g. because it exited)
     */
    public static StackTraceElement[] getThreadStackTrace(Thread t) {
        // RoboVM note: This is native in Android.
        return t.getStackTrace();
    }

    /**
     * Retrieves a partial stack trace from the specified thread into
     * the provided array.
     *
     * @param t
     *      thread of interest
     * @param stackTraceElements
     *      preallocated array for use when only the top of stack is
     *      desired. Unused elements will be filled with null values.
     * @return the number of elements filled
     */
    public static int fillStackTraceElements(Thread t,
        StackTraceElement[] stackTraceElements) {
        // RoboVM note: This is native in Android.
        Arrays.fill(stackTraceElements, null);
        StackTraceElement[] st = t.getStackTrace();
        int n = Math.min(st.length, stackTraceElements.length);
        System.arraycopy(st, 0, stackTraceElements, 0, n);
        return n;
    }
}