1 /*
   2  * Copyright (c) 2015, 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 (os.simpleArch == "x64" | os.simpleArch == "sparcv9" | os.simpleArch == "aarch64")
  28  * @library / /testlibrary /test/lib
  29  * @library ../common/patches
  30  * @modules java.base/jdk.internal.org.objectweb.asm
  31  *          java.base/jdk.internal.org.objectweb.asm.tree
  32  *          jdk.vm.ci/jdk.vm.ci.hotspot
  33  *          jdk.vm.ci/jdk.vm.ci.code
  34  *          jdk.vm.ci/jdk.vm.ci.meta
  35  * @build jdk.vm.ci/jdk.vm.ci.hotspot.CompilerToVMHelper
  36  * @build compiler.jvmci.compilerToVM.GetNextStackFrameTest
  37  * @run main/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
  38  *                   compiler.jvmci.compilerToVM.GetNextStackFrameTest
  39  */
  40 
  41 package compiler.jvmci.compilerToVM;
  42 
  43 import compiler.jvmci.common.CTVMUtilities;
  44 import java.lang.reflect.Method;
  45 import jdk.vm.ci.hotspot.CompilerToVMHelper;
  46 import jdk.vm.ci.hotspot.HotSpotStackFrameReference;
  47 import jdk.vm.ci.meta.ResolvedJavaMethod;
  48 import jdk.test.lib.Asserts;
  49 
  50 public class GetNextStackFrameTest {
  51     private static final int RECURSION_AMOUNT = 3;
  52     private static final ResolvedJavaMethod REC_FRAME_METHOD;
  53     private static final ResolvedJavaMethod FRAME1_METHOD;
  54     private static final ResolvedJavaMethod FRAME2_METHOD;
  55     private static final ResolvedJavaMethod FRAME3_METHOD;
  56     private static final ResolvedJavaMethod FRAME4_METHOD;
  57     private static final ResolvedJavaMethod RUN_METHOD;
  58 
  59     static {
  60         Method method;
  61         try {
  62             Class<?> aClass = GetNextStackFrameTest.class;
  63             method = aClass.getDeclaredMethod("recursiveFrame", int.class);
  64             REC_FRAME_METHOD = CTVMUtilities.getResolvedMethod(method);
  65             method = aClass.getDeclaredMethod("frame1");
  66             FRAME1_METHOD = CTVMUtilities.getResolvedMethod(method);
  67             method = aClass.getDeclaredMethod("frame2");
  68             FRAME2_METHOD = CTVMUtilities.getResolvedMethod(method);
  69             method = aClass.getDeclaredMethod("frame3");
  70             FRAME3_METHOD = CTVMUtilities.getResolvedMethod(method);
  71             method = aClass.getDeclaredMethod("frame4");
  72             FRAME4_METHOD = CTVMUtilities.getResolvedMethod(method);
  73             method = Thread.class.getDeclaredMethod("run");
  74             RUN_METHOD = CTVMUtilities.getResolvedMethod(Thread.class, method);
  75         } catch (NoSuchMethodException e) {
  76             throw new Error("TEST BUG: can't find a test method : " + e, e);
  77         }
  78     }
  79 
  80     public static void main(String[] args) {
  81         new GetNextStackFrameTest().test();
  82     }
  83 
  84     private void test() {
  85         // Create new thread to get new clean stack
  86         Thread thread = new Thread(() -> recursiveFrame(RECURSION_AMOUNT));
  87         thread.start();
  88         try {
  89             thread.join();
  90         } catch (InterruptedException e) {
  91             throw new Error("Interrupted while waiting to join", e);
  92         }
  93     }
  94 
  95     // Helper methods for a longer stack
  96     private void recursiveFrame(int recursionAmount) {
  97         if (--recursionAmount != 0) {
  98             recursiveFrame(recursionAmount);
  99         } else {
 100             frame1();
 101         }
 102     }
 103 
 104     private void frame1() {
 105         frame2();
 106     }
 107 
 108     private void frame2() {
 109         frame3();
 110     }
 111 
 112     private void frame3() {
 113         frame4();
 114     }
 115 
 116     private void frame4() {
 117         check();
 118     }
 119 
 120     private void check() {
 121         findFirst();
 122         walkThrough();
 123         skipAll();
 124         findNextSkipped();
 125         findYourself();
 126     }
 127 
 128     /**
 129      * Finds the first topmost frame from the list of methods to search
 130      */
 131     private void findFirst() {
 132         checkNextFrameFor(null /* topmost frame */,
 133                 new ResolvedJavaMethod[]
 134                         {FRAME2_METHOD, FRAME3_METHOD, FRAME4_METHOD},
 135                 FRAME4_METHOD, 0);
 136     }
 137 
 138     /**
 139      * Walks through whole stack and checks that every frame could be found
 140      * while going down the stack till the end
 141      */
 142     private void walkThrough() {
 143         // Check that we would get a frame 4 starting from the topmost frame
 144         HotSpotStackFrameReference nextStackFrame = checkNextFrameFor(
 145                 null /* topmost frame */,
 146                 new ResolvedJavaMethod[] {FRAME4_METHOD},
 147                 FRAME4_METHOD, 0);
 148         // Check that we would get a frame 3 starting from frame 4 when we try
 149         // to search one of the next two frames
 150         nextStackFrame = checkNextFrameFor(nextStackFrame,
 151                 new ResolvedJavaMethod[] {FRAME3_METHOD,
 152                         FRAME2_METHOD},
 153                 FRAME3_METHOD, 0);
 154         // Check that we would get a frame 1
 155         nextStackFrame = checkNextFrameFor(nextStackFrame,
 156                 new ResolvedJavaMethod[] {FRAME1_METHOD},
 157                 FRAME1_METHOD, 0);
 158         // Check that we would skip (RECURSION_AMOUNT - 1) methods and find a
 159         // recursionFrame starting from frame 1
 160         nextStackFrame = checkNextFrameFor(nextStackFrame,
 161                 new ResolvedJavaMethod[] {REC_FRAME_METHOD},
 162                 REC_FRAME_METHOD, RECURSION_AMOUNT - 1);
 163         // Check that we would get a Thread::run method frame;
 164         nextStackFrame = checkNextFrameFor(nextStackFrame,
 165                 new ResolvedJavaMethod[] {RUN_METHOD},
 166                 RUN_METHOD, 0);
 167         // Check that there are no more frames after thread's run method
 168         nextStackFrame = CompilerToVMHelper.getNextStackFrame(nextStackFrame,
 169                 null /* any */, 0);
 170         Asserts.assertNull(nextStackFrame,
 171                 "Found stack frame after Thread::run");
 172     }
 173 
 174     /**
 175      * Skips all frames to get null at the end of the stack
 176      */
 177     private void skipAll() {
 178         // Skip all frames (stack size) + 2 (getNextStackFrame() itself
 179         // and from CompilerToVMHelper)
 180         int initialSkip = Thread.currentThread().getStackTrace().length + 2;
 181         HotSpotStackFrameReference nextStackFrame = CompilerToVMHelper
 182                 .getNextStackFrame(null /* topmost frame */, null /* any */,
 183                         initialSkip);
 184         Asserts.assertNull(nextStackFrame, "Unexpected frame");
 185     }
 186 
 187     /**
 188      * Search for any frame skipping one frame
 189      */
 190     private void findNextSkipped() {
 191         // Get frame 4
 192         HotSpotStackFrameReference nextStackFrame = CompilerToVMHelper
 193                 .getNextStackFrame(null /* topmost frame */,
 194                         new ResolvedJavaMethod[] {FRAME4_METHOD}, 0);
 195         // Get frame 2 by skipping one method starting from frame 4
 196         checkNextFrameFor(nextStackFrame, null /* any */,
 197                 FRAME2_METHOD , 1 /* skip one */);
 198     }
 199 
 200     /**
 201      * Finds test method in the stack
 202      */
 203     private void findYourself() {
 204         Method method;
 205         Class<?> aClass = CompilerToVMHelper.CompilerToVMClass();
 206         try {
 207             method = aClass.getDeclaredMethod(
 208                     "getNextStackFrame",
 209                     HotSpotStackFrameReference.class,
 210                     ResolvedJavaMethod[].class,
 211                     int.class);
 212         } catch (NoSuchMethodException e) {
 213             throw new Error("TEST BUG: can't find getNextStackFrame : " + e, e);
 214         }
 215         ResolvedJavaMethod self
 216                 = CTVMUtilities.getResolvedMethod(aClass, method);
 217         checkNextFrameFor(null /* topmost frame */, null /* any */, self, 0);
 218     }
 219 
 220     /**
 221      * Searches next frame and checks that it equals to expected
 222      *
 223      * @param currentFrame  start frame to search from
 224      * @param searchMethods a list of methods to search
 225      * @param expected      expected frame
 226      * @param skip          amount of frames to be skipped
 227      * @return frame reference
 228      */
 229     private HotSpotStackFrameReference checkNextFrameFor(
 230             HotSpotStackFrameReference currentFrame,
 231             ResolvedJavaMethod[] searchMethods,
 232             ResolvedJavaMethod expected,
 233             int skip) {
 234         HotSpotStackFrameReference nextStackFrame = CompilerToVMHelper
 235                 .getNextStackFrame(currentFrame, searchMethods, skip);
 236         Asserts.assertNotNull(nextStackFrame);
 237         Asserts.assertTrue(nextStackFrame.isMethod(expected),
 238                 "Unexpected next frame: " + nextStackFrame
 239                         + " from current frame: " + currentFrame);
 240         return nextStackFrame;
 241     }
 242 }