--- /dev/null	2015-11-09 17:14:58.000000000 -0800
+++ new/jdk/src/java.base/share/classes/java/lang/LiveStackFrameInfo.java	2015-11-09 17:14:58.000000000 -0800
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.lang;
+
+import java.lang.StackWalker.Option;
+import java.util.EnumSet;
+import java.util.Set;
+
+import static java.lang.StackWalker.ExtendedOption.*;
+
+final class LiveStackFrameInfo extends StackFrameInfo implements LiveStackFrame {
+    private static Object[] EMPTY_ARRAY = new Object[0];
+
+    /**
+     * Gets {@code StackWalker} that can get locals and operands.
+     *
+     * @throws SecurityException if the security manager is present and
+     * denies access to {@code RuntimePermission(""liveStackFrames")}
+     */
+    public static StackWalker getStackWalker() {
+        return getStackWalker(EnumSet.noneOf(Option.class));
+    }
+
+
+    /**
+     * Gets a {@code StackWalker} instance with the given options specifying
+     * the stack frame information it can access, and which will traverse at most
+     * the given {@code maxDepth} number of stack frames.  If no option is
+     * specified, this {@code StackWalker} obtains the method name and
+     * the class name with all
+     * {@linkplain StackWalker.Option#SHOW_HIDDEN_FRAMES hidden frames} skipped.
+     * The returned {@code StackWalker} can get locals and operands.
+     *
+     * <p>
+     * If a security manager is present and the given
+     * {@code options} contains {@link Option#RETAIN_CLASS_REFERENCE}, it will call its
+     * {@link SecurityManager#checkPermission checkPermission} method for
+     * {@code StackFramePermission("classReference")}.
+     *
+     * @param options stack walk {@link Option options}
+     *
+     * @throws IllegalArgumentException if {@code maxDepth <= 0}
+     * @throws SecurityException if a security manager exists and its
+     *         {@code checkPermission} method denies access.
+     * @throws SecurityException if the security manager is present and
+     * denies access to {@code RuntimePermission(""liveStackFrames")}
+     */
+    public static StackWalker getStackWalker(Set<Option> options) {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkPermission(new RuntimePermission("liveStackFrames"));
+        }
+        return StackWalker.newInstance(options, LOCALS_AND_OPERANDS);
+    }
+
+    LiveStackFrameInfo(StackWalker walker) {
+        super(walker);
+    }
+
+    // These fields are initialized by the VM if ExtendedOption.LOCALS_AND_OPERANDS is set
+    private Object[] monitors = EMPTY_ARRAY;
+    private Object[] locals = EMPTY_ARRAY;
+    private Object[] operands = EMPTY_ARRAY;
+
+    @Override
+    public Object[] getMonitors() {
+        return monitors;
+    }
+
+    @Override
+    public Object[] getLocals() {
+        return locals;
+    }
+
+    @Override
+    public Object[] getStack() {
+        return operands;
+    }
+
+    /*
+     * Convert primitive value to {@code Primitive} object to represent
+     * a local variable or an element on the operand stack of primitive type.
+     */
+    static PrimitiveValue asPrimitive(boolean value) {
+        return new BooleanPrimitive(value);
+    }
+
+    static PrimitiveValue asPrimitive(int value) {
+        return new IntPrimitive(value);
+    }
+
+    static PrimitiveValue asPrimitive(short value) {
+        return new ShortPrimitive(value);
+    }
+
+    static PrimitiveValue asPrimitive(char value) {
+        System.out.println("CharPrimitive "  + value);
+        return new CharPrimitive(value);
+    }
+
+    static PrimitiveValue asPrimitive(byte value) {
+        return new BytePrimitive(value);
+    }
+
+    static PrimitiveValue asPrimitive(long value) {
+        return new LongPrimitive(value);
+    }
+
+    static PrimitiveValue asPrimitive(float value) {
+        return new FloatPrimitive(value);
+    }
+
+    static PrimitiveValue asPrimitive(double value) {
+        return new DoublePrimitive(value);
+    }
+
+    private static class IntPrimitive implements PrimitiveValue {
+        final int value;
+        IntPrimitive(int value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'I';
+        }
+
+        @Override
+        public int intValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    private static class ShortPrimitive implements PrimitiveValue {
+        final short value;
+        ShortPrimitive(short value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'S';
+        }
+
+        @Override
+        public short shortValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    private static class BooleanPrimitive implements PrimitiveValue {
+        final boolean value;
+        BooleanPrimitive(boolean value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'Z';
+        }
+
+        @Override
+        public boolean booleanValue()  {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    private static class CharPrimitive implements PrimitiveValue {
+        final char value;
+        CharPrimitive(char value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'C';
+        }
+
+        @Override
+        public char charValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    private static class BytePrimitive implements PrimitiveValue {
+        final byte value;
+        BytePrimitive(byte value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'B';
+        }
+
+        @Override
+        public byte byteValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    private static class LongPrimitive implements PrimitiveValue {
+        final long value;
+        LongPrimitive(long value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'J';
+        }
+
+        @Override
+        public long longValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    private static class FloatPrimitive implements PrimitiveValue {
+        final float value;
+        FloatPrimitive(float value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'F';
+        }
+
+        @Override
+        public float floatValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    private static class DoublePrimitive implements PrimitiveValue {
+        final double value;
+        DoublePrimitive(double value) {
+            this.value = value;
+        }
+
+        @Override
+        public char type() {
+            return 'D';
+        }
+
+        @Override
+        public double doubleValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+}