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 * @summary Smoke test for code reflection with primitive casts.
27 * @build PrimitiveCastTest
28 * @build CodeReflectionTester
29 * @run main CodeReflectionTester PrimitiveCastTest
30 */
31
32 import java.lang.runtime.CodeReflection;
33
34 public class PrimitiveCastTest {
35
36 @CodeReflection
37 @IR("""
38 func @"testFromDouble" (%0 : PrimitiveCastTest, %1 : double)void -> {
39 %2 : Var<double> = var %1 @"v";
40 %3 : double = var.load %2;
41 %4 : Var<double> = var %3 @"d";
42 %5 : double = var.load %2;
43 %6 : float = conv %5;
44 %7 : Var<float> = var %6 @"f";
45 %8 : double = var.load %2;
46 %9 : long = conv %8;
47 %10 : Var<long> = var %9 @"l";
48 %11 : double = var.load %2;
49 %12 : int = conv %11;
50 %13 : Var<int> = var %12 @"i";
51 %14 : double = var.load %2;
52 %15 : short = conv %14;
53 %16 : Var<short> = var %15 @"s";
54 %17 : double = var.load %2;
55 %18 : char = conv %17;
56 %19 : Var<char> = var %18 @"c";
57 %20 : double = var.load %2;
58 %21 : byte = conv %20;
59 %22 : Var<byte> = var %21 @"b";
60 return;
61 };
62 """)
63 @SuppressWarnings("cast")
64 void testFromDouble(double v) {
65 double d = (double) v;
66 float f = (float) v;
67 long l = (long) v;
68 int i = (int) v;
69 short s = (short) v;
70 char c = (char) v;
71 byte b = (byte) v;
72 }
73
74 @CodeReflection
75 @IR("""
76 func @"testFromFloat" (%0 : PrimitiveCastTest, %1 : float)void -> {
77 %2 : Var<float> = var %1 @"v";
78 %3 : float = var.load %2;
79 %4 : double = conv %3;
80 %5 : Var<double> = var %4 @"d";
81 %6 : float = var.load %2;
82 %7 : Var<float> = var %6 @"f";
83 %8 : float = var.load %2;
84 %9 : long = conv %8;
85 %10 : Var<long> = var %9 @"l";
86 %11 : float = var.load %2;
87 %12 : int = conv %11;
88 %13 : Var<int> = var %12 @"i";
89 %14 : float = var.load %2;
90 %15 : short = conv %14;
91 %16 : Var<short> = var %15 @"s";
92 %17 : float = var.load %2;
93 %18 : char = conv %17;
94 %19 : Var<char> = var %18 @"c";
95 %20 : float = var.load %2;
96 %21 : byte = conv %20;
97 %22 : Var<byte> = var %21 @"b";
98 return;
99 };
100 """)
101 @SuppressWarnings("cast")
102 void testFromFloat(float v) {
103 double d = (double) v;
104 float f = (float) v;
105 long l = (long) v;
106 int i = (int) v;
107 short s = (short) v;
108 char c = (char) v;
109 byte b = (byte) v;
110 }
111
112 @CodeReflection
113 @IR("""
114 func @"testFromLong" (%0 : PrimitiveCastTest, %1 : long)void -> {
115 %2 : Var<long> = var %1 @"v";
116 %3 : long = var.load %2;
117 %4 : double = conv %3;
118 %5 : Var<double> = var %4 @"d";
119 %6 : long = var.load %2;
120 %7 : float = conv %6;
121 %8 : Var<float> = var %7 @"f";
122 %9 : long = var.load %2;
123 %10 : Var<long> = var %9 @"l";
124 %11 : long = var.load %2;
125 %12 : int = conv %11;
126 %13 : Var<int> = var %12 @"i";
127 %14 : long = var.load %2;
128 %15 : short = conv %14;
129 %16 : Var<short> = var %15 @"s";
130 %17 : long = var.load %2;
131 %18 : char = conv %17;
132 %19 : Var<char> = var %18 @"c";
133 %20 : long = var.load %2;
134 %21 : byte = conv %20;
135 %22 : Var<byte> = var %21 @"b";
136 return;
137 };
138 """)
139 @SuppressWarnings("cast")
140 void testFromLong(long v) {
141 double d = (double) v;
142 float f = (float) v;
143 long l = (long) v;
144 int i = (int) v;
145 short s = (short) v;
146 char c = (char) v;
147 byte b = (byte) v;
148 }
149
150 @CodeReflection
151 @IR("""
152 func @"testFromInt" (%0 : PrimitiveCastTest, %1 : int)void -> {
153 %2 : Var<int> = var %1 @"v";
154 %3 : int = var.load %2;
155 %4 : double = conv %3;
156 %5 : Var<double> = var %4 @"d";
157 %6 : int = var.load %2;
158 %7 : float = conv %6;
159 %8 : Var<float> = var %7 @"f";
160 %9 : int = var.load %2;
161 %10 : long = conv %9;
162 %11 : Var<long> = var %10 @"l";
163 %12 : int = var.load %2;
164 %13 : Var<int> = var %12 @"i";
165 %14 : int = var.load %2;
166 %15 : short = conv %14;
167 %16 : Var<short> = var %15 @"s";
168 %17 : int = var.load %2;
169 %18 : char = conv %17;
170 %19 : Var<char> = var %18 @"c";
171 %20 : int = var.load %2;
172 %21 : byte = conv %20;
173 %22 : Var<byte> = var %21 @"b";
174 return;
175 };
176 """)
177 @SuppressWarnings("cast")
178 void testFromInt(int v) {
179 double d = (double) v;
180 float f = (float) v;
181 long l = (long) v;
182 int i = (int) v;
183 short s = (short) v;
184 char c = (char) v;
185 byte b = (byte) v;
186 }
187
188 @CodeReflection
189 @IR("""
190 func @"testFromShort" (%0 : PrimitiveCastTest, %1 : short)void -> {
191 %2 : Var<short> = var %1 @"v";
192 %3 : short = var.load %2;
193 %4 : double = conv %3;
194 %5 : Var<double> = var %4 @"d";
195 %6 : short = var.load %2;
196 %7 : float = conv %6;
197 %8 : Var<float> = var %7 @"f";
198 %9 : short = var.load %2;
199 %10 : long = conv %9;
200 %11 : Var<long> = var %10 @"l";
201 %12 : short = var.load %2;
202 %13 : int = conv %12;
203 %14 : Var<int> = var %13 @"i";
204 %15 : short = var.load %2;
205 %16 : Var<short> = var %15 @"s";
206 %17 : short = var.load %2;
207 %18 : char = conv %17;
208 %19 : Var<char> = var %18 @"c";
209 %20 : short = var.load %2;
210 %21 : byte = conv %20;
211 %22 : Var<byte> = var %21 @"b";
212 return;
213 };
214 """)
215 @SuppressWarnings("cast")
216 void testFromShort(short v) {
217 double d = (double) v;
218 float f = (float) v;
219 long l = (long) v;
220 int i = (int) v;
221 short s = (short) v;
222 char c = (char) v;
223 byte b = (byte) v;
224 }
225
226 @CodeReflection
227 @IR("""
228 func @"testFromChar" (%0 : PrimitiveCastTest, %1 : char)void -> {
229 %2 : Var<char> = var %1 @"v";
230 %3 : char = var.load %2;
231 %4 : double = conv %3;
232 %5 : Var<double> = var %4 @"d";
233 %6 : char = var.load %2;
234 %7 : float = conv %6;
235 %8 : Var<float> = var %7 @"f";
236 %9 : char = var.load %2;
237 %10 : long = conv %9;
238 %11 : Var<long> = var %10 @"l";
239 %12 : char = var.load %2;
240 %13 : int = conv %12;
241 %14 : Var<int> = var %13 @"i";
242 %15 : char = var.load %2;
243 %16 : short = conv %15;
244 %17 : Var<short> = var %16 @"s";
245 %18 : char = var.load %2;
246 %19 : Var<char> = var %18 @"c";
247 %20 : char = var.load %2;
248 %21 : byte = conv %20;
249 %22 : Var<byte> = var %21 @"b";
250 return;
251 };
252 """)
253 @SuppressWarnings("cast")
254 void testFromChar(char v) {
255 double d = (double) v;
256 float f = (float) v;
257 long l = (long) v;
258 int i = (int) v;
259 short s = (short) v;
260 char c = (char) v;
261 byte b = (byte) v;
262 }
263
264 @CodeReflection
265 @IR("""
266 func @"testFromByte" (%0 : PrimitiveCastTest, %1 : byte)void -> {
267 %2 : Var<byte> = var %1 @"v";
268 %3 : byte = var.load %2;
269 %4 : double = conv %3;
270 %5 : Var<double> = var %4 @"d";
271 %6 : byte = var.load %2;
272 %7 : float = conv %6;
273 %8 : Var<float> = var %7 @"f";
274 %9 : byte = var.load %2;
275 %10 : long = conv %9;
276 %11 : Var<long> = var %10 @"l";
277 %12 : byte = var.load %2;
278 %13 : int = conv %12;
279 %14 : Var<int> = var %13 @"i";
280 %15 : byte = var.load %2;
281 %16 : short = conv %15;
282 %17 : Var<short> = var %16 @"s";
283 %18 : byte = var.load %2;
284 %19 : char = conv %18;
285 %20 : Var<char> = var %19 @"c";
286 %21 : byte = var.load %2;
287 %22 : Var<byte> = var %21 @"b";
288 return;
289 };
290 """)
291 @SuppressWarnings("cast")
292 void testFromByte(byte v) {
293 double d = (double) v;
294 float f = (float) v;
295 long l = (long) v;
296 int i = (int) v;
297 short s = (short) v;
298 char c = (char) v;
299 byte b = (byte) v;
300 }
301 }