1 /* 2 * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 25 package org.graalvm.compiler.core.test; 26 27 import static java.lang.reflect.Modifier.isStatic; 28 import static jdk.vm.ci.runtime.JVMCICompiler.INVOCATION_ENTRY_BCI; 29 import static org.graalvm.compiler.nodes.ConstantNode.getConstantNodes; 30 import static org.graalvm.compiler.nodes.graphbuilderconf.InlineInvokePlugin.InlineInfo.DO_NOT_INLINE_NO_EXCEPTION; 31 import static org.graalvm.compiler.nodes.graphbuilderconf.InlineInvokePlugin.InlineInfo.DO_NOT_INLINE_WITH_EXCEPTION; 32 33 import java.lang.annotation.ElementType; 34 import java.lang.annotation.Retention; 35 import java.lang.annotation.RetentionPolicy; 36 import java.lang.annotation.Target; 37 import java.lang.reflect.Constructor; 38 import java.lang.reflect.Executable; 39 import java.lang.reflect.InvocationTargetException; 40 import java.lang.reflect.Method; 41 import java.util.ArrayList; 42 import java.util.Arrays; 43 import java.util.Collection; 44 import java.util.Collections; 45 import java.util.EnumMap; 46 import java.util.List; 47 import java.util.ListIterator; 48 import java.util.Map; 49 import java.util.Set; 50 import java.util.concurrent.ConcurrentHashMap; 51 import java.util.function.Supplier; 52 53 import org.graalvm.compiler.api.directives.GraalDirectives; 54 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider; 55 import org.graalvm.compiler.api.test.Graal; 56 import org.graalvm.compiler.code.CompilationResult; 57 import org.graalvm.compiler.core.CompilationPrinter; 58 import org.graalvm.compiler.core.GraalCompiler; 59 import org.graalvm.compiler.core.GraalCompiler.Request; 60 import org.graalvm.compiler.core.common.CompilationIdentifier; 61 import org.graalvm.compiler.core.common.type.StampFactory; 62 import org.graalvm.compiler.core.target.Backend; 63 import org.graalvm.compiler.debug.DebugContext; 64 import org.graalvm.compiler.debug.DebugDumpHandler; 65 import org.graalvm.compiler.debug.DebugDumpScope; 66 import org.graalvm.compiler.debug.DebugHandlersFactory; 67 import org.graalvm.compiler.debug.GraalError; 68 import org.graalvm.compiler.debug.TTY; 69 import org.graalvm.compiler.graph.Node; 70 import org.graalvm.compiler.graph.NodeClass; 71 import org.graalvm.compiler.graph.NodeMap; 72 import org.graalvm.compiler.java.BytecodeParser; 73 import org.graalvm.compiler.java.ComputeLoopFrequenciesClosure; 74 import org.graalvm.compiler.java.GraphBuilderPhase; 75 import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory; 76 import org.graalvm.compiler.lir.phases.LIRSuites; 77 import org.graalvm.compiler.nodeinfo.NodeInfo; 78 import org.graalvm.compiler.nodeinfo.NodeSize; 79 import org.graalvm.compiler.nodeinfo.Verbosity; 80 import org.graalvm.compiler.nodes.BreakpointNode; 81 import org.graalvm.compiler.nodes.Cancellable; 82 import org.graalvm.compiler.nodes.ConstantNode; 83 import org.graalvm.compiler.nodes.FixedWithNextNode; 84 import org.graalvm.compiler.nodes.FrameState; 85 import org.graalvm.compiler.nodes.FullInfopointNode; 86 import org.graalvm.compiler.nodes.Invoke; 87 import org.graalvm.compiler.nodes.InvokeNode; 88 import org.graalvm.compiler.nodes.InvokeWithExceptionNode; 89 import org.graalvm.compiler.nodes.ParameterNode; 90 import org.graalvm.compiler.nodes.ProxyNode; 91 import org.graalvm.compiler.nodes.ReturnNode; 92 import org.graalvm.compiler.nodes.StructuredGraph; 93 import org.graalvm.compiler.nodes.StructuredGraph.AllowAssumptions; 94 import org.graalvm.compiler.nodes.StructuredGraph.Builder; 95 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult; 96 import org.graalvm.compiler.nodes.ValueNode; 97 import org.graalvm.compiler.nodes.cfg.Block; 98 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration; 99 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; 100 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderContext; 101 import org.graalvm.compiler.nodes.graphbuilderconf.InlineInvokePlugin; 102 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin; 103 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins; 104 import org.graalvm.compiler.nodes.java.AccessFieldNode; 105 import org.graalvm.compiler.nodes.spi.LoweringProvider; 106 import org.graalvm.compiler.nodes.spi.Replacements; 107 import org.graalvm.compiler.nodes.virtual.VirtualObjectNode; 108 import org.graalvm.compiler.options.OptionValues; 109 import org.graalvm.compiler.phases.BasePhase; 110 import org.graalvm.compiler.phases.OptimisticOptimizations; 111 import org.graalvm.compiler.phases.Phase; 112 import org.graalvm.compiler.phases.PhaseSuite; 113 import org.graalvm.compiler.phases.common.CanonicalizerPhase; 114 import org.graalvm.compiler.loop.phases.ConvertDeoptimizeToGuardPhase; 115 import org.graalvm.compiler.phases.common.inlining.InliningPhase; 116 import org.graalvm.compiler.phases.common.inlining.info.InlineInfo; 117 import org.graalvm.compiler.phases.common.inlining.policy.GreedyInliningPolicy; 118 import org.graalvm.compiler.phases.schedule.SchedulePhase; 119 import org.graalvm.compiler.phases.schedule.SchedulePhase.SchedulingStrategy; 120 import org.graalvm.compiler.phases.tiers.HighTierContext; 121 import org.graalvm.compiler.phases.tiers.MidTierContext; 122 import org.graalvm.compiler.phases.tiers.Suites; 123 import org.graalvm.compiler.phases.tiers.TargetProvider; 124 import org.graalvm.compiler.phases.util.Providers; 125 import org.graalvm.compiler.printer.GraalDebugHandlersFactory; 126 import org.graalvm.compiler.runtime.RuntimeProvider; 127 import org.graalvm.compiler.test.AddExports; 128 import org.graalvm.compiler.test.GraalTest; 129 import org.graalvm.compiler.test.JLModule; 130 import org.junit.After; 131 import org.junit.Assert; 132 import org.junit.Test; 133 import org.junit.internal.AssumptionViolatedException; 134 135 import jdk.vm.ci.code.Architecture; 136 import jdk.vm.ci.code.BailoutException; 137 import jdk.vm.ci.code.CodeCacheProvider; 138 import jdk.vm.ci.code.InstalledCode; 139 import jdk.vm.ci.code.TargetDescription; 140 import jdk.vm.ci.meta.Assumptions.Assumption; 141 import jdk.vm.ci.meta.ConstantReflectionProvider; 142 import jdk.vm.ci.meta.DeoptimizationReason; 143 import jdk.vm.ci.meta.JavaConstant; 144 import jdk.vm.ci.meta.JavaKind; 145 import jdk.vm.ci.meta.JavaType; 146 import jdk.vm.ci.meta.MetaAccessProvider; 147 import jdk.vm.ci.meta.ProfilingInfo; 148 import jdk.vm.ci.meta.ResolvedJavaMethod; 149 import jdk.vm.ci.meta.ResolvedJavaType; 150 import jdk.vm.ci.meta.SpeculationLog; 151 152 /** 153 * Base class for Graal compiler unit tests. 154 * <p> 155 * White box tests for Graal compiler transformations use this pattern: 156 * <ol> 157 * <li>Create a graph by {@linkplain #parseEager parsing} a method.</li> 158 * <li>Manually modify the graph (e.g. replace a parameter node with a constant).</li> 159 * <li>Apply a transformation to the graph.</li> 160 * <li>Assert that the transformed graph is equal to an expected graph.</li> 161 * </ol> 162 * <p> 163 * See {@link InvokeHintsTest} as an example of a white box test. 164 * <p> 165 * Black box tests use the {@link #test(String, Object...)} or 166 * {@link #testN(int, String, Object...)} to execute some method in the interpreter and compare its 167 * result against that produced by a Graal compiled version of the method. 168 * <p> 169 * These tests will be run by the {@code mx unittest} command. 170 */ 171 @AddExports({"java.base/jdk.internal.org.objectweb.asm", "java.base/jdk.internal.org.objectweb.asm.tree"}) 172 public abstract class GraalCompilerTest extends GraalTest { 173 174 /** 175 * Gets the initial option values provided by the Graal runtime. These are option values 176 * typically parsed from the command line. 177 */ 178 public static OptionValues getInitialOptions() { 179 return Graal.getRequiredCapability(OptionValues.class); 180 } 181 182 private static final int BAILOUT_RETRY_LIMIT = 1; 183 private final Providers providers; 184 private final Backend backend; 185 186 /** 187 * Representative class for the {@code java.base} module. 188 */ 189 public static final Class<?> JAVA_BASE = Class.class; 190 191 /** 192 * Exports the package named {@code packageName} declared in {@code moduleMember}'s module to 193 * this object's module. This must be called before accessing packages that are no longer public 194 * as of JDK 9. 195 */ 196 protected final void exportPackage(Class<?> moduleMember, String packageName) { 197 if (!Java8OrEarlier) { 198 JLModule.exportPackageTo(moduleMember, packageName, getClass()); 199 } 200 } 201 202 /** 203 * Denotes a test method that must be inlined by the {@link BytecodeParser}. 204 */ 205 @Target({ElementType.METHOD, ElementType.CONSTRUCTOR}) 206 @Retention(RetentionPolicy.RUNTIME) 207 public @interface BytecodeParserForceInline { 208 } 209 210 /** 211 * Denotes a test method that must never be inlined by the {@link BytecodeParser}. 212 */ 213 @Retention(RetentionPolicy.RUNTIME) 214 @Target({ElementType.METHOD, ElementType.CONSTRUCTOR}) 215 public @interface BytecodeParserNeverInline { 216 /** 217 * Specifies if the call should be implemented with {@link InvokeWithExceptionNode} instead 218 * of {@link InvokeNode}. 219 */ 220 boolean invokeWithException() default false; 221 } 222 223 /** 224 * Can be overridden by unit tests to verify properties of the graph. 225 * 226 * @param graph the graph at the end of HighTier 227 */ 228 protected boolean checkHighTierGraph(StructuredGraph graph) { 229 return true; 230 } 231 232 /** 233 * Can be overridden by unit tests to verify properties of the graph. 234 * 235 * @param graph the graph at the end of MidTier 236 */ 237 protected boolean checkMidTierGraph(StructuredGraph graph) { 238 return true; 239 } 240 241 /** 242 * Can be overridden by unit tests to verify properties of the graph. 243 * 244 * @param graph the graph at the end of LowTier 245 */ 246 protected boolean checkLowTierGraph(StructuredGraph graph) { 247 return true; 248 } 249 250 protected static void breakpoint() { 251 } 252 253 @SuppressWarnings("unused") 254 protected static void breakpoint(int arg0) { 255 } 256 257 protected static void shouldBeOptimizedAway() { 258 } 259 260 protected Suites createSuites(OptionValues opts) { 261 Suites ret = backend.getSuites().getDefaultSuites(opts).copy(); 262 ListIterator<BasePhase<? super HighTierContext>> iter = ret.getHighTier().findPhase(ConvertDeoptimizeToGuardPhase.class, true); 263 if (iter == null) { 264 /* 265 * in the economy configuration, we don't have the ConvertDeoptimizeToGuard phase, so we 266 * just select the first CanonicalizerPhase in HighTier 267 */ 268 iter = ret.getHighTier().findPhase(CanonicalizerPhase.class); 269 } 270 iter.add(new Phase() { 271 272 @Override 273 protected void run(StructuredGraph graph) { 274 ComputeLoopFrequenciesClosure.compute(graph); 275 } 276 277 @Override 278 public float codeSizeIncrease() { 279 return NodeSize.IGNORE_SIZE_CONTRACT_FACTOR; 280 } 281 282 @Override 283 protected CharSequence getName() { 284 return "ComputeLoopFrequenciesPhase"; 285 } 286 }); 287 ret.getHighTier().appendPhase(new Phase() { 288 289 @Override 290 protected void run(StructuredGraph graph) { 291 assert checkHighTierGraph(graph) : "failed HighTier graph check"; 292 } 293 294 @Override 295 public float codeSizeIncrease() { 296 return NodeSize.IGNORE_SIZE_CONTRACT_FACTOR; 297 } 298 299 @Override 300 protected CharSequence getName() { 301 return "CheckGraphPhase"; 302 } 303 }); 304 ret.getMidTier().appendPhase(new Phase() { 305 306 @Override 307 protected void run(StructuredGraph graph) { 308 assert checkMidTierGraph(graph) : "failed MidTier graph check"; 309 } 310 311 @Override 312 public float codeSizeIncrease() { 313 return NodeSize.IGNORE_SIZE_CONTRACT_FACTOR; 314 } 315 316 @Override 317 protected CharSequence getName() { 318 return "CheckGraphPhase"; 319 } 320 }); 321 ret.getLowTier().appendPhase(new Phase() { 322 323 @Override 324 protected void run(StructuredGraph graph) { 325 assert checkLowTierGraph(graph) : "failed LowTier graph check"; 326 } 327 328 @Override 329 public float codeSizeIncrease() { 330 return NodeSize.IGNORE_SIZE_CONTRACT_FACTOR; 331 } 332 333 @Override 334 protected CharSequence getName() { 335 return "CheckGraphPhase"; 336 } 337 }); 338 return ret; 339 } 340 341 protected LIRSuites createLIRSuites(OptionValues opts) { 342 LIRSuites ret = backend.getSuites().getDefaultLIRSuites(opts).copy(); 343 return ret; 344 } 345 346 public GraalCompilerTest() { 347 this.backend = Graal.getRequiredCapability(RuntimeProvider.class).getHostBackend(); 348 this.providers = getBackend().getProviders(); 349 } 350 351 /** 352 * Set up a test for a non-default backend. The test should check (via {@link #getBackend()} ) 353 * whether the desired backend is available. 354 * 355 * @param arch the name of the desired backend architecture 356 */ 357 public GraalCompilerTest(Class<? extends Architecture> arch) { 358 RuntimeProvider runtime = Graal.getRequiredCapability(RuntimeProvider.class); 359 Backend b = runtime.getBackend(arch); 360 if (b != null) { 361 this.backend = b; 362 } else { 363 // Fall back to the default/host backend 364 this.backend = runtime.getHostBackend(); 365 } 366 this.providers = backend.getProviders(); 367 } 368 369 /** 370 * Set up a test for a non-default backend. 371 * 372 * @param backend the desired backend 373 */ 374 public GraalCompilerTest(Backend backend) { 375 this.backend = backend; 376 this.providers = backend.getProviders(); 377 } 378 379 @Override 380 @After 381 public void afterTest() { 382 if (invocationPluginExtensions != null) { 383 synchronized (this) { 384 if (invocationPluginExtensions != null) { 385 extendedInvocationPlugins.removeTestPlugins(invocationPluginExtensions); 386 extendedInvocationPlugins = null; 387 invocationPluginExtensions = null; 388 } 389 } 390 } 391 super.afterTest(); 392 } 393 394 /** 395 * Gets a {@link DebugContext} object corresponding to {@code options}, creating a new one if 396 * none currently exists. Debug contexts created by this method will have their 397 * {@link DebugDumpHandler}s closed in {@link #afterTest()}. 398 */ 399 protected DebugContext getDebugContext() { 400 return getDebugContext(getInitialOptions(), null, null); 401 } 402 403 @Override 404 protected Collection<DebugHandlersFactory> getDebugHandlersFactories() { 405 return Collections.singletonList(new GraalDebugHandlersFactory(getSnippetReflection())); 406 } 407 408 protected void assertEquals(StructuredGraph expected, StructuredGraph graph) { 409 assertEquals(expected, graph, false, true); 410 } 411 412 protected int countUnusedConstants(StructuredGraph graph) { 413 int total = 0; 414 for (ConstantNode node : getConstantNodes(graph)) { 415 if (node.hasNoUsages()) { 416 total++; 417 } 418 } 419 return total; 420 } 421 422 protected int getNodeCountExcludingUnusedConstants(StructuredGraph graph) { 423 return graph.getNodeCount() - countUnusedConstants(graph); 424 } 425 426 protected void assertEquals(StructuredGraph expected, StructuredGraph graph, boolean excludeVirtual, boolean checkConstants) { 427 String expectedString = getCanonicalGraphString(expected, excludeVirtual, checkConstants); 428 String actualString = getCanonicalGraphString(graph, excludeVirtual, checkConstants); 429 String mismatchString = compareGraphStrings(expected, expectedString, graph, actualString); 430 431 if (!excludeVirtual && getNodeCountExcludingUnusedConstants(expected) != getNodeCountExcludingUnusedConstants(graph)) { 432 expected.getDebug().dump(DebugContext.BASIC_LEVEL, expected, "Node count not matching - expected"); 433 graph.getDebug().dump(DebugContext.BASIC_LEVEL, graph, "Node count not matching - actual"); 434 Assert.fail("Graphs do not have the same number of nodes: " + expected.getNodeCount() + " vs. " + graph.getNodeCount() + "\n" + mismatchString); 435 } 436 if (!expectedString.equals(actualString)) { 437 expected.getDebug().dump(DebugContext.BASIC_LEVEL, expected, "mismatching graphs - expected"); 438 graph.getDebug().dump(DebugContext.BASIC_LEVEL, graph, "mismatching graphs - actual"); 439 Assert.fail(mismatchString); 440 } 441 } 442 443 private static String compareGraphStrings(StructuredGraph expectedGraph, String expectedString, StructuredGraph actualGraph, String actualString) { 444 if (!expectedString.equals(actualString)) { 445 String[] expectedLines = expectedString.split("\n"); 446 String[] actualLines = actualString.split("\n"); 447 int diffIndex = -1; 448 int limit = Math.min(actualLines.length, expectedLines.length); 449 String marker = " <<<"; 450 for (int i = 0; i < limit; i++) { 451 if (!expectedLines[i].equals(actualLines[i])) { 452 diffIndex = i; 453 break; 454 } 455 } 456 if (diffIndex == -1) { 457 // Prefix is the same so add some space after the prefix 458 diffIndex = limit; 459 if (actualLines.length == limit) { 460 actualLines = Arrays.copyOf(actualLines, limit + 1); 461 actualLines[diffIndex] = ""; 462 } else { 463 assert expectedLines.length == limit; 464 expectedLines = Arrays.copyOf(expectedLines, limit + 1); 465 expectedLines[diffIndex] = ""; 466 } 467 } 468 // Place a marker next to the first line that differs 469 expectedLines[diffIndex] = expectedLines[diffIndex] + marker; 470 actualLines[diffIndex] = actualLines[diffIndex] + marker; 471 String ediff = String.join("\n", expectedLines); 472 String adiff = String.join("\n", actualLines); 473 return "mismatch in graphs:\n========= expected (" + expectedGraph + ") =========\n" + ediff + "\n\n========= actual (" + actualGraph + ") =========\n" + adiff; 474 } else { 475 return "mismatch in graphs"; 476 } 477 } 478 479 protected void assertOptimizedAway(StructuredGraph g) { 480 Assert.assertEquals(0, g.getNodes().filter(NotOptimizedNode.class).count()); 481 } 482 483 protected void assertConstantReturn(StructuredGraph graph, int value) { 484 String graphString = getCanonicalGraphString(graph, false, true); 485 Assert.assertEquals("unexpected number of ReturnNodes: " + graphString, graph.getNodes(ReturnNode.TYPE).count(), 1); 486 ValueNode result = graph.getNodes(ReturnNode.TYPE).first().result(); 487 Assert.assertTrue("unexpected ReturnNode result node: " + graphString, result.isConstant()); 488 Assert.assertEquals("unexpected ReturnNode result kind: " + graphString, result.asJavaConstant().getJavaKind(), JavaKind.Int); 489 Assert.assertEquals("unexpected ReturnNode result: " + graphString, result.asJavaConstant().asInt(), value); 490 } 491 492 protected static String getCanonicalGraphString(StructuredGraph graph, boolean excludeVirtual, boolean checkConstants) { 493 SchedulePhase schedule = new SchedulePhase(SchedulingStrategy.EARLIEST); 494 schedule.apply(graph); 495 ScheduleResult scheduleResult = graph.getLastSchedule(); 496 497 NodeMap<Integer> canonicalId = graph.createNodeMap(); 498 int nextId = 0; 499 500 List<String> constantsLines = new ArrayList<>(); 501 502 StringBuilder result = new StringBuilder(); 503 for (Block block : scheduleResult.getCFG().getBlocks()) { 504 result.append("Block ").append(block).append(' '); 505 if (block == scheduleResult.getCFG().getStartBlock()) { 506 result.append("* "); 507 } 508 result.append("-> "); 509 for (Block succ : block.getSuccessors()) { 510 result.append(succ).append(' '); 511 } 512 result.append('\n'); 513 for (Node node : scheduleResult.getBlockToNodesMap().get(block)) { 514 if (node instanceof ValueNode && node.isAlive()) { 515 if (!excludeVirtual || !(node instanceof VirtualObjectNode || node instanceof ProxyNode || node instanceof FullInfopointNode || node instanceof ParameterNode)) { 516 if (node instanceof ConstantNode) { 517 String name = checkConstants ? node.toString(Verbosity.Name) : node.getClass().getSimpleName(); 518 if (excludeVirtual) { 519 constantsLines.add(name); 520 } else { 521 constantsLines.add(name + " (" + filteredUsageCount(node) + ")"); 522 } 523 } else { 524 int id; 525 if (canonicalId.get(node) != null) { 526 id = canonicalId.get(node); 527 } else { 528 id = nextId++; 529 canonicalId.set(node, id); 530 } 531 String name = node.getClass().getSimpleName(); 532 result.append(" ").append(id).append('|').append(name); 533 if (node instanceof AccessFieldNode) { 534 result.append('#'); 535 result.append(((AccessFieldNode) node).field()); 536 } 537 if (!excludeVirtual) { 538 result.append(" ("); 539 result.append(filteredUsageCount(node)); 540 result.append(')'); 541 } 542 result.append('\n'); 543 } 544 } 545 } 546 } 547 } 548 549 StringBuilder constantsLinesResult = new StringBuilder(); 550 constantsLinesResult.append(constantsLines.size()).append(" constants:\n"); 551 Collections.sort(constantsLines); 552 for (String s : constantsLines) { 553 constantsLinesResult.append(s); 554 constantsLinesResult.append('\n'); 555 } 556 557 return constantsLinesResult.toString() + result.toString(); 558 } 559 560 /** 561 * @return usage count excluding {@link FrameState} usages 562 */ 563 private static int filteredUsageCount(Node node) { 564 return node.usages().filter(n -> !(n instanceof FrameState)).count(); 565 } 566 567 /** 568 * @param graph 569 * @return a scheduled textual dump of {@code graph} . 570 */ 571 protected static String getScheduledGraphString(StructuredGraph graph) { 572 SchedulePhase schedule = new SchedulePhase(SchedulingStrategy.EARLIEST_WITH_GUARD_ORDER); 573 schedule.apply(graph); 574 ScheduleResult scheduleResult = graph.getLastSchedule(); 575 576 StringBuilder result = new StringBuilder(); 577 Block[] blocks = scheduleResult.getCFG().getBlocks(); 578 for (Block block : blocks) { 579 result.append("Block ").append(block).append(' '); 580 if (block == scheduleResult.getCFG().getStartBlock()) { 581 result.append("* "); 582 } 583 result.append("-> "); 584 for (Block succ : block.getSuccessors()) { 585 result.append(succ).append(' '); 586 } 587 result.append('\n'); 588 for (Node node : scheduleResult.getBlockToNodesMap().get(block)) { 589 result.append(String.format("%1S\n", node)); 590 } 591 } 592 return result.toString(); 593 } 594 595 protected Backend getBackend() { 596 return backend; 597 } 598 599 protected final Providers getProviders() { 600 return providers; 601 } 602 603 protected HighTierContext getDefaultHighTierContext() { 604 return new HighTierContext(getProviders(), getDefaultGraphBuilderSuite(), getOptimisticOptimizations()); 605 } 606 607 protected MidTierContext getDefaultMidTierContext() { 608 return new MidTierContext(getProviders(), getTargetProvider(), getOptimisticOptimizations(), null); 609 } 610 611 protected SnippetReflectionProvider getSnippetReflection() { 612 return Graal.getRequiredCapability(SnippetReflectionProvider.class); 613 } 614 615 protected TargetDescription getTarget() { 616 return getTargetProvider().getTarget(); 617 } 618 619 protected TargetProvider getTargetProvider() { 620 return getBackend(); 621 } 622 623 protected CodeCacheProvider getCodeCache() { 624 return getProviders().getCodeCache(); 625 } 626 627 protected ConstantReflectionProvider getConstantReflection() { 628 return getProviders().getConstantReflection(); 629 } 630 631 protected MetaAccessProvider getMetaAccess() { 632 return getProviders().getMetaAccess(); 633 } 634 635 protected LoweringProvider getLowerer() { 636 return getProviders().getLowerer(); 637 } 638 639 protected final BasePhase<HighTierContext> createInliningPhase() { 640 return createInliningPhase(new CanonicalizerPhase()); 641 } 642 643 protected BasePhase<HighTierContext> createInliningPhase(CanonicalizerPhase canonicalizer) { 644 return createInliningPhase(null, canonicalizer); 645 } 646 647 static class GreedyTestInliningPolicy extends GreedyInliningPolicy { 648 GreedyTestInliningPolicy(Map<Invoke, Double> hints) { 649 super(hints); 650 } 651 652 @Override 653 protected int previousLowLevelGraphSize(InlineInfo info) { 654 // Ignore previous compiles for tests 655 return 0; 656 } 657 } 658 659 protected BasePhase<HighTierContext> createInliningPhase(Map<Invoke, Double> hints, CanonicalizerPhase canonicalizer) { 660 return new InliningPhase(new GreedyTestInliningPolicy(hints), canonicalizer); 661 } 662 663 protected CompilationIdentifier getCompilationId(ResolvedJavaMethod method) { 664 return getBackend().getCompilationIdentifier(method); 665 } 666 667 protected CompilationIdentifier getOrCreateCompilationId(final ResolvedJavaMethod installedCodeOwner, StructuredGraph graph) { 668 if (graph != null) { 669 return graph.compilationId(); 670 } 671 return getCompilationId(installedCodeOwner); 672 } 673 674 protected void testN(int n, final String name, final Object... args) { 675 final List<Throwable> errors = new ArrayList<>(n); 676 Thread[] threads = new Thread[n]; 677 for (int i = 0; i < n; i++) { 678 Thread t = new Thread(i + ":" + name) { 679 680 @Override 681 public void run() { 682 try { 683 test(name, args); 684 } catch (Throwable e) { 685 errors.add(e); 686 } 687 } 688 }; 689 threads[i] = t; 690 t.start(); 691 } 692 for (int i = 0; i < n; i++) { 693 try { 694 threads[i].join(); 695 } catch (InterruptedException e) { 696 errors.add(e); 697 } 698 } 699 if (!errors.isEmpty()) { 700 throw new MultiCauseAssertionError(errors.size() + " failures", errors.toArray(new Throwable[errors.size()])); 701 } 702 } 703 704 protected Object referenceInvoke(ResolvedJavaMethod method, Object receiver, Object... args) 705 throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException { 706 return invoke(method, receiver, args); 707 } 708 709 public static class Result { 710 711 public final Object returnValue; 712 public final Throwable exception; 713 714 public Result(Object returnValue, Throwable exception) { 715 this.returnValue = returnValue; 716 this.exception = exception; 717 } 718 719 @Override 720 public String toString() { 721 return exception == null ? returnValue == null ? "null" : returnValue.toString() : "!" + exception; 722 } 723 } 724 725 /** 726 * Called before a test is executed. 727 */ 728 protected void before(@SuppressWarnings("unused") ResolvedJavaMethod method) { 729 } 730 731 /** 732 * Called after a test is executed. 733 */ 734 protected void after() { 735 } 736 737 protected Result executeExpected(ResolvedJavaMethod method, Object receiver, Object... args) { 738 before(method); 739 try { 740 // This gives us both the expected return value as well as ensuring that the method to 741 // be compiled is fully resolved 742 return new Result(referenceInvoke(method, receiver, args), null); 743 } catch (InvocationTargetException e) { 744 return new Result(null, e.getTargetException()); 745 } catch (Exception e) { 746 throw new RuntimeException(e); 747 } finally { 748 after(); 749 } 750 } 751 752 protected Result executeActual(ResolvedJavaMethod method, Object receiver, Object... args) { 753 return executeActual(getInitialOptions(), method, receiver, args); 754 } 755 756 protected Result executeActual(OptionValues options, ResolvedJavaMethod method, Object receiver, Object... args) { 757 before(method); 758 Object[] executeArgs = argsWithReceiver(receiver, args); 759 760 checkArgs(method, executeArgs); 761 762 InstalledCode compiledMethod = getCode(method, options); 763 try { 764 return new Result(compiledMethod.executeVarargs(executeArgs), null); 765 } catch (Throwable e) { 766 return new Result(null, e); 767 } finally { 768 after(); 769 } 770 } 771 772 protected void checkArgs(ResolvedJavaMethod method, Object[] args) { 773 JavaType[] sig = method.toParameterTypes(); 774 Assert.assertEquals(sig.length, args.length); 775 for (int i = 0; i < args.length; i++) { 776 JavaType javaType = sig[i]; 777 JavaKind kind = javaType.getJavaKind(); 778 Object arg = args[i]; 779 if (kind == JavaKind.Object) { 780 if (arg != null && javaType instanceof ResolvedJavaType) { 781 ResolvedJavaType resolvedJavaType = (ResolvedJavaType) javaType; 782 Assert.assertTrue(resolvedJavaType + " from " + getMetaAccess().lookupJavaType(arg.getClass()), resolvedJavaType.isAssignableFrom(getMetaAccess().lookupJavaType(arg.getClass()))); 783 } 784 } else { 785 Assert.assertNotNull(arg); 786 Assert.assertEquals(kind.toBoxedJavaClass(), arg.getClass()); 787 } 788 } 789 } 790 791 /** 792 * Prepends a non-null receiver argument to a given list or args. 793 * 794 * @param receiver the receiver argument to prepend if it is non-null 795 */ 796 protected Object[] argsWithReceiver(Object receiver, Object... args) { 797 Object[] executeArgs; 798 if (receiver == null) { 799 executeArgs = args; 800 } else { 801 executeArgs = new Object[args.length + 1]; 802 executeArgs[0] = receiver; 803 for (int i = 0; i < args.length; i++) { 804 executeArgs[i + 1] = args[i]; 805 } 806 } 807 return applyArgSuppliers(executeArgs); 808 } 809 810 protected final Result test(String name, Object... args) { 811 return test(getInitialOptions(), name, args); 812 } 813 814 protected final Result test(OptionValues options, String name, Object... args) { 815 try { 816 ResolvedJavaMethod method = getResolvedJavaMethod(name); 817 Object receiver = method.isStatic() ? null : this; 818 return test(options, method, receiver, args); 819 } catch (AssumptionViolatedException e) { 820 // Suppress so that subsequent calls to this method within the 821 // same Junit @Test annotated method can proceed. 822 return null; 823 } 824 } 825 826 /** 827 * Type denoting a lambda that supplies a fresh value each time it is called. This is useful 828 * when supplying an argument to {@link GraalCompilerTest#test(String, Object...)} where the 829 * test modifies the state of the argument (e.g., updates a field). 830 */ 831 @FunctionalInterface 832 public interface ArgSupplier extends Supplier<Object> { 833 } 834 835 /** 836 * Convenience method for using an {@link ArgSupplier} lambda in a varargs list. 837 */ 838 public static Object supply(ArgSupplier supplier) { 839 return supplier; 840 } 841 842 protected Result test(ResolvedJavaMethod method, Object receiver, Object... args) { 843 return test(getInitialOptions(), method, receiver, args); 844 } 845 846 protected Result test(OptionValues options, ResolvedJavaMethod method, Object receiver, Object... args) { 847 Result expect = executeExpected(method, receiver, args); 848 if (getCodeCache() != null) { 849 testAgainstExpected(options, method, expect, receiver, args); 850 } 851 return expect; 852 } 853 854 /** 855 * Process a given set of arguments, converting any {@link ArgSupplier} argument to the argument 856 * it supplies. 857 */ 858 protected Object[] applyArgSuppliers(Object... args) { 859 Object[] res = args; 860 for (int i = 0; i < args.length; i++) { 861 if (args[i] instanceof ArgSupplier) { 862 if (res == args) { 863 res = args.clone(); 864 } 865 res[i] = ((ArgSupplier) args[i]).get(); 866 } 867 } 868 return res; 869 } 870 871 protected final void testAgainstExpected(ResolvedJavaMethod method, Result expect, Object receiver, Object... args) { 872 testAgainstExpected(getInitialOptions(), method, expect, Collections.<DeoptimizationReason> emptySet(), receiver, args); 873 } 874 875 protected void testAgainstExpected(ResolvedJavaMethod method, Result expect, Set<DeoptimizationReason> shouldNotDeopt, Object receiver, Object... args) { 876 testAgainstExpected(getInitialOptions(), method, expect, shouldNotDeopt, receiver, args); 877 } 878 879 protected final void testAgainstExpected(OptionValues options, ResolvedJavaMethod method, Result expect, Object receiver, Object... args) { 880 testAgainstExpected(options, method, expect, Collections.<DeoptimizationReason> emptySet(), receiver, args); 881 } 882 883 protected void testAgainstExpected(OptionValues options, ResolvedJavaMethod method, Result expect, Set<DeoptimizationReason> shouldNotDeopt, Object receiver, Object... args) { 884 Result actual = executeActualCheckDeopt(options, method, shouldNotDeopt, receiver, args); 885 assertEquals(expect, actual); 886 } 887 888 protected Result executeActualCheckDeopt(OptionValues options, ResolvedJavaMethod method, Set<DeoptimizationReason> shouldNotDeopt, Object receiver, Object... args) { 889 Map<DeoptimizationReason, Integer> deoptCounts = new EnumMap<>(DeoptimizationReason.class); 890 ProfilingInfo profile = method.getProfilingInfo(); 891 for (DeoptimizationReason reason : shouldNotDeopt) { 892 deoptCounts.put(reason, profile.getDeoptimizationCount(reason)); 893 } 894 Result actual = executeActual(options, method, receiver, args); 895 profile = method.getProfilingInfo(); // profile can change after execution 896 for (DeoptimizationReason reason : shouldNotDeopt) { 897 Assert.assertEquals("wrong number of deopt counts for " + reason, (int) deoptCounts.get(reason), profile.getDeoptimizationCount(reason)); 898 } 899 return actual; 900 } 901 902 private static final List<Class<?>> C2_OMIT_STACK_TRACE_IN_FAST_THROW_EXCEPTIONS = Arrays.asList( 903 ArithmeticException.class, 904 ArrayIndexOutOfBoundsException.class, 905 ArrayStoreException.class, 906 ClassCastException.class, 907 NullPointerException.class); 908 909 protected void assertEquals(Result expect, Result actual) { 910 if (expect.exception != null) { 911 Assert.assertTrue("expected " + expect.exception, actual.exception != null); 912 Assert.assertEquals("Exception class", expect.exception.getClass(), actual.exception.getClass()); 913 // C2 can optimize out the stack trace and message in some cases 914 if (expect.exception.getMessage() != null || !C2_OMIT_STACK_TRACE_IN_FAST_THROW_EXCEPTIONS.contains(expect.exception.getClass())) { 915 Assert.assertEquals("Exception message", expect.exception.getMessage(), actual.exception.getMessage()); 916 } 917 } else { 918 if (actual.exception != null) { 919 throw new AssertionError("expected " + expect.returnValue + " but got an exception", actual.exception); 920 } 921 assertDeepEquals(expect.returnValue, actual.returnValue); 922 } 923 } 924 925 private Map<ResolvedJavaMethod, InstalledCode> cache = new ConcurrentHashMap<>(); 926 927 /** 928 * Gets installed code for a given method, compiling it first if necessary. The graph is parsed 929 * {@link #parseEager eagerly}. 930 */ 931 protected final InstalledCode getCode(ResolvedJavaMethod method) { 932 return getCode(method, null, false, false, getInitialOptions()); 933 } 934 935 protected final InstalledCode getCode(ResolvedJavaMethod method, OptionValues options) { 936 return getCode(method, null, false, false, options); 937 } 938 939 /** 940 * Gets installed code for a given method, compiling it first if necessary. 941 * 942 * @param installedCodeOwner the method the compiled code will be associated with when installed 943 * @param graph the graph to be compiled. If null, a graph will be obtained from 944 * {@code installedCodeOwner} via {@link #parseForCompile(ResolvedJavaMethod)}. 945 */ 946 protected final InstalledCode getCode(ResolvedJavaMethod installedCodeOwner, StructuredGraph graph) { 947 return getCode(installedCodeOwner, graph, false, false, graph == null ? getInitialOptions() : graph.getOptions()); 948 } 949 950 /** 951 * Gets installed code for a given method and graph, compiling it first if necessary. 952 * 953 * @param installedCodeOwner the method the compiled code will be associated with when installed 954 * @param graph the graph to be compiled. If null, a graph will be obtained from 955 * {@code installedCodeOwner} via {@link #parseForCompile(ResolvedJavaMethod)}. 956 * @param forceCompile specifies whether to ignore any previous code cached for the (method, 957 * key) pair 958 */ 959 protected final InstalledCode getCode(final ResolvedJavaMethod installedCodeOwner, StructuredGraph graph, boolean forceCompile) { 960 return getCode(installedCodeOwner, graph, forceCompile, false, graph == null ? getInitialOptions() : graph.getOptions()); 961 } 962 963 /** 964 * Gets installed code for a given method and graph, compiling it first if necessary. 965 * 966 * @param installedCodeOwner the method the compiled code will be associated with when installed 967 * @param graph the graph to be compiled. If null, a graph will be obtained from 968 * {@code installedCodeOwner} via {@link #parseForCompile(ResolvedJavaMethod)}. 969 * @param forceCompile specifies whether to ignore any previous code cached for the (method, 970 * key) pair 971 * @param installAsDefault specifies whether to install as the default implementation 972 * @param options the options that will be used in {@link #parseForCompile(ResolvedJavaMethod)} 973 */ 974 @SuppressWarnings("try") 975 protected InstalledCode getCode(final ResolvedJavaMethod installedCodeOwner, StructuredGraph graph, boolean forceCompile, boolean installAsDefault, OptionValues options) { 976 boolean useCache = !forceCompile && getArgumentToBind() == null; 977 if (useCache && graph == null) { 978 InstalledCode cached = cache.get(installedCodeOwner); 979 if (cached != null) { 980 if (cached.isValid()) { 981 return cached; 982 } 983 } 984 } 985 // loop for retrying compilation 986 for (int retry = 0; retry <= BAILOUT_RETRY_LIMIT; retry++) { 987 final CompilationIdentifier id = getOrCreateCompilationId(installedCodeOwner, graph); 988 989 InstalledCode installedCode = null; 990 StructuredGraph graphToCompile = graph == null ? parseForCompile(installedCodeOwner, id, options) : graph; 991 DebugContext debug = graphToCompile.getDebug(); 992 993 try (AllocSpy spy = AllocSpy.open(installedCodeOwner); DebugContext.Scope ds = debug.scope("Compiling", new DebugDumpScope(id.toString(CompilationIdentifier.Verbosity.ID), true))) { 994 CompilationPrinter printer = CompilationPrinter.begin(options, id, installedCodeOwner, INVOCATION_ENTRY_BCI); 995 CompilationResult compResult = compile(installedCodeOwner, graphToCompile, new CompilationResult(graphToCompile.compilationId()), id, options); 996 printer.finish(compResult); 997 998 try (DebugContext.Scope s = debug.scope("CodeInstall", getCodeCache(), installedCodeOwner, compResult); 999 DebugContext.Activation a = debug.activate()) { 1000 try { 1001 if (installAsDefault) { 1002 installedCode = addDefaultMethod(debug, installedCodeOwner, compResult); 1003 } else { 1004 installedCode = addMethod(debug, installedCodeOwner, compResult); 1005 } 1006 if (installedCode == null) { 1007 throw new GraalError("Could not install code for " + installedCodeOwner.format("%H.%n(%p)")); 1008 } 1009 } catch (BailoutException e) { 1010 if (retry < BAILOUT_RETRY_LIMIT && graph == null && !e.isPermanent()) { 1011 // retry (if there is no predefined graph) 1012 TTY.println(String.format("Restart compilation %s (%s) due to a non-permanent bailout!", installedCodeOwner, id)); 1013 continue; 1014 } 1015 throw e; 1016 } 1017 } catch (Throwable e) { 1018 throw debug.handle(e); 1019 } 1020 } catch (Throwable e) { 1021 throw debug.handle(e); 1022 } 1023 1024 if (useCache) { 1025 cache.put(installedCodeOwner, installedCode); 1026 } 1027 return installedCode; 1028 } 1029 throw GraalError.shouldNotReachHere(); 1030 } 1031 1032 /** 1033 * Used to produce a graph for a method about to be compiled by 1034 * {@link #compile(ResolvedJavaMethod, StructuredGraph)} if the second parameter to that method 1035 * is null. 1036 * 1037 * The default implementation in {@link GraalCompilerTest} is to call {@link #parseEager}. 1038 */ 1039 protected StructuredGraph parseForCompile(ResolvedJavaMethod method, OptionValues options) { 1040 return parseEager(method, AllowAssumptions.YES, getCompilationId(method), options); 1041 } 1042 1043 protected final StructuredGraph parseForCompile(ResolvedJavaMethod method, DebugContext debug) { 1044 return parseEager(method, AllowAssumptions.YES, debug); 1045 } 1046 1047 protected final StructuredGraph parseForCompile(ResolvedJavaMethod method) { 1048 return parseEager(method, AllowAssumptions.YES, getCompilationId(method), getInitialOptions()); 1049 } 1050 1051 protected StructuredGraph parseForCompile(ResolvedJavaMethod method, CompilationIdentifier compilationId, OptionValues options) { 1052 return parseEager(method, AllowAssumptions.YES, compilationId, options); 1053 } 1054 1055 /** 1056 * Compiles a given method. 1057 * 1058 * @param installedCodeOwner the method the compiled code will be associated with when installed 1059 * @param graph the graph to be compiled for {@code installedCodeOwner}. If null, a graph will 1060 * be obtained from {@code installedCodeOwner} via 1061 * {@link #parseForCompile(ResolvedJavaMethod)}. 1062 */ 1063 protected final CompilationResult compile(ResolvedJavaMethod installedCodeOwner, StructuredGraph graph) { 1064 OptionValues options = graph == null ? getInitialOptions() : graph.getOptions(); 1065 CompilationIdentifier compilationId = getOrCreateCompilationId(installedCodeOwner, graph); 1066 return compile(installedCodeOwner, graph, new CompilationResult(compilationId), compilationId, options); 1067 } 1068 1069 protected final CompilationResult compile(ResolvedJavaMethod installedCodeOwner, StructuredGraph graph, CompilationIdentifier compilationId) { 1070 OptionValues options = graph == null ? getInitialOptions() : graph.getOptions(); 1071 return compile(installedCodeOwner, graph, new CompilationResult(compilationId), compilationId, options); 1072 } 1073 1074 protected final CompilationResult compile(ResolvedJavaMethod installedCodeOwner, StructuredGraph graph, OptionValues options) { 1075 assert graph == null || graph.getOptions() == options; 1076 CompilationIdentifier compilationId = getOrCreateCompilationId(installedCodeOwner, graph); 1077 return compile(installedCodeOwner, graph, new CompilationResult(compilationId), compilationId, options); 1078 } 1079 1080 protected OptimisticOptimizations getOptimisticOptimizations() { 1081 return OptimisticOptimizations.ALL; 1082 } 1083 1084 /** 1085 * Compiles a given method. 1086 * 1087 * @param installedCodeOwner the method the compiled code will be associated with when installed 1088 * @param graph the graph to be compiled for {@code installedCodeOwner}. If null, a graph will 1089 * be obtained from {@code installedCodeOwner} via 1090 * {@link #parseForCompile(ResolvedJavaMethod)}. 1091 * @param compilationId 1092 */ 1093 @SuppressWarnings("try") 1094 protected CompilationResult compile(ResolvedJavaMethod installedCodeOwner, StructuredGraph graph, CompilationResult compilationResult, CompilationIdentifier compilationId, OptionValues options) { 1095 StructuredGraph graphToCompile = graph == null ? parseForCompile(installedCodeOwner, compilationId, options) : graph; 1096 lastCompiledGraph = graphToCompile; 1097 DebugContext debug = graphToCompile.getDebug(); 1098 try (DebugContext.Scope s = debug.scope("Compile", graphToCompile)) { 1099 assert options != null; 1100 Request<CompilationResult> request = new Request<>(graphToCompile, installedCodeOwner, getProviders(), getBackend(), getDefaultGraphBuilderSuite(), getOptimisticOptimizations(), 1101 graphToCompile.getProfilingInfo(), createSuites(options), createLIRSuites(options), compilationResult, CompilationResultBuilderFactory.Default, true); 1102 return GraalCompiler.compile(request); 1103 } catch (Throwable e) { 1104 throw debug.handle(e); 1105 } 1106 } 1107 1108 protected StructuredGraph getFinalGraph(String method) { 1109 return getFinalGraph(getResolvedJavaMethod(method)); 1110 } 1111 1112 protected StructuredGraph getFinalGraph(ResolvedJavaMethod method) { 1113 StructuredGraph graph = parseForCompile(method); 1114 applyFrontEnd(graph); 1115 return graph; 1116 } 1117 1118 protected void applyFrontEnd(StructuredGraph graph) { 1119 GraalCompiler.emitFrontEnd(getProviders(), getBackend(), graph, getDefaultGraphBuilderSuite(), getOptimisticOptimizations(), graph.getProfilingInfo(), createSuites(graph.getOptions())); 1120 } 1121 1122 protected StructuredGraph lastCompiledGraph; 1123 1124 protected SpeculationLog getSpeculationLog() { 1125 return null; 1126 } 1127 1128 protected InstalledCode addMethod(DebugContext debug, final ResolvedJavaMethod method, final CompilationResult compilationResult) { 1129 return backend.addInstalledCode(debug, method, null, compilationResult); 1130 } 1131 1132 protected InstalledCode addDefaultMethod(DebugContext debug, final ResolvedJavaMethod method, final CompilationResult compilationResult) { 1133 return backend.createDefaultInstalledCode(debug, method, compilationResult); 1134 } 1135 1136 private final Map<ResolvedJavaMethod, Executable> methodMap = new ConcurrentHashMap<>(); 1137 1138 /** 1139 * Converts a reflection {@link Method} to a {@link ResolvedJavaMethod}. 1140 */ 1141 protected ResolvedJavaMethod asResolvedJavaMethod(Executable method) { 1142 ResolvedJavaMethod javaMethod = getMetaAccess().lookupJavaMethod(method); 1143 methodMap.put(javaMethod, method); 1144 return javaMethod; 1145 } 1146 1147 protected ResolvedJavaMethod getResolvedJavaMethod(String methodName) { 1148 return asResolvedJavaMethod(getMethod(methodName)); 1149 } 1150 1151 protected ResolvedJavaMethod getResolvedJavaMethod(Class<?> clazz, String methodName) { 1152 return asResolvedJavaMethod(getMethod(clazz, methodName)); 1153 } 1154 1155 protected ResolvedJavaMethod getResolvedJavaMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) { 1156 return asResolvedJavaMethod(getMethod(clazz, methodName, parameterTypes)); 1157 } 1158 1159 /** 1160 * Gets the reflection {@link Method} from which a given {@link ResolvedJavaMethod} was created 1161 * or null if {@code javaMethod} does not correspond to a reflection method. 1162 */ 1163 protected Executable lookupMethod(ResolvedJavaMethod javaMethod) { 1164 return methodMap.get(javaMethod); 1165 } 1166 1167 @SuppressWarnings("deprecation") 1168 protected Object invoke(ResolvedJavaMethod javaMethod, Object receiver, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException { 1169 Executable method = lookupMethod(javaMethod); 1170 Assert.assertTrue(method != null); 1171 if (!method.isAccessible()) { 1172 method.setAccessible(true); 1173 } 1174 if (method instanceof Method) { 1175 return ((Method) method).invoke(receiver, applyArgSuppliers(args)); 1176 } 1177 assert receiver == null : "no receiver for constructor invokes"; 1178 return ((Constructor<?>) method).newInstance(applyArgSuppliers(args)); 1179 } 1180 1181 /** 1182 * Parses a Java method in {@linkplain GraphBuilderConfiguration#getDefault default} mode to 1183 * produce a graph. 1184 * 1185 * @param methodName the name of the method in {@code this.getClass()} to be parsed 1186 * @param allowAssumptions specifies if {@link Assumption}s can be made compiling the graph 1187 */ 1188 protected final StructuredGraph parseProfiled(String methodName, AllowAssumptions allowAssumptions) { 1189 ResolvedJavaMethod method = getResolvedJavaMethod(methodName); 1190 return parse(builder(method, allowAssumptions), getDefaultGraphBuilderSuite()); 1191 } 1192 1193 /** 1194 * Parses a Java method in {@linkplain GraphBuilderConfiguration#getDefault default} mode to 1195 * produce a graph. 1196 * 1197 * @param method the method to be parsed 1198 * @param allowAssumptions specifies if {@link Assumption}s can be made compiling the graph 1199 */ 1200 protected final StructuredGraph parseProfiled(ResolvedJavaMethod method, AllowAssumptions allowAssumptions) { 1201 return parse(builder(method, allowAssumptions), getDefaultGraphBuilderSuite()); 1202 } 1203 1204 /** 1205 * Parses a Java method with {@linkplain GraphBuilderConfiguration#withEagerResolving(boolean)} 1206 * set to true to produce a graph. 1207 * 1208 * @param methodName the name of the method in {@code this.getClass()} to be parsed 1209 * @param allowAssumptions specifies if {@link Assumption}s can be made compiling the graph 1210 */ 1211 protected final StructuredGraph parseEager(String methodName, AllowAssumptions allowAssumptions) { 1212 ResolvedJavaMethod method = getResolvedJavaMethod(methodName); 1213 return parse(builder(method, allowAssumptions), getEagerGraphBuilderSuite()); 1214 } 1215 1216 /** 1217 * Parses a Java method with {@linkplain GraphBuilderConfiguration#withEagerResolving(boolean)} 1218 * set to true to produce a graph. 1219 * 1220 * @param methodName the name of the method in {@code this.getClass()} to be parsed 1221 * @param allowAssumptions specifies if {@link Assumption}s can be made compiling the graph 1222 * @param options the option values to be used when compiling the graph 1223 */ 1224 protected final StructuredGraph parseEager(String methodName, AllowAssumptions allowAssumptions, OptionValues options) { 1225 ResolvedJavaMethod method = getResolvedJavaMethod(methodName); 1226 return parse(builder(method, allowAssumptions, options), getEagerGraphBuilderSuite()); 1227 } 1228 1229 protected final StructuredGraph parseEager(String methodName, AllowAssumptions allowAssumptions, DebugContext debug) { 1230 ResolvedJavaMethod method = getResolvedJavaMethod(methodName); 1231 return parse(builder(method, allowAssumptions, debug), getEagerGraphBuilderSuite()); 1232 } 1233 1234 /** 1235 * Parses a Java method with {@linkplain GraphBuilderConfiguration#withEagerResolving(boolean)} 1236 * set to true to produce a graph. 1237 * 1238 * @param method the method to be parsed 1239 * @param allowAssumptions specifies if {@link Assumption}s can be made compiling the graph 1240 */ 1241 protected final StructuredGraph parseEager(ResolvedJavaMethod method, AllowAssumptions allowAssumptions) { 1242 return parse(builder(method, allowAssumptions), getEagerGraphBuilderSuite()); 1243 } 1244 1245 protected final StructuredGraph parseEager(ResolvedJavaMethod method, AllowAssumptions allowAssumptions, DebugContext debug) { 1246 return parse(builder(method, allowAssumptions, debug), getEagerGraphBuilderSuite()); 1247 } 1248 1249 /** 1250 * Parses a Java method with {@linkplain GraphBuilderConfiguration#withEagerResolving(boolean)} 1251 * set to true to produce a graph. 1252 * 1253 * @param method the method to be parsed 1254 * @param allowAssumptions specifies if {@link Assumption}s can be made compiling the graph 1255 * @param options the option values to be used when compiling the graph 1256 */ 1257 protected final StructuredGraph parseEager(ResolvedJavaMethod method, AllowAssumptions allowAssumptions, OptionValues options) { 1258 return parse(builder(method, allowAssumptions, options), getEagerGraphBuilderSuite()); 1259 } 1260 1261 /** 1262 * Parses a Java method with {@linkplain GraphBuilderConfiguration#withEagerResolving(boolean)} 1263 * set to true to produce a graph. 1264 * 1265 * @param method the method to be parsed 1266 * @param allowAssumptions specifies if {@link Assumption}s can be made compiling the graph 1267 * @param compilationId the compilation identifier to be associated with the graph 1268 * @param options the option values to be used when compiling the graph 1269 */ 1270 protected final StructuredGraph parseEager(ResolvedJavaMethod method, AllowAssumptions allowAssumptions, CompilationIdentifier compilationId, OptionValues options) { 1271 return parse(builder(method, allowAssumptions, compilationId, options), getEagerGraphBuilderSuite()); 1272 } 1273 1274 protected final Builder builder(ResolvedJavaMethod method, AllowAssumptions allowAssumptions, DebugContext debug) { 1275 OptionValues options = debug.getOptions(); 1276 return new Builder(options, debug, allowAssumptions).method(method).compilationId(getCompilationId(method)); 1277 } 1278 1279 protected final Builder builder(ResolvedJavaMethod method, AllowAssumptions allowAssumptions) { 1280 OptionValues options = getInitialOptions(); 1281 return new Builder(options, getDebugContext(options, null, method), allowAssumptions).method(method).compilationId(getCompilationId(method)); 1282 } 1283 1284 protected final Builder builder(ResolvedJavaMethod method, AllowAssumptions allowAssumptions, CompilationIdentifier compilationId, OptionValues options) { 1285 return new Builder(options, getDebugContext(options, compilationId.toString(CompilationIdentifier.Verbosity.ID), method), allowAssumptions).method(method).compilationId(compilationId); 1286 } 1287 1288 protected final Builder builder(ResolvedJavaMethod method, AllowAssumptions allowAssumptions, OptionValues options) { 1289 return new Builder(options, getDebugContext(options, null, method), allowAssumptions).method(method).compilationId(getCompilationId(method)); 1290 } 1291 1292 protected PhaseSuite<HighTierContext> getDebugGraphBuilderSuite() { 1293 return getCustomGraphBuilderSuite(GraphBuilderConfiguration.getDefault(getDefaultGraphBuilderPlugins()).withFullInfopoints(true)); 1294 } 1295 1296 @SuppressWarnings("try") 1297 protected StructuredGraph parse(StructuredGraph.Builder builder, PhaseSuite<HighTierContext> graphBuilderSuite) { 1298 ResolvedJavaMethod javaMethod = builder.getMethod(); 1299 builder.speculationLog(getSpeculationLog()); 1300 if (builder.getCancellable() == null) { 1301 builder.cancellable(getCancellable(javaMethod)); 1302 } 1303 assert javaMethod.getAnnotation(Test.class) == null : "shouldn't parse method with @Test annotation: " + javaMethod; 1304 StructuredGraph graph = builder.build(); 1305 DebugContext debug = graph.getDebug(); 1306 try (DebugContext.Scope ds = debug.scope("Parsing", javaMethod, graph)) { 1307 graphBuilderSuite.apply(graph, getDefaultHighTierContext()); 1308 Object[] args = getArgumentToBind(); 1309 if (args != null) { 1310 bindArguments(graph, args); 1311 } 1312 return graph; 1313 } catch (Throwable e) { 1314 throw debug.handle(e); 1315 } 1316 } 1317 1318 protected void bindArguments(StructuredGraph graph, Object[] argsToBind) { 1319 ResolvedJavaMethod m = graph.method(); 1320 Object receiver = isStatic(m.getModifiers()) ? null : this; 1321 Object[] args = argsWithReceiver(receiver, argsToBind); 1322 JavaType[] parameterTypes = m.toParameterTypes(); 1323 assert parameterTypes.length == args.length; 1324 for (ParameterNode param : graph.getNodes(ParameterNode.TYPE)) { 1325 JavaConstant c = getSnippetReflection().forBoxed(parameterTypes[param.index()].getJavaKind(), args[param.index()]); 1326 ConstantNode replacement = ConstantNode.forConstant(c, getMetaAccess(), graph); 1327 param.replaceAtUsages(replacement); 1328 } 1329 } 1330 1331 protected Object[] getArgumentToBind() { 1332 return null; 1333 } 1334 1335 protected PhaseSuite<HighTierContext> getEagerGraphBuilderSuite() { 1336 return getCustomGraphBuilderSuite(GraphBuilderConfiguration.getDefault(getDefaultGraphBuilderPlugins()).withEagerResolving(true).withUnresolvedIsError(true)); 1337 } 1338 1339 /** 1340 * Gets the cancellable that should be associated with a graph being created by any of the 1341 * {@code parse...()} methods. 1342 * 1343 * @param method the method being parsed into a graph 1344 */ 1345 protected Cancellable getCancellable(ResolvedJavaMethod method) { 1346 return null; 1347 } 1348 1349 protected Plugins getDefaultGraphBuilderPlugins() { 1350 PhaseSuite<HighTierContext> suite = backend.getSuites().getDefaultGraphBuilderSuite(); 1351 Plugins defaultPlugins = ((GraphBuilderPhase) suite.findPhase(GraphBuilderPhase.class).previous()).getGraphBuilderConfig().getPlugins(); 1352 // defensive copying 1353 return new Plugins(defaultPlugins); 1354 } 1355 1356 protected PhaseSuite<HighTierContext> getDefaultGraphBuilderSuite() { 1357 // defensive copying 1358 return backend.getSuites().getDefaultGraphBuilderSuite().copy(); 1359 } 1360 1361 /** 1362 * Registers extra invocation plugins for this test. The extra plugins are removed in the 1363 * {@link #afterTest()} method. 1364 * 1365 * Subclasses overriding this method should always call the same method on the super class in 1366 * case it wants to register plugins. 1367 * 1368 * @param invocationPlugins 1369 */ 1370 protected void registerInvocationPlugins(InvocationPlugins invocationPlugins) { 1371 invocationPlugins.register(new InvocationPlugin() { 1372 @Override 1373 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { 1374 b.add(new BreakpointNode()); 1375 return true; 1376 } 1377 }, GraalCompilerTest.class, "breakpoint"); 1378 invocationPlugins.register(new InvocationPlugin() { 1379 @Override 1380 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode arg0) { 1381 b.add(new BreakpointNode(arg0)); 1382 return true; 1383 } 1384 }, GraalCompilerTest.class, "breakpoint", int.class); 1385 invocationPlugins.register(new InvocationPlugin() { 1386 @Override 1387 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { 1388 b.add(new NotOptimizedNode()); 1389 return true; 1390 } 1391 }, GraalCompilerTest.class, "shouldBeOptimizedAway"); 1392 } 1393 1394 /** 1395 * The {@link #testN(int, String, Object...)} method means multiple threads trying to initialize 1396 * this field. 1397 */ 1398 private volatile InvocationPlugins invocationPluginExtensions; 1399 1400 private InvocationPlugins extendedInvocationPlugins; 1401 1402 protected PhaseSuite<HighTierContext> getCustomGraphBuilderSuite(GraphBuilderConfiguration gbConf) { 1403 PhaseSuite<HighTierContext> suite = getDefaultGraphBuilderSuite(); 1404 ListIterator<BasePhase<? super HighTierContext>> iterator = suite.findPhase(GraphBuilderPhase.class); 1405 initializeInvocationPluginExtensions(); 1406 GraphBuilderConfiguration gbConfCopy = editGraphBuilderConfiguration(gbConf.copy()); 1407 iterator.remove(); 1408 iterator.add(new GraphBuilderPhase(gbConfCopy)); 1409 return suite; 1410 } 1411 1412 private void initializeInvocationPluginExtensions() { 1413 if (invocationPluginExtensions == null) { 1414 synchronized (this) { 1415 if (invocationPluginExtensions == null) { 1416 InvocationPlugins invocationPlugins = new InvocationPlugins(); 1417 registerInvocationPlugins(invocationPlugins); 1418 extendedInvocationPlugins = getReplacements().getGraphBuilderPlugins().getInvocationPlugins(); 1419 extendedInvocationPlugins.addTestPlugins(invocationPlugins, null); 1420 invocationPluginExtensions = invocationPlugins; 1421 } 1422 } 1423 } 1424 } 1425 1426 protected GraphBuilderConfiguration editGraphBuilderConfiguration(GraphBuilderConfiguration conf) { 1427 conf.getPlugins().prependInlineInvokePlugin(new InlineInvokePlugin() { 1428 1429 @Override 1430 public InlineInfo shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { 1431 BytecodeParserNeverInline neverInline = method.getAnnotation(BytecodeParserNeverInline.class); 1432 if (neverInline != null) { 1433 return neverInline.invokeWithException() ? DO_NOT_INLINE_WITH_EXCEPTION : DO_NOT_INLINE_NO_EXCEPTION; 1434 } 1435 if (method.getAnnotation(BytecodeParserForceInline.class) != null) { 1436 return InlineInfo.createStandardInlineInfo(method); 1437 } 1438 return bytecodeParserShouldInlineInvoke(b, method, args); 1439 } 1440 }); 1441 return conf; 1442 } 1443 1444 /** 1445 * Supplements {@link BytecodeParserForceInline} and {@link BytecodeParserNeverInline} in terms 1446 * of allowing a test to influence the inlining decision made during bytecode parsing. 1447 * 1448 * @see InlineInvokePlugin#shouldInlineInvoke(GraphBuilderContext, ResolvedJavaMethod, 1449 * ValueNode[]) 1450 */ 1451 @SuppressWarnings("unused") 1452 protected InlineInvokePlugin.InlineInfo bytecodeParserShouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { 1453 return null; 1454 } 1455 1456 @NodeInfo 1457 public static class NotOptimizedNode extends FixedWithNextNode { 1458 private static final NodeClass<NotOptimizedNode> TYPE = NodeClass.create(NotOptimizedNode.class); 1459 1460 protected NotOptimizedNode() { 1461 super(TYPE, StampFactory.forVoid()); 1462 } 1463 1464 } 1465 1466 protected Replacements getReplacements() { 1467 return getProviders().getReplacements(); 1468 } 1469 1470 /** 1471 * Inject a probability for a branch condition into the profiling information of this test case. 1472 * 1473 * @param p the probability that cond is true 1474 * @param cond the condition of the branch 1475 * @return cond 1476 */ 1477 protected static boolean branchProbability(double p, boolean cond) { 1478 return GraalDirectives.injectBranchProbability(p, cond); 1479 } 1480 1481 /** 1482 * Inject an iteration count for a loop condition into the profiling information of this test 1483 * case. 1484 * 1485 * @param i the iteration count of the loop 1486 * @param cond the condition of the loop 1487 * @return cond 1488 */ 1489 protected static boolean iterationCount(double i, boolean cond) { 1490 return GraalDirectives.injectIterationCount(i, cond); 1491 } 1492 1493 /** 1494 * Test if the current test runs on the given platform. The name must match the name given in 1495 * the {@link Architecture#getName()}. 1496 * 1497 * @param name The name to test 1498 * @return true if we run on the architecture given by name 1499 */ 1500 protected boolean isArchitecture(String name) { 1501 return name.equals(backend.getTarget().arch.getName()); 1502 } 1503 }