1 /*
2 * Copyright (c) 2024, 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 * @test
26 * @modules jdk.incubator.code
27 * @run junit CoreBinaryOpsTest
28 * @run junit/othervm -Dbabylon.ssa=cytron CoreBinaryOpsTest
29 */
30
31 import jdk.incubator.code.Op;
32 import jdk.incubator.code.dialect.core.CoreType;
33 import org.junit.jupiter.api.Named;
34 import org.junit.jupiter.api.extension.ExtensionContext;
35 import org.junit.jupiter.api.function.ThrowingSupplier;
36 import org.junit.jupiter.params.ParameterizedTest;
37 import org.junit.jupiter.params.provider.Arguments;
38 import org.junit.jupiter.params.provider.ArgumentsProvider;
39 import org.junit.jupiter.params.provider.ArgumentsSource;
40
41 import java.lang.annotation.ElementType;
42 import java.lang.annotation.Retention;
43 import java.lang.annotation.RetentionPolicy;
44 import java.lang.annotation.Target;
45 import java.lang.invoke.MethodHandle;
46 import java.lang.invoke.MethodHandles;
47 import java.lang.invoke.MethodType;
48 import java.lang.reflect.AccessFlag;
49 import java.lang.reflect.Method;
50 import java.lang.reflect.Parameter;
51 import jdk.incubator.code.OpTransformer;
52 import jdk.incubator.code.TypeElement;
53 import jdk.incubator.code.analysis.SSA;
54 import jdk.incubator.code.bytecode.BytecodeGenerator;
55 import jdk.incubator.code.interpreter.Interpreter;
56 import jdk.incubator.code.dialect.core.CoreOp;
57 import jdk.incubator.code.dialect.core.FunctionType;
58 import jdk.incubator.code.dialect.java.JavaType;
59 import jdk.incubator.code.CodeReflection;
60 import java.util.*;
61 import java.util.stream.Stream;
62
63 import static org.junit.jupiter.api.Assertions.*;
64
65 public class CoreBinaryOpsTest {
66
67 @CodeReflection
68 @SupportedTypes(TypeList.INTEGRAL_BOOLEAN)
69 static int and(int left, int right) {
70 return left & right;
71 }
72
73 @CodeReflection
74 @SupportedTypes(TypeList.INTEGRAL_FLOATING_POINT)
75 static int add(int left, int right) {
76 return left + right;
77 }
78
79 @CodeReflection
80 @SupportedTypes(TypeList.INTEGRAL_FLOATING_POINT)
81 static int div(int left, int right) {
82 return left / right;
83 }
84
85 @CodeReflection
86 @SupportedTypes(TypeList.INT_LONG)
87 static int leftShift(int left, int right) {
88 return left << right;
89 }
90
91 @CodeReflection
92 @Direct
93 static int leftShiftIL(int left, long right) {
94 return left << right;
95 }
96
97 @CodeReflection
98 @Direct
99 static long leftShiftLI(long left, int right) {
100 return left << right;
101 }
102
103 @CodeReflection
104 @SupportedTypes(TypeList.INTEGRAL_FLOATING_POINT)
105 static int mod(int left, int right) {
106 return left % right;
107 }
108
109 @CodeReflection
110 @SupportedTypes(TypeList.INTEGRAL_FLOATING_POINT)
111 static int mul(int left, int right) {
112 return left * right;
113 }
114
115 @CodeReflection
116 @SupportedTypes(TypeList.INTEGRAL_BOOLEAN)
117 static int or(int left, int right) {
118 return left | right;
119 }
120
121 @CodeReflection
122 @SupportedTypes(TypeList.INT_LONG)
123 static int signedRightShift(int left, int right) {
124 return left >> right;
125 }
126
127 @CodeReflection
128 @Direct
129 static int signedRightShiftIL(int left, long right) {
130 return left >> right;
131 }
132
133 @CodeReflection
134 @Direct
135 static long signedRightShiftLI(long left, int right) {
136 return left >> right;
137 }
138
139 @CodeReflection
140 @SupportedTypes(TypeList.INTEGRAL_FLOATING_POINT)
141 static int sub(int left, int right) {
142 return left - right;
143 }
144
145 @CodeReflection
146 @SupportedTypes(TypeList.INT_LONG)
147 static int unsignedRightShift(int left, int right) {
148 return left >>> right;
149 }
150
151 @CodeReflection
152 @Direct
153 static int unsignedRightShiftIL(int left, long right) {
154 return left >>> right;
155 }
156
157 @CodeReflection
158 @Direct
159 static long unsignedRightShiftLI(long left, int right) {
160 return left >>> right;
161 }
162
163 @CodeReflection
164 @SupportedTypes(TypeList.INTEGRAL_BOOLEAN)
165 static int xor(int left, int right) {
166 return left ^ right;
167 }
168
169 @ParameterizedTest
170 @CodeReflectionExecutionSource
171 void test(CoreOp.FuncOp funcOp, Object left, Object right) {
172 Result interpret = runCatching(() -> interpret(left, right, funcOp));
173 Result bytecode = runCatching(() -> bytecode(left, right, funcOp));
174 assertResults(interpret, bytecode);
175 }
176
177 @Retention(RetentionPolicy.RUNTIME)
178 @Target(ElementType.METHOD)
179 @interface SupportedTypes {
180 TypeList value();
181 }
182
183 enum TypeList {
184 INT_LONG(int.class, long.class),
185 INTEGRAL_BOOLEAN(int.class, long.class, byte.class, short.class, char.class, boolean.class),
186 INTEGRAL_FLOATING_POINT(int.class, long.class, byte.class, short.class, char.class, float.class, double.class);
187
188 private final Class<?>[] types;
189
190 TypeList(Class<?>... types) {
191 this.types = types;
192 }
193
194 public Class<?>[] types() {
195 return types;
196 }
197 }
198
199 // mark as "do not transform"
200 @Retention(RetentionPolicy.RUNTIME)
201 @Target(ElementType.METHOD)
202 @interface Direct {
203 }
204
205 @Retention(RetentionPolicy.RUNTIME)
206 @Target(ElementType.METHOD)
207 @ArgumentsSource(CodeReflectionSourceProvider.class)
208 @interface CodeReflectionExecutionSource {
209 }
210
211 static class CodeReflectionSourceProvider implements ArgumentsProvider {
212 private static final Map<JavaType, List<?>> INTERESTING_INPUTS = Map.of(
213 // explicit type parameters to ensure boxing results in the expected type
214 JavaType.INT, List.<Integer>of(Integer.MIN_VALUE, Integer.MAX_VALUE, 1, 0, -1),
215 JavaType.LONG, List.<Long>of(Long.MIN_VALUE, Long.MAX_VALUE, 1L, 0L, -1L),
216 JavaType.BYTE, List.<Byte>of(Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 1, (byte) 0, (byte) -1),
217 JavaType.SHORT, List.<Short>of(Short.MIN_VALUE, Short.MAX_VALUE, (short) 1, (short) 0, (short) -1),
218 JavaType.CHAR, List.<Character>of(Character.MIN_VALUE, Character.MAX_VALUE, (char) 1, (char) 0, (char) -1),
219 JavaType.DOUBLE, List.<Double>of(Double.MIN_VALUE, Double.MAX_VALUE, Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.MIN_NORMAL, 1d, 0d, -1d),
220 JavaType.FLOAT, List.<Float>of(Float.MIN_VALUE, Float.MAX_VALUE, Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, Float.MIN_NORMAL, 1f, 0f, -1f),
221 JavaType.BOOLEAN, List.<Boolean>of(true, false)
222 );
223
224 @Override
225 public Stream<? extends Arguments> provideArguments(ExtensionContext extensionContext) {
226 Method testMethod = extensionContext.getRequiredTestMethod();
227 return codeReflectionMethods(extensionContext.getRequiredTestClass())
228 .flatMap(method -> {
229 CoreOp.FuncOp funcOp = Op.ofMethod(method).orElseThrow(
230 () -> new IllegalStateException("Expected code model to be present for method " + method)
231 );
232 SupportedTypes supportedTypes = method.getAnnotation(SupportedTypes.class);
233 if (method.isAnnotationPresent(Direct.class)) {
234 if (supportedTypes != null) {
235 throw new IllegalArgumentException("Direct should not be combined with SupportedTypes");
236 }
237 return Stream.of(funcOp);
238 }
239 if (supportedTypes == null || supportedTypes.value().types().length == 0) {
240 throw new IllegalArgumentException("Missing supported types");
241 }
242 return Arrays.stream(supportedTypes.value().types())
243 .map(type -> retype(funcOp, type));
244 })
245 .flatMap(transformedFunc -> argumentsForMethod(transformedFunc, testMethod));
246 }
247
248 private static <T> Stream<List<T>> cartesianProduct(List<List<? extends T>> source) {
249 if (source.isEmpty()) {
250 return Stream.of(new ArrayList<>());
251 }
252 return source.getFirst().stream()
253 .flatMap(e -> cartesianProduct(source.subList(1, source.size())).map(l -> {
254 ArrayList<T> newList = new ArrayList<>(l);
255 newList.add(e);
256 return newList;
257 }));
258 }
259
260 private static CoreOp.FuncOp retype(CoreOp.FuncOp original, Class<?> newType) {
261 JavaType type = JavaType.type(newType);
262 FunctionType functionType = original.invokableType();
263 if (functionType.parameterTypes().stream().allMatch(t -> t.equals(type))) {
264 return original; // already expected type
265 }
266 if (functionType.parameterTypes().stream().distinct().count() != 1) {
267 System.err.println(original.toText());
268 throw new IllegalArgumentException("Only FuncOps with exactly one distinct parameter type are supported");
269 }
270 // if the return type does not match the input types, we keep it
271 TypeElement retType = functionType.returnType().equals(functionType.parameterTypes().getFirst())
272 ? type
273 : functionType.returnType();
274 return CoreOp.func(original.funcName(), CoreType.functionType(retType, type, type))
275 .body(builder -> builder.transformBody(original.body(), builder.parameters(), OpTransformer.COPYING_TRANSFORMER)
276 );
277 }
278
279 private static Stream<Arguments> argumentsForMethod(CoreOp.FuncOp funcOp, Method testMethod) {
280 Parameter[] testMethodParameters = testMethod.getParameters();
281 List<TypeElement> funcParameters = funcOp.invokableType().parameterTypes();
282 if (testMethodParameters.length - 1 != funcParameters.size()) {
283 throw new IllegalArgumentException("method " + testMethod + " does not take the correct number of parameters");
284 }
285 if (testMethodParameters[0].getType() != CoreOp.FuncOp.class) {
286 throw new IllegalArgumentException("method " + testMethod + " does not take a leading FuncOp argument");
287 }
288 Named<CoreOp.FuncOp> opNamed = Named.of(funcOp.funcName() + "{" + funcOp.invokableType() + "}", funcOp);
289 MethodHandles.Lookup lookup = MethodHandles.lookup();
290 for (int i = 1; i < testMethodParameters.length; i++) {
291 Class<?> resolved = resolveParameter(funcParameters.get(i - 1), lookup);
292 if (!isCompatible(resolved, testMethodParameters[i].getType())) {
293 System.out.println(testMethod + " does not accept inputs of type " + resolved + " at index " + i);
294 return Stream.empty();
295 }
296 }
297 List<List<?>> allInputs = new ArrayList<>();
298 for (TypeElement parameterType : funcParameters) {
299 allInputs.add(INTERESTING_INPUTS.get((JavaType) parameterType));
300 }
301 return cartesianProduct(allInputs)
302 .map(objects -> {
303 objects.add(opNamed);
304 return objects.reversed().toArray(); // reverse so FuncOp is at the beginning
305 })
306 .map(Arguments::of);
307 }
308
309 private static Class<?> resolveParameter(TypeElement typeElement, MethodHandles.Lookup lookup) {
310 try {
311 return (Class<?>)((JavaType) typeElement).erasure().resolve(lookup);
312 } catch (ReflectiveOperationException e) {
313 throw new RuntimeException(e);
314 }
315 }
316
317 // check whether elements of type sourceType can be passed to a parameter of parameterType
318 private static boolean isCompatible(Class<?> sourceType, Class<?> parameterType) {
319 return wrapped(parameterType).isAssignableFrom(wrapped(sourceType));
320 }
321
322 private static Class<?> wrapped(Class<?> target) {
323 return MethodType.methodType(target).wrap().returnType();
324 }
325
326 private static Stream<Method> codeReflectionMethods(Class<?> testClass) {
327 return Arrays.stream(testClass.getDeclaredMethods())
328 .filter(method -> method.accessFlags().contains(AccessFlag.STATIC))
329 .filter(method -> method.isAnnotationPresent(CodeReflection.class));
330 }
331
332 }
333
334 private static Object interpret(Object left, Object right, CoreOp.FuncOp op) {
335 return Interpreter.invoke(MethodHandles.lookup(), op, left, right);
336 }
337
338 private static Object bytecode(Object left, Object right, CoreOp.FuncOp op) throws Throwable {
339 CoreOp.FuncOp func = SSA.transform(op.transform(OpTransformer.LOWERING_TRANSFORMER));
340 MethodHandle handle = BytecodeGenerator.generate(MethodHandles.lookup(), func);
341 return handle.invoke(left, right);
342 }
343
344 private static void assertResults(Result first, Result second) {
345 System.out.println("first: " + first);
346 System.out.println("second: " + second);
347 // either the same error occurred on both or no error occurred
348 if (first.throwable != null || second.throwable != null) {
349 assertNotNull(first.throwable, () -> "only second threw an exception: " + second.throwable);
350 assertNotNull(second.throwable, () -> "only first threw an exception: " + first.throwable);
351 if (first.throwable.getClass() != second.throwable.getClass()) {
352 first.throwable.printStackTrace();
353 second.throwable.printStackTrace();
354 fail("Different exceptions were thrown");
355 }
356 return;
357 }
358 // otherwise, both results should be non-null and equals
359 assertNotNull(first.onSuccess);
360 assertEquals(first.onSuccess, second.onSuccess);
361 }
362
363 private static <T> Result runCatching(ThrowingSupplier<T> supplier) {
364 Object value = null;
365 Throwable interpretThrowable = null;
366 try {
367 value = supplier.get();
368 } catch (Throwable t) {
369 interpretThrowable = t;
370 }
371 return new Result(value, interpretThrowable);
372 }
373
374 record Result(Object onSuccess, Throwable throwable) {
375 }
376
377 }