20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.api.directives.test;
  24 
  25 import java.lang.annotation.ElementType;
  26 import java.lang.annotation.Retention;
  27 import java.lang.annotation.RetentionPolicy;
  28 import java.lang.annotation.Target;
  29 
  30 import org.junit.Assert;
  31 import org.junit.Test;
  32 
  33 import org.graalvm.compiler.api.directives.GraalDirectives;
  34 import org.graalvm.compiler.core.test.GraalCompilerTest;
  35 import org.graalvm.compiler.nodes.ConstantNode;
  36 import org.graalvm.compiler.nodes.ReturnNode;
  37 import org.graalvm.compiler.nodes.StructuredGraph;
  38 import org.graalvm.compiler.nodes.calc.AddNode;
  39 import org.graalvm.compiler.nodes.calc.ConditionalNode;



  40 
  41 /**
  42  * Tests for {@link GraalDirectives#opaque}.
  43  *
  44  * There are two snippets for each kind:
  45  * <ul>
  46  * <li>opaque&lt;Kind&gt;Snippet verifies that constant folding is prevented by the opaque
  47  * directive.
  48  * <li>&lt;kind&gt;Snippet verifies that constant folding does happen if the opaque directive is not
  49  * there.
  50  * </ul>
  51  *
  52  */
  53 public class OpaqueDirectiveTest extends GraalCompilerTest {
  54 
  55     @Retention(RetentionPolicy.RUNTIME)
  56     @Target(ElementType.METHOD)
  57     private @interface OpaqueSnippet {
  58         Class<?> expectedReturnNode();
  59     }

 108 
 109     private static class Dummy {
 110     }
 111 
 112     @OpaqueSnippet(expectedReturnNode = ConstantNode.class)
 113     public static boolean objectSnippet() {
 114         Object obj = new Dummy();
 115         return obj == null;
 116     }
 117 
 118     @OpaqueSnippet(expectedReturnNode = ConditionalNode.class)
 119     public static boolean opaqueObjectSnippet() {
 120         Object obj = new Dummy();
 121         return GraalDirectives.opaque(obj) == null;
 122     }
 123 
 124     @Test
 125     public void testObject() {
 126         test("objectSnippet");
 127         test("opaqueObjectSnippet");





 128     }
 129 
 130     @Override
 131     protected boolean checkLowTierGraph(StructuredGraph graph) {
 132         OpaqueSnippet snippet = graph.method().getAnnotation(OpaqueSnippet.class);
 133         for (ReturnNode returnNode : graph.getNodes(ReturnNode.TYPE)) {
 134             Assert.assertEquals(snippet.expectedReturnNode(), returnNode.result().getClass());
 135         }
 136         return true;
 137     }
 138 }

  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.api.directives.test;
  24 
  25 import java.lang.annotation.ElementType;
  26 import java.lang.annotation.Retention;
  27 import java.lang.annotation.RetentionPolicy;
  28 import java.lang.annotation.Target;
  29 
  30 import org.junit.Assert;
  31 import org.junit.Test;
  32 
  33 import org.graalvm.compiler.api.directives.GraalDirectives;
  34 import org.graalvm.compiler.core.test.GraalCompilerTest;
  35 import org.graalvm.compiler.nodes.ConstantNode;
  36 import org.graalvm.compiler.nodes.ReturnNode;
  37 import org.graalvm.compiler.nodes.StructuredGraph;
  38 import org.graalvm.compiler.nodes.calc.AddNode;
  39 import org.graalvm.compiler.nodes.calc.ConditionalNode;
  40 import org.graalvm.compiler.phases.OptimisticOptimizations;
  41 import org.graalvm.compiler.phases.OptimisticOptimizations.Optimization;
  42 import org.graalvm.compiler.phases.tiers.HighTierContext;
  43 
  44 /**
  45  * Tests for {@link GraalDirectives#opaque}.
  46  *
  47  * There are two snippets for each kind:
  48  * <ul>
  49  * <li>opaque&lt;Kind&gt;Snippet verifies that constant folding is prevented by the opaque
  50  * directive.
  51  * <li>&lt;kind&gt;Snippet verifies that constant folding does happen if the opaque directive is not
  52  * there.
  53  * </ul>
  54  *
  55  */
  56 public class OpaqueDirectiveTest extends GraalCompilerTest {
  57 
  58     @Retention(RetentionPolicy.RUNTIME)
  59     @Target(ElementType.METHOD)
  60     private @interface OpaqueSnippet {
  61         Class<?> expectedReturnNode();
  62     }

 111 
 112     private static class Dummy {
 113     }
 114 
 115     @OpaqueSnippet(expectedReturnNode = ConstantNode.class)
 116     public static boolean objectSnippet() {
 117         Object obj = new Dummy();
 118         return obj == null;
 119     }
 120 
 121     @OpaqueSnippet(expectedReturnNode = ConditionalNode.class)
 122     public static boolean opaqueObjectSnippet() {
 123         Object obj = new Dummy();
 124         return GraalDirectives.opaque(obj) == null;
 125     }
 126 
 127     @Test
 128     public void testObject() {
 129         test("objectSnippet");
 130         test("opaqueObjectSnippet");
 131     }
 132 
 133     @Override
 134     protected HighTierContext getDefaultHighTierContext() {
 135         return new HighTierContext(getProviders(), getDefaultGraphBuilderSuite(), OptimisticOptimizations.ALL.remove(Optimization.RemoveNeverExecutedCode));
 136     }
 137 
 138     @Override
 139     protected boolean checkLowTierGraph(StructuredGraph graph) {
 140         OpaqueSnippet snippet = graph.method().getAnnotation(OpaqueSnippet.class);
 141         for (ReturnNode returnNode : graph.getNodes(ReturnNode.TYPE)) {
 142             Assert.assertEquals(snippet.expectedReturnNode(), returnNode.result().getClass());
 143         }
 144         return true;
 145     }
 146 }