1 /*
   2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug 8136421
  27  * @requires vm.jvmci
  28  * @library / /test/lib
  29  * @library ../common/patches
  30  * @modules java.base/jdk.internal.misc
  31  * @modules java.base/jdk.internal.org.objectweb.asm
  32  *          java.base/jdk.internal.org.objectweb.asm.tree
  33  *          jdk.internal.vm.ci/jdk.vm.ci.hotspot
  34  *          jdk.internal.vm.ci/jdk.vm.ci.code
  35  *          jdk.internal.vm.ci/jdk.vm.ci.meta
  36  * @build jdk.internal.vm.ci/jdk.vm.ci.hotspot.CompilerToVMHelper
  37  * @run main/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
  38  *                   -Djvmci.Compiler=null
  39  *                   compiler.jvmci.compilerToVM.GetNextStackFrameTest
  40  */
  41 
  42 package compiler.jvmci.compilerToVM;
  43 
  44 import compiler.jvmci.common.CTVMUtilities;
  45 import jdk.test.lib.Asserts;
  46 import jdk.vm.ci.hotspot.CompilerToVMHelper;
  47 import jdk.vm.ci.hotspot.HotSpotStackFrameReference;
  48 import jdk.vm.ci.meta.ResolvedJavaMethod;
  49 
  50 import java.lang.reflect.Method;
  51 
  52 public class GetNextStackFrameTest {
  53     private static final int RECURSION_AMOUNT = 3;
  54     private static final ResolvedJavaMethod REC_FRAME_METHOD;
  55     private static final ResolvedJavaMethod FRAME1_METHOD;
  56     private static final ResolvedJavaMethod FRAME2_METHOD;
  57     private static final ResolvedJavaMethod FRAME3_METHOD;
  58     private static final ResolvedJavaMethod FRAME4_METHOD;
  59     private static final ResolvedJavaMethod RUN_METHOD;
  60 
  61     static {
  62         Method method;
  63         try {
  64             Class<?> aClass = GetNextStackFrameTest.class;
  65             method = aClass.getDeclaredMethod("recursiveFrame", int.class);
  66             REC_FRAME_METHOD = CTVMUtilities.getResolvedMethod(method);
  67             method = aClass.getDeclaredMethod("frame1");
  68             FRAME1_METHOD = CTVMUtilities.getResolvedMethod(method);
  69             method = aClass.getDeclaredMethod("frame2");
  70             FRAME2_METHOD = CTVMUtilities.getResolvedMethod(method);
  71             method = aClass.getDeclaredMethod("frame3");
  72             FRAME3_METHOD = CTVMUtilities.getResolvedMethod(method);
  73             method = aClass.getDeclaredMethod("frame4");
  74             FRAME4_METHOD = CTVMUtilities.getResolvedMethod(method);
  75             method = Thread.class.getDeclaredMethod("run");
  76             RUN_METHOD = CTVMUtilities.getResolvedMethod(Thread.class, method);
  77         } catch (NoSuchMethodException e) {
  78             throw new Error("TEST BUG: can't find a test method : " + e, e);
  79         }
  80     }
  81 
  82     public static void main(String[] args) {
  83         new GetNextStackFrameTest().test();
  84     }
  85 
  86     private void test() {
  87         // Create new thread to get new clean stack
  88         Thread thread = new Thread(() -> recursiveFrame(RECURSION_AMOUNT));
  89         thread.start();
  90         try {
  91             thread.join();
  92         } catch (InterruptedException e) {
  93             throw new Error("Interrupted while waiting to join", e);
  94         }
  95     }
  96 
  97     // Helper methods for a longer stack
  98     private void recursiveFrame(int recursionAmount) {
  99         if (--recursionAmount != 0) {
 100             recursiveFrame(recursionAmount);
 101         } else {
 102             frame1();
 103         }
 104     }
 105 
 106     private void frame1() {
 107         frame2();
 108     }
 109 
 110     private void frame2() {
 111         frame3();
 112     }
 113 
 114     private void frame3() {
 115         frame4();
 116     }
 117 
 118     private void frame4() {
 119         check();
 120     }
 121 
 122     private void check() {
 123         findFirst();
 124         walkThrough();
 125         skipAll();
 126         findNextSkipped();
 127         findYourself();
 128     }
 129 
 130     /**
 131      * Finds the first topmost frame from the list of methods to search
 132      */
 133     private void findFirst() {
 134         checkNextFrameFor(null /* topmost frame */,
 135                 new ResolvedJavaMethod[]
 136                         {FRAME2_METHOD, FRAME3_METHOD, FRAME4_METHOD},
 137                 FRAME4_METHOD, 0);
 138     }
 139 
 140     /**
 141      * Walks through whole stack and checks that every frame could be found
 142      * while going down the stack till the end
 143      */
 144     private void walkThrough() {
 145         // Check that we would get a frame 4 starting from the topmost frame
 146         HotSpotStackFrameReference nextStackFrame = checkNextFrameFor(
 147                 null /* topmost frame */,
 148                 new ResolvedJavaMethod[] {FRAME4_METHOD},
 149                 FRAME4_METHOD, 0);
 150         // Check that we would get a frame 3 starting from frame 4 when we try
 151         // to search one of the next two frames
 152         nextStackFrame = checkNextFrameFor(nextStackFrame,
 153                 new ResolvedJavaMethod[] {FRAME3_METHOD,
 154                         FRAME2_METHOD},
 155                 FRAME3_METHOD, 0);
 156         // Check that we would get a frame 1
 157         nextStackFrame = checkNextFrameFor(nextStackFrame,
 158                 new ResolvedJavaMethod[] {FRAME1_METHOD},
 159                 FRAME1_METHOD, 0);
 160         // Check that we would skip (RECURSION_AMOUNT - 1) methods and find a
 161         // recursionFrame starting from frame 1
 162         nextStackFrame = checkNextFrameFor(nextStackFrame,
 163                 new ResolvedJavaMethod[] {REC_FRAME_METHOD},
 164                 REC_FRAME_METHOD, RECURSION_AMOUNT - 1);
 165         // Check that we would get a Thread::run method frame;
 166         nextStackFrame = checkNextFrameFor(nextStackFrame,
 167                 new ResolvedJavaMethod[] {RUN_METHOD},
 168                 RUN_METHOD, 0);
 169         // Check that there are no more frames after thread's run method
 170         nextStackFrame = CompilerToVMHelper.getNextStackFrame(nextStackFrame,
 171                 null /* any */, 0);
 172         Asserts.assertNull(nextStackFrame,
 173                 "Found stack frame after Thread::run");
 174     }
 175 
 176     /**
 177      * Skips all frames to get null at the end of the stack
 178      */
 179     private void skipAll() {
 180         // Skip all frames (stack size) + 2 (getNextStackFrame() itself
 181         // and from CompilerToVMHelper)
 182         int initialSkip = Thread.currentThread().getStackTrace().length + 2;
 183         HotSpotStackFrameReference nextStackFrame = CompilerToVMHelper
 184                 .getNextStackFrame(null /* topmost frame */, null /* any */,
 185                         initialSkip);
 186         Asserts.assertNull(nextStackFrame, "Unexpected frame");
 187     }
 188 
 189     /**
 190      * Search for any frame skipping one frame
 191      */
 192     private void findNextSkipped() {
 193         // Get frame 4
 194         HotSpotStackFrameReference nextStackFrame = CompilerToVMHelper
 195                 .getNextStackFrame(null /* topmost frame */,
 196                         new ResolvedJavaMethod[] {FRAME4_METHOD}, 0);
 197         // Get frame 2 by skipping one method starting from frame 4
 198         checkNextFrameFor(nextStackFrame, null /* any */,
 199                 FRAME2_METHOD , 1 /* skip one */);
 200     }
 201 
 202     /**
 203      * Finds test method in the stack
 204      */
 205     private void findYourself() {
 206         Method method;
 207         Class<?> aClass = CompilerToVMHelper.CompilerToVMClass();
 208         try {
 209             method = aClass.getDeclaredMethod(
 210                     "getNextStackFrame",
 211                     HotSpotStackFrameReference.class,
 212                     ResolvedJavaMethod[].class,
 213                     int.class);
 214         } catch (NoSuchMethodException e) {
 215             throw new Error("TEST BUG: can't find getNextStackFrame : " + e, e);
 216         }
 217         ResolvedJavaMethod self
 218                 = CTVMUtilities.getResolvedMethod(aClass, method);
 219         checkNextFrameFor(null /* topmost frame */, null /* any */, self, 0);
 220     }
 221 
 222     /**
 223      * Searches next frame and checks that it equals to expected
 224      *
 225      * @param currentFrame  start frame to search from
 226      * @param searchMethods a list of methods to search
 227      * @param expected      expected frame
 228      * @param skip          amount of frames to be skipped
 229      * @return frame reference
 230      */
 231     private HotSpotStackFrameReference checkNextFrameFor(
 232             HotSpotStackFrameReference currentFrame,
 233             ResolvedJavaMethod[] searchMethods,
 234             ResolvedJavaMethod expected,
 235             int skip) {
 236         HotSpotStackFrameReference nextStackFrame = CompilerToVMHelper
 237                 .getNextStackFrame(currentFrame, searchMethods, skip);
 238         Asserts.assertNotNull(nextStackFrame);
 239         Asserts.assertTrue(nextStackFrame.isMethod(expected),
 240                 "Unexpected next frame: " + nextStackFrame
 241                         + " from current frame: " + currentFrame);
 242         return nextStackFrame;
 243     }
 244 }
--- EOF ---