1 /*
   2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.core.test;
  24 
  25 import static org.graalvm.compiler.core.common.CompilationIdentifier.INVALID_COMPILATION_ID;
  26 
  27 import java.lang.reflect.Method;
  28 import java.lang.reflect.Modifier;
  29 
  30 import org.junit.Test;
  31 
  32 import org.graalvm.compiler.api.test.Graal;
  33 import org.graalvm.compiler.common.PermanentBailoutException;
  34 import org.graalvm.compiler.common.RetryableBailoutException;
  35 import org.graalvm.compiler.debug.Debug;
  36 import org.graalvm.compiler.debug.DebugConfigScope;
  37 import org.graalvm.compiler.debug.GraalError;
  38 import org.graalvm.compiler.java.GraphBuilderPhase;
  39 import org.graalvm.compiler.nodes.StructuredGraph;
  40 import org.graalvm.compiler.nodes.StructuredGraph.AllowAssumptions;
  41 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration;
  42 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins;
  43 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins;
  44 import org.graalvm.compiler.phases.OptimisticOptimizations;
  45 import org.graalvm.compiler.phases.Phase;
  46 import org.graalvm.compiler.phases.PhaseSuite;
  47 import org.graalvm.compiler.phases.VerifyPhase.VerificationError;
  48 import org.graalvm.compiler.phases.tiers.HighTierContext;
  49 import org.graalvm.compiler.phases.util.Providers;
  50 import org.graalvm.compiler.phases.verify.VerifyBailoutUsage;
  51 import org.graalvm.compiler.runtime.RuntimeProvider;
  52 
  53 import jdk.vm.ci.code.BailoutException;
  54 import jdk.vm.ci.meta.MetaAccessProvider;
  55 import jdk.vm.ci.meta.ResolvedJavaMethod;
  56 
  57 public class VerifyBailoutUsageTest {
  58 
  59     private static class InvalidBailoutUsagePhase1 extends Phase {
  60         @Override
  61         protected void run(StructuredGraph graph) {
  62             throw new BailoutException("Bailout in graph %s", graph);
  63         }
  64     }
  65 
  66     private static class InvalidBailoutUsagePhase2 extends Phase {
  67         @Override
  68         protected void run(StructuredGraph graph) {
  69             throw new BailoutException(new GraalError("other cause"), "Bailout in graph %s", graph);
  70         }
  71     }
  72 
  73     private static class InvalidBailoutUsagePhase3 extends Phase {
  74         @Override
  75         protected void run(StructuredGraph graph) {
  76             throw new BailoutException(true/* permanent */, "Bailout in graph %s", graph);
  77         }
  78     }
  79 
  80     private static class ValidPermanentBailoutUsage extends Phase {
  81         @Override
  82         protected void run(StructuredGraph graph) {
  83             throw new PermanentBailoutException("Valid permanent bailout %s", graph);
  84         }
  85     }
  86 
  87     private static class ValidRetryableBailoutUsage extends Phase {
  88         @Override
  89         protected void run(StructuredGraph graph) {
  90             throw new RetryableBailoutException("Valid retryable bailout %s", graph);
  91         }
  92     }
  93 
  94     @Test(expected = VerificationError.class)
  95     public void testInvalidBailout01() {
  96         testBailoutUsage(InvalidBailoutUsagePhase1.class);
  97     }
  98 
  99     @Test(expected = VerificationError.class)
 100     public void testInvalidBailout02() {
 101         testBailoutUsage(InvalidBailoutUsagePhase2.class);
 102     }
 103 
 104     @Test(expected = VerificationError.class)
 105     public void testInvalidBailout03() {
 106         testBailoutUsage(InvalidBailoutUsagePhase3.class);
 107     }
 108 
 109     @Test
 110     public void testValidPermanentBailout() {
 111         testBailoutUsage(ValidPermanentBailoutUsage.class);
 112     }
 113 
 114     @Test
 115     public void testValidRetryableBailout() {
 116         testBailoutUsage(ValidRetryableBailoutUsage.class);
 117     }
 118 
 119     @SuppressWarnings("try")
 120     private static void testBailoutUsage(Class<?> c) {
 121         RuntimeProvider rt = Graal.getRequiredCapability(RuntimeProvider.class);
 122         Providers providers = rt.getHostBackend().getProviders();
 123         MetaAccessProvider metaAccess = providers.getMetaAccess();
 124         PhaseSuite<HighTierContext> graphBuilderSuite = new PhaseSuite<>();
 125         Plugins plugins = new Plugins(new InvocationPlugins(metaAccess));
 126         GraphBuilderConfiguration config = GraphBuilderConfiguration.getDefault(plugins).withEagerResolving(true);
 127         graphBuilderSuite.appendPhase(new GraphBuilderPhase(config));
 128         HighTierContext context = new HighTierContext(providers, graphBuilderSuite, OptimisticOptimizations.NONE);
 129         for (Method m : c.getDeclaredMethods()) {
 130             if (!Modifier.isNative(m.getModifiers()) && !Modifier.isAbstract(m.getModifiers())) {
 131                 ResolvedJavaMethod method = metaAccess.lookupJavaMethod(m);
 132                 StructuredGraph graph = new StructuredGraph(method, AllowAssumptions.NO, INVALID_COMPILATION_ID);
 133                 graphBuilderSuite.apply(graph, context);
 134                 try (DebugConfigScope s = Debug.disableIntercept()) {
 135                     new VerifyBailoutUsage().apply(graph, context);
 136                 }
 137             }
 138         }
 139     }
 140 }