1 /*
2 * Copyright (c) 2019, 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 #include "precompiled.hpp"
26 #include "memory/allocation.hpp"
27 #include "utilities/globalDefinitions.hpp"
28 #include "unittest.hpp"
29
30 class TestJavaArithSupport : public AllStatic {
31 public:
32 template<typename T> struct BinOpData { T x; T y; T r; };
33 template<typename T> struct ShiftOpData { T x; jint shift; T r; };
34 };
35
36 typedef TestJavaArithSupport::BinOpData<jint> BinOpJintData;
37 typedef TestJavaArithSupport::BinOpData<jlong> BinOpJlongData;
38
39 typedef TestJavaArithSupport::ShiftOpData<jint> ShiftOpJintData;
40 typedef TestJavaArithSupport::ShiftOpData<jlong> ShiftOpJlongData;
41
42 const BinOpJintData add_jint_data[] = {
43 { 0, 0, 0 },
44 { 0, 1, 1 },
45 { 0, -1, -1 },
46 { max_jint, 1, min_jint },
47 { max_jint, -1, max_jint - 1 },
48 { min_jint, 1, min_jint + 1 },
49 { min_jint, -1, max_jint },
50 { max_jint, 10, min_jint + 9 },
51 { max_jint, -10, max_jint - 10 },
52 { min_jint, 10, min_jint + 10 },
53 { min_jint, -10, max_jint - 9 },
54 { max_jint, max_jint, -2 },
55 { min_jint, min_jint, 0 }
56 };
57
58 const BinOpJlongData add_jlong_data[] = {
59 { 0, 0, 0 },
60 { 0, 1, 1 },
61 { 0, -1, -1 },
62 { max_jlong, 1, min_jlong },
63 { max_jlong, -1, max_jlong - 1 },
64 { min_jlong, 1, min_jlong + 1 },
65 { min_jlong, -1, max_jlong },
66 { max_jlong, 10, min_jlong + 9 },
67 { max_jlong, -10, max_jlong - 10 },
68 { min_jlong, 10, min_jlong + 10 },
69 { min_jlong, -10, max_jlong - 9 },
70 { max_jlong, max_jlong, -2 },
71 { min_jlong, min_jlong, 0 }
72 };
73
74 TEST(TestJavaArithmetic, add_sub_jint) {
75 const volatile BinOpJintData* data = add_jint_data;
76 for (size_t i = 0; i < ARRAY_SIZE(add_jint_data); ++i) {
77 ASSERT_EQ(data[i].r, java_add(data[i].x, data[i].y));
78 ASSERT_EQ(data[i].r, java_add(data[i].y, data[i].x));
79 ASSERT_EQ(data[i].x, java_subtract(data[i].r, data[i].y));
80 ASSERT_EQ(data[i].y, java_subtract(data[i].r, data[i].x));
81 }
82 }
83
84 TEST(TestJavaArithmetic, add_sub_jlong) {
85 const volatile BinOpJlongData* data = add_jlong_data;
86 for (size_t i = 0; i < ARRAY_SIZE(add_jlong_data); ++i) {
87 ASSERT_EQ(data[i].r, java_add(data[i].x, data[i].y));
88 ASSERT_EQ(data[i].r, java_add(data[i].y, data[i].x));
89 ASSERT_EQ(data[i].x, java_subtract(data[i].r, data[i].y));
90 ASSERT_EQ(data[i].y, java_subtract(data[i].r, data[i].x));
91 }
92 }
93
94 static const BinOpJintData mul_jint_data[] = {
95 { 0, 0, 0 },
96 { 0, 1, 0 },
97 { 0, max_jint, 0 },
98 { 0, min_jint, 0 },
99 { 1, 1, 1 },
100 { 1, max_jint, max_jint },
101 { 1, min_jint, min_jint },
102 { -1, 1, -1 },
103 { -1, max_jint, min_jint + 1 },
104 { 5, max_jint, max_jint - 4 },
105 { -5, max_jint, min_jint + 5 },
106 { max_jint, max_jint, 1 },
107 { max_jint, min_jint, min_jint },
108 { min_jint, min_jint, 0 }
109 };
110
111 static const BinOpJlongData mul_jlong_data[] = {
112 { 0, 0, 0 },
113 { 0, 1, 0 },
114 { 0, max_jlong, 0 },
115 { 0, min_jlong, 0 },
116 { 1, 1, 1 },
117 { 1, max_jlong, max_jlong },
118 { 1, min_jlong, min_jlong },
119 { -1, 1, -1 },
120 { -1, max_jlong, min_jlong + 1 },
121 { 5, max_jlong, max_jlong - 4 },
122 { -5, max_jlong, min_jlong + 5 },
123 { max_jlong, max_jlong, 1 },
124 { max_jlong, min_jlong, min_jlong },
125 { min_jlong, min_jlong, 0 }
126 };
127
128 TEST(TestJavaArithmetic, mul_jint) {
129 const volatile BinOpJintData* data = mul_jint_data;
130 for (size_t i = 0; i < ARRAY_SIZE(mul_jint_data); ++i) {
131 ASSERT_EQ(data[i].r, java_multiply(data[i].x, data[i].y));
132 ASSERT_EQ(data[i].r, java_multiply(data[i].y, data[i].x));
133 }
134 }
135
136 TEST(TestJavaArithmetic, mul_jlong) {
137 const volatile BinOpJlongData* data = mul_jlong_data;
138 for (size_t i = 0; i < ARRAY_SIZE(mul_jlong_data); ++i) {
139 ASSERT_EQ(data[i].r, java_multiply(data[i].x, data[i].y));
140 ASSERT_EQ(data[i].r, java_multiply(data[i].y, data[i].x));
141 }
142 }
143
144 static const ShiftOpJintData asl_jint_data[] = {
145 { 0, 0, 0 },
146 { 0, 10, 0 },
147 { 0, 50, 0 },
148 { 1, 0, 1 },
149 { 1, 10, (jint)1 << 10 },
150 { 1, 50, (jint)1 << 18 },
151 { 5, 0, 5 },
152 { 5, 10, (jint)5 << 10 },
153 { 5, 50, (jint)5 << 18 },
154 { -1, 0, -1 },
155 { -1, 10, (jint)-1 * (1 << 10) },
156 { -1, 50, (jint)-1 * (1 << 18) },
157 { -5, 0, -5 },
158 { -5, 10, (jint)-5 * (1 << 10) },
159 { -5, 50, (jint)-5 * (1 << 18) },
160 { max_jint, 0, max_jint },
161 { max_jint, 10, (jint)0xFFFFFC00 },
162 { max_jint, 50, (jint)0xFFFC0000 },
163 { min_jint, 0, min_jint },
164 { min_jint, 10, 0 },
165 { min_jint, 50, 0 }
166 };
167
168 static const ShiftOpJlongData asl_jlong_data[] = {
169 { 0, 0, 0 },
170 { 0, 10, 0 },
171 { 0, 82, 0 },
172 { 1, 0, 1 },
173 { 1, 10, (jlong)1 << 10 },
174 { 1, 82, (jlong)1 << 18 },
175 { 5, 0, 5 },
176 { 5, 10, (jlong)5 << 10 },
177 { 5, 82, (jlong)5 << 18 },
178 { -1, 0, -1 },
179 { -1, 10, (jlong)-1 * (1 << 10) },
180 { -1, 82, (jlong)-1 * (1 << 18) },
181 { -5, 0, -5 },
182 { -5, 10, (jlong)-5 * (1 << 10) },
183 { -5, 82, (jlong)-5 * (1 << 18) },
184 { max_jlong, 0, max_jlong },
185 { max_jlong, 10, (jlong)0xFFFFFFFFFFFFFC00 },
186 { max_jlong, 82, (jlong)0xFFFFFFFFFFFC0000 },
187 { min_jlong, 0, min_jlong },
188 { min_jlong, 10, 0 },
189 { min_jlong, 82, 0 }
190 };
191
192 TEST(TestJavaArithmetic, shift_left_jint) {
193 const volatile ShiftOpJintData* data = asl_jint_data;
194 for (size_t i = 0; i < ARRAY_SIZE(asl_jint_data); ++i) {
195 ASSERT_EQ(data[i].r, java_shift_left(data[i].x, data[i].shift));
196 }
197 }
198
199 TEST(TestJavaArithmetic, shift_left_jlong) {
200 const volatile ShiftOpJlongData* data = asl_jlong_data;
201 for (size_t i = 0; i < ARRAY_SIZE(asl_jlong_data); ++i) {
202 ASSERT_EQ(data[i].r, java_shift_left(data[i].x, data[i].shift));
203 }
204 }
205
206 static const ShiftOpJintData asr_jint_data[] = {
207 { 0, 0, 0 },
208 { 0, 10, 0 },
209 { 0, 50, 0 },
210 { 1, 0, 1 },
211 { 1, 10, 0 },
212 { 1, 50, 0 },
213 { 5, 0, 5 },
214 { 5, 1, 2 },
215 { 5, 10, 0 },
216 { 5, 33, 2 },
217 { 5, 50, 0 },
218 { -1, 0, -1 },
219 { -1, 10, -1 },
220 { -1, 50, -1 },
221 { -5, 0, -5 },
222 { -5, 1, -3 },
223 { -5, 10, -1 },
224 { -5, 33, -3 },
225 { -5, 50, -1 },
226 { max_jint, 0, max_jint },
227 { max_jint, 10, (jint)0x001FFFFF },
228 { max_jint, 50, (jint)0x00001FFF },
229 { min_jint, 0, min_jint },
230 { min_jint, 10, (jint)0xFFE00000 },
231 { min_jint, 50, (jint)0xFFFFE000 }
232 };
233
234 static const ShiftOpJlongData asr_jlong_data[] = {
235 { 0, 0, 0 },
236 { 0, 10, 0 },
237 { 0, 82, 0 },
238 { 1, 0, 1 },
239 { 1, 10, 0 },
240 { 1, 82, 0 },
241 { 5, 0, 5 },
242 { 5, 1, 2 },
243 { 5, 10, 0 },
244 { 5, 65, 2 },
245 { 5, 82, 0 },
246 { -1, 0, -1 },
247 { -1, 10, -1 },
248 { -1, 82, -1 },
249 { -5, 0, -5 },
250 { -5, 1, -3 },
251 { -5, 10, -1 },
252 { -5, 65, -3 },
253 { -5, 82, -1 },
254 { max_jlong, 0, max_jlong },
255 { max_jlong, 10, (jlong)0x001FFFFFFFFFFFFF },
256 { max_jlong, 82, (jlong)0x00001FFFFFFFFFFF },
257 { min_jlong, 0, min_jlong },
258 { min_jlong, 10, (jlong)0xFFE0000000000000 },
259 { min_jlong, 82, (jlong)0xFFFFE00000000000 }
260 };
261
262 TEST(TestJavaArithmetic, shift_right_jint) {
263 const volatile ShiftOpJintData* data = asr_jint_data;
264 for (size_t i = 0; i < ARRAY_SIZE(asr_jint_data); ++i) {
265 ASSERT_EQ(data[i].r, java_shift_right(data[i].x, data[i].shift));
266 }
267 }
268
269 TEST(TestJavaArithmetic, shift_right_jlong) {
270 const volatile ShiftOpJlongData* data = asr_jlong_data;
271 for (size_t i = 0; i < ARRAY_SIZE(asr_jlong_data); ++i) {
272 ASSERT_EQ(data[i].r, java_shift_right(data[i].x, data[i].shift));
273 }
274 }
275
276 static const ShiftOpJintData lsr_jint_data[] = {
277 { 0, 0, 0 },
278 { 0, 10, 0 },
279 { 0, 50, 0 },
280 { 1, 0, 1 },
281 { 1, 10, 0 },
282 { 1, 50, 0 },
283 { 5, 0, 5 },
284 { 5, 1, 2 },
285 { 5, 10, 0 },
286 { 5, 33, 2 },
287 { 5, 50, 0 },
288 { -1, 0, -1 },
289 { -1, 10, (jint)0x003FFFFF },
290 { -1, 50, (jint)0x00003FFF },
291 { -5, 0, -5 },
292 { -5, 1, (jint)0x7FFFFFFD },
293 { -5, 10, (jint)0x003FFFFF },
294 { -5, 50, (jint)0x00003FFF },
295 { max_jint, 0, max_jint },
296 { max_jint, 1, (jint)0x3FFFFFFF },
297 { max_jint, 10, (jint)0x001FFFFF },
298 { max_jint, 50, (jint)0x00001FFF },
299 { min_jint, 0, min_jint },
300 { min_jint, 1, (jint)0x40000000 },
301 { min_jint, 10, (jint)0x00200000 },
302 { min_jint, 50, (jint)0x00002000 }
303 };
304
305 static const ShiftOpJlongData lsr_jlong_data[] = {
306 { 0, 0, 0 },
307 { 0, 10, 0 },
308 { 0, 82, 0 },
309 { 1, 0, 1 },
310 { 1, 10, 0 },
311 { 1, 82, 0 },
312 { 5, 0, 5 },
313 { 5, 1, 2 },
314 { 5, 10, 0 },
315 { 5, 65, 2 },
316 { 5, 82, 0 },
317 { -1, 0, -1 },
318 { -1, 10, (jlong)0x003FFFFFFFFFFFFF },
319 { -1, 82, (jlong)0x00003FFFFFFFFFFF },
320 { -5, 0, -5 },
321 { -5, 1, (jlong)0x7FFFFFFFFFFFFFFD },
322 { -5, 10, (jlong)0x003FFFFFFFFFFFFF },
323 { -5, 82, (jlong)0x00003FFFFFFFFFFF },
324 { max_jlong, 0, max_jlong },
325 { max_jlong, 1, (jlong)0x3FFFFFFFFFFFFFFF },
326 { max_jlong, 10, (jlong)0x001FFFFFFFFFFFFF },
327 { max_jlong, 82, (jlong)0x00001FFFFFFFFFFF },
328 { min_jlong, 0, min_jlong },
329 { min_jlong, 1, (jlong)0x4000000000000000 },
330 { min_jlong, 10, (jlong)0x0020000000000000 },
331 { min_jlong, 82, (jlong)0x0000200000000000 }
332 };
333
334 TEST(TestJavaArithmetic, shift_right_unsigned_jint) {
335 const volatile ShiftOpJintData* data = lsr_jint_data;
336 for (size_t i = 0; i < ARRAY_SIZE(lsr_jint_data); ++i) {
337 ASSERT_EQ(data[i].r, java_shift_right_unsigned(data[i].x, data[i].shift));
338 }
339 }
340
341 TEST(TestJavaArithmetic, shift_right_unsigned_jlong) {
342 const volatile ShiftOpJlongData* data = lsr_jlong_data;
343 for (size_t i = 0; i < ARRAY_SIZE(lsr_jlong_data); ++i) {
344 ASSERT_EQ(data[i].r, java_shift_right_unsigned(data[i].x, data[i].shift));
345 }
346 }