29 import org.graalvm.compiler.api.replacements.MethodSubstitution; |
29 import org.graalvm.compiler.api.replacements.MethodSubstitution; |
30 import org.graalvm.compiler.nodes.IfNode; |
30 import org.graalvm.compiler.nodes.IfNode; |
31 import org.graalvm.compiler.nodes.StructuredGraph; |
31 import org.graalvm.compiler.nodes.StructuredGraph; |
32 import org.graalvm.compiler.nodes.calc.AbsNode; |
32 import org.graalvm.compiler.nodes.calc.AbsNode; |
33 import org.graalvm.compiler.nodes.calc.ReinterpretNode; |
33 import org.graalvm.compiler.nodes.calc.ReinterpretNode; |
|
34 import org.graalvm.compiler.replacements.amd64.AMD64CountLeadingZerosNode; |
|
35 import org.graalvm.compiler.replacements.amd64.AMD64CountTrailingZerosNode; |
34 import org.graalvm.compiler.replacements.nodes.BitCountNode; |
36 import org.graalvm.compiler.replacements.nodes.BitCountNode; |
35 import org.graalvm.compiler.replacements.nodes.BitScanForwardNode; |
37 import org.graalvm.compiler.replacements.nodes.BitScanForwardNode; |
36 import org.graalvm.compiler.replacements.nodes.BitScanReverseNode; |
38 import org.graalvm.compiler.replacements.nodes.BitScanReverseNode; |
37 import org.graalvm.compiler.replacements.nodes.ReverseBytesNode; |
39 import org.graalvm.compiler.replacements.nodes.ReverseBytesNode; |
38 import org.junit.Test; |
40 import org.junit.Test; |
130 |
132 |
131 public static double mathAll(double value) { |
133 public static double mathAll(double value) { |
132 return Math.sqrt(value) + Math.log(value) + Math.log10(value) + Math.sin(value) + Math.cos(value) + Math.tan(value); |
134 return Math.sqrt(value) + Math.log(value) + Math.log10(value) + Math.sin(value) + Math.cos(value) + Math.tan(value); |
133 } |
135 } |
134 |
136 |
135 public void testSubstitution(String testMethodName, Class<?> intrinsicClass, Class<?> holder, String methodName, boolean optional, Object... args) { |
137 public void testSubstitution(String testMethodName, Class<?> holder, String methodName, boolean optional, Object[] args, Class<?>... intrinsicClasses) { |
136 ResolvedJavaMethod realJavaMethod = getResolvedJavaMethod(holder, methodName); |
138 ResolvedJavaMethod realJavaMethod = getResolvedJavaMethod(holder, methodName); |
137 ResolvedJavaMethod testJavaMethod = getResolvedJavaMethod(testMethodName); |
139 ResolvedJavaMethod testJavaMethod = getResolvedJavaMethod(testMethodName); |
138 StructuredGraph graph = testGraph(testMethodName); |
140 StructuredGraph graph = testGraph(testMethodName); |
139 |
141 |
140 // Check to see if the resulting graph contains the expected node |
142 // Check to see if the resulting graph contains the expected node |
141 StructuredGraph replacement = getReplacements().getSubstitution(realJavaMethod, -1, false, null, graph.getOptions()); |
143 StructuredGraph replacement = getReplacements().getSubstitution(realJavaMethod, -1, false, null, graph.getOptions()); |
142 if (replacement == null && !optional) { |
144 if (replacement == null && !optional) { |
143 assertInGraph(graph, intrinsicClass); |
145 assertInGraph(graph, intrinsicClasses); |
144 } |
146 } |
145 |
147 |
146 for (Object l : args) { |
148 for (Object l : args) { |
147 // Force compilation |
149 // Force compilation |
148 InstalledCode code = getCode(testJavaMethod); |
150 InstalledCode code = getCode(testJavaMethod); |
157 |
159 |
158 @Test |
160 @Test |
159 public void testCharSubstitutions() { |
161 public void testCharSubstitutions() { |
160 Object[] args = new Character[]{Character.MIN_VALUE, (char) -1, (char) 0, (char) 1, Character.MAX_VALUE}; |
162 Object[] args = new Character[]{Character.MIN_VALUE, (char) -1, (char) 0, (char) 1, Character.MAX_VALUE}; |
161 |
163 |
162 testSubstitution("charReverseBytes", ReverseBytesNode.class, Character.class, "reverseBytes", false, args); |
164 testSubstitution("charReverseBytes", Character.class, "reverseBytes", false, args, ReverseBytesNode.class); |
163 } |
165 } |
164 |
166 |
165 public static char charReverseBytes(char value) { |
167 public static char charReverseBytes(char value) { |
166 return Character.reverseBytes(value); |
168 return Character.reverseBytes(value); |
167 } |
169 } |
181 |
183 |
182 @Test |
184 @Test |
183 public void testShortSubstitutions() { |
185 public void testShortSubstitutions() { |
184 Object[] args = new Short[]{Short.MIN_VALUE, -1, 0, 1, Short.MAX_VALUE}; |
186 Object[] args = new Short[]{Short.MIN_VALUE, -1, 0, 1, Short.MAX_VALUE}; |
185 |
187 |
186 testSubstitution("shortReverseBytes", ReverseBytesNode.class, Short.class, "reverseBytes", false, args); |
188 testSubstitution("shortReverseBytes", Short.class, "reverseBytes", false, args, ReverseBytesNode.class); |
187 } |
189 } |
188 |
190 |
189 public static short shortReverseBytes(short value) { |
191 public static short shortReverseBytes(short value) { |
190 return Short.reverseBytes(value); |
192 return Short.reverseBytes(value); |
191 } |
193 } |
205 |
207 |
206 @Test |
208 @Test |
207 public void testIntegerSubstitutions() { |
209 public void testIntegerSubstitutions() { |
208 Object[] args = new Object[]{Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE}; |
210 Object[] args = new Object[]{Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE}; |
209 |
211 |
210 testSubstitution("integerReverseBytes", ReverseBytesNode.class, Integer.class, "reverseBytes", false, args); |
212 testSubstitution("integerReverseBytes", Integer.class, "reverseBytes", false, args, ReverseBytesNode.class); |
211 testSubstitution("integerNumberOfLeadingZeros", BitScanReverseNode.class, Integer.class, "numberOfLeadingZeros", true, args); |
213 testSubstitution("integerNumberOfLeadingZeros", Integer.class, "numberOfLeadingZeros", true, args, BitScanReverseNode.class, AMD64CountLeadingZerosNode.class); |
212 testSubstitution("integerNumberOfTrailingZeros", BitScanForwardNode.class, Integer.class, "numberOfTrailingZeros", false, args); |
214 testSubstitution("integerNumberOfTrailingZeros", Integer.class, "numberOfTrailingZeros", false, args, BitScanForwardNode.class, AMD64CountTrailingZerosNode.class); |
213 testSubstitution("integerBitCount", BitCountNode.class, Integer.class, "bitCount", true, args); |
215 testSubstitution("integerBitCount", Integer.class, "bitCount", true, args, BitCountNode.class); |
214 } |
216 } |
215 |
217 |
216 public static int integerReverseBytes(int value) { |
218 public static int integerReverseBytes(int value) { |
217 return Integer.reverseBytes(value); |
219 return Integer.reverseBytes(value); |
218 } |
220 } |
231 |
233 |
232 @Test |
234 @Test |
233 public void testLongSubstitutions() { |
235 public void testLongSubstitutions() { |
234 Object[] args = new Object[]{Long.MIN_VALUE, -1L, 0L, 1L, Long.MAX_VALUE}; |
236 Object[] args = new Object[]{Long.MIN_VALUE, -1L, 0L, 1L, Long.MAX_VALUE}; |
235 |
237 |
236 testSubstitution("longReverseBytes", ReverseBytesNode.class, Long.class, "reverseBytes", false, args); |
238 testSubstitution("longReverseBytes", Long.class, "reverseBytes", false, args, ReverseBytesNode.class); |
237 testSubstitution("longNumberOfLeadingZeros", BitScanReverseNode.class, Long.class, "numberOfLeadingZeros", true, args); |
239 testSubstitution("longNumberOfLeadingZeros", Long.class, "numberOfLeadingZeros", true, args, BitScanReverseNode.class, AMD64CountLeadingZerosNode.class); |
238 testSubstitution("longNumberOfTrailingZeros", BitScanForwardNode.class, Long.class, "numberOfTrailingZeros", false, args); |
240 testSubstitution("longNumberOfTrailingZeros", Long.class, "numberOfTrailingZeros", false, args, BitScanForwardNode.class, AMD64CountTrailingZerosNode.class); |
239 testSubstitution("longBitCount", BitCountNode.class, Long.class, "bitCount", true, args); |
241 testSubstitution("longBitCount", Long.class, "bitCount", true, args, BitCountNode.class); |
240 } |
242 } |
241 |
243 |
242 public static long longReverseBytes(long value) { |
244 public static long longReverseBytes(long value) { |
243 return Long.reverseBytes(value); |
245 return Long.reverseBytes(value); |
244 } |
246 } |