1 /* 2 * Copyright (c) 2020 SAP SE. 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 /** 26 * @test 27 * @bug 8227745 28 * @summary Collection of test cases that check if optimizations based on escape analysis are reverted just before non-escaping objects escape through JVMTI. 29 * @author Richard Reingruber richard DOT reingruber AT sap DOT com 30 * 31 * @requires ((vm.compMode == "Xmixed") & vm.compiler2.enabled) 32 * @library /test/lib /test/hotspot/jtreg 33 * 34 * @run build TestScaffold VMConnection TargetListener TargetAdapter jdk.test.whitebox.WhiteBox 35 * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox 36 * @run compile -g EATests.java 37 * @run driver EATests 38 * -XX:+UnlockDiagnosticVMOptions 39 * -Xms256m -Xmx256m 40 * -Xbootclasspath/a:. 41 * -XX:CompileCommand=dontinline,*::dontinline_* 42 * -XX:+WhiteBoxAPI 43 * -Xbatch 44 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks -XX:+UseBiasedLocking 45 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 46 * @run driver EATests 47 * -XX:+UnlockDiagnosticVMOptions 48 * -Xms256m -Xmx256m 49 * -Xbootclasspath/a:. 50 * -XX:CompileCommand=dontinline,*::dontinline_* 51 * -XX:+WhiteBoxAPI 52 * -Xbatch 53 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:-EliminateLocks -XX:+EliminateNestedLocks -XX:+UseBiasedLocking -XX:-UseOptoBiasInlining 54 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 55 * @run driver EATests 56 * -XX:+UnlockDiagnosticVMOptions 57 * -Xms256m -Xmx256m 58 * -Xbootclasspath/a:. 59 * -XX:CompileCommand=dontinline,*::dontinline_* 60 * -XX:+WhiteBoxAPI 61 * -Xbatch 62 * -XX:+DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks -XX:+UseBiasedLocking 63 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 64 * @run driver EATests 65 * -XX:+UnlockDiagnosticVMOptions 66 * -Xms256m -Xmx256m 67 * -Xbootclasspath/a:. 68 * -XX:CompileCommand=dontinline,*::dontinline_* 69 * -XX:+WhiteBoxAPI 70 * -Xbatch 71 * -XX:-DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks -XX:+UseBiasedLocking 72 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 73 * @run driver EATests 74 * -XX:+UnlockDiagnosticVMOptions 75 * -Xms256m -Xmx256m 76 * -Xbootclasspath/a:. 77 * -XX:CompileCommand=dontinline,*::dontinline_* 78 * -XX:+WhiteBoxAPI 79 * -Xbatch 80 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks -XX:-UseBiasedLocking 81 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 82 * @run driver EATests 83 * -XX:+UnlockDiagnosticVMOptions 84 * -Xms256m -Xmx256m 85 * -Xbootclasspath/a:. 86 * -XX:CompileCommand=dontinline,*::dontinline_* 87 * -XX:+WhiteBoxAPI 88 * -Xbatch 89 * -XX:+DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks -XX:-UseBiasedLocking 90 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 91 * @run driver EATests 92 * -XX:+UnlockDiagnosticVMOptions 93 * -Xms256m -Xmx256m 94 * -Xbootclasspath/a:. 95 * -XX:CompileCommand=dontinline,*::dontinline_* 96 * -XX:+WhiteBoxAPI 97 * -Xbatch 98 * -XX:-DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks -XX:-UseBiasedLocking 99 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 100 * 101 * @run driver EATests 102 * -XX:+UnlockDiagnosticVMOptions 103 * -Xms256m -Xmx256m 104 * -Xbootclasspath/a:. 105 * -XX:CompileCommand=dontinline,*::dontinline_* 106 * -XX:+WhiteBoxAPI 107 * -Xbatch 108 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks 109 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=2 110 * @run driver EATests 111 * -XX:+UnlockDiagnosticVMOptions 112 * -Xms256m -Xmx256m 113 * -Xbootclasspath/a:. 114 * -XX:CompileCommand=dontinline,*::dontinline_* 115 * -XX:+WhiteBoxAPI 116 * -Xbatch 117 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:-EliminateLocks -XX:+EliminateNestedLocks 118 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=2 119 * @run driver EATests 120 * -XX:+UnlockDiagnosticVMOptions 121 * -Xms256m -Xmx256m 122 * -Xbootclasspath/a:. 123 * -XX:CompileCommand=dontinline,*::dontinline_* 124 * -XX:+WhiteBoxAPI 125 * -Xbatch 126 * -XX:+DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks 127 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=2 128 * @run driver EATests 129 * -XX:+UnlockDiagnosticVMOptions 130 * -Xms256m -Xmx256m 131 * -Xbootclasspath/a:. 132 * -XX:CompileCommand=dontinline,*::dontinline_* 133 * -XX:+WhiteBoxAPI 134 * -Xbatch 135 * -XX:-DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks 136 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=2 137 * 138 * @comment Excercise -XX:+DeoptimizeObjectsALot. Mostly to prevent bit-rot because the option is meant to stress object deoptimization 139 * with non-synthetic workloads. 140 * @run driver EATests 141 * -XX:+UnlockDiagnosticVMOptions 142 * -Xms256m -Xmx256m 143 * -Xbootclasspath/a:. 144 * -XX:CompileCommand=dontinline,*::dontinline_* 145 * -XX:+WhiteBoxAPI 146 * -Xbatch 147 * -XX:-DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks -XX:-UseBiasedLocking 148 * -XX:+IgnoreUnrecognizedVMOptions -XX:+DeoptimizeObjectsALot 149 * 150 * @bug 8324881 151 * @comment Regression test for using the wrong thread when logging during re-locking from deoptimization. 152 * 153 * @comment DiagnoseSyncOnValueBasedClasses=2 will cause logging when locking on \@ValueBased objects. 154 * @run driver EATests 155 * -XX:+UnlockDiagnosticVMOptions 156 * -Xms256m -Xmx256m 157 * -Xbootclasspath/a:. 158 * -XX:CompileCommand=dontinline,*::dontinline_* 159 * -XX:+WhiteBoxAPI 160 * -Xbatch 161 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks 162 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 163 * -XX:DiagnoseSyncOnValueBasedClasses=2 164 * 165 * @comment Re-lock may inflate monitors when re-locking, which cause monitorinflation trace logging. 166 * @run driver EATests 167 * -XX:+UnlockDiagnosticVMOptions 168 * -Xms256m -Xmx256m 169 * -Xbootclasspath/a:. 170 * -XX:CompileCommand=dontinline,*::dontinline_* 171 * -XX:+WhiteBoxAPI 172 * -Xbatch 173 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks 174 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=2 175 * -Xlog:monitorinflation=trace:file=monitorinflation.log 176 * 177 * @comment Re-lock may race with deflation. 178 * @run driver EATests 179 * -XX:+UnlockDiagnosticVMOptions 180 * -Xms256m -Xmx256m 181 * -Xbootclasspath/a:. 182 * -XX:CompileCommand=dontinline,*::dontinline_* 183 * -XX:+WhiteBoxAPI 184 * -Xbatch 185 * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks 186 * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=0 187 * -XX:GuaranteedAsyncDeflationInterval=1000 188 */ 189 190 /** 191 * @test 192 * @bug 8227745 193 * 194 * @summary This is another configuration of EATests.java to test Graal. Some testcases are expected 195 * to fail because Graal does not provide all information about non-escaping objects in 196 * scope. These are skipped. 197 * 198 * @author Richard Reingruber richard DOT reingruber AT sap DOT com 199 * 200 * @requires ((vm.compMode == "Xmixed") & vm.graal.enabled) 201 * 202 * @library /test/lib /test/hotspot/jtreg 203 * 204 * @run build TestScaffold VMConnection TargetListener TargetAdapter jdk.test.whitebox.WhiteBox 205 * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox 206 * @run compile -g EATests.java 207 * 208 * @comment Test with Graal. Some testcases are expected to fail because Graal does not provide all information about non-escaping 209 * objects in scope. These are skipped. 210 * @run driver EATests 211 * -XX:+UnlockDiagnosticVMOptions 212 * -Xms256m -Xmx256m 213 * -Xbootclasspath/a:. 214 * -XX:CompileCommand=dontinline,*::dontinline_* 215 * -XX:+WhiteBoxAPI 216 * -Xbatch 217 * -XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler 218 */ 219 220 import com.sun.jdi.*; 221 import com.sun.jdi.event.*; 222 import compiler.testlibrary.CompilerUtils; 223 import compiler.whitebox.CompilerWhiteBoxTest; 224 225 import java.lang.reflect.Array; 226 import java.util.Arrays; 227 import java.util.List; 228 import java.util.Map; 229 import java.util.function.Function; 230 231 import jdk.test.lib.Asserts; 232 import jdk.test.whitebox.WhiteBox; 233 import jdk.test.whitebox.gc.GC; 234 235 236 // 237 // ANALYZING TEST FAILURES 238 // 239 // - Executing just a single test case with the property EATests.onlytestcase. 240 // 241 // Example: java -DEATests.onlytestcase=<test case name> ... EATests 242 // 243 // - Interactive execution allows for attaching a native debugger, e.g. gdb 244 // 245 // Example: java -DEATests.interactive=true ... EATests 246 // 247 // - Java arguments to the test are passed as vm options to the debuggee: 248 // 249 // Example: java ... EATests -XX:+UseNewCode 250 // 251 252 253 254 ///////////////////////////////////////////////////////////////////////////// 255 // 256 // Shared base class for test cases for both, debugger and debuggee. 257 // 258 ///////////////////////////////////////////////////////////////////////////// 259 260 class EATestCaseBaseShared { 261 // In interactive mode we wait for a keypress before every test case. 262 public static final boolean INTERACTIVE = 263 System.getProperty("EATests.interactive") != null && 264 System.getProperty("EATests.interactive").equals("true"); 265 266 // If the property is given, then just the test case it refers to is executed. 267 // Use it to diagnose test failures. 268 public static final String RUN_ONLY_TEST_CASE_PROPERTY = "EATests.onlytestcase"; 269 public static final String RUN_ONLY_TEST_CASE = System.getProperty(RUN_ONLY_TEST_CASE_PROPERTY); 270 271 public final String testCaseName; 272 273 public EATestCaseBaseShared() { 274 String clName = getClass().getName(); 275 int tidx = clName.lastIndexOf("Target"); 276 testCaseName = tidx > 0 ? clName.substring(0, tidx) : clName; 277 } 278 279 public boolean shouldSkip() { 280 return EATestCaseBaseShared.RUN_ONLY_TEST_CASE != null && 281 EATestCaseBaseShared.RUN_ONLY_TEST_CASE.length() > 0 && 282 !testCaseName.equals(EATestCaseBaseShared.RUN_ONLY_TEST_CASE); 283 } 284 } 285 286 ///////////////////////////////////////////////////////////////////////////// 287 // 288 // Target main class, i.e. the program to be debugged. 289 // 290 ///////////////////////////////////////////////////////////////////////////// 291 292 class EATestsTarget { 293 294 public static void main(String[] args) { 295 EATestCaseBaseTarget.staticSetUp(); 296 EATestCaseBaseTarget.staticSetUpDone(); 297 298 // Materializing test cases, i.e. reallocating objects on the heap 299 new EAMaterializeLocalVariableUponGetTarget() .run(); 300 new EAGetWithoutMaterializeTarget() .run(); 301 new EAMaterializeLocalAtObjectReturnTarget() .run(); 302 new EAMaterializeLocalAtObjectPollReturnReturnTarget() .run(); 303 new EAMaterializeIntArrayTarget() .run(); 304 new EAMaterializeLongArrayTarget() .run(); 305 new EAMaterializeFloatArrayTarget() .run(); 306 new EAMaterializeDoubleArrayTarget() .run(); 307 new EAMaterializeObjectArrayTarget() .run(); 308 new EAMaterializeObjectWithConstantAndNotConstantValuesTarget() .run(); 309 new EAMaterializeObjReferencedBy2LocalsTarget() .run(); 310 new EAMaterializeObjReferencedBy2LocalsAndModifyTarget() .run(); 311 new EAMaterializeObjReferencedBy2LocalsInDifferentVirtFramesTarget() .run(); 312 new EAMaterializeObjReferencedBy2LocalsInDifferentVirtFramesAndModifyTarget() .run(); 313 new EAMaterializeObjReferencedFromOperandStackTarget() .run(); 314 new EAMaterializeLocalVariableUponGetAfterSetIntegerTarget() .run(); 315 316 // Relocking test cases 317 new EARelockingSimpleTarget() .run(); 318 new EARelockingSimple_2Target() .run(); 319 new EARelockingSimpleWithAccessInOtherThreadTarget() .run(); 320 new EARelockingRecursiveTarget() .run(); 321 new EARelockingNestedInflatedTarget() .run(); 322 new EARelockingNestedInflated_02Target() .run(); 323 new EARelockingNestedInflated_03Target() .run(); 324 new EARelockingArgEscapeLWLockedInCalleeFrameTarget() .run(); 325 new EARelockingArgEscapeLWLockedInCalleeFrame_2Target() .run(); 326 new EARelockingArgEscapeLWLockedInCalleeFrame_3Target() .run(); 327 new EARelockingArgEscapeLWLockedInCalleeFrame_4Target() .run(); 328 new EAGetOwnedMonitorsTarget() .run(); 329 new EAEntryCountTarget() .run(); 330 new EARelockingObjectCurrentlyWaitingOnTarget() .run(); 331 new EARelockingValueBasedTarget() .run(); 332 333 // Test cases that require deoptimization even though neither 334 // locks nor allocations are eliminated at the point where 335 // escape state is changed. 336 new EADeoptFrameAfterReadLocalObject_01Target() .run(); 337 new EADeoptFrameAfterReadLocalObject_01BTarget() .run(); 338 new EADeoptFrameAfterReadLocalObject_02Target() .run(); 339 new EADeoptFrameAfterReadLocalObject_02BTarget() .run(); 340 new EADeoptFrameAfterReadLocalObject_02CTarget() .run(); 341 new EADeoptFrameAfterReadLocalObject_03Target() .run(); 342 343 // PopFrame test cases 344 new EAPopFrameNotInlinedTarget() .run(); 345 new EAPopFrameNotInlinedReallocFailureTarget() .run(); 346 new EAPopInlinedMethodWithScalarReplacedObjectsReallocFailureTarget() .run(); 347 348 // ForceEarlyReturn test cases 349 new EAForceEarlyReturnNotInlinedTarget() .run(); 350 new EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsTarget() .run(); 351 new EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsReallocFailureTarget().run(); 352 353 // Instances of ReferenceType 354 new EAGetInstancesOfReferenceTypeTarget() .run(); 355 } 356 } 357 358 ///////////////////////////////////////////////////////////////////////////// 359 // 360 // Debugger main class 361 // 362 ///////////////////////////////////////////////////////////////////////////// 363 364 public class EATests extends TestScaffold { 365 366 public TargetVMOptions targetVMOptions; 367 public ThreadReference targetMainThread; 368 369 EATests(String args[]) { 370 super(args); 371 } 372 373 public static void main(String[] args) throws Exception { 374 if (EATestCaseBaseShared.RUN_ONLY_TEST_CASE != null) { 375 args = Arrays.copyOf(args, args.length + 1); 376 args[args.length - 1] = "-D" + EATestCaseBaseShared.RUN_ONLY_TEST_CASE_PROPERTY + "=" + EATestCaseBaseShared.RUN_ONLY_TEST_CASE; 377 } 378 new EATests(args).startTests(); 379 } 380 381 public static class TargetVMOptions { 382 383 public final boolean UseJVMCICompiler; 384 public final boolean EliminateAllocations; 385 public final boolean DeoptimizeObjectsALot; 386 public final boolean DoEscapeAnalysis; 387 public final boolean ZGCIsSelected; 388 public final boolean StressReflectiveCode; 389 390 public TargetVMOptions(EATests env, ClassType testCaseBaseTargetClass) { 391 Value val; 392 val = testCaseBaseTargetClass.getValue(testCaseBaseTargetClass.fieldByName("DoEscapeAnalysis")); 393 DoEscapeAnalysis = ((PrimitiveValue) val).booleanValue(); 394 // Escape analysis is a prerequisite for scalar replacement (EliminateAllocations) 395 val = testCaseBaseTargetClass.getValue(testCaseBaseTargetClass.fieldByName("EliminateAllocations")); 396 EliminateAllocations = DoEscapeAnalysis && ((PrimitiveValue) val).booleanValue(); 397 val = testCaseBaseTargetClass.getValue(testCaseBaseTargetClass.fieldByName("DeoptimizeObjectsALot")); 398 DeoptimizeObjectsALot = ((PrimitiveValue) val).booleanValue(); 399 val = testCaseBaseTargetClass.getValue(testCaseBaseTargetClass.fieldByName("UseJVMCICompiler")); 400 UseJVMCICompiler = ((PrimitiveValue) val).booleanValue(); 401 val = testCaseBaseTargetClass.getValue(testCaseBaseTargetClass.fieldByName("ZGCIsSelected")); 402 ZGCIsSelected = ((PrimitiveValue) val).booleanValue(); 403 val = testCaseBaseTargetClass.getValue(testCaseBaseTargetClass.fieldByName("StressReflectiveCode")); 404 StressReflectiveCode = ((PrimitiveValue) val).booleanValue(); 405 } 406 407 } 408 409 // Execute known test cases 410 protected void runTests() throws Exception { 411 String targetProgName = EATestsTarget.class.getName(); 412 msg("starting to main method in class " + targetProgName); 413 startToMain(targetProgName); 414 msg("resuming to EATestCaseBaseTarget.staticSetUpDone()V"); 415 targetMainThread = resumeTo("EATestCaseBaseTarget", "staticSetUpDone", "()V").thread(); 416 Location loc = targetMainThread.frame(0).location(); 417 Asserts.assertEQ("staticSetUpDone", loc.method().name()); 418 419 targetVMOptions = new TargetVMOptions(this, (ClassType) loc.declaringType()); 420 421 // Materializing test cases, i.e. reallocating objects on the heap 422 new EAMaterializeLocalVariableUponGet() .run(this); 423 new EAGetWithoutMaterialize() .run(this); 424 new EAMaterializeLocalAtObjectReturn() .run(this); 425 new EAMaterializeLocalAtObjectPollReturnReturn() .run(this); 426 new EAMaterializeIntArray() .run(this); 427 new EAMaterializeLongArray() .run(this); 428 new EAMaterializeFloatArray() .run(this); 429 new EAMaterializeDoubleArray() .run(this); 430 new EAMaterializeObjectArray() .run(this); 431 new EAMaterializeObjectWithConstantAndNotConstantValues() .run(this); 432 new EAMaterializeObjReferencedBy2Locals() .run(this); 433 new EAMaterializeObjReferencedBy2LocalsAndModify() .run(this); 434 new EAMaterializeObjReferencedBy2LocalsInDifferentVirtFrames() .run(this); 435 new EAMaterializeObjReferencedBy2LocalsInDifferentVirtFramesAndModify() .run(this); 436 new EAMaterializeObjReferencedFromOperandStack() .run(this); 437 new EAMaterializeLocalVariableUponGetAfterSetInteger() .run(this); 438 439 // Relocking test cases 440 new EARelockingSimple() .run(this); 441 new EARelockingSimple_2() .run(this); 442 new EARelockingSimpleWithAccessInOtherThread() .run(this); 443 new EARelockingRecursive() .run(this); 444 new EARelockingNestedInflated() .run(this); 445 new EARelockingNestedInflated_02() .run(this); 446 new EARelockingNestedInflated_03() .run(this); 447 new EARelockingArgEscapeLWLockedInCalleeFrame() .run(this); 448 new EARelockingArgEscapeLWLockedInCalleeFrame_2() .run(this); 449 new EARelockingArgEscapeLWLockedInCalleeFrame_3() .run(this); 450 new EARelockingArgEscapeLWLockedInCalleeFrame_4() .run(this); 451 new EAGetOwnedMonitors() .run(this); 452 new EAEntryCount() .run(this); 453 new EARelockingObjectCurrentlyWaitingOn() .run(this); 454 new EARelockingValueBased() .run(this); 455 456 // Test cases that require deoptimization even though neither 457 // locks nor allocations are eliminated at the point where 458 // escape state is changed. 459 new EADeoptFrameAfterReadLocalObject_01() .run(this); 460 new EADeoptFrameAfterReadLocalObject_01B() .run(this); 461 new EADeoptFrameAfterReadLocalObject_02() .run(this); 462 new EADeoptFrameAfterReadLocalObject_02B() .run(this); 463 new EADeoptFrameAfterReadLocalObject_02C() .run(this); 464 new EADeoptFrameAfterReadLocalObject_03() .run(this); 465 466 // PopFrame test cases 467 new EAPopFrameNotInlined() .run(this); 468 new EAPopFrameNotInlinedReallocFailure() .run(this); 469 new EAPopInlinedMethodWithScalarReplacedObjectsReallocFailure() .run(this); 470 471 // ForceEarlyReturn test cases 472 new EAForceEarlyReturnNotInlined() .run(this); 473 new EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjects() .run(this); 474 new EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsReallocFailure().run(this); 475 476 // Instances of ReferenceType 477 new EAGetInstancesOfReferenceType() .run(this); 478 479 // resume the target listening for events 480 listenUntilVMDisconnect(); 481 } 482 483 // Print a Message 484 public void msg(String m) { 485 System.out.println(); 486 System.out.println("###(Debugger) " + m); 487 System.out.println(); 488 } 489 490 // Highlighted message. 491 public void msgHL(String m) { 492 System.out.println(); 493 System.out.println(); 494 System.out.println("##########################################################"); 495 System.out.println("### " + m); 496 System.out.println("### "); 497 System.out.println(); 498 System.out.println(); 499 } 500 } 501 502 ///////////////////////////////////////////////////////////////////////////// 503 // 504 // Base class for debugger side of test cases. 505 // 506 ///////////////////////////////////////////////////////////////////////////// 507 508 abstract class EATestCaseBaseDebugger extends EATestCaseBaseShared { 509 510 protected EATests env; 511 512 public ObjectReference testCase; 513 514 public static final String TARGET_TESTCASE_BASE_NAME = EATestCaseBaseTarget.class.getName(); 515 516 public static final String XYVAL_NAME = XYVal.class.getName(); 517 518 public abstract void runTestCase() throws Exception; 519 520 @Override 521 public boolean shouldSkip() { 522 // Skip if StressReflectiveCode because it effectively disables escape analysis 523 return super.shouldSkip() || env.targetVMOptions.StressReflectiveCode; 524 } 525 526 public void run(EATests env) { 527 this.env = env; 528 if (shouldSkip()) { 529 msg("skipping " + testCaseName); 530 return; 531 } 532 try { 533 msgHL("Executing test case " + getClass().getName()); 534 env.testFailed = false; 535 536 if (INTERACTIVE) 537 env.waitForInput(); 538 539 resumeToWarmupDone(); 540 runTestCase(); 541 Asserts.assertTrue(env.targetMainThread.isSuspended(), "must be suspended after the testcase"); 542 resumeToTestCaseDone(); 543 checkPostConditions(); 544 } catch (Exception e) { 545 Asserts.fail("Unexpected exception in test case " + getClass().getName(), e); 546 } 547 } 548 549 /** 550 * Set a breakpoint in the given method and resume all threads. The 551 * breakpoint is configured to suspend just the thread that reaches it 552 * instead of all threads. This is important when running with graal. 553 */ 554 public BreakpointEvent resumeTo(String clsName, String methodName, String signature) { 555 boolean suspendThreadOnly = true; 556 return env.resumeTo(clsName, methodName, signature, suspendThreadOnly); 557 } 558 559 public void resumeToWarmupDone() throws Exception { 560 msg("resuming to " + TARGET_TESTCASE_BASE_NAME + ".warmupDone()V"); 561 resumeTo(TARGET_TESTCASE_BASE_NAME, "warmupDone", "()V"); 562 testCase = env.targetMainThread.frame(0).thisObject(); 563 } 564 565 public void resumeToTestCaseDone() { 566 msg("resuming to " + TARGET_TESTCASE_BASE_NAME + ".testCaseDone()V"); 567 resumeTo(TARGET_TESTCASE_BASE_NAME, "testCaseDone", "()V"); 568 } 569 570 public void checkPostConditions() throws Exception { 571 Asserts.assertFalse(env.getExceptionCaught(), "Uncaught exception in Debuggee"); 572 573 String testName = getClass().getName(); 574 if (!env.testFailed) { 575 env.println(testName + ": passed"); 576 } else { 577 throw new Exception(testName + ": failed"); 578 } 579 } 580 581 public void printStack(ThreadReference thread) throws Exception { 582 msg("Debuggee Stack:"); 583 List<StackFrame> stack_frames = thread.frames(); 584 int i = 0; 585 for (StackFrame ff : stack_frames) { 586 System.out.println("frame[" + i++ +"]: " + ff.location().method() + " (bci:" + ff.location().codeIndex() + ")"); 587 } 588 } 589 590 public void msg(String m) { 591 env.msg(m); 592 } 593 594 public void msgHL(String m) { 595 env.msgHL(m); 596 } 597 598 // See Field Descriptors in The Java Virtual Machine Specification 599 // (https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.3.2) 600 enum FD { 601 I, // int 602 J, // long 603 F, // float 604 D, // double 605 } 606 607 // Map field descriptor to jdi type string 608 public static final Map<FD, String> FD2JDIArrType = Map.of(FD.I, "int[]", FD.J, "long[]", FD.F, "float[]", FD.D, "double[]"); 609 610 // Map field descriptor to PrimitiveValue getter 611 public static final Function<PrimitiveValue, Integer> v2I = PrimitiveValue::intValue; 612 public static final Function<PrimitiveValue, Long> v2J = PrimitiveValue::longValue; 613 public static final Function<PrimitiveValue, Float> v2F = PrimitiveValue::floatValue; 614 public static final Function<PrimitiveValue, Double> v2D = PrimitiveValue::doubleValue; 615 Map<FD, Function<PrimitiveValue, ?>> FD2getter = Map.of(FD.I, v2I, FD.J, v2J, FD.F, v2F, FD.D, v2D); 616 617 /** 618 * Retrieve array of primitive values referenced by a local variable in target and compare with 619 * an array of expected values. 620 * @param frame Frame in the target holding the local variable 621 * @param lName Name of the local variable referencing the array to be retrieved 622 * @param desc Array element type given as field descriptor. 623 * @param expVals Array of expected values. 624 * @throws Exception 625 */ 626 protected void checkLocalPrimitiveArray(StackFrame frame, String lName, FD desc, Object expVals) throws Exception { 627 String lType = FD2JDIArrType.get(desc); 628 Asserts.assertNotNull(lType, "jdi type not found"); 629 Asserts.assertEQ(EATestCaseBaseTarget.TESTMETHOD_DEFAULT_NAME, frame .location().method().name()); 630 List<LocalVariable> localVars = frame.visibleVariables(); 631 msg("Check if the local array variable '" + lName + "' in " + EATestCaseBaseTarget.TESTMETHOD_DEFAULT_NAME + " has the expected elements: "); 632 boolean found = false; 633 for (LocalVariable lv : localVars) { 634 if (lv.name().equals(lName)) { 635 found = true; 636 Value lVal = frame.getValue(lv); 637 Asserts.assertNotNull(lVal); 638 Asserts.assertEQ(lVal.type().name(), lType); 639 ArrayReference aRef = (ArrayReference) lVal; 640 Asserts.assertEQ(3, aRef.length()); 641 // now check the elements 642 for (int i = 0; i < aRef.length(); i++) { 643 Object actVal = FD2getter.get(desc).apply((PrimitiveValue)aRef.getValue(i)); 644 Object expVal = Array.get(expVals, i); 645 Asserts.assertEQ(expVal, actVal, "checking element at index " + i); 646 } 647 } 648 } 649 Asserts.assertTrue(found); 650 msg("OK."); 651 } 652 653 /** 654 * Retrieve array of objects referenced by a local variable in target and compare with an array 655 * of expected values. 656 * @param frame Frame in the target holding the local variable 657 * @param lName Name of the local variable referencing the array to be retrieved 658 * @param lType Local type, e.g. java.lang.Long[] 659 * @param expVals Array of expected values. 660 * @throws Exception 661 */ 662 protected void checkLocalObjectArray(StackFrame frame, String lName, String lType, ObjectReference[] expVals) throws Exception { 663 Asserts.assertEQ(EATestCaseBaseTarget.TESTMETHOD_DEFAULT_NAME, frame .location().method().name()); 664 List<LocalVariable> localVars = frame.visibleVariables(); 665 msg("Check if the local array variable '" + lName + "' in " + EATestCaseBaseTarget.TESTMETHOD_DEFAULT_NAME + " has the expected elements: "); 666 boolean found = false; 667 for (LocalVariable lv : localVars) { 668 if (lv.name().equals(lName)) { 669 found = true; 670 Value lVal = frame.getValue(lv); 671 Asserts.assertNotNull(lVal); 672 Asserts.assertEQ(lType, lVal.type().name()); 673 ArrayReference aRef = (ArrayReference) lVal; 674 Asserts.assertEQ(3, aRef.length()); 675 // now check the elements 676 for (int i = 0; i < aRef.length(); i++) { 677 ObjectReference actVal = (ObjectReference)aRef.getValue(i); 678 Asserts.assertSame(expVals[i], actVal, "checking element at index " + i); 679 } 680 } 681 } 682 Asserts.assertTrue(found); 683 msg("OK."); 684 } 685 686 /** 687 * Retrieve a reference held by a local variable in the given frame. Check if the frame's method 688 * is the expected method if the retrieved local value has the expected type and is not null. 689 * @param frame The frame to retrieve the local variable value from. 690 * @param expectedMethodName The name of the frames method should match the expectedMethodName. 691 * @param lName The name of the local variable which is read. 692 * @param expectedType Is the expected type of the object referenced by the local variable. 693 * @return 694 * @throws Exception 695 */ 696 protected ObjectReference getLocalRef(StackFrame frame, String expectedMethodName, String lName, String expectedType) throws Exception { 697 Asserts.assertEQ(expectedMethodName, frame.location().method().name()); 698 List<LocalVariable> localVars = frame.visibleVariables(); 699 msg("Get and check local variable '" + lName + "' in " + expectedMethodName); 700 ObjectReference lRef = null; 701 for (LocalVariable lv : localVars) { 702 if (lv.name().equals(lName)) { 703 Value lVal = frame.getValue(lv); 704 Asserts.assertNotNull(lVal); 705 Asserts.assertEQ(expectedType, lVal.type().name()); 706 lRef = (ObjectReference) lVal; 707 break; 708 } 709 } 710 Asserts.assertNotNull(lRef, "Local variable '" + lName + "' not found"); 711 msg("OK."); 712 return lRef; 713 } 714 715 /** 716 * Retrieve a reference held by a local variable in the given frame. Check if the frame's method 717 * matches {@link EATestCaseBaseTarget#TESTMETHOD_DEFAULT_NAME} if the retrieved local value has 718 * the expected type and is not null. 719 * @param frame The frame to retrieve the local variable value from. 720 * @param expectedMethodName The name of the frames method should match the expectedMethodName. 721 * @param lName The name of the local variable which is read. 722 * @param expectedType Is the expected type of the object referenced by the local variable. 723 * @return 724 * @throws Exception 725 */ 726 protected ObjectReference getLocalRef(StackFrame frame, String lType, String lName) throws Exception { 727 return getLocalRef(frame, EATestCaseBaseTarget.TESTMETHOD_DEFAULT_NAME, lName, lType); 728 } 729 730 /** 731 * Set the value of a local variable in the given frame. Check if the frame's method is the expected method. 732 * @param frame The frame holding the local variable. 733 * @param expectedMethodName The expected name of the frame's method. 734 * @param lName The name of the local variable to change. 735 * @param val The new value of the local variable. 736 * @throws Exception 737 */ 738 public void setLocal(StackFrame frame, String expectedMethodName, String lName, Value val) throws Exception { 739 Asserts.assertEQ(expectedMethodName, frame.location().method().name()); 740 List<LocalVariable> localVars = frame.visibleVariables(); 741 msg("Set local variable '" + lName + "' = " + val + " in " + expectedMethodName); 742 for (LocalVariable lv : localVars) { 743 if (lv.name().equals(lName)) { 744 frame.setValue(lv, val); 745 break; 746 } 747 } 748 msg("OK."); 749 } 750 751 /** 752 * Set the value of a local variable in the given frame. Check if the frame's method matches 753 * {@link EATestCaseBaseTarget#TESTMETHOD_DEFAULT_NAME}. 754 * @param frame The frame holding the local variable. 755 * @param expectedMethodName The expected name of the frame's method. 756 * @param lName The name of the local variable to change. 757 * @param val The new value of the local variable. 758 * @throws Exception 759 */ 760 public void setLocal(StackFrame frame, String lName, Value val) throws Exception { 761 setLocal(frame, EATestCaseBaseTarget.TESTMETHOD_DEFAULT_NAME, lName, val); 762 } 763 764 /** 765 * Check if a field has the expected primitive value. 766 * @param o Object holding the field. 767 * @param desc Field descriptor. 768 * @param fName Field name 769 * @param expVal Expected primitive value 770 * @throws Exception 771 */ 772 protected void checkPrimitiveField(ObjectReference o, FD desc, String fName, Object expVal) throws Exception { 773 msg("check field " + fName); 774 ReferenceType rt = o.referenceType(); 775 Field fld = rt.fieldByName(fName); 776 Value val = o.getValue(fld); 777 Object actVal = FD2getter.get(desc).apply((PrimitiveValue) val); 778 Asserts.assertEQ(expVal, actVal, "field '" + fName + "' has unexpected value."); 779 msg("ok"); 780 } 781 782 /** 783 * Check if a field references the expected object. 784 * @param obj Object holding the field. 785 * @param fName Field name 786 * @param expVal Object expected to be referenced by the field 787 * @throws Exception 788 */ 789 protected void checkObjField(ObjectReference obj, String fName, ObjectReference expVal) throws Exception { 790 msg("check field " + fName); 791 ReferenceType rt = obj.referenceType(); 792 Field fld = rt.fieldByName(fName); 793 Value actVal = obj.getValue(fld); 794 Asserts.assertEQ(expVal, actVal, "field '" + fName + "' has unexpected value."); 795 msg("ok"); 796 } 797 798 protected void setField(ObjectReference obj, String fName, Value val) throws Exception { 799 msg("set field " + fName + " = " + val); 800 ReferenceType rt = obj.referenceType(); 801 Field fld = rt.fieldByName(fName); 802 obj.setValue(fld, val); 803 msg("ok"); 804 } 805 806 protected Value getField(ObjectReference obj, String fName) throws Exception { 807 msg("get field " + fName); 808 ReferenceType rt = obj.referenceType(); 809 Field fld = rt.fieldByName(fName); 810 Value val = obj.getValue(fld); 811 msg("result : " + val); 812 return val; 813 } 814 815 /** 816 * Free the memory consumed in the target by {@link EATestCaseBaseTarget#consumedMemory} 817 * @throws Exception 818 */ 819 public void freeAllMemory() throws Exception { 820 msg("free consumed memory"); 821 setField(testCase, "consumedMemory", null); 822 } 823 824 /** 825 * @return The value of {@link EATestCaseBaseTarget#targetIsInLoop}. The target must set that field to true as soon as it 826 * enters the endless loop. 827 * @throws Exception 828 */ 829 public boolean targetHasEnteredEndlessLoop() throws Exception { 830 Value v = getField(testCase, "targetIsInLoop"); 831 return ((PrimitiveValue) v).booleanValue(); 832 } 833 834 /** 835 * Poll {@link EATestCaseBaseTarget#targetIsInLoop} and return if it is found to be true. 836 * @throws Exception 837 */ 838 public void waitUntilTargetHasEnteredEndlessLoop() throws Exception { 839 while(!targetHasEnteredEndlessLoop()) { 840 msg("Target has not yet entered the loop. Sleep 200ms."); 841 try { Thread.sleep(200); } catch (InterruptedException e) { /*ignore */ } 842 } 843 } 844 845 /** 846 * Set {@link EATestCaseBaseTarget#doLoop} to <code>false</code>. This will allow the target to 847 * leave the endless loop. 848 * @throws Exception 849 */ 850 public void terminateEndlessLoop() throws Exception { 851 msg("terminate loop"); 852 setField(testCase, "doLoop", env.vm().mirrorOf(false)); 853 } 854 } 855 856 ///////////////////////////////////////////////////////////////////////////// 857 // 858 // Base class for debuggee side of test cases. 859 // 860 ///////////////////////////////////////////////////////////////////////////// 861 862 abstract class EATestCaseBaseTarget extends EATestCaseBaseShared implements Runnable { 863 864 /** 865 * The target must set that field to true as soon as it enters the endless loop. 866 */ 867 public volatile boolean targetIsInLoop; 868 869 /** 870 * Used for busy loops. See {@link #dontinline_endlessLoop()}. 871 */ 872 public volatile long loopCount; 873 874 /** 875 * Used in {@link EATestCaseBaseDebugger#terminateEndlessLoop()} to signal target to leave the endless loop. 876 */ 877 public volatile boolean doLoop; 878 879 public long checkSum; 880 881 public static final String TESTMETHOD_DEFAULT_NAME = "dontinline_testMethod"; 882 883 public static final WhiteBox WB = WhiteBox.getWhiteBox(); 884 885 public static boolean unbox(Boolean value, boolean dflt) { 886 return value == null ? dflt : value; 887 } 888 889 // Some of the fields are only read by the debugger 890 public static final boolean UseJVMCICompiler = unbox(WB.getBooleanVMFlag("UseJVMCICompiler"), false); 891 public static final boolean DoEscapeAnalysis = unbox(WB.getBooleanVMFlag("DoEscapeAnalysis"), UseJVMCICompiler); 892 public static final boolean EliminateAllocations = unbox(WB.getBooleanVMFlag("EliminateAllocations"), UseJVMCICompiler); 893 public static final boolean DeoptimizeObjectsALot = WB.getBooleanVMFlag("DeoptimizeObjectsALot"); 894 public static final long BiasedLockingBulkRebiasThreshold = WB.getIntxVMFlag("BiasedLockingBulkRebiasThreshold"); 895 public static final long BiasedLockingBulkRevokeThreshold = WB.getIntxVMFlag("BiasedLockingBulkRevokeThreshold"); 896 public static final boolean ZGCIsSelected = GC.Z.isSelected(); 897 public static final boolean StressReflectiveCode = unbox(WB.getBooleanVMFlag("StressReflectiveCode"), false); 898 899 public String testMethodName; 900 public int testMethodDepth; 901 902 // Results produced by dontinline_testMethod() 903 public int iResult; 904 public long lResult; 905 public float fResult; 906 public double dResult; 907 908 909 public boolean warmupDone; 910 911 public volatile Object biasToBeRevoked; 912 913 // an object with an inflated monitor 914 public static XYVal inflatedLock; 915 public static Thread inflatorThread; 916 public static boolean inflatedLockIsPermanentlyInflated; 917 918 public static int NOT_CONST_1I = 1; 919 public static long NOT_CONST_1L = 1L; 920 public static float NOT_CONST_1F = 1.1F; 921 public static double NOT_CONST_1D = 1.1D; 922 923 public static Long NOT_CONST_1_OBJ = Long.valueOf(1); 924 925 926 public static final Long CONST_2_OBJ = Long.valueOf(2); 927 public static final Long CONST_3_OBJ = Long.valueOf(3); 928 929 @Override 930 public boolean shouldSkip() { 931 // Skip if StressReflectiveCode because it effectively disables escape analysis 932 return super.shouldSkip() || StressReflectiveCode; 933 } 934 935 /** 936 * Main driver of a test case. 937 * <ul> 938 * <li> Skips test case if not selected (see {@link EATestCaseBaseShared#RUN_ONLY_TEST_CASE} 939 * <li> Call {@link #setUp()} 940 * <li> warm-up and compile {@link #dontinline_testMethod()} (see {@link #compileTestMethod()} 941 * <li> calling {@link #dontinline_testMethod()} 942 * <li> checking the result (see {@link #checkResult()} 943 * <ul> 944 */ 945 public void run() { 946 try { 947 if (shouldSkip()) { 948 msg("skipping " + testCaseName); 949 return; 950 } 951 setUp(); 952 msg(testCaseName + " is up and running."); 953 compileTestMethod(); 954 msg(testCaseName + " warmup done."); 955 warmupDone(); 956 checkCompLevel(); 957 dontinline_testMethod(); 958 checkResult(); 959 msg(testCaseName + " done."); 960 testCaseDone(); 961 } catch (Exception e) { 962 Asserts.fail("Caught unexpected exception", e); 963 } 964 } 965 966 public static void staticSetUp() { 967 inflatedLock = new XYVal(1, 1); 968 synchronized (inflatedLock) { 969 inflatorThread = new Thread("Lock Inflator (test thread)") { 970 @Override 971 public void run() { 972 synchronized (inflatedLock) { 973 inflatedLockIsPermanentlyInflated = true; 974 inflatedLock.notify(); // main thread 975 while (true) { 976 try { 977 // calling wait() on a monitor will cause inflation into a heavy monitor 978 inflatedLock.wait(); 979 } catch (InterruptedException e) { /* ignored */ } 980 } 981 } 982 } 983 }; 984 inflatorThread.setDaemon(true); 985 inflatorThread.start(); 986 987 // wait until the lock is permanently inflated by the inflatorThread 988 while(!inflatedLockIsPermanentlyInflated) { 989 try { 990 inflatedLock.wait(); // until inflated 991 } catch (InterruptedException e1) { /* ignored */ } 992 } 993 } 994 } 995 996 // Debugger will set breakpoint here to sync with target. 997 public static void staticSetUpDone() { 998 } 999 1000 public void setUp() { 1001 testMethodDepth = 1; 1002 testMethodName = TESTMETHOD_DEFAULT_NAME; 1003 } 1004 1005 public abstract void dontinline_testMethod() throws Exception; 1006 1007 public int dontinline_brkpt_iret() { 1008 dontinline_brkpt(); 1009 return 42; 1010 } 1011 1012 /** 1013 * It is a common protocol to have the debugger set a breakpoint in this method and have {@link 1014 * #dontinline_testMethod()} call it and then perform some test actions on debugger side. 1015 * After that it is checked if a frame of {@link #dontinline_testMethod()} is found at the 1016 * expected depth on stack and if it is (not) marked for deoptimization as expected. 1017 */ 1018 public void dontinline_brkpt() { 1019 // will set breakpoint here after warmup 1020 if (warmupDone) { 1021 // check if test method is at expected depth 1022 StackTraceElement[] frames = Thread.currentThread().getStackTrace(); 1023 int stackTraceDepth = testMethodDepth + 1; // ignore java.lang.Thread.getStackTrace() 1024 Asserts.assertEQ(testMethodName, frames[stackTraceDepth].getMethodName(), 1025 testCaseName + ": test method not found at depth " + testMethodDepth); 1026 // check if the frame is (not) deoptimized as expected 1027 if (!DeoptimizeObjectsALot) { 1028 if (testFrameShouldBeDeoptimized()) { 1029 Asserts.assertTrue(WB.isFrameDeoptimized(testMethodDepth+1), 1030 testCaseName + ": expected test method frame at depth " + testMethodDepth + " to be deoptimized"); 1031 } else { 1032 Asserts.assertFalse(WB.isFrameDeoptimized(testMethodDepth+1), 1033 testCaseName + ": expected test method frame at depth " + testMethodDepth + " not to be deoptimized"); 1034 } 1035 } 1036 } 1037 } 1038 1039 /** 1040 * Some test cases run busy endless loops by initializing {@link #loopCount} 1041 * to {@link Long#MAX_VALUE} after warm-up and then counting down to 0 in their main test method. 1042 * During warm-up {@link #loopCount} is initialized to a small value. 1043 */ 1044 public long dontinline_endlessLoop() { 1045 long cs = checkSum; 1046 doLoop = true; 1047 while (loopCount-- > 0 && doLoop) { 1048 targetIsInLoop = true; 1049 checkSum += checkSum % ++cs; 1050 } 1051 loopCount = 3; 1052 targetIsInLoop = false; 1053 return checkSum; 1054 } 1055 1056 public boolean testFrameShouldBeDeoptimized() { 1057 return DoEscapeAnalysis; 1058 } 1059 1060 public void warmupDone() { 1061 warmupDone = true; 1062 } 1063 1064 // Debugger will set breakpoint here to sync with target. 1065 public void testCaseDone() { 1066 } 1067 1068 public void compileTestMethod() throws Exception { 1069 int callCount = CompilerWhiteBoxTest.THRESHOLD; 1070 while (callCount-- > 0) { 1071 dontinline_testMethod(); 1072 } 1073 } 1074 1075 public void checkCompLevel() { 1076 java.lang.reflect.Method m = null; 1077 try { 1078 m = getClass().getMethod(TESTMETHOD_DEFAULT_NAME); 1079 } catch (NoSuchMethodException | SecurityException e) { 1080 Asserts.fail("could not check compilation level of", e); 1081 } 1082 int highestLevel = CompilerUtils.getMaxCompilationLevel(); 1083 int compLevel = WB.getMethodCompilationLevel(m); 1084 if (!UseJVMCICompiler) { 1085 Asserts.assertEQ(highestLevel, compLevel, 1086 m + " not on expected compilation level"); 1087 } else { 1088 // Background compilation (-Xbatch) will block a thread with timeout 1089 // (see CompileBroker::wait_for_jvmci_completion()). Therefore it is 1090 // possible to reach here before the main test method is compiled. 1091 // In that case we wait for it to be compiled. 1092 while (compLevel != highestLevel) { 1093 msg(TESTMETHOD_DEFAULT_NAME + " is compiled on level " + compLevel + 1094 ". Wait until highes level (" + highestLevel + ") is reached."); 1095 try { 1096 Thread.sleep(200); 1097 } catch (InterruptedException e) { /* ignored */ } 1098 compLevel = WB.getMethodCompilationLevel(m); 1099 } 1100 } 1101 } 1102 1103 // to be overridden as appropriate 1104 public int getExpectedIResult() { 1105 return 0; 1106 } 1107 1108 // to be overridden as appropriate 1109 public long getExpectedLResult() { 1110 return 0; 1111 } 1112 1113 // to be overridden as appropriate 1114 public float getExpectedFResult() { 1115 return 0f; 1116 } 1117 1118 // to be overridden as appropriate 1119 public double getExpectedDResult() { 1120 return 0d; 1121 } 1122 1123 private void checkResult() { 1124 Asserts.assertEQ(getExpectedIResult(), iResult, "checking iResult"); 1125 Asserts.assertEQ(getExpectedLResult(), lResult, "checking lResult"); 1126 Asserts.assertEQ(getExpectedFResult(), fResult, "checking fResult"); 1127 Asserts.assertEQ(getExpectedDResult(), dResult, "checking dResult"); 1128 } 1129 1130 public void msg(String m) { 1131 System.out.println(); 1132 System.out.println("###(Target) " + m); 1133 System.out.println(); 1134 } 1135 1136 // The object passed will be ArgEscape if it was NoEscape before. 1137 public final void dontinline_make_arg_escape(XYVal xy) { 1138 } 1139 1140 /** 1141 * Call a method indirectly using reflection. The indirection is a limit for escape 1142 * analysis in the sense that the VM need not search beyond for frames that might have 1143 * an object being read by an JVMTI agent as ArgEscape. 1144 * @param receiver The receiver object of the call. 1145 * @param methodName The name of the method to be called. 1146 */ 1147 public final void dontinline_call_with_entry_frame(Object receiver, String methodName) { 1148 Asserts.assertTrue(warmupDone, "We want to take the slow path through jni, so don't call in warmup"); 1149 1150 Class<?> cls = receiver.getClass(); 1151 Class<?>[] none = {}; 1152 1153 java.lang.reflect.Method m; 1154 try { 1155 m = cls.getDeclaredMethod(methodName, none); 1156 m.invoke(receiver); 1157 } catch (Exception e) { 1158 Asserts.fail("Call through reflection failed", e); 1159 } 1160 } 1161 1162 /** 1163 * Trigger bulk rebiasing for the given class by creating new instances and calling <code> hashCode() </code> on them. 1164 * @param cls The class to bulk rebias 1165 */ 1166 public void dontinline_bulkRebiasAfterWarmup(Class<?> cls) { 1167 if (warmupDone) { 1168 try { 1169 for (int i=0; i < BiasedLockingBulkRebiasThreshold+2; i++) { 1170 biasToBeRevoked = cls.getDeclaredConstructor(int.class, int.class).newInstance(1, 1); 1171 synchronized (biasToBeRevoked) { // bias towards current thread 1172 checkSum++; 1173 } 1174 biasToBeRevoked.hashCode(); // calling hashCode triggers revocation 1175 } 1176 } catch (Throwable e) { 1177 Asserts.fail("failed to create new instance of " + cls.getName(), e); 1178 } 1179 } 1180 } 1181 1182 /** 1183 * Trigger bulk revoke of biases for the given class by creating new instances and calling <code> hashCode() </code> on them. 1184 * @param cls The class to bulk rebias 1185 */ 1186 public void dontinline_bulkRevokeAfterWarmup(Class<?> cls) { 1187 if (warmupDone) { 1188 try { 1189 for (int i=0; i < BiasedLockingBulkRevokeThreshold+2; i++) { 1190 biasToBeRevoked = cls.getDeclaredConstructor(int.class, int.class).newInstance(1, 1); 1191 synchronized (biasToBeRevoked) { // bias towards current thread 1192 checkSum++; 1193 } 1194 biasToBeRevoked.hashCode(); // calling hashCode triggers revocation 1195 } 1196 } catch (Throwable e) { 1197 Asserts.fail("failed to create new instance of " + cls.getName(), e); 1198 } 1199 } 1200 } 1201 1202 static class LinkedList { 1203 LinkedList l; 1204 public long[] array; 1205 public LinkedList(LinkedList l, int size) { 1206 this.array = size > 0 ? new long[size] : null; 1207 this.l = l; 1208 } 1209 } 1210 1211 public LinkedList consumedMemory; 1212 1213 public void consumeAllMemory() { 1214 msg("consume all memory"); 1215 int size = 128 * 1024 * 1024; 1216 while(true) { 1217 try { 1218 while(true) { 1219 consumedMemory = new LinkedList(consumedMemory, size); 1220 } 1221 } catch(OutOfMemoryError oom) { 1222 if (size == 0) break; 1223 } 1224 size = size / 2; 1225 } 1226 } 1227 } 1228 1229 ///////////////////////////////////////////////////////////////////////////// 1230 // 1231 // Test Cases 1232 // 1233 ///////////////////////////////////////////////////////////////////////////// 1234 1235 // make sure a compiled frame is not deoptimized if an escaping local is accessed 1236 class EAGetWithoutMaterializeTarget extends EATestCaseBaseTarget { 1237 1238 public XYVal getAway; 1239 1240 public void dontinline_testMethod() { 1241 XYVal xy = new XYVal(4, 2); 1242 getAway = xy; // allocated object escapes 1243 dontinline_brkpt(); 1244 iResult = xy.x + xy.y; 1245 } 1246 1247 @Override 1248 public int getExpectedIResult() { 1249 return 4 + 2; 1250 } 1251 1252 @Override 1253 public boolean testFrameShouldBeDeoptimized() { 1254 return false; 1255 } 1256 } 1257 1258 class EAGetWithoutMaterialize extends EATestCaseBaseDebugger { 1259 1260 public void runTestCase() throws Exception { 1261 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1262 printStack(bpe.thread()); 1263 ObjectReference o = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "xy"); 1264 checkPrimitiveField(o, FD.I, "x", 4); 1265 checkPrimitiveField(o, FD.I, "y", 2); 1266 } 1267 } 1268 1269 ///////////////////////////////////////////////////////////////////////////// 1270 1271 // 1272 // Tests the following: 1273 // 1274 // 1. Debugger can obtain a reference to a scalar replaced object R from java thread J. 1275 // See runTestCase. 1276 // 1277 // 2. Subsequent modifications of R by J are noticed by the debugger. 1278 // See checkPostConditions. 1279 // 1280 class EAMaterializeLocalVariableUponGet extends EATestCaseBaseDebugger { 1281 1282 private ObjectReference o; 1283 1284 public void runTestCase() throws Exception { 1285 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1286 printStack(bpe.thread()); 1287 // check 1. 1288 o = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "xy"); 1289 // o is referenced in checkPostConditions() and must not be gc'ed. 1290 o.disableCollection(); 1291 checkPrimitiveField(o, FD.I, "x", 4); 1292 checkPrimitiveField(o, FD.I, "y", 2); 1293 } 1294 1295 @Override 1296 public void checkPostConditions() throws Exception { 1297 super.checkPostConditions(); 1298 // check 2. 1299 checkPrimitiveField(o, FD.I, "x", 5); 1300 } 1301 } 1302 1303 class EAMaterializeLocalVariableUponGetTarget extends EATestCaseBaseTarget { 1304 1305 public void dontinline_testMethod() { 1306 XYVal xy = new XYVal(4, 2); 1307 dontinline_brkpt(); // Debugger obtains scalar replaced object at this point. 1308 xy.x += 1; // Change scalar replaced object after debugger obtained a reference to it. 1309 iResult = xy.x + xy.y; 1310 } 1311 1312 @Override 1313 public int getExpectedIResult() { 1314 return 4 + 2 + 1; 1315 } 1316 } 1317 1318 ///////////////////////////////////////////////////////////////////////////// 1319 1320 // Test if an eliminated object can be reallocated in a frame with an active 1321 // call that will return another object 1322 class EAMaterializeLocalAtObjectReturn extends EATestCaseBaseDebugger { 1323 public void runTestCase() throws Exception { 1324 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1325 printStack(bpe.thread()); 1326 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "xy"); 1327 checkPrimitiveField(o, FD.I, "x", 4); 1328 checkPrimitiveField(o, FD.I, "y", 2); 1329 } 1330 } 1331 1332 class EAMaterializeLocalAtObjectReturnTarget extends EATestCaseBaseTarget { 1333 @Override 1334 public void setUp() { 1335 super.setUp(); 1336 testMethodDepth = 2; 1337 } 1338 1339 public void dontinline_testMethod() { 1340 XYVal xy = new XYVal(4, 2); 1341 Integer io = // Read xy here triggers reallocation 1342 dontinline_brkpt_return_Integer(); 1343 iResult = xy.x + xy.y + io; 1344 } 1345 1346 public Integer dontinline_brkpt_return_Integer() { 1347 // We can't break directly in this method, as this results in making 1348 // the test method not entrant caused by an existing dependency 1349 dontinline_brkpt(); 1350 return Integer.valueOf(23); 1351 } 1352 1353 @Override 1354 public int getExpectedIResult() { 1355 return 4 + 2 + 23; 1356 } 1357 } 1358 1359 ///////////////////////////////////////////////////////////////////////////// 1360 1361 // Test if an eliminated object can be reallocated *just* before a call returns an object. 1362 // (See CompiledMethod::is_at_poll_return()) 1363 // Details: the callee method has just one safepoint poll at the return. The other safepoint 1364 // is at the end of an iteration of the endless loop. We can detect if we suspended the target 1365 // there because the local xy is out of scope there. 1366 class EAMaterializeLocalAtObjectPollReturnReturn extends EATestCaseBaseDebugger { 1367 public void runTestCase() throws Exception { 1368 msg("Resume " + env.targetMainThread); 1369 env.vm().resume(); 1370 waitUntilTargetHasEnteredEndlessLoop(); 1371 ObjectReference o = null; 1372 int retryCount = 0; 1373 do { 1374 env.targetMainThread.suspend(); 1375 printStack(env.targetMainThread); 1376 try { 1377 o = getLocalRef(env.targetMainThread.frame(0), XYVAL_NAME, "xy"); 1378 } catch (Exception e) { 1379 ++retryCount; 1380 msg("The local variable xy is out of scope because we suspended at the wrong bci. Resume and try again! (" + retryCount + ")"); 1381 env.targetMainThread.resume(); 1382 if ((retryCount % 10) == 0) { 1383 Thread.sleep(200); 1384 } 1385 } 1386 } while (o == null); 1387 checkPrimitiveField(o, FD.I, "x", 4); 1388 checkPrimitiveField(o, FD.I, "y", 2); 1389 terminateEndlessLoop(); 1390 } 1391 } 1392 1393 class EAMaterializeLocalAtObjectPollReturnReturnTarget extends EATestCaseBaseTarget { 1394 @Override 1395 public void setUp() { 1396 super.setUp(); 1397 loopCount = 3; 1398 doLoop = true; 1399 } 1400 1401 public void warmupDone() { 1402 super.warmupDone(); 1403 msg("enter 'endless' loop by setting loopCount = Long.MAX_VALUE"); 1404 loopCount = Long.MAX_VALUE; // endless loop 1405 } 1406 1407 public void dontinline_testMethod() { 1408 long result = 0; 1409 while (doLoop && loopCount-- > 0) { 1410 targetIsInLoop = true; 1411 XYVal xy = new XYVal(4, 2); 1412 Integer io = // Read xy here triggers reallocation just before the call returns 1413 dontinline_brkpt_return_Integer(); 1414 result += xy.x + xy.y + io; 1415 } // Here is a second safepoint. We were suspended here if xy is not in scope. 1416 targetIsInLoop = false; 1417 lResult = result; 1418 } 1419 1420 public Integer dontinline_brkpt_return_Integer() { 1421 return Integer.valueOf(23); 1422 } 1423 1424 @Override 1425 public long getExpectedLResult() { 1426 return (Long.MAX_VALUE - loopCount) * (4+2+23); 1427 } 1428 } 1429 1430 ///////////////////////////////////////////////////////////////////////////// 1431 // Test case collection that tests rematerialization of different 1432 // array types where the first element is always not constant and the 1433 // other elements are constants. Not constant values are stored in 1434 // the stack frame for rematerialization whereas constants are kept 1435 // in the debug info of the nmethod. 1436 1437 class EAMaterializeIntArrayTarget extends EATestCaseBaseTarget { 1438 1439 public void dontinline_testMethod() { 1440 int nums[] = {NOT_CONST_1I , 2, 3}; 1441 dontinline_brkpt(); 1442 iResult = nums[0] + nums[1] + nums[2]; 1443 } 1444 1445 @Override 1446 public int getExpectedIResult() { 1447 return NOT_CONST_1I + 2 + 3; 1448 } 1449 } 1450 1451 class EAMaterializeIntArray extends EATestCaseBaseDebugger { 1452 public void runTestCase() throws Exception { 1453 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1454 printStack(bpe.thread()); 1455 int[] expectedVals = {1, 2, 3}; 1456 checkLocalPrimitiveArray(bpe.thread().frame(1), "nums", FD.I, expectedVals); 1457 } 1458 } 1459 1460 ///////////////////////////////////////////////////////////////////////////// 1461 1462 class EAMaterializeLongArrayTarget extends EATestCaseBaseTarget { 1463 1464 public void dontinline_testMethod() { 1465 long nums[] = {NOT_CONST_1L , 2, 3}; 1466 dontinline_brkpt(); 1467 lResult = nums[0] + nums[1] + nums[2]; 1468 } 1469 1470 @Override 1471 public long getExpectedLResult() { 1472 return NOT_CONST_1L + 2 + 3; 1473 } 1474 } 1475 1476 class EAMaterializeLongArray extends EATestCaseBaseDebugger { 1477 public void runTestCase() throws Exception { 1478 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1479 printStack(bpe.thread()); 1480 long[] expectedVals = {1, 2, 3}; 1481 checkLocalPrimitiveArray(bpe.thread().frame(1), "nums", FD.J, expectedVals); 1482 } 1483 } 1484 1485 ///////////////////////////////////////////////////////////////////////////// 1486 1487 class EAMaterializeFloatArrayTarget extends EATestCaseBaseTarget { 1488 1489 public void dontinline_testMethod() { 1490 float nums[] = {NOT_CONST_1F , 2.2f, 3.3f}; 1491 dontinline_brkpt(); 1492 fResult = nums[0] + nums[1] + nums[2]; 1493 } 1494 1495 @Override 1496 public float getExpectedFResult() { 1497 return NOT_CONST_1F + 2.2f + 3.3f; 1498 } 1499 } 1500 1501 class EAMaterializeFloatArray extends EATestCaseBaseDebugger { 1502 public void runTestCase() throws Exception { 1503 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1504 printStack(bpe.thread()); 1505 float[] expectedVals = {1.1f, 2.2f, 3.3f}; 1506 checkLocalPrimitiveArray(bpe.thread().frame(1), "nums", FD.F, expectedVals); 1507 } 1508 } 1509 1510 ///////////////////////////////////////////////////////////////////////////// 1511 1512 class EAMaterializeDoubleArrayTarget extends EATestCaseBaseTarget { 1513 1514 public void dontinline_testMethod() { 1515 double nums[] = {NOT_CONST_1D , 2.2d, 3.3d}; 1516 dontinline_brkpt(); 1517 dResult = nums[0] + nums[1] + nums[2]; 1518 } 1519 1520 @Override 1521 public double getExpectedDResult() { 1522 return NOT_CONST_1D + 2.2d + 3.3d; 1523 } 1524 } 1525 1526 class EAMaterializeDoubleArray extends EATestCaseBaseDebugger { 1527 public void runTestCase() throws Exception { 1528 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1529 printStack(bpe.thread()); 1530 double[] expectedVals = {1.1d, 2.2d, 3.3d}; 1531 checkLocalPrimitiveArray(bpe.thread().frame(1), "nums", FD.D, expectedVals); 1532 } 1533 } 1534 1535 ///////////////////////////////////////////////////////////////////////////// 1536 1537 class EAMaterializeObjectArrayTarget extends EATestCaseBaseTarget { 1538 1539 public void dontinline_testMethod() { 1540 Long nums[] = {NOT_CONST_1_OBJ , CONST_2_OBJ, CONST_3_OBJ}; 1541 dontinline_brkpt(); 1542 lResult = nums[0] + nums[1] + nums[2]; 1543 } 1544 1545 @Override 1546 public long getExpectedLResult() { 1547 return 1 + 2 + 3; 1548 } 1549 } 1550 1551 class EAMaterializeObjectArray extends EATestCaseBaseDebugger { 1552 public void runTestCase() throws Exception { 1553 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1554 printStack(bpe.thread()); 1555 ReferenceType clazz = bpe.thread().frame(0).location().declaringType(); 1556 ObjectReference[] expectedVals = { 1557 (ObjectReference) clazz.getValue(clazz.fieldByName("NOT_CONST_1_OBJ")), 1558 (ObjectReference) clazz.getValue(clazz.fieldByName("CONST_2_OBJ")), 1559 (ObjectReference) clazz.getValue(clazz.fieldByName("CONST_3_OBJ")) 1560 }; 1561 checkLocalObjectArray(bpe.thread().frame(1), "nums", "java.lang.Long[]", expectedVals); 1562 } 1563 } 1564 1565 ///////////////////////////////////////////////////////////////////////////// 1566 1567 // Materialize an object whose fields have constant and not constant values at 1568 // the point where the object is materialized. 1569 class EAMaterializeObjectWithConstantAndNotConstantValuesTarget extends EATestCaseBaseTarget { 1570 1571 public void dontinline_testMethod() { 1572 ILFDO o = new ILFDO(NOT_CONST_1I, 2, 1573 NOT_CONST_1L, 2L, 1574 NOT_CONST_1F, 2.1F, 1575 NOT_CONST_1D, 2.1D, 1576 NOT_CONST_1_OBJ, CONST_2_OBJ 1577 ); 1578 dontinline_brkpt(); 1579 dResult = 1580 o.i + o.i2 + o.l + o.l2 + o.f + o.f2 + o.d + o.d2 + o.o + o.o2; 1581 } 1582 1583 @Override 1584 public double getExpectedDResult() { 1585 return NOT_CONST_1I + 2 + NOT_CONST_1L + 2L + NOT_CONST_1F + 2.1F + NOT_CONST_1D + 2.1D + NOT_CONST_1_OBJ + CONST_2_OBJ; 1586 } 1587 } 1588 1589 class EAMaterializeObjectWithConstantAndNotConstantValues extends EATestCaseBaseDebugger { 1590 public void runTestCase() throws Exception { 1591 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1592 printStack(bpe.thread()); 1593 ObjectReference o = getLocalRef(bpe.thread().frame(1), "ILFDO", "o"); 1594 checkPrimitiveField(o, FD.I, "i", 1); 1595 checkPrimitiveField(o, FD.I, "i2", 2); 1596 checkPrimitiveField(o, FD.J, "l", 1L); 1597 checkPrimitiveField(o, FD.J, "l2", 2L); 1598 checkPrimitiveField(o, FD.F, "f", 1.1f); 1599 checkPrimitiveField(o, FD.F, "f2", 2.1f); 1600 checkPrimitiveField(o, FD.D, "d", 1.1d); 1601 checkPrimitiveField(o, FD.D, "d2", 2.1d); 1602 ReferenceType clazz = bpe.thread().frame(1).location().declaringType(); 1603 ObjectReference[] expVals = { 1604 (ObjectReference) clazz.getValue(clazz.fieldByName("NOT_CONST_1_OBJ")), 1605 (ObjectReference) clazz.getValue(clazz.fieldByName("CONST_2_OBJ")), 1606 }; 1607 checkObjField(o, "o", expVals[0]); 1608 checkObjField(o, "o2", expVals[1]); 1609 } 1610 } 1611 1612 ///////////////////////////////////////////////////////////////////////////// 1613 1614 // Two local variables reference the same object. 1615 // Check if the debugger obtains the same object when reading the two variables 1616 class EAMaterializeObjReferencedBy2LocalsTarget extends EATestCaseBaseTarget { 1617 1618 public void dontinline_testMethod() { 1619 XYVal xy = new XYVal(2, 3); 1620 XYVal alias = xy; 1621 dontinline_brkpt(); 1622 iResult = xy.x + alias.x; 1623 } 1624 1625 @Override 1626 public int getExpectedIResult() { 1627 return 2 + 2; 1628 } 1629 } 1630 1631 class EAMaterializeObjReferencedBy2Locals extends EATestCaseBaseDebugger { 1632 1633 public void runTestCase() throws Exception { 1634 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1635 printStack(bpe.thread()); 1636 ObjectReference xy = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "xy"); 1637 ObjectReference alias = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "alias"); 1638 Asserts.assertSame(xy, alias, "xy and alias are expected to reference the same object"); 1639 } 1640 1641 } 1642 1643 ///////////////////////////////////////////////////////////////////////////// 1644 1645 // Two local variables reference the same object. 1646 // Check if it has the expected effect in the target if the debugger modifies the object. 1647 class EAMaterializeObjReferencedBy2LocalsAndModifyTarget extends EATestCaseBaseTarget { 1648 1649 public void dontinline_testMethod() { 1650 XYVal xy = new XYVal(2, 3); 1651 XYVal alias = xy; 1652 dontinline_brkpt(); // debugger: alias.x = 42 1653 iResult = xy.x + alias.x; 1654 } 1655 1656 @Override 1657 public int getExpectedIResult() { 1658 return 42 + 42; 1659 } 1660 } 1661 1662 class EAMaterializeObjReferencedBy2LocalsAndModify extends EATestCaseBaseDebugger { 1663 1664 public void runTestCase() throws Exception { 1665 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1666 printStack(bpe.thread()); 1667 ObjectReference alias = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "alias"); 1668 setField(alias, "x", env.vm().mirrorOf(42)); 1669 } 1670 } 1671 1672 ///////////////////////////////////////////////////////////////////////////// 1673 1674 // Two local variables of the same compiled frame but in different virtual frames reference the same 1675 // object. 1676 // Check if the debugger obtains the same object when reading the two variables 1677 class EAMaterializeObjReferencedBy2LocalsInDifferentVirtFramesTarget extends EATestCaseBaseTarget { 1678 1679 @Override 1680 public void setUp() { 1681 super.setUp(); 1682 testMethodDepth = 2; 1683 } 1684 1685 public void dontinline_testMethod() { 1686 XYVal xy = new XYVal(2, 3); 1687 testMethod_inlined(xy); 1688 iResult += xy.x; 1689 } 1690 1691 public void testMethod_inlined(XYVal xy) { 1692 XYVal alias = xy; 1693 dontinline_brkpt(); 1694 iResult = alias.x; 1695 } 1696 1697 @Override 1698 public int getExpectedIResult() { 1699 return 2 + 2; 1700 } 1701 } 1702 1703 class EAMaterializeObjReferencedBy2LocalsInDifferentVirtFrames extends EATestCaseBaseDebugger { 1704 1705 public void runTestCase() throws Exception { 1706 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1707 printStack(bpe.thread()); 1708 ObjectReference xy = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "xy"); 1709 ObjectReference alias = getLocalRef(bpe.thread().frame(1), "testMethod_inlined", "alias", XYVAL_NAME); 1710 Asserts.assertSame(xy, alias, "xy and alias are expected to reference the same object"); 1711 } 1712 1713 } 1714 1715 ///////////////////////////////////////////////////////////////////////////// 1716 1717 // Two local variables of the same compiled frame but in different virtual frames reference the same 1718 // object. 1719 // Check if it has the expected effect in the target if the debugger modifies the object. 1720 class EAMaterializeObjReferencedBy2LocalsInDifferentVirtFramesAndModifyTarget extends EATestCaseBaseTarget { 1721 1722 @Override 1723 public void setUp() { 1724 super.setUp(); 1725 testMethodDepth = 2; 1726 } 1727 1728 public void dontinline_testMethod() { 1729 XYVal xy = new XYVal(2, 3); 1730 testMethod_inlined(xy); // debugger: xy.x = 42 1731 iResult += xy.x; 1732 } 1733 1734 public void testMethod_inlined(XYVal xy) { 1735 XYVal alias = xy; 1736 dontinline_brkpt(); 1737 iResult = alias.x; 1738 } 1739 1740 @Override 1741 public int getExpectedIResult() { 1742 return 42 + 42; 1743 } 1744 } 1745 1746 class EAMaterializeObjReferencedBy2LocalsInDifferentVirtFramesAndModify extends EATestCaseBaseDebugger { 1747 1748 public void runTestCase() throws Exception { 1749 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1750 printStack(bpe.thread()); 1751 ObjectReference alias = getLocalRef(bpe.thread().frame(1), "testMethod_inlined", "alias", XYVAL_NAME); 1752 setField(alias, "x", env.vm().mirrorOf(42)); 1753 } 1754 1755 } 1756 1757 ///////////////////////////////////////////////////////////////////////////// 1758 1759 // Test materialization of an object referenced only from expression stack 1760 class EAMaterializeObjReferencedFromOperandStackTarget extends EATestCaseBaseTarget { 1761 1762 @Override 1763 public void setUp() { 1764 super.setUp(); 1765 testMethodDepth = 2; 1766 } 1767 1768 public void dontinline_testMethod() { 1769 @SuppressWarnings("unused") 1770 XYVal xy1 = new XYVal(2, 3); 1771 // Debugger breaks in call to dontinline_brkpt_ret_100() and reads 1772 // the value of the local 'xy1'. This triggers materialization 1773 // of the object on the operand stack 1774 iResult = testMethodInlined(new XYVal(4, 2), dontinline_brkpt_ret_100()); 1775 } 1776 1777 public int testMethodInlined(XYVal xy2, int dontinline_brkpt_ret_100) { 1778 return xy2.x + dontinline_brkpt_ret_100; 1779 } 1780 1781 public int dontinline_brkpt_ret_100() { 1782 dontinline_brkpt(); 1783 return 100; 1784 } 1785 1786 @Override 1787 public int getExpectedIResult() { 1788 return 4 + 100; 1789 } 1790 } 1791 1792 class EAMaterializeObjReferencedFromOperandStack extends EATestCaseBaseDebugger { 1793 1794 public void runTestCase() throws Exception { 1795 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1796 printStack(bpe.thread()); 1797 ObjectReference xy1 = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "xy1"); 1798 checkPrimitiveField(xy1, FD.I, "x", 2); 1799 checkPrimitiveField(xy1, FD.I, "y", 3); 1800 } 1801 1802 } 1803 1804 ///////////////////////////////////////////////////////////////////////////// 1805 1806 /** 1807 * Tests a regression in the implementation by setting the value of a local int which triggers the 1808 * creation of a deferred update and then getting the reference to a scalar replaced object. The 1809 * issue was that the scalar replaced object was not reallocated. Because of the deferred update it 1810 * was assumed that the reallocation already happened. 1811 */ 1812 class EAMaterializeLocalVariableUponGetAfterSetInteger extends EATestCaseBaseDebugger { 1813 1814 public void runTestCase() throws Exception { 1815 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1816 printStack(bpe.thread()); 1817 setLocal(bpe.thread().frame(1), "i", env.vm().mirrorOf(43)); 1818 ObjectReference o = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "xy"); 1819 checkPrimitiveField(o, FD.I, "x", 4); 1820 checkPrimitiveField(o, FD.I, "y", 2); 1821 } 1822 } 1823 1824 class EAMaterializeLocalVariableUponGetAfterSetIntegerTarget extends EATestCaseBaseTarget { 1825 1826 public void dontinline_testMethod() { 1827 XYVal xy = new XYVal(4, 2); 1828 int i = 42; 1829 dontinline_brkpt(); 1830 iResult = xy.x + xy.y + i; 1831 } 1832 1833 @Override 1834 public int getExpectedIResult() { 1835 return 4 + 2 + 43; 1836 } 1837 1838 @Override 1839 public boolean testFrameShouldBeDeoptimized() { 1840 return true; // setting local variable i always triggers deoptimization 1841 } 1842 } 1843 1844 ///////////////////////////////////////////////////////////////////////////// 1845 // 1846 // Locking Tests 1847 // 1848 ///////////////////////////////////////////////////////////////////////////// 1849 1850 class EARelockingSimple extends EATestCaseBaseDebugger { 1851 1852 public void runTestCase() throws Exception { 1853 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1854 printStack(bpe.thread()); 1855 @SuppressWarnings("unused") 1856 ObjectReference o = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "l1"); 1857 } 1858 } 1859 1860 class EARelockingSimpleTarget extends EATestCaseBaseTarget { 1861 1862 public void dontinline_testMethod() { 1863 XYVal l1 = new XYVal(4, 2); 1864 synchronized (l1) { 1865 dontinline_brkpt(); 1866 } 1867 } 1868 } 1869 1870 ///////////////////////////////////////////////////////////////////////////// 1871 1872 /** 1873 * Test if the bias of an object O that escapes globally is revoked correctly if local objects 1874 * escape through JVMTI. O is referenced by field l0. 1875 * This tests a regression of a previous version of the implementation. 1876 */ 1877 class EARelockingSimple_2 extends EATestCaseBaseDebugger { 1878 1879 1880 public void runTestCase() throws Exception { 1881 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1882 printStack(bpe.thread()); 1883 @SuppressWarnings("unused") 1884 ObjectReference o = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "l1"); 1885 } 1886 } 1887 1888 class EARelockingSimple_2Target extends EATestCaseBaseTarget { 1889 1890 public XYVal l0; 1891 1892 public void dontinline_testMethod() { 1893 l0 = new XYVal(4, 2); // GobalEscape 1894 XYVal l1 = new XYVal(4, 2); 1895 synchronized (l0) { 1896 synchronized (l1) { 1897 dontinline_brkpt(); 1898 } 1899 } 1900 } 1901 } 1902 1903 ///////////////////////////////////////////////////////////////////////////// 1904 1905 // The debugger reads and publishes an object with eliminated locking to an instance field. 1906 // A 2nd thread in the debuggee finds it there and changes its state using a synchronized method. 1907 // Without eager relocking the accesses are unsynchronized which can be observed. 1908 class EARelockingSimpleWithAccessInOtherThread extends EATestCaseBaseDebugger { 1909 1910 public void runTestCase() throws Exception { 1911 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1912 printStack(bpe.thread()); 1913 String l1ClassName = EARelockingSimpleWithAccessInOtherThreadTarget.SyncCounter.class.getName(); 1914 ObjectReference ctr = getLocalRef(bpe.thread().frame(1), l1ClassName, "l1"); 1915 setField(testCase, "sharedCounter", ctr); 1916 terminateEndlessLoop(); 1917 } 1918 } 1919 1920 class EARelockingSimpleWithAccessInOtherThreadTarget extends EATestCaseBaseTarget { 1921 1922 public static class SyncCounter { 1923 private int val; 1924 public synchronized int inc() { return val++; } 1925 } 1926 1927 public volatile SyncCounter sharedCounter; 1928 1929 @Override 1930 public void setUp() { 1931 super.setUp(); 1932 doLoop = true; 1933 Thread t = new Thread() { 1934 public void run() { 1935 while (doLoop) { 1936 SyncCounter ctr = sharedCounter; 1937 if (ctr != null) { 1938 ctr.inc(); 1939 } 1940 } 1941 } 1942 }; 1943 t.setDaemon(true); 1944 t.start(); 1945 } 1946 1947 public void dontinline_testMethod() { 1948 SyncCounter l1 = new SyncCounter(); 1949 synchronized (l1) { // Eliminated locking 1950 l1.inc(); 1951 dontinline_brkpt(); // Debugger publishes l1 to sharedCounter. 1952 iResult = l1.inc(); // Changes by the 2nd thread will be observed if l1 1953 // was not relocked before passing it to the debugger. 1954 } 1955 } 1956 1957 @Override 1958 public int getExpectedIResult() { 1959 return 1; 1960 } 1961 } 1962 1963 ///////////////////////////////////////////////////////////////////////////// 1964 1965 // Test recursive locking 1966 class EARelockingRecursiveTarget extends EATestCaseBaseTarget { 1967 1968 @Override 1969 public void setUp() { 1970 super.setUp(); 1971 testMethodDepth = 2; 1972 } 1973 1974 public void dontinline_testMethod() { 1975 XYVal l1 = new XYVal(4, 2); 1976 synchronized (l1) { 1977 testMethod_inlined(l1); 1978 } 1979 } 1980 1981 public void testMethod_inlined(XYVal l2) { 1982 synchronized (l2) { 1983 dontinline_brkpt(); 1984 } 1985 } 1986 } 1987 1988 class EARelockingRecursive extends EATestCaseBaseDebugger { 1989 1990 public void runTestCase() throws Exception { 1991 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 1992 printStack(bpe.thread()); 1993 @SuppressWarnings("unused") 1994 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1"); 1995 } 1996 } 1997 1998 ///////////////////////////////////////////////////////////////////////////// 1999 2000 // Object ref l1 is retrieved by the debugger at a location where nested locks are omitted. The 2001 // accessed object is globally reachable already before the access, therefore no relocking is done. 2002 class EARelockingNestedInflatedTarget extends EATestCaseBaseTarget { 2003 2004 @Override 2005 public void setUp() { 2006 super.setUp(); 2007 testMethodDepth = 2; 2008 } 2009 2010 @Override 2011 public boolean testFrameShouldBeDeoptimized() { 2012 // Access does not trigger deopt., as escape state is already global escape. 2013 return false; 2014 } 2015 2016 public void dontinline_testMethod() { 2017 XYVal l1 = inflatedLock; 2018 synchronized (l1) { 2019 testMethod_inlined(l1); 2020 } 2021 } 2022 2023 public void testMethod_inlined(XYVal l2) { 2024 synchronized (l2) { // eliminated nested locking 2025 dontinline_brkpt(); 2026 } 2027 } 2028 } 2029 2030 class EARelockingNestedInflated extends EATestCaseBaseDebugger { 2031 2032 public void runTestCase() throws Exception { 2033 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2034 printStack(bpe.thread()); 2035 @SuppressWarnings("unused") 2036 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1"); 2037 } 2038 } 2039 2040 ///////////////////////////////////////////////////////////////////////////// 2041 2042 /** 2043 * Like {@link EARelockingNestedInflated} with the difference that there is 2044 * a scalar replaced object in the scope from which the object with eliminated nested locking 2045 * is read. This triggers materialization and relocking. 2046 */ 2047 class EARelockingNestedInflated_02 extends EATestCaseBaseDebugger { 2048 2049 public void runTestCase() throws Exception { 2050 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2051 printStack(bpe.thread()); 2052 @SuppressWarnings("unused") 2053 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1"); 2054 } 2055 } 2056 2057 class EARelockingNestedInflated_02Target extends EATestCaseBaseTarget { 2058 2059 @Override 2060 public void setUp() { 2061 super.setUp(); 2062 testMethodDepth = 2; 2063 } 2064 2065 public void dontinline_testMethod() { 2066 @SuppressWarnings("unused") 2067 XYVal xy = new XYVal(1, 1); // scalar replaced 2068 XYVal l1 = inflatedLock; // read by debugger 2069 synchronized (l1) { 2070 testMethod_inlined(l1); 2071 } 2072 } 2073 2074 public void testMethod_inlined(XYVal l2) { 2075 synchronized (l2) { // eliminated nested locking 2076 dontinline_brkpt(); 2077 } 2078 } 2079 } 2080 2081 ///////////////////////////////////////////////////////////////////////////// 2082 2083 /** 2084 * Like {@link EARelockingNestedInflated_02} with the difference that the 2085 * inflation of the lock happens because of contention. 2086 */ 2087 class EARelockingNestedInflated_03 extends EATestCaseBaseDebugger { 2088 2089 public void runTestCase() throws Exception { 2090 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2091 printStack(bpe.thread()); 2092 @SuppressWarnings("unused") 2093 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1"); 2094 } 2095 } 2096 2097 class EARelockingNestedInflated_03Target extends EATestCaseBaseTarget { 2098 2099 public XYVal lockInflatedByContention; 2100 public boolean doLockNow; 2101 public EATestCaseBaseTarget testCase; 2102 2103 @Override 2104 public void setUp() { 2105 super.setUp(); 2106 testMethodDepth = 2; 2107 lockInflatedByContention = new XYVal(1, 1); 2108 testCase = this; 2109 } 2110 2111 @Override 2112 public void warmupDone() { 2113 super.warmupDone(); 2114 // Use new lock. lockInflatedByContention might have been inflated because of recursion. 2115 lockInflatedByContention = new XYVal(1, 1); 2116 // Start thread that tries to enter lockInflatedByContention while the main thread owns it -> inflation 2117 new Thread(() -> { 2118 while (true) { 2119 synchronized (testCase) { 2120 try { 2121 if (doLockNow) { 2122 doLockNow = false; // reset for main thread 2123 testCase.notify(); 2124 break; 2125 } 2126 testCase.wait(); 2127 } catch (InterruptedException e) { /* ignored */ } 2128 } 2129 } 2130 synchronized (lockInflatedByContention) { // will block and trigger inflation 2131 msg(Thread.currentThread().getName() + ": acquired lockInflatedByContention"); 2132 } 2133 }, testCaseName + ": Lock Contender (test thread)").start(); 2134 } 2135 2136 public void dontinline_testMethod() { 2137 @SuppressWarnings("unused") 2138 XYVal xy = new XYVal(1, 1); // scalar replaced 2139 XYVal l1 = lockInflatedByContention; // read by debugger 2140 synchronized (l1) { 2141 testMethod_inlined(l1); 2142 } 2143 } 2144 2145 public void testMethod_inlined(XYVal l2) { 2146 synchronized (l2) { // eliminated nested locking 2147 dontinline_notifyOtherThread(); 2148 dontinline_brkpt(); 2149 } 2150 } 2151 2152 public void dontinline_notifyOtherThread() { 2153 if (!warmupDone) { 2154 return; 2155 } 2156 synchronized (testCase) { 2157 doLockNow = true; 2158 testCase.notify(); 2159 // wait for other thread to reset doLockNow again 2160 while (doLockNow) { 2161 try { 2162 testCase.wait(); 2163 } catch (InterruptedException e) { /* ignored */ } 2164 } 2165 } 2166 } 2167 } 2168 2169 ///////////////////////////////////////////////////////////////////////////// 2170 2171 /** 2172 * Checks if an eliminated lock of an ArgEscape object l1 can be relocked if 2173 * l1 is locked in a callee frame. 2174 */ 2175 class EARelockingArgEscapeLWLockedInCalleeFrame extends EATestCaseBaseDebugger { 2176 2177 public void runTestCase() throws Exception { 2178 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2179 printStack(bpe.thread()); 2180 @SuppressWarnings("unused") 2181 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1"); 2182 } 2183 } 2184 2185 class EARelockingArgEscapeLWLockedInCalleeFrameTarget extends EATestCaseBaseTarget { 2186 2187 @Override 2188 public void setUp() { 2189 super.setUp(); 2190 testMethodDepth = 2; 2191 } 2192 2193 public void dontinline_testMethod() { 2194 XYVal l1 = new XYVal(1, 1); // ArgEscape 2195 synchronized (l1) { // eliminated 2196 l1.dontinline_sync_method(this); // l1 escapes 2197 } 2198 } 2199 2200 @Override 2201 public boolean testFrameShouldBeDeoptimized() { 2202 // Graal does not provide debug info about arg escape objects, therefore the frame is not deoptimized 2203 return !UseJVMCICompiler && super.testFrameShouldBeDeoptimized(); 2204 } 2205 } 2206 2207 ///////////////////////////////////////////////////////////////////////////// 2208 2209 /** 2210 * Similar to {@link EARelockingArgEscapeLWLockedInCalleeFrame}. In addition 2211 * the test method has got a scalar replaced object with eliminated locking. 2212 * This pattern matches a regression in the implementation. 2213 */ 2214 class EARelockingArgEscapeLWLockedInCalleeFrame_2 extends EATestCaseBaseDebugger { 2215 2216 public void runTestCase() throws Exception { 2217 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2218 printStack(bpe.thread()); 2219 @SuppressWarnings("unused") 2220 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1"); 2221 } 2222 } 2223 2224 class EARelockingArgEscapeLWLockedInCalleeFrame_2Target extends EATestCaseBaseTarget { 2225 2226 @Override 2227 public void setUp() { 2228 super.setUp(); 2229 testMethodDepth = 2; 2230 } 2231 2232 public void dontinline_testMethod() { 2233 XYVal l1 = new XYVal(1, 1); // ArgEscape 2234 XYVal l2 = new XYVal(4, 2); // NoEscape, scalar replaced 2235 synchronized (l1) { // eliminated 2236 synchronized (l2) { // eliminated 2237 l1.dontinline_sync_method(this); // l1 escapes 2238 } 2239 } 2240 iResult = l2.x + l2.y; 2241 } 2242 2243 @Override 2244 public int getExpectedIResult() { 2245 return 6; 2246 } 2247 } 2248 2249 ///////////////////////////////////////////////////////////////////////////// 2250 2251 /** 2252 * Similar to {@link EARelockingArgEscapeLWLockedInCalleeFrame}. 2253 * A bulk rebias operation is triggered at a position where all locks on the local object referenced 2254 * by l1 are eliminated. This leaves the object with an outdated biased locking epoch which has to be 2255 * considered when relocking. 2256 * This tests a regression in a previous version. 2257 */ 2258 class EARelockingArgEscapeLWLockedInCalleeFrame_3 extends EATestCaseBaseDebugger { 2259 2260 public static final String XYVAL_LOCAL_NAME = EARelockingArgEscapeLWLockedInCalleeFrame_3Target.XYValLocal.class.getName(); 2261 2262 public void runTestCase() throws Exception { 2263 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2264 printStack(bpe.thread()); 2265 @SuppressWarnings("unused") 2266 ObjectReference o = getLocalRef(bpe.thread().frame(1), XYVAL_LOCAL_NAME, "l1"); 2267 } 2268 } 2269 2270 class EARelockingArgEscapeLWLockedInCalleeFrame_3Target extends EATestCaseBaseTarget { 2271 2272 // Using local type to avoid side effects on biased locking heuristics 2273 public static class XYValLocal extends XYVal { 2274 public XYValLocal(int x, int y) { 2275 super(x,y); 2276 } 2277 } 2278 2279 public void dontinline_testMethod() { 2280 XYVal l1 = new XYValLocal(1, 1); // ArgEscape 2281 synchronized (l1) { // eliminated 2282 l1.dontinline_sync_method_no_brkpt(this); // l1 escapes 2283 // trigger bulk rebias 2284 dontinline_bulkRebiasAfterWarmup(l1.getClass()); 2285 // Now the epoch of l1 does not match the epoch of its class. 2286 // This has to be considered when relocking because of JVMTI access 2287 dontinline_brkpt(); 2288 } 2289 } 2290 2291 @Override 2292 public boolean testFrameShouldBeDeoptimized() { 2293 // Graal does not provide debug info about arg escape objects, therefore the frame is not deoptimized 2294 return !UseJVMCICompiler && super.testFrameShouldBeDeoptimized(); 2295 } 2296 } 2297 2298 ///////////////////////////////////////////////////////////////////////////// 2299 2300 /** 2301 * Similar to {@link EARelockingArgEscapeLWLockedInCalleeFrame_3}. 2302 * But instead of a bulk rebias a bulk revoke operation is triggered. 2303 * This leaves the object with a stale bias as the prototype header of its calls lost its bias 2304 * pattern in the bulk revoke which has to be considered during relocking. 2305 * This tests a regression in a previous version. 2306 */ 2307 class EARelockingArgEscapeLWLockedInCalleeFrame_4 extends EATestCaseBaseDebugger { 2308 2309 public static final String XYVAL_LOCAL_NAME = EARelockingArgEscapeLWLockedInCalleeFrame_4Target.XYValLocal.class.getName(); 2310 2311 public void runTestCase() throws Exception { 2312 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2313 printStack(bpe.thread()); 2314 @SuppressWarnings("unused") 2315 ObjectReference o = getLocalRef(bpe.thread().frame(1), XYVAL_LOCAL_NAME, "l1"); 2316 } 2317 } 2318 2319 class EARelockingArgEscapeLWLockedInCalleeFrame_4Target extends EATestCaseBaseTarget { 2320 2321 // Using local type to avoid side effects on biased locking heuristics 2322 public static class XYValLocal extends XYVal { 2323 public XYValLocal(int x, int y) { 2324 super(x,y); 2325 } 2326 } 2327 2328 public void dontinline_testMethod() { 2329 XYVal l1 = new XYValLocal(1, 1); // ArgEscape 2330 synchronized (l1) { // eliminated 2331 l1.dontinline_sync_method_no_brkpt(this); // l1 escapes 2332 // trigger bulk rebias 2333 dontinline_bulkRevokeAfterWarmup(l1.getClass()); 2334 // Now the epoch of l1 does not match the epoch of its class. 2335 // This has to be considered when relocking because of JVMTI access 2336 dontinline_brkpt(); 2337 } 2338 } 2339 2340 2341 @Override 2342 public boolean testFrameShouldBeDeoptimized() { 2343 // Graal does not provide debug info about arg escape objects, therefore the frame is not deoptimized 2344 return !UseJVMCICompiler && super.testFrameShouldBeDeoptimized(); 2345 } 2346 } 2347 2348 ///////////////////////////////////////////////////////////////////////////// 2349 2350 /** 2351 * Similar to {@link EARelockingArgEscapeLWLockedInCalleeFrame_2Target}. It does 2352 * not use recursive locking and exposed a bug in the lightweight-locking implementation. 2353 */ 2354 class EARelockingArgEscapeLWLockedInCalleeFrameNoRecursive extends EATestCaseBaseDebugger { 2355 2356 public void runTestCase() throws Exception { 2357 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2358 printStack(bpe.thread()); 2359 @SuppressWarnings("unused") 2360 ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1"); 2361 } 2362 } 2363 2364 class EARelockingArgEscapeLWLockedInCalleeFrameNoRecursiveTarget extends EATestCaseBaseTarget { 2365 2366 @Override 2367 public void setUp() { 2368 super.setUp(); 2369 testMethodDepth = 2; 2370 } 2371 2372 public void dontinline_testMethod() { 2373 XYVal l1 = new XYVal(1, 1); // NoEscape, scalar replaced 2374 XYVal l2 = new XYVal(4, 2); // NoEscape, scalar replaced 2375 XYVal l3 = new XYVal(5, 3); // ArgEscape 2376 synchronized (l1) { // eliminated 2377 synchronized (l2) { // eliminated 2378 l3.dontinline_sync_method(this); // l3 escapes 2379 } 2380 } 2381 iResult = l2.x + l2.y; 2382 } 2383 2384 @Override 2385 public int getExpectedIResult() { 2386 return 6; 2387 } 2388 } 2389 2390 ///////////////////////////////////////////////////////////////////////////// 2391 2392 /** 2393 * Test relocking eliminated (nested) locks of an object on which the 2394 * target thread currently waits. 2395 */ 2396 class EARelockingObjectCurrentlyWaitingOn extends EATestCaseBaseDebugger { 2397 2398 public void runTestCase() throws Exception { 2399 env.vm().resume(); 2400 boolean inWait = false; 2401 do { 2402 Thread.sleep(100); 2403 env.targetMainThread.suspend(); 2404 printStack(env.targetMainThread); 2405 inWait = env.targetMainThread.frame(0).location().method().name().equals("wait"); 2406 if (!inWait) { 2407 msg("Target not yet in java.lang.Object.wait(long)."); 2408 env.targetMainThread.resume(); 2409 } 2410 } while(!inWait); 2411 StackFrame testMethodFrame = env.targetMainThread.frame(4); 2412 // Access triggers relocking of all eliminated locks, including nested locks of l1 which references 2413 // the object on which the target main thread is currently waiting. 2414 ObjectReference l0 = getLocalRef(testMethodFrame, EARelockingObjectCurrentlyWaitingOnTarget.ForLocking.class.getName(), "l0"); 2415 Asserts.assertEQ(l0.entryCount(), 1, "wrong entry count"); 2416 ObjectReference l1 = getLocalRef(testMethodFrame, EARelockingObjectCurrentlyWaitingOnTarget.ForLocking.class.getName(), "l1"); 2417 Asserts.assertEQ(l1.entryCount(), 0, "wrong entry count"); 2418 setField(testCase, "objToNotifyOn", l1); 2419 } 2420 } 2421 2422 class EARelockingObjectCurrentlyWaitingOnTarget extends EATestCaseBaseTarget { 2423 2424 public static class ForLocking { 2425 } 2426 2427 public volatile Object objToNotifyOn; // debugger assigns value when notify thread should call objToNotifyOn.notifyAll() 2428 2429 @Override 2430 public void setUp() { 2431 super.setUp(); 2432 testMethodDepth = 2; 2433 } 2434 2435 @Override 2436 public void warmupDone() { 2437 super.warmupDone(); 2438 Thread t = new Thread(() -> doNotify()); 2439 t.start(); 2440 } 2441 2442 public void doNotify() { 2443 while (objToNotifyOn == null) { 2444 try { 2445 msg("objToNotifyOn is still null"); 2446 Thread.sleep(100); 2447 } catch (InterruptedException e) { /* ignored */ } 2448 } 2449 synchronized (objToNotifyOn) { 2450 // will be received by the target main thread waiting in dontinline_waitWhenWarmupDone 2451 msg("calling objToNotifyOn.notifyAll()"); 2452 objToNotifyOn.notifyAll(); 2453 } 2454 } 2455 2456 @Override 2457 public boolean testFrameShouldBeDeoptimized() { 2458 return false; 2459 } 2460 2461 @Override 2462 public void dontinline_testMethod() throws Exception { 2463 ForLocking l0 = new ForLocking(); // will be scalar replaced; access triggers realloc/relock 2464 ForLocking l1 = new ForLocking(); 2465 synchronized (l0) { 2466 synchronized (l1) { 2467 testMethod_inlined(l1); 2468 } 2469 } 2470 } 2471 2472 public void testMethod_inlined(ForLocking l2) throws Exception { 2473 synchronized (l2) { // eliminated nested locking 2474 dontinline_waitWhenWarmupDone(l2); 2475 } 2476 } 2477 2478 public void dontinline_waitWhenWarmupDone(ForLocking l2) throws Exception { 2479 if (warmupDone) { 2480 l2.wait(); 2481 } 2482 } 2483 } 2484 2485 2486 ///////////////////////////////////////////////////////////////////////////// 2487 2488 /** 2489 * Test relocking eliminated @ValueBased object. 2490 */ 2491 class EARelockingValueBased extends EATestCaseBaseDebugger { 2492 2493 public void runTestCase() throws Exception { 2494 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2495 printStack(bpe.thread()); 2496 @SuppressWarnings("unused") 2497 ObjectReference o = getLocalRef(bpe.thread().frame(1), Integer.class.getName(), "l1"); 2498 } 2499 } 2500 2501 class EARelockingValueBasedTarget extends EATestCaseBaseTarget { 2502 2503 public void dontinline_testMethod() { 2504 Integer l1 = new Integer(255); 2505 synchronized (l1) { 2506 dontinline_brkpt(); 2507 } 2508 } 2509 } 2510 2511 ///////////////////////////////////////////////////////////////////////////// 2512 // 2513 // Test cases that require deoptimization even though neither locks 2514 // nor allocations are eliminated at the point where escape state is changed. 2515 // 2516 ///////////////////////////////////////////////////////////////////////////// 2517 2518 /** 2519 * Let xy be NoEscape whose allocation cannot be eliminated (simulated by 2520 * -XX:-EliminateAllocations). The holding compiled frame has to be deoptimized when debugger 2521 * accesses xy because afterwards locking on xy is omitted. 2522 * Note: there are no EA based optimizations at the escape point. 2523 */ 2524 class EADeoptFrameAfterReadLocalObject_01 extends EATestCaseBaseDebugger { 2525 2526 public void runTestCase() throws Exception { 2527 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2528 printStack(bpe.thread()); 2529 @SuppressWarnings("unused") 2530 ObjectReference xy = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "xy"); 2531 } 2532 } 2533 2534 class EADeoptFrameAfterReadLocalObject_01Target extends EATestCaseBaseTarget { 2535 2536 public void dontinline_testMethod() { 2537 XYVal xy = new XYVal(1, 1); 2538 dontinline_brkpt(); // Debugger reads xy, when there are no virtual objects or eliminated locks in scope 2539 synchronized (xy) { // Locking is eliminated. 2540 xy.x++; 2541 xy.y++; 2542 } 2543 } 2544 } 2545 2546 ///////////////////////////////////////////////////////////////////////////// 2547 2548 /** 2549 * Similar to {@link EADeoptFrameAfterReadLocalObject_01} with the difference that the debugger 2550 * reads xy from an inlined callee. So xy is NoEscape instead of ArgEscape. 2551 */ 2552 class EADeoptFrameAfterReadLocalObject_01BTarget extends EATestCaseBaseTarget { 2553 2554 @Override 2555 public void setUp() { 2556 super.setUp(); 2557 testMethodDepth = 2; 2558 } 2559 2560 public void dontinline_testMethod() { 2561 XYVal xy = new XYVal(1, 1); 2562 callee(xy); // Debugger acquires ref to xy from inlined callee 2563 // xy is NoEscape, nevertheless the object is not replaced 2564 // by scalars if running with -XX:-EliminateAllocations. 2565 // In that case there are no EA based optimizations were 2566 // the debugger reads the NoEscape object. 2567 synchronized (xy) { // Locking is eliminated. 2568 xy.x++; 2569 xy.y++; 2570 } 2571 } 2572 2573 public void callee(XYVal xy) { 2574 dontinline_brkpt(); // Debugger reads xy. 2575 // There are no virtual objects or eliminated locks. 2576 } 2577 } 2578 2579 class EADeoptFrameAfterReadLocalObject_01B extends EATestCaseBaseDebugger { 2580 2581 public void runTestCase() throws Exception { 2582 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2583 printStack(bpe.thread()); 2584 @SuppressWarnings("unused") 2585 ObjectReference xy = getLocalRef(bpe.thread().frame(1), "callee", "xy", XYVAL_NAME); 2586 } 2587 } 2588 2589 ///////////////////////////////////////////////////////////////////////////// 2590 2591 /** 2592 * Let xy be ArgEscape. The frame dontinline_testMethod() has to be deoptimized when debugger 2593 * acquires xy from dontinline_callee() because afterwards locking on xy is omitted. 2594 * Note: there are no EA based optimizations at the escape point. 2595 */ 2596 class EADeoptFrameAfterReadLocalObject_02 extends EATestCaseBaseDebugger { 2597 2598 public void runTestCase() throws Exception { 2599 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2600 printStack(bpe.thread()); 2601 @SuppressWarnings("unused") 2602 ObjectReference xy = getLocalRef(bpe.thread().frame(1), "dontinline_callee", "xy", XYVAL_NAME); 2603 } 2604 } 2605 2606 class EADeoptFrameAfterReadLocalObject_02Target extends EATestCaseBaseTarget { 2607 2608 public void dontinline_testMethod() { 2609 XYVal xy = new XYVal(1, 1); 2610 dontinline_callee(xy); // xy is ArgEscape, debugger acquires ref to xy from callee 2611 synchronized (xy) { // Locking is eliminated. 2612 xy.x++; 2613 xy.y++; 2614 } 2615 } 2616 2617 public void dontinline_callee(XYVal xy) { 2618 dontinline_brkpt(); // Debugger reads xy. 2619 // There are no virtual objects or eliminated locks. 2620 } 2621 2622 @Override 2623 public void setUp() { 2624 super.setUp(); 2625 testMethodDepth = 2; 2626 } 2627 2628 @Override 2629 public boolean testFrameShouldBeDeoptimized() { 2630 // Graal does not provide debug info about arg escape objects, therefore the frame is not deoptimized 2631 return !UseJVMCICompiler && super.testFrameShouldBeDeoptimized(); 2632 } 2633 } 2634 2635 ///////////////////////////////////////////////////////////////////////////// 2636 2637 /** 2638 * Similar to {@link EADeoptFrameAfterReadLocalObject_02} there is an ArgEscape object xy, but in 2639 * contrast it is not in the parameter list of a call when the debugger reads an object. 2640 * Therefore the frame of the test method should not be deoptimized 2641 */ 2642 class EADeoptFrameAfterReadLocalObject_02B extends EATestCaseBaseDebugger { 2643 2644 public void runTestCase() throws Exception { 2645 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2646 printStack(bpe.thread()); 2647 @SuppressWarnings("unused") 2648 ObjectReference xy = getLocalRef(bpe.thread().frame(1), "dontinline_callee", "xy", XYVAL_NAME); 2649 } 2650 } 2651 2652 class EADeoptFrameAfterReadLocalObject_02BTarget extends EATestCaseBaseTarget { 2653 2654 public void dontinline_testMethod() { 2655 XYVal xy = new XYVal(1, 1); 2656 dontinline_make_arg_escape(xy); // because of this call xy is ArgEscape 2657 dontinline_callee(); // xy is ArgEscape, but not a parameter of this call 2658 synchronized (xy) { // Locking is eliminated. 2659 xy.x++; 2660 xy.y++; 2661 } 2662 } 2663 2664 public void dontinline_callee() { 2665 @SuppressWarnings("unused") 2666 XYVal xy = new XYVal(2, 2); 2667 dontinline_brkpt(); // Debugger reads xy. 2668 // No need to deoptimize the caller frame 2669 } 2670 2671 @Override 2672 public void setUp() { 2673 super.setUp(); 2674 testMethodDepth = 2; 2675 } 2676 2677 @Override 2678 public boolean testFrameShouldBeDeoptimized() { 2679 return false; 2680 } 2681 } 2682 2683 ///////////////////////////////////////////////////////////////////////////// 2684 2685 /** 2686 * Similar to {@link EADeoptFrameAfterReadLocalObject_02} there is an ArgEscape object xy in 2687 * dontinline_testMethod() which is being passed as parameter when the debugger accesses a local object. 2688 * Nevertheless dontinline_testMethod must not be deoptimized because there is an entry frame 2689 * between it and the frame accessed by the debugger. 2690 */ 2691 class EADeoptFrameAfterReadLocalObject_02C extends EATestCaseBaseDebugger { 2692 2693 public void runTestCase() throws Exception { 2694 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2695 printStack(bpe.thread()); 2696 @SuppressWarnings("unused") 2697 ObjectReference xy = getLocalRef(bpe.thread().frame(1), "dontinline_callee_accessed_by_debugger", "xy", XYVAL_NAME); 2698 } 2699 } 2700 2701 class EADeoptFrameAfterReadLocalObject_02CTarget extends EATestCaseBaseTarget { 2702 2703 public void dontinline_testMethod() { 2704 XYVal xy = new XYVal(1, 1); 2705 dontinline_callee(xy); // xy is ArgEscape and being passed as parameter 2706 synchronized (xy) { // Locking is eliminated. 2707 xy.x++; 2708 xy.y++; 2709 } 2710 } 2711 2712 public void dontinline_callee(XYVal xy) { 2713 if (warmupDone) { 2714 dontinline_call_with_entry_frame(this, "dontinline_callee_accessed_by_debugger"); 2715 } 2716 } 2717 2718 public void dontinline_callee_accessed_by_debugger() { 2719 @SuppressWarnings("unused") 2720 XYVal xy = new XYVal(2, 2); 2721 dontinline_brkpt(); // Debugger reads xy. 2722 // No need to deoptimize the caller frame 2723 } 2724 2725 @Override 2726 public void setUp() { 2727 super.setUp(); 2728 testMethodDepth = 8; 2729 } 2730 2731 @Override 2732 public boolean testFrameShouldBeDeoptimized() { 2733 return false; 2734 } 2735 } 2736 2737 ///////////////////////////////////////////////////////////////////////////// 2738 2739 /** 2740 * Let xy be NoEscape whose allocation cannot be eliminated (e.g. because of 2741 * -XX:-EliminateAllocations). The holding compiled frame has to be deoptimized when debugger 2742 * accesses xy because the following field accesses get eliminated. Note: there are no EA based 2743 * optimizations at the escape point. 2744 */ 2745 class EADeoptFrameAfterReadLocalObject_03 extends EATestCaseBaseDebugger { 2746 2747 public void runTestCase() throws Exception { 2748 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2749 printStack(bpe.thread()); 2750 ObjectReference xy = getLocalRef(bpe.thread().frame(1), XYVAL_NAME, "xy"); 2751 setField(xy, "x", env.vm().mirrorOf(1)); 2752 } 2753 } 2754 2755 class EADeoptFrameAfterReadLocalObject_03Target extends EATestCaseBaseTarget { 2756 2757 public void dontinline_testMethod() { 2758 XYVal xy = new XYVal(0, 1); 2759 dontinline_brkpt(); // Debugger reads xy, when there are no virtual objects or 2760 // eliminated locks in scope and modifies xy.x 2761 iResult = xy.x + xy.y; // Loads are replaced by constants 0 and 1. 2762 } 2763 2764 @Override 2765 public int getExpectedIResult() { 2766 return 1 + 1; 2767 } 2768 } 2769 2770 ///////////////////////////////////////////////////////////////////////////// 2771 // 2772 // Monitor info tests 2773 // 2774 ///////////////////////////////////////////////////////////////////////////// 2775 2776 class EAGetOwnedMonitorsTarget extends EATestCaseBaseTarget { 2777 2778 public long checkSum; 2779 2780 public void dontinline_testMethod() { 2781 XYVal l1 = new XYVal(4, 2); 2782 synchronized (l1) { 2783 dontinline_endlessLoop(); 2784 } 2785 } 2786 2787 @Override 2788 public void setUp() { 2789 super.setUp(); 2790 testMethodDepth = 2; 2791 loopCount = 3; 2792 } 2793 2794 public void warmupDone() { 2795 super.warmupDone(); 2796 msg("enter 'endless' loop by setting loopCount = Long.MAX_VALUE"); 2797 loopCount = Long.MAX_VALUE; // endless loop 2798 } 2799 } 2800 2801 class EAGetOwnedMonitors extends EATestCaseBaseDebugger { 2802 2803 public void runTestCase() throws Exception { 2804 msg("resume"); 2805 env.vm().resume(); 2806 waitUntilTargetHasEnteredEndlessLoop(); 2807 // In contrast to JVMTI, JDWP requires a target thread to be suspended, before the owned monitors can be queried 2808 msg("suspend target"); 2809 env.targetMainThread.suspend(); 2810 msg("Get owned monitors"); 2811 List<ObjectReference> monitors = env.targetMainThread.ownedMonitors(); 2812 Asserts.assertEQ(monitors.size(), 1, "unexpected number of owned monitors"); 2813 terminateEndlessLoop(); 2814 } 2815 } 2816 2817 ///////////////////////////////////////////////////////////////////////////// 2818 2819 class EAEntryCountTarget extends EATestCaseBaseTarget { 2820 2821 public long checkSum; 2822 2823 public void dontinline_testMethod() { 2824 XYVal l1 = new XYVal(4, 2); 2825 synchronized (l1) { 2826 inline_testMethod2(l1); 2827 } 2828 } 2829 2830 public void inline_testMethod2(XYVal l1) { 2831 synchronized (l1) { 2832 dontinline_endlessLoop(); 2833 } 2834 } 2835 2836 @Override 2837 public void setUp() { 2838 super.setUp(); 2839 testMethodDepth = 2; 2840 loopCount = 3; 2841 } 2842 2843 public void warmupDone() { 2844 super.warmupDone(); 2845 msg("enter 'endless' loop by setting loopCount = Long.MAX_VALUE"); 2846 loopCount = Long.MAX_VALUE; // endless loop 2847 } 2848 } 2849 2850 class EAEntryCount extends EATestCaseBaseDebugger { 2851 2852 public void runTestCase() throws Exception { 2853 msg("resume"); 2854 env.vm().resume(); 2855 waitUntilTargetHasEnteredEndlessLoop(); 2856 // In contrast to JVMTI, JDWP requires a target thread to be suspended, before the owned monitors can be queried 2857 msg("suspend target"); 2858 env.targetMainThread.suspend(); 2859 msg("Get owned monitors"); 2860 List<ObjectReference> monitors = env.targetMainThread.ownedMonitors(); 2861 Asserts.assertEQ(monitors.size(), 1, "unexpected number of owned monitors"); 2862 msg("Get entry count"); 2863 int entryCount = monitors.get(0).entryCount(); 2864 Asserts.assertEQ(entryCount, 2, "wrong entry count"); 2865 terminateEndlessLoop(); 2866 } 2867 } 2868 2869 ///////////////////////////////////////////////////////////////////////////// 2870 // 2871 // PopFrame tests 2872 // 2873 ///////////////////////////////////////////////////////////////////////////// 2874 2875 /** 2876 * PopFrame into caller frame with scalar replaced objects. 2877 */ 2878 class EAPopFrameNotInlined extends EATestCaseBaseDebugger { 2879 2880 public void runTestCase() throws Exception { 2881 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2882 printStack(bpe.thread()); 2883 msg("PopFrame"); 2884 bpe.thread().popFrames(bpe.thread().frame(0)); 2885 msg("PopFrame DONE"); 2886 } 2887 2888 @Override 2889 public boolean shouldSkip() { 2890 // And Graal currently doesn't support PopFrame 2891 return super.shouldSkip() || env.targetVMOptions.UseJVMCICompiler; 2892 } 2893 } 2894 2895 class EAPopFrameNotInlinedTarget extends EATestCaseBaseTarget { 2896 2897 public void dontinline_testMethod() { 2898 XYVal xy = new XYVal(4, 2); 2899 dontinline_brkpt(); 2900 iResult = xy.x + xy.y; 2901 } 2902 2903 @Override 2904 public boolean testFrameShouldBeDeoptimized() { 2905 // Test is only performed after the frame pop. 2906 // Then dontinline_testMethod is interpreted. 2907 return false; 2908 } 2909 2910 @Override 2911 public int getExpectedIResult() { 2912 return 4 + 2; 2913 } 2914 2915 @Override 2916 public boolean shouldSkip() { 2917 // And Graal currently doesn't support PopFrame 2918 return super.shouldSkip() || UseJVMCICompiler; 2919 } 2920 } 2921 2922 ///////////////////////////////////////////////////////////////////////////// 2923 2924 /** 2925 * Pop frames into {@link EAPopFrameNotInlinedReallocFailureTarget#dontinline_testMethod()} which 2926 * holds scalar replaced objects. In preparation of the pop frame operations the vm eagerly 2927 * reallocates scalar replaced objects to avoid failures when actually popping the frames. We provoke 2928 * a reallocation failures and expect {@link VMOutOfMemoryException}. 2929 */ 2930 class EAPopFrameNotInlinedReallocFailure extends EATestCaseBaseDebugger { 2931 2932 public void runTestCase() throws Exception { 2933 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 2934 ThreadReference thread = bpe.thread(); 2935 printStack(thread); 2936 // frame[0]: EATestCaseBaseTarget.dontinline_brkpt() 2937 // frame[1]: EAPopFrameNotInlinedReallocFailureTarget.dontinline_consume_all_memory_brkpt() 2938 // frame[2]: EAPopFrameNotInlinedReallocFailureTarget.dontinline_testMethod() 2939 // frame[3]: EATestCaseBaseTarget.run() 2940 // frame[4]: EATestsTarget.main(java.lang.String[]) 2941 msg("PopFrame"); 2942 boolean coughtOom = false; 2943 try { 2944 // try to pop dontinline_consume_all_memory_brkpt 2945 thread.popFrames(thread.frame(1)); 2946 } catch (VMOutOfMemoryException oom) { 2947 // as expected 2948 msg("cought OOM"); 2949 coughtOom = true; 2950 } 2951 freeAllMemory(); 2952 // We succeeded to pop just one frame. When we continue, we will call dontinline_brkpt() again. 2953 Asserts.assertTrue(coughtOom, "PopFrame should have triggered an OOM exception in target"); 2954 String expectedTopFrame = "dontinline_consume_all_memory_brkpt"; 2955 Asserts.assertEQ(expectedTopFrame, thread.frame(0).location().method().name()); 2956 printStack(thread); 2957 } 2958 2959 @Override 2960 public boolean shouldSkip() { 2961 // OOMEs because of realloc failures with DeoptimizeObjectsALot are too random. 2962 // And Graal currently doesn't provide all information about non-escaping objects in debug info 2963 return super.shouldSkip() || 2964 !env.targetVMOptions.EliminateAllocations || 2965 // With ZGC the OOME is not always thrown as expected 2966 env.targetVMOptions.ZGCIsSelected || 2967 env.targetVMOptions.DeoptimizeObjectsALot || 2968 env.targetVMOptions.UseJVMCICompiler; 2969 } 2970 } 2971 2972 class EAPopFrameNotInlinedReallocFailureTarget extends EATestCaseBaseTarget { 2973 2974 public boolean doneAlready; 2975 2976 public void dontinline_testMethod() { 2977 long a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // scalar replaced 2978 Vector10 v = new Vector10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // scalar replaced 2979 dontinline_consume_all_memory_brkpt(); 2980 lResult = a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] 2981 + v.i0 + v.i1 + v.i2 + v.i3 + v.i4 + v.i5 + v.i6 + v.i7 + v.i8 + v.i9; 2982 } 2983 2984 public void dontinline_consume_all_memory_brkpt() { 2985 if (warmupDone && !doneAlready) { 2986 doneAlready = true; 2987 consumeAllMemory(); // provoke reallocation failure 2988 dontinline_brkpt(); 2989 } 2990 } 2991 2992 @Override 2993 public void setUp() { 2994 super.setUp(); 2995 testMethodDepth = 2; 2996 } 2997 2998 @Override 2999 public long getExpectedLResult() { 3000 long n = 10; 3001 return 2*n*(n+1)/2; 3002 } 3003 3004 @Override 3005 public boolean shouldSkip() { 3006 // OOMEs because of realloc failures with DeoptimizeObjectsALot are too random. 3007 // And Graal currently doesn't provide all information about non-escaping objects in debug info 3008 return super.shouldSkip() || 3009 !EliminateAllocations || 3010 // With ZGC the OOME is not always thrown as expected 3011 ZGCIsSelected || 3012 DeoptimizeObjectsALot || 3013 UseJVMCICompiler; 3014 } 3015 } 3016 3017 ///////////////////////////////////////////////////////////////////////////// 3018 3019 /** 3020 * Pop inlined top frame dropping into method with scalar replaced opjects. 3021 */ 3022 class EAPopInlinedMethodWithScalarReplacedObjectsReallocFailure extends EATestCaseBaseDebugger { 3023 3024 public void runTestCase() throws Exception { 3025 ThreadReference thread = env.targetMainThread; 3026 env.vm().resume(); 3027 waitUntilTargetHasEnteredEndlessLoop(); 3028 3029 thread.suspend(); 3030 printStack(thread); 3031 // frame[0]: EAPopInlinedMethodWithScalarReplacedObjectsReallocFailureTarget.inlinedCallForcedToReturn() 3032 // frame[1]: EAPopInlinedMethodWithScalarReplacedObjectsReallocFailureTarget.dontinline_testMethod() 3033 // frame[2]: EATestCaseBaseTarget.run() 3034 3035 msg("Pop Frames"); 3036 boolean coughtOom = false; 3037 try { 3038 thread.popFrames(thread.frame(0)); // Request pop frame of inlinedCallForcedToReturn() 3039 // reallocation is triggered here 3040 } catch (VMOutOfMemoryException oom) { 3041 // as expected 3042 msg("cought OOM"); 3043 coughtOom = true; 3044 } 3045 printStack(thread); 3046 // frame[0]: EAPopInlinedMethodWithScalarReplacedObjectsReallocFailureTarget.inlinedCallForcedToReturn() 3047 // frame[1]: EAPopInlinedMethodWithScalarReplacedObjectsReallocFailureTarget.dontinline_testMethod() 3048 // frame[2]: EATestCaseBaseTarget.run() 3049 3050 freeAllMemory(); 3051 setField(testCase, "loopCount", env.vm().mirrorOf(0)); // terminate loop 3052 Asserts.assertTrue(coughtOom, "PopFrame should have triggered an OOM exception in target"); 3053 String expectedTopFrame = "inlinedCallForcedToReturn"; 3054 Asserts.assertEQ(expectedTopFrame, thread.frame(0).location().method().name()); 3055 } 3056 3057 @Override 3058 public boolean shouldSkip() { 3059 // OOMEs because of realloc failures with DeoptimizeObjectsALot are too random. 3060 // And Graal currently doesn't provide all information about non-escaping objects in debug info 3061 return super.shouldSkip() || 3062 !env.targetVMOptions.EliminateAllocations || 3063 // With ZGC the OOME is not always thrown as expected 3064 env.targetVMOptions.ZGCIsSelected || 3065 env.targetVMOptions.DeoptimizeObjectsALot || 3066 env.targetVMOptions.UseJVMCICompiler; 3067 } 3068 } 3069 3070 class EAPopInlinedMethodWithScalarReplacedObjectsReallocFailureTarget extends EATestCaseBaseTarget { 3071 3072 public long checkSum; 3073 3074 public void dontinline_testMethod() { 3075 long a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // scalar replaced 3076 Vector10 v = new Vector10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // scalar replaced 3077 long l = inlinedCallForcedToReturn(); 3078 lResult = a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] 3079 + v.i0 + v.i1 + v.i2 + v.i3 + v.i4 + v.i5 + v.i6 + v.i7 + v.i8 + v.i9; 3080 } 3081 3082 public long inlinedCallForcedToReturn() { 3083 long cs = checkSum; 3084 dontinline_consumeAllMemory(); 3085 while (loopCount-- > 0) { 3086 targetIsInLoop = true; 3087 checkSum += checkSum % ++cs; 3088 } 3089 loopCount = 3; 3090 targetIsInLoop = false; 3091 return checkSum; 3092 } 3093 3094 public void dontinline_consumeAllMemory() { 3095 if (warmupDone && (loopCount > 3)) { 3096 consumeAllMemory(); 3097 } 3098 } 3099 3100 @Override 3101 public long getExpectedLResult() { 3102 long n = 10; 3103 return 2*n*(n+1)/2; 3104 } 3105 3106 @Override 3107 public void setUp() { 3108 super.setUp(); 3109 loopCount = 3; 3110 } 3111 3112 public void warmupDone() { 3113 super.warmupDone(); 3114 msg("enter 'endless' loop by setting loopCount = Long.MAX_VALUE"); 3115 loopCount = Long.MAX_VALUE; // endless loop 3116 } 3117 3118 @Override 3119 public boolean shouldSkip() { 3120 // OOMEs because of realloc failures with DeoptimizeObjectsALot are too random. 3121 // And Graal currently doesn't provide all information about non-escaping objects in debug info 3122 return super.shouldSkip() || 3123 !EliminateAllocations || 3124 // With ZGC the OOME is not always thrown as expected 3125 ZGCIsSelected || 3126 DeoptimizeObjectsALot || 3127 UseJVMCICompiler; 3128 } 3129 } 3130 3131 ///////////////////////////////////////////////////////////////////////////// 3132 // 3133 // ForceEarlyReturn tests 3134 // 3135 ///////////////////////////////////////////////////////////////////////////// 3136 3137 /** 3138 * ForceEarlyReturn into caller frame with scalar replaced objects. 3139 */ 3140 class EAForceEarlyReturnNotInlined extends EATestCaseBaseDebugger { 3141 3142 public void runTestCase() throws Exception { 3143 BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V"); 3144 ThreadReference thread = bpe.thread(); 3145 printStack(thread); 3146 // frame[0]: EATestCaseBaseTarget.dontinline_brkpt() 3147 // frame[1]: EATestCaseBaseTarget.dontinline_brkpt_iret() 3148 // frame[2]: EAForceEarlyReturnNotInlinedTarget.dontinline_testMethod() 3149 // frame[3]: EATestCaseBaseTarget.run() 3150 // frame[4]: EATestsTarget.main(java.lang.String[]) 3151 3152 msg("Step out"); 3153 env.stepOut(thread); // return from dontinline_brkpt 3154 printStack(thread); 3155 msg("ForceEarlyReturn"); 3156 thread.forceEarlyReturn(env.vm().mirrorOf(43)); // return from dontinline_brkpt_iret, 3157 // does not trigger reallocation in contrast to PopFrame 3158 msg("Step over line"); 3159 env.stepOverLine(thread); // reallocation is triggered here 3160 printStack(thread); 3161 msg("ForceEarlyReturn DONE"); 3162 } 3163 3164 @Override 3165 public boolean shouldSkip() { 3166 // Graal currently doesn't support Force Early Return 3167 return super.shouldSkip() || env.targetVMOptions.UseJVMCICompiler; 3168 } 3169 } 3170 3171 class EAForceEarlyReturnNotInlinedTarget extends EATestCaseBaseTarget { 3172 3173 public void dontinline_testMethod() { 3174 XYVal xy = new XYVal(4, 2); 3175 int i = dontinline_brkpt_iret(); 3176 iResult = xy.x + xy.y + i; 3177 } 3178 3179 @Override 3180 public int getExpectedIResult() { 3181 return 4 + 2 + 43; 3182 } 3183 3184 @Override 3185 public void setUp() { 3186 super.setUp(); 3187 testMethodDepth = 2; 3188 } 3189 3190 public boolean testFrameShouldBeDeoptimized() { 3191 return true; // because of stepping 3192 } 3193 3194 @Override 3195 public boolean shouldSkip() { 3196 // Graal currently doesn't support Force Early Return 3197 return super.shouldSkip() || UseJVMCICompiler; 3198 } 3199 } 3200 3201 ///////////////////////////////////////////////////////////////////////////// 3202 3203 /** 3204 * ForceEarlyReturn at safepoint in frame with scalar replaced objects. 3205 */ 3206 class EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjects extends EATestCaseBaseDebugger { 3207 3208 public void runTestCase() throws Exception { 3209 ThreadReference thread = env.targetMainThread; 3210 env.vm().resume(); 3211 waitUntilTargetHasEnteredEndlessLoop(); 3212 3213 thread.suspend(); 3214 printStack(thread); 3215 // frame[0]: EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsTarget.inlinedCallForcedToReturn() 3216 // frame[1]: EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsTarget.dontinline_testMethod() 3217 // frame[2]: EATestCaseBaseTarget.run() 3218 3219 msg("ForceEarlyReturn"); 3220 thread.forceEarlyReturn(env.vm().mirrorOf(43)); // Request force return 43 from inlinedCallForcedToReturn() 3221 // reallocation is triggered here 3222 msg("Step over instruction to do the forced return"); 3223 env.stepOverInstruction(thread); 3224 printStack(thread); 3225 msg("ForceEarlyReturn DONE"); 3226 } 3227 3228 @Override 3229 public boolean shouldSkip() { 3230 // Graal currently doesn't support Force Early Return 3231 return super.shouldSkip() || env.targetVMOptions.UseJVMCICompiler; 3232 } 3233 } 3234 3235 class EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsTarget extends EATestCaseBaseTarget { 3236 3237 public int checkSum; 3238 3239 public void dontinline_testMethod() { 3240 XYVal xy = new XYVal(4, 2); 3241 int i = inlinedCallForcedToReturn(); 3242 iResult = xy.x + xy.y + i; 3243 } 3244 3245 public int inlinedCallForcedToReturn() { // forced to return 43 3246 int i = checkSum; 3247 while (loopCount-- > 0) { 3248 targetIsInLoop = true; 3249 checkSum += checkSum % ++i; 3250 } 3251 loopCount = 3; 3252 targetIsInLoop = false; 3253 return checkSum; 3254 } 3255 3256 @Override 3257 public int getExpectedIResult() { 3258 return 4 + 2 + 43; 3259 } 3260 3261 @Override 3262 public void setUp() { 3263 super.setUp(); 3264 testMethodDepth = 2; 3265 loopCount = 3; 3266 } 3267 3268 public void warmupDone() { 3269 super.warmupDone(); 3270 msg("enter 'endless' loop by setting loopCount = Long.MAX_VALUE"); 3271 loopCount = Long.MAX_VALUE; // endless loop 3272 } 3273 3274 public boolean testFrameShouldBeDeoptimized() { 3275 return true; // because of stepping 3276 } 3277 3278 @Override 3279 public boolean shouldSkip() { 3280 // Graal currently doesn't support Force Early Return 3281 return super.shouldSkip() || UseJVMCICompiler; 3282 } 3283 } 3284 3285 ///////////////////////////////////////////////////////////////////////////// 3286 3287 /** 3288 * ForceEarlyReturn with reallocation failure. 3289 */ 3290 class EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsReallocFailure extends EATestCaseBaseDebugger { 3291 3292 public void runTestCase() throws Exception { 3293 ThreadReference thread = env.targetMainThread; 3294 env.vm().resume(); 3295 waitUntilTargetHasEnteredEndlessLoop(); 3296 3297 thread.suspend(); 3298 printStack(thread); 3299 // frame[0]: EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsReallocFailureTarget.inlinedCallForcedToReturn() 3300 // frame[1]: EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsReallocFailureTarget.dontinline_testMethod() 3301 // frame[2]: EATestCaseBaseTarget.run() 3302 3303 msg("ForceEarlyReturn"); 3304 boolean coughtOom = false; 3305 try { 3306 thread.forceEarlyReturn(env.vm().mirrorOf(43)); // Request force return 43 from inlinedCallForcedToReturn() 3307 // reallocation is triggered here 3308 } catch (VMOutOfMemoryException oom) { 3309 // as expected 3310 msg("cought OOM"); 3311 coughtOom = true; 3312 } 3313 freeAllMemory(); 3314 Asserts.assertTrue(coughtOom, "ForceEarlyReturn should have triggered an OOM exception in target"); 3315 printStack(thread); 3316 msg("ForceEarlyReturn(2)"); 3317 thread.forceEarlyReturn(env.vm().mirrorOf(43)); 3318 msg("Step over instruction to do the forced return"); 3319 env.stepOverInstruction(thread); 3320 printStack(thread); 3321 msg("ForceEarlyReturn DONE"); 3322 } 3323 3324 @Override 3325 public boolean shouldSkip() { 3326 // OOMEs because of realloc failures with DeoptimizeObjectsALot are too random. 3327 // And Graal currently doesn't support Force Early Return 3328 return super.shouldSkip() || 3329 !env.targetVMOptions.EliminateAllocations || 3330 // With ZGC the OOME is not always thrown as expected 3331 env.targetVMOptions.ZGCIsSelected || 3332 env.targetVMOptions.DeoptimizeObjectsALot || 3333 env.targetVMOptions.UseJVMCICompiler; 3334 } 3335 } 3336 3337 class EAForceEarlyReturnOfInlinedMethodWithScalarReplacedObjectsReallocFailureTarget extends EATestCaseBaseTarget { 3338 3339 public int checkSum; 3340 3341 public void dontinline_testMethod() { 3342 long a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // scalar replaced 3343 Vector10 v = new Vector10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // scalar replaced 3344 long l = inlinedCallForcedToReturn(); 3345 lResult = a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] 3346 + v.i0 + v.i1 + v.i2 + v.i3 + v.i4 + v.i5 + v.i6 + v.i7 + v.i8 + v.i9 + l; 3347 } 3348 3349 public long inlinedCallForcedToReturn() { // forced to return 43 3350 long cs = checkSum; 3351 dontinline_consumeAllMemory(); 3352 while (loopCount-- > 0) { 3353 targetIsInLoop = true; 3354 checkSum += checkSum % ++cs; 3355 } 3356 loopCount = 3; 3357 targetIsInLoop = false; 3358 return checkSum; 3359 } 3360 3361 public void dontinline_consumeAllMemory() { 3362 if (warmupDone) { 3363 consumeAllMemory(); 3364 } 3365 } 3366 3367 @Override 3368 public long getExpectedLResult() { 3369 long n = 10; 3370 return 2*n*(n+1)/2 + 43; 3371 } 3372 3373 @Override 3374 public void setUp() { 3375 super.setUp(); 3376 testMethodDepth = 2; 3377 loopCount = 3; 3378 } 3379 3380 public void warmupDone() { 3381 super.warmupDone(); 3382 msg("enter 'endless' loop by setting loopCount = Long.MAX_VALUE"); 3383 loopCount = Long.MAX_VALUE; // endless loop 3384 } 3385 3386 @Override 3387 public boolean shouldSkip() { 3388 // OOMEs because of realloc failures with DeoptimizeObjectsALot are too random. 3389 // And Graal currently doesn't support Force Early Return 3390 return super.shouldSkip() || 3391 !EliminateAllocations || 3392 // With ZGC the OOME is not always thrown as expected 3393 ZGCIsSelected || 3394 DeoptimizeObjectsALot || 3395 UseJVMCICompiler; 3396 } 3397 } 3398 3399 ///////////////////////////////////////////////////////////////////////////// 3400 // 3401 // Get Instances of ReferenceType 3402 // 3403 ///////////////////////////////////////////////////////////////////////////// 3404 3405 /** 3406 * Check if instances of a type are found even if they are scalar replaced. To stress the 3407 * implementation a little more, the instances should be retrieved while the target is running. 3408 */ 3409 class EAGetInstancesOfReferenceType extends EATestCaseBaseDebugger { 3410 3411 public void runTestCase() throws Exception { 3412 printStack(env.targetMainThread); 3413 ReferenceType cls = ((ClassObjectReference)getField(testCase, "cls")).reflectedType(); 3414 msg("reflected type is " + cls); 3415 msg("resume"); 3416 env.vm().resume(); 3417 waitUntilTargetHasEnteredEndlessLoop(); 3418 // do this while thread is running! 3419 msg("Retrieve instances of " + cls.name()); 3420 List<ObjectReference> instances = cls.instances(10); 3421 Asserts.assertEQ(instances.size(), 3, "unexpected number of instances of " + cls.name()); 3422 // invariant: main thread is suspended at the end of the test case 3423 msg("suspend"); 3424 env.targetMainThread.suspend(); 3425 terminateEndlessLoop(); 3426 } 3427 } 3428 3429 class EAGetInstancesOfReferenceTypeTarget extends EATestCaseBaseTarget { 3430 3431 public long checkSum; 3432 3433 public static Class<LocalXYVal> cls = LocalXYVal.class; 3434 3435 public static class LocalXYVal { 3436 public int x, y; 3437 3438 public LocalXYVal(int x, int y) { 3439 this.x = x; this.y = y; 3440 } 3441 } 3442 3443 @Override 3444 public void dontinline_testMethod() { 3445 LocalXYVal p1 = new LocalXYVal(4, 2); 3446 LocalXYVal p2 = new LocalXYVal(5, 3); 3447 LocalXYVal p3 = new LocalXYVal(6, 4); 3448 dontinline_endlessLoop(); 3449 iResult = p1.x+p1.y + p2.x+p2.y + p3.x+p3.y; 3450 } 3451 3452 @Override 3453 public int getExpectedIResult() { 3454 return 6+8+10; 3455 } 3456 3457 @Override 3458 public void setUp() { 3459 super.setUp(); 3460 testMethodDepth = 2; 3461 loopCount = 3; 3462 } 3463 3464 public void warmupDone() { 3465 super.warmupDone(); 3466 msg("enter 'endless' loop by setting loopCount = Long.MAX_VALUE"); 3467 loopCount = Long.MAX_VALUE; // endless loop 3468 } 3469 } 3470 3471 3472 // End of test case collection 3473 ///////////////////////////////////////////////////////////////////////////// 3474 3475 ///////////////////////////////////////////////////////////////////////////// 3476 // Helper classes 3477 class XYVal { 3478 3479 public int x, y; 3480 3481 public XYVal(int x, int y) { 3482 this.x = x; 3483 this.y = y; 3484 } 3485 3486 /** 3487 * Note that we don't use a sync block here because javac would generate an synthetic exception 3488 * handler for the synchronized block that catches Throwable E, unlocks and throws E 3489 * again. The throw bytecode causes the BCEscapeAnalyzer to set the escape state to GlobalEscape 3490 * (see comment on exception handlers in BCEscapeAnalyzer::iterate_blocks()) 3491 */ 3492 public synchronized void dontinline_sync_method(EATestCaseBaseTarget target) { 3493 target.dontinline_brkpt(); 3494 } 3495 3496 /** 3497 * Just like {@link #dontinline_sync_method(EATestCaseBaseTarget)} but without the call to 3498 * {@link EATestCaseBaseTarget#dontinline_brkpt()}. 3499 */ 3500 public synchronized void dontinline_sync_method_no_brkpt(EATestCaseBaseTarget target) { 3501 } 3502 } 3503 3504 class Vector10 { 3505 int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; 3506 public Vector10(int j0, int j1, int j2, int j3, int j4, int j5, int j6, int j7, int j8, int j9) { 3507 i0=j0; i1=j1; i2=j2; i3=j3; i4=j4; i5=j5; i6=j6; i7=j7; i8=j8; i9=j9; 3508 } 3509 } 3510 3511 class ILFDO { 3512 3513 public int i; 3514 public int i2; 3515 public long l; 3516 public long l2; 3517 public float f; 3518 public float f2; 3519 public double d; 3520 public double d2; 3521 public Long o; 3522 public Long o2; 3523 3524 public ILFDO(int i, 3525 int i2, 3526 long l, 3527 long l2, 3528 float f, 3529 float f2, 3530 double d, 3531 double d2, 3532 Long o, 3533 Long o2) { 3534 this.i = i; 3535 this.i2 = i2; 3536 this.l = l; 3537 this.l2 = l2; 3538 this.f = f; 3539 this.f2 = f2; 3540 this.d = d; 3541 this.d2 = d2; 3542 this.o = o; 3543 this.o2 = o2; 3544 } 3545 3546 } --- EOF ---