1 /*
2  * Copyright (C) 2023 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 public class Main {
main(String[] args)18     public static void main(String[] args) {
19         $noinline$testReverseInt();
20         $noinline$testReverseLong();
21         $noinline$testReverseBytesInt();
22         $noinline$testReverseBytesLong();
23         $noinline$testReverseBytesShort();
24         $noinline$testBitCountInt();
25         $noinline$testBitCountLong();
26         $noinline$testDivideUnsignedInt();
27         $noinline$testDivideUnsignedLong();
28         $noinline$testHighestOneBitInt();
29         $noinline$testHighestOneBitLong();
30         $noinline$testLowestOneBitInt();
31         $noinline$testLowestOneBitLong();
32         $noinline$testLeadingZerosInt();
33         $noinline$testLeadingZerosLong();
34         $noinline$testTrailingZerosInt();
35         $noinline$testTrailingZerosLong();
36     }
37 
38     /// CHECK-START: void Main.$noinline$testReverseInt() constant_folding (before)
39     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerReverse
40 
41     /// CHECK-START: void Main.$noinline$testReverseInt() constant_folding (after)
42     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerReverse
$noinline$testReverseInt()43     private static void $noinline$testReverseInt() {
44         $noinline$assertIntEquals(-2, Integer.reverse(Integer.MAX_VALUE));
45         $noinline$assertIntEquals(1, Integer.reverse(Integer.MIN_VALUE));
46         $noinline$assertIntEquals(0, Integer.reverse(0));
47         // 0101... to 1010....
48         $noinline$assertIntEquals(0x55555555, Integer.reverse(0xAAAAAAAA));
49         // 1010.... to 0101...
50         $noinline$assertIntEquals(0xAAAAAAAA, Integer.reverse(0x55555555));
51         $noinline$testReverseInt_powerOfTwo();
52     }
53 
54     /// CHECK-START: void Main.$noinline$testReverseInt_powerOfTwo() constant_folding (before)
55     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerReverse
56 
57     /// CHECK-START: void Main.$noinline$testReverseInt_powerOfTwo() constant_folding (after)
58     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerReverse
$noinline$testReverseInt_powerOfTwo()59     private static void $noinline$testReverseInt_powerOfTwo() {
60         $noinline$assertIntEquals(1 << 31, Integer.reverse(1 << 0));
61         $noinline$assertIntEquals(1 << 30, Integer.reverse(1 << 1));
62         $noinline$assertIntEquals(1 << 29, Integer.reverse(1 << 2));
63         $noinline$assertIntEquals(1 << 28, Integer.reverse(1 << 3));
64         $noinline$assertIntEquals(1 << 27, Integer.reverse(1 << 4));
65         $noinline$assertIntEquals(1 << 26, Integer.reverse(1 << 5));
66         $noinline$assertIntEquals(1 << 25, Integer.reverse(1 << 6));
67         $noinline$assertIntEquals(1 << 24, Integer.reverse(1 << 7));
68         $noinline$assertIntEquals(1 << 23, Integer.reverse(1 << 8));
69         $noinline$assertIntEquals(1 << 22, Integer.reverse(1 << 9));
70         $noinline$assertIntEquals(1 << 21, Integer.reverse(1 << 10));
71         $noinline$assertIntEquals(1 << 20, Integer.reverse(1 << 11));
72         $noinline$assertIntEquals(1 << 19, Integer.reverse(1 << 12));
73         $noinline$assertIntEquals(1 << 18, Integer.reverse(1 << 13));
74         $noinline$assertIntEquals(1 << 17, Integer.reverse(1 << 14));
75         $noinline$assertIntEquals(1 << 16, Integer.reverse(1 << 15));
76         $noinline$assertIntEquals(1 << 15, Integer.reverse(1 << 16));
77         $noinline$assertIntEquals(1 << 14, Integer.reverse(1 << 17));
78         $noinline$assertIntEquals(1 << 13, Integer.reverse(1 << 18));
79         $noinline$assertIntEquals(1 << 12, Integer.reverse(1 << 19));
80         $noinline$assertIntEquals(1 << 11, Integer.reverse(1 << 20));
81         $noinline$assertIntEquals(1 << 10, Integer.reverse(1 << 21));
82         $noinline$assertIntEquals(1 << 9, Integer.reverse(1 << 22));
83         $noinline$assertIntEquals(1 << 8, Integer.reverse(1 << 23));
84         $noinline$assertIntEquals(1 << 7, Integer.reverse(1 << 24));
85         $noinline$assertIntEquals(1 << 6, Integer.reverse(1 << 25));
86         $noinline$assertIntEquals(1 << 5, Integer.reverse(1 << 26));
87         $noinline$assertIntEquals(1 << 4, Integer.reverse(1 << 27));
88         $noinline$assertIntEquals(1 << 3, Integer.reverse(1 << 28));
89         $noinline$assertIntEquals(1 << 2, Integer.reverse(1 << 29));
90         $noinline$assertIntEquals(1 << 1, Integer.reverse(1 << 30));
91         $noinline$assertIntEquals(1 << 0, Integer.reverse(1 << 31));
92     }
93 
94     /// CHECK-START: void Main.$noinline$testReverseLong() constant_folding (before)
95     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongReverse
96 
97     /// CHECK-START: void Main.$noinline$testReverseLong() constant_folding (after)
98     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongReverse
$noinline$testReverseLong()99     private static void $noinline$testReverseLong() {
100         $noinline$assertLongEquals(-2L, Long.reverse(Long.MAX_VALUE));
101         $noinline$assertLongEquals(1L, Long.reverse(Long.MIN_VALUE));
102         $noinline$assertLongEquals(0L, Long.reverse(0L));
103         // 0101... to 1010....
104         $noinline$assertLongEquals(0x5555555555555555L, Long.reverse(0xAAAAAAAAAAAAAAAAL));
105         // 1010.... to 0101...
106         $noinline$assertLongEquals(0xAAAAAAAAAAAAAAAAL, Long.reverse(0x5555555555555555L));
107         $noinline$testReverseLongFirst32_powerOfTwo();
108         $noinline$testReverseLongLast32_powerOfTwo();
109     }
110 
111     /// CHECK-START: void Main.$noinline$testReverseLongFirst32_powerOfTwo() constant_folding (before)
112     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongReverse
113 
114     /// CHECK-START: void Main.$noinline$testReverseLongFirst32_powerOfTwo() constant_folding (after)
115     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongReverse
$noinline$testReverseLongFirst32_powerOfTwo()116     private static void $noinline$testReverseLongFirst32_powerOfTwo() {
117         $noinline$assertLongEquals(1L << 63, Long.reverse(1L << 0));
118         $noinline$assertLongEquals(1L << 62, Long.reverse(1L << 1));
119         $noinline$assertLongEquals(1L << 61, Long.reverse(1L << 2));
120         $noinline$assertLongEquals(1L << 60, Long.reverse(1L << 3));
121         $noinline$assertLongEquals(1L << 59, Long.reverse(1L << 4));
122         $noinline$assertLongEquals(1L << 58, Long.reverse(1L << 5));
123         $noinline$assertLongEquals(1L << 57, Long.reverse(1L << 6));
124         $noinline$assertLongEquals(1L << 56, Long.reverse(1L << 7));
125         $noinline$assertLongEquals(1L << 55, Long.reverse(1L << 8));
126         $noinline$assertLongEquals(1L << 54, Long.reverse(1L << 9));
127         $noinline$assertLongEquals(1L << 53, Long.reverse(1L << 10));
128         $noinline$assertLongEquals(1L << 52, Long.reverse(1L << 11));
129         $noinline$assertLongEquals(1L << 51, Long.reverse(1L << 12));
130         $noinline$assertLongEquals(1L << 50, Long.reverse(1L << 13));
131         $noinline$assertLongEquals(1L << 49, Long.reverse(1L << 14));
132         $noinline$assertLongEquals(1L << 48, Long.reverse(1L << 15));
133         $noinline$assertLongEquals(1L << 47, Long.reverse(1L << 16));
134         $noinline$assertLongEquals(1L << 46, Long.reverse(1L << 17));
135         $noinline$assertLongEquals(1L << 45, Long.reverse(1L << 18));
136         $noinline$assertLongEquals(1L << 44, Long.reverse(1L << 19));
137         $noinline$assertLongEquals(1L << 43, Long.reverse(1L << 20));
138         $noinline$assertLongEquals(1L << 42, Long.reverse(1L << 21));
139         $noinline$assertLongEquals(1L << 41, Long.reverse(1L << 22));
140         $noinline$assertLongEquals(1L << 40, Long.reverse(1L << 23));
141         $noinline$assertLongEquals(1L << 39, Long.reverse(1L << 24));
142         $noinline$assertLongEquals(1L << 38, Long.reverse(1L << 25));
143         $noinline$assertLongEquals(1L << 37, Long.reverse(1L << 26));
144         $noinline$assertLongEquals(1L << 36, Long.reverse(1L << 27));
145         $noinline$assertLongEquals(1L << 35, Long.reverse(1L << 28));
146         $noinline$assertLongEquals(1L << 34, Long.reverse(1L << 29));
147         $noinline$assertLongEquals(1L << 33, Long.reverse(1L << 30));
148         $noinline$assertLongEquals(1L << 32, Long.reverse(1L << 31));
149     }
150 
151     /// CHECK-START: void Main.$noinline$testReverseLongLast32_powerOfTwo() constant_folding (before)
152     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongReverse
153 
154     /// CHECK-START: void Main.$noinline$testReverseLongLast32_powerOfTwo() constant_folding (after)
155     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongReverse
$noinline$testReverseLongLast32_powerOfTwo()156     private static void $noinline$testReverseLongLast32_powerOfTwo() {
157         $noinline$assertLongEquals(1L << 31, Long.reverse(1L << 32));
158         $noinline$assertLongEquals(1L << 30, Long.reverse(1L << 33));
159         $noinline$assertLongEquals(1L << 29, Long.reverse(1L << 34));
160         $noinline$assertLongEquals(1L << 28, Long.reverse(1L << 35));
161         $noinline$assertLongEquals(1L << 27, Long.reverse(1L << 36));
162         $noinline$assertLongEquals(1L << 26, Long.reverse(1L << 37));
163         $noinline$assertLongEquals(1L << 25, Long.reverse(1L << 38));
164         $noinline$assertLongEquals(1L << 24, Long.reverse(1L << 39));
165         $noinline$assertLongEquals(1L << 23, Long.reverse(1L << 40));
166         $noinline$assertLongEquals(1L << 22, Long.reverse(1L << 41));
167         $noinline$assertLongEquals(1L << 21, Long.reverse(1L << 42));
168         $noinline$assertLongEquals(1L << 20, Long.reverse(1L << 43));
169         $noinline$assertLongEquals(1L << 19, Long.reverse(1L << 44));
170         $noinline$assertLongEquals(1L << 18, Long.reverse(1L << 45));
171         $noinline$assertLongEquals(1L << 17, Long.reverse(1L << 46));
172         $noinline$assertLongEquals(1L << 16, Long.reverse(1L << 47));
173         $noinline$assertLongEquals(1L << 15, Long.reverse(1L << 48));
174         $noinline$assertLongEquals(1L << 14, Long.reverse(1L << 49));
175         $noinline$assertLongEquals(1L << 13, Long.reverse(1L << 50));
176         $noinline$assertLongEquals(1L << 12, Long.reverse(1L << 51));
177         $noinline$assertLongEquals(1L << 11, Long.reverse(1L << 52));
178         $noinline$assertLongEquals(1L << 10, Long.reverse(1L << 53));
179         $noinline$assertLongEquals(1L << 9, Long.reverse(1L << 54));
180         $noinline$assertLongEquals(1L << 8, Long.reverse(1L << 55));
181         $noinline$assertLongEquals(1L << 7, Long.reverse(1L << 56));
182         $noinline$assertLongEquals(1L << 6, Long.reverse(1L << 57));
183         $noinline$assertLongEquals(1L << 5, Long.reverse(1L << 58));
184         $noinline$assertLongEquals(1L << 4, Long.reverse(1L << 59));
185         $noinline$assertLongEquals(1L << 3, Long.reverse(1L << 60));
186         $noinline$assertLongEquals(1L << 2, Long.reverse(1L << 61));
187         $noinline$assertLongEquals(1L << 1, Long.reverse(1L << 62));
188         $noinline$assertLongEquals(1L << 0, Long.reverse(1L << 63));
189     }
190 
191     /// CHECK-START: void Main.$noinline$testReverseBytesInt() constant_folding (before)
192     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerReverseBytes
193 
194     /// CHECK-START: void Main.$noinline$testReverseBytesInt() constant_folding (after)
195     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerReverseBytes
$noinline$testReverseBytesInt()196     private static void $noinline$testReverseBytesInt() {
197         $noinline$assertIntEquals(-129, Integer.reverseBytes(Integer.MAX_VALUE));
198         $noinline$assertIntEquals(128, Integer.reverseBytes(Integer.MIN_VALUE));
199         $noinline$assertIntEquals(0, Integer.reverseBytes(0));
200         // 0101... to 0101....
201         $noinline$assertIntEquals(0x55555555, Integer.reverseBytes(0x55555555));
202         // 1010.... to 1010...
203         $noinline$assertIntEquals(0xAAAAAAAA, Integer.reverseBytes(0xAAAAAAAA));
204         // Going up/down the hex digits.
205         $noinline$assertIntEquals(0x01234567, Integer.reverseBytes(0x67452301));
206         $noinline$assertIntEquals(0x89ABCDEF, Integer.reverseBytes(0xEFCDAB89));
207         $noinline$assertIntEquals(0xFEDCBA98, Integer.reverseBytes(0x98BADCFE));
208         $noinline$assertIntEquals(0x76543210, Integer.reverseBytes(0x10325476));
209         $noinline$testReverseBytesInt_powerOfTwo();
210     }
211 
212     /// CHECK-START: void Main.$noinline$testReverseBytesInt_powerOfTwo() constant_folding (before)
213     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerReverseBytes
214 
215     /// CHECK-START: void Main.$noinline$testReverseBytesInt_powerOfTwo() constant_folding (after)
216     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerReverseBytes
$noinline$testReverseBytesInt_powerOfTwo()217     private static void $noinline$testReverseBytesInt_powerOfTwo() {
218         $noinline$assertIntEquals(1 << 24, Integer.reverseBytes(1 << 0));
219         $noinline$assertIntEquals(1 << 25, Integer.reverseBytes(1 << 1));
220         $noinline$assertIntEquals(1 << 26, Integer.reverseBytes(1 << 2));
221         $noinline$assertIntEquals(1 << 27, Integer.reverseBytes(1 << 3));
222         $noinline$assertIntEquals(1 << 28, Integer.reverseBytes(1 << 4));
223         $noinline$assertIntEquals(1 << 29, Integer.reverseBytes(1 << 5));
224         $noinline$assertIntEquals(1 << 30, Integer.reverseBytes(1 << 6));
225         $noinline$assertIntEquals(1 << 31, Integer.reverseBytes(1 << 7));
226         $noinline$assertIntEquals(1 << 16, Integer.reverseBytes(1 << 8));
227         $noinline$assertIntEquals(1 << 17, Integer.reverseBytes(1 << 9));
228         $noinline$assertIntEquals(1 << 18, Integer.reverseBytes(1 << 10));
229         $noinline$assertIntEquals(1 << 19, Integer.reverseBytes(1 << 11));
230         $noinline$assertIntEquals(1 << 20, Integer.reverseBytes(1 << 12));
231         $noinline$assertIntEquals(1 << 21, Integer.reverseBytes(1 << 13));
232         $noinline$assertIntEquals(1 << 22, Integer.reverseBytes(1 << 14));
233         $noinline$assertIntEquals(1 << 23, Integer.reverseBytes(1 << 15));
234         $noinline$assertIntEquals(1 << 8, Integer.reverseBytes(1 << 16));
235         $noinline$assertIntEquals(1 << 9, Integer.reverseBytes(1 << 17));
236         $noinline$assertIntEquals(1 << 10, Integer.reverseBytes(1 << 18));
237         $noinline$assertIntEquals(1 << 11, Integer.reverseBytes(1 << 19));
238         $noinline$assertIntEquals(1 << 12, Integer.reverseBytes(1 << 20));
239         $noinline$assertIntEquals(1 << 13, Integer.reverseBytes(1 << 21));
240         $noinline$assertIntEquals(1 << 14, Integer.reverseBytes(1 << 22));
241         $noinline$assertIntEquals(1 << 15, Integer.reverseBytes(1 << 23));
242         $noinline$assertIntEquals(1 << 0, Integer.reverseBytes(1 << 24));
243         $noinline$assertIntEquals(1 << 1, Integer.reverseBytes(1 << 25));
244         $noinline$assertIntEquals(1 << 2, Integer.reverseBytes(1 << 26));
245         $noinline$assertIntEquals(1 << 3, Integer.reverseBytes(1 << 27));
246         $noinline$assertIntEquals(1 << 4, Integer.reverseBytes(1 << 28));
247         $noinline$assertIntEquals(1 << 5, Integer.reverseBytes(1 << 29));
248         $noinline$assertIntEquals(1 << 6, Integer.reverseBytes(1 << 30));
249         $noinline$assertIntEquals(1 << 7, Integer.reverseBytes(1 << 31));
250     }
251 
252     /// CHECK-START: void Main.$noinline$testReverseBytesLong() constant_folding (before)
253     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongReverseBytes
254 
255     /// CHECK-START: void Main.$noinline$testReverseBytesLong() constant_folding (after)
256     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongReverseBytes
$noinline$testReverseBytesLong()257     private static void $noinline$testReverseBytesLong() {
258         $noinline$assertLongEquals(-129L, Long.reverseBytes(Long.MAX_VALUE));
259         $noinline$assertLongEquals(128L, Long.reverseBytes(Long.MIN_VALUE));
260         $noinline$assertLongEquals(0L, Long.reverseBytes(0L));
261         // 0101... to 0101....
262         $noinline$assertLongEquals(0x5555555555555555L, Long.reverseBytes(0x5555555555555555L));
263         // 1010.... to 1010...
264         $noinline$assertLongEquals(0xAAAAAAAAAAAAAAAAL, Long.reverseBytes(0xAAAAAAAAAAAAAAAAL));
265         // Going up/down the hex digits.
266         $noinline$assertLongEquals(0x0123456789ABCDEFL, Long.reverseBytes(0xEFCDAB8967452301L));
267         $noinline$assertLongEquals(0xFEDCBA9876543210L, Long.reverseBytes(0x1032547698BADCFEL));
268         $noinline$testReverseBytesLongFirst32_powerOfTwo();
269         $noinline$testReverseBytesLongLast32_powerOfTwo();
270     }
271 
272     /// CHECK-START: void Main.$noinline$testReverseBytesLongFirst32_powerOfTwo() constant_folding (before)
273     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongReverseBytes
274 
275     /// CHECK-START: void Main.$noinline$testReverseBytesLongFirst32_powerOfTwo() constant_folding (after)
276     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongReverseBytes
$noinline$testReverseBytesLongFirst32_powerOfTwo()277     private static void $noinline$testReverseBytesLongFirst32_powerOfTwo() {
278         $noinline$assertLongEquals(1L << 56, Long.reverseBytes(1L << 0));
279         $noinline$assertLongEquals(1L << 57, Long.reverseBytes(1L << 1));
280         $noinline$assertLongEquals(1L << 58, Long.reverseBytes(1L << 2));
281         $noinline$assertLongEquals(1L << 59, Long.reverseBytes(1L << 3));
282         $noinline$assertLongEquals(1L << 60, Long.reverseBytes(1L << 4));
283         $noinline$assertLongEquals(1L << 61, Long.reverseBytes(1L << 5));
284         $noinline$assertLongEquals(1L << 62, Long.reverseBytes(1L << 6));
285         $noinline$assertLongEquals(1L << 63, Long.reverseBytes(1L << 7));
286         $noinline$assertLongEquals(1L << 48, Long.reverseBytes(1L << 8));
287         $noinline$assertLongEquals(1L << 49, Long.reverseBytes(1L << 9));
288         $noinline$assertLongEquals(1L << 50, Long.reverseBytes(1L << 10));
289         $noinline$assertLongEquals(1L << 51, Long.reverseBytes(1L << 11));
290         $noinline$assertLongEquals(1L << 52, Long.reverseBytes(1L << 12));
291         $noinline$assertLongEquals(1L << 53, Long.reverseBytes(1L << 13));
292         $noinline$assertLongEquals(1L << 54, Long.reverseBytes(1L << 14));
293         $noinline$assertLongEquals(1L << 55, Long.reverseBytes(1L << 15));
294         $noinline$assertLongEquals(1L << 40, Long.reverseBytes(1L << 16));
295         $noinline$assertLongEquals(1L << 41, Long.reverseBytes(1L << 17));
296         $noinline$assertLongEquals(1L << 42, Long.reverseBytes(1L << 18));
297         $noinline$assertLongEquals(1L << 43, Long.reverseBytes(1L << 19));
298         $noinline$assertLongEquals(1L << 44, Long.reverseBytes(1L << 20));
299         $noinline$assertLongEquals(1L << 45, Long.reverseBytes(1L << 21));
300         $noinline$assertLongEquals(1L << 46, Long.reverseBytes(1L << 22));
301         $noinline$assertLongEquals(1L << 47, Long.reverseBytes(1L << 23));
302         $noinline$assertLongEquals(1L << 32, Long.reverseBytes(1L << 24));
303         $noinline$assertLongEquals(1L << 33, Long.reverseBytes(1L << 25));
304         $noinline$assertLongEquals(1L << 34, Long.reverseBytes(1L << 26));
305         $noinline$assertLongEquals(1L << 35, Long.reverseBytes(1L << 27));
306         $noinline$assertLongEquals(1L << 36, Long.reverseBytes(1L << 28));
307         $noinline$assertLongEquals(1L << 37, Long.reverseBytes(1L << 29));
308         $noinline$assertLongEquals(1L << 38, Long.reverseBytes(1L << 30));
309         $noinline$assertLongEquals(1L << 39, Long.reverseBytes(1L << 31));
310     }
311 
312     /// CHECK-START: void Main.$noinline$testReverseBytesLongLast32_powerOfTwo() constant_folding (before)
313     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongReverseBytes
314 
315     /// CHECK-START: void Main.$noinline$testReverseBytesLongLast32_powerOfTwo() constant_folding (after)
316     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongReverseBytes
$noinline$testReverseBytesLongLast32_powerOfTwo()317     private static void $noinline$testReverseBytesLongLast32_powerOfTwo() {
318         $noinline$assertLongEquals(1L << 24, Long.reverseBytes(1L << 32));
319         $noinline$assertLongEquals(1L << 25, Long.reverseBytes(1L << 33));
320         $noinline$assertLongEquals(1L << 26, Long.reverseBytes(1L << 34));
321         $noinline$assertLongEquals(1L << 27, Long.reverseBytes(1L << 35));
322         $noinline$assertLongEquals(1L << 28, Long.reverseBytes(1L << 36));
323         $noinline$assertLongEquals(1L << 29, Long.reverseBytes(1L << 37));
324         $noinline$assertLongEquals(1L << 30, Long.reverseBytes(1L << 38));
325         $noinline$assertLongEquals(1L << 31, Long.reverseBytes(1L << 39));
326         $noinline$assertLongEquals(1L << 16, Long.reverseBytes(1L << 40));
327         $noinline$assertLongEquals(1L << 17, Long.reverseBytes(1L << 41));
328         $noinline$assertLongEquals(1L << 18, Long.reverseBytes(1L << 42));
329         $noinline$assertLongEquals(1L << 19, Long.reverseBytes(1L << 43));
330         $noinline$assertLongEquals(1L << 20, Long.reverseBytes(1L << 44));
331         $noinline$assertLongEquals(1L << 21, Long.reverseBytes(1L << 45));
332         $noinline$assertLongEquals(1L << 22, Long.reverseBytes(1L << 46));
333         $noinline$assertLongEquals(1L << 23, Long.reverseBytes(1L << 47));
334         $noinline$assertLongEquals(1L << 8, Long.reverseBytes(1L << 48));
335         $noinline$assertLongEquals(1L << 9, Long.reverseBytes(1L << 49));
336         $noinline$assertLongEquals(1L << 10, Long.reverseBytes(1L << 50));
337         $noinline$assertLongEquals(1L << 11, Long.reverseBytes(1L << 51));
338         $noinline$assertLongEquals(1L << 12, Long.reverseBytes(1L << 52));
339         $noinline$assertLongEquals(1L << 13, Long.reverseBytes(1L << 53));
340         $noinline$assertLongEquals(1L << 14, Long.reverseBytes(1L << 54));
341         $noinline$assertLongEquals(1L << 15, Long.reverseBytes(1L << 55));
342         $noinline$assertLongEquals(1L << 0, Long.reverseBytes(1L << 56));
343         $noinline$assertLongEquals(1L << 1, Long.reverseBytes(1L << 57));
344         $noinline$assertLongEquals(1L << 2, Long.reverseBytes(1L << 58));
345         $noinline$assertLongEquals(1L << 3, Long.reverseBytes(1L << 59));
346         $noinline$assertLongEquals(1L << 4, Long.reverseBytes(1L << 60));
347         $noinline$assertLongEquals(1L << 5, Long.reverseBytes(1L << 61));
348         $noinline$assertLongEquals(1L << 6, Long.reverseBytes(1L << 62));
349         $noinline$assertLongEquals(1L << 7, Long.reverseBytes(1L << 63));
350     }
351 
352     /// CHECK-START: void Main.$noinline$testReverseBytesShort() constant_folding (before)
353     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:ShortReverseBytes
354 
355     /// CHECK-START: void Main.$noinline$testReverseBytesShort() constant_folding (after)
356     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:ShortReverseBytes
$noinline$testReverseBytesShort()357     private static void $noinline$testReverseBytesShort() {
358         $noinline$assertShortEquals((short) (-129), Short.reverseBytes(Short.MAX_VALUE));
359         $noinline$assertShortEquals((short) (128), Short.reverseBytes(Short.MIN_VALUE));
360         $noinline$assertShortEquals((short) (0), Short.reverseBytes((short) 0));
361         // 0101... to 0101....
362         $noinline$assertShortEquals((short) (0x5555), Short.reverseBytes((short) 0x5555));
363         // 1010.... to 1010...
364         $noinline$assertShortEquals((short) (0xAAAA), Short.reverseBytes((short) 0xAAAA));
365         // Going up/down the hex digits.
366         $noinline$assertShortEquals((short) (0x0123), Short.reverseBytes((short) 0x2301));
367         $noinline$assertShortEquals((short) (0x4567), Short.reverseBytes((short) 0x6745));
368         $noinline$assertShortEquals((short) (0x89AB), Short.reverseBytes((short) 0xAB89));
369         $noinline$assertShortEquals((short) (0xCDEF), Short.reverseBytes((short) 0xEFCD));
370         $noinline$assertShortEquals((short) (0xFEDC), Short.reverseBytes((short) 0xDCFE));
371         $noinline$assertShortEquals((short) (0xBA98), Short.reverseBytes((short) 0x98BA));
372         $noinline$assertShortEquals((short) (0x7654), Short.reverseBytes((short) 0x5476));
373         $noinline$assertShortEquals((short) (0x3210), Short.reverseBytes((short) 0x1032));
374         $noinline$testReverseBytesShort_powerOfTwo();
375     }
376 
377     /// CHECK-START: void Main.$noinline$testReverseBytesShort_powerOfTwo() constant_folding (before)
378     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:ShortReverseBytes
379 
380     /// CHECK-START: void Main.$noinline$testReverseBytesShort_powerOfTwo() constant_folding (after)
381     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:ShortReverseBytes
$noinline$testReverseBytesShort_powerOfTwo()382     private static void $noinline$testReverseBytesShort_powerOfTwo() {
383         $noinline$assertShortEquals((short) (1 << 8), Short.reverseBytes((short) (1 << 0)));
384         $noinline$assertShortEquals((short) (1 << 9), Short.reverseBytes((short) (1 << 1)));
385         $noinline$assertShortEquals((short) (1 << 10), Short.reverseBytes((short) (1 << 2)));
386         $noinline$assertShortEquals((short) (1 << 11), Short.reverseBytes((short) (1 << 3)));
387         $noinline$assertShortEquals((short) (1 << 12), Short.reverseBytes((short) (1 << 4)));
388         $noinline$assertShortEquals((short) (1 << 13), Short.reverseBytes((short) (1 << 5)));
389         $noinline$assertShortEquals((short) (1 << 14), Short.reverseBytes((short) (1 << 6)));
390         $noinline$assertShortEquals((short) (1 << 15), Short.reverseBytes((short) (1 << 7)));
391         $noinline$assertShortEquals((short) (1 << 0), Short.reverseBytes((short) (1 << 8)));
392         $noinline$assertShortEquals((short) (1 << 1), Short.reverseBytes((short) (1 << 9)));
393         $noinline$assertShortEquals((short) (1 << 2), Short.reverseBytes((short) (1 << 10)));
394         $noinline$assertShortEquals((short) (1 << 3), Short.reverseBytes((short) (1 << 11)));
395         $noinline$assertShortEquals((short) (1 << 4), Short.reverseBytes((short) (1 << 12)));
396         $noinline$assertShortEquals((short) (1 << 5), Short.reverseBytes((short) (1 << 13)));
397         $noinline$assertShortEquals((short) (1 << 6), Short.reverseBytes((short) (1 << 14)));
398         $noinline$assertShortEquals((short) (1 << 7), Short.reverseBytes((short) (1 << 15)));
399     }
400 
401     /// CHECK-START: void Main.$noinline$testBitCountInt() constant_folding (before)
402     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerBitCount
403 
404     /// CHECK-START: void Main.$noinline$testBitCountInt() constant_folding (after)
405     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerBitCount
$noinline$testBitCountInt()406     private static void $noinline$testBitCountInt() {
407         $noinline$assertIntEquals(31, Integer.bitCount(Integer.MAX_VALUE));
408         $noinline$assertIntEquals(1, Integer.bitCount(Integer.MIN_VALUE));
409         // 0101... and 1010...
410         $noinline$assertIntEquals(16, Integer.bitCount(0x55555555));
411         $noinline$assertIntEquals(16, Integer.bitCount(0xAAAAAAAA));
412         // 0000... and 1111...
413         $noinline$assertIntEquals(0, Integer.bitCount(0));
414         $noinline$assertIntEquals(32, Integer.bitCount(0xFFFFFFFF));
415         $noinline$testBitCountInt_powerOfTwo();
416         $noinline$testBitCountInt_powerOfTwoMinusOne();
417     }
418 
419     /// CHECK-START: void Main.$noinline$testBitCountInt_powerOfTwo() constant_folding (before)
420     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerBitCount
421 
422     /// CHECK-START: void Main.$noinline$testBitCountInt_powerOfTwo() constant_folding (after)
423     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerBitCount
$noinline$testBitCountInt_powerOfTwo()424     private static void $noinline$testBitCountInt_powerOfTwo() {
425         $noinline$assertIntEquals(1, Integer.bitCount(1 << 0));
426         $noinline$assertIntEquals(1, Integer.bitCount(1 << 1));
427         $noinline$assertIntEquals(1, Integer.bitCount(1 << 2));
428         $noinline$assertIntEquals(1, Integer.bitCount(1 << 3));
429         $noinline$assertIntEquals(1, Integer.bitCount(1 << 4));
430         $noinline$assertIntEquals(1, Integer.bitCount(1 << 5));
431         $noinline$assertIntEquals(1, Integer.bitCount(1 << 6));
432         $noinline$assertIntEquals(1, Integer.bitCount(1 << 7));
433         $noinline$assertIntEquals(1, Integer.bitCount(1 << 8));
434         $noinline$assertIntEquals(1, Integer.bitCount(1 << 9));
435         $noinline$assertIntEquals(1, Integer.bitCount(1 << 10));
436         $noinline$assertIntEquals(1, Integer.bitCount(1 << 11));
437         $noinline$assertIntEquals(1, Integer.bitCount(1 << 12));
438         $noinline$assertIntEquals(1, Integer.bitCount(1 << 13));
439         $noinline$assertIntEquals(1, Integer.bitCount(1 << 14));
440         $noinline$assertIntEquals(1, Integer.bitCount(1 << 15));
441         $noinline$assertIntEquals(1, Integer.bitCount(1 << 16));
442         $noinline$assertIntEquals(1, Integer.bitCount(1 << 17));
443         $noinline$assertIntEquals(1, Integer.bitCount(1 << 18));
444         $noinline$assertIntEquals(1, Integer.bitCount(1 << 19));
445         $noinline$assertIntEquals(1, Integer.bitCount(1 << 20));
446         $noinline$assertIntEquals(1, Integer.bitCount(1 << 21));
447         $noinline$assertIntEquals(1, Integer.bitCount(1 << 22));
448         $noinline$assertIntEquals(1, Integer.bitCount(1 << 23));
449         $noinline$assertIntEquals(1, Integer.bitCount(1 << 24));
450         $noinline$assertIntEquals(1, Integer.bitCount(1 << 25));
451         $noinline$assertIntEquals(1, Integer.bitCount(1 << 26));
452         $noinline$assertIntEquals(1, Integer.bitCount(1 << 27));
453         $noinline$assertIntEquals(1, Integer.bitCount(1 << 28));
454         $noinline$assertIntEquals(1, Integer.bitCount(1 << 29));
455         $noinline$assertIntEquals(1, Integer.bitCount(1 << 30));
456         $noinline$assertIntEquals(1, Integer.bitCount(1 << 31));
457     }
458 
459     /// CHECK-START: void Main.$noinline$testBitCountInt_powerOfTwoMinusOne() constant_folding (before)
460     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerBitCount
461 
462     /// CHECK-START: void Main.$noinline$testBitCountInt_powerOfTwoMinusOne() constant_folding (after)
463     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerBitCount
$noinline$testBitCountInt_powerOfTwoMinusOne()464     private static void $noinline$testBitCountInt_powerOfTwoMinusOne() {
465         // We start on `(1 << 2) - 1` (i.e. `3`) as the other values are already being tested.
466         $noinline$assertIntEquals(2, Integer.bitCount((1 << 2) - 1));
467         $noinline$assertIntEquals(3, Integer.bitCount((1 << 3) - 1));
468         $noinline$assertIntEquals(4, Integer.bitCount((1 << 4) - 1));
469         $noinline$assertIntEquals(5, Integer.bitCount((1 << 5) - 1));
470         $noinline$assertIntEquals(6, Integer.bitCount((1 << 6) - 1));
471         $noinline$assertIntEquals(7, Integer.bitCount((1 << 7) - 1));
472         $noinline$assertIntEquals(8, Integer.bitCount((1 << 8) - 1));
473         $noinline$assertIntEquals(9, Integer.bitCount((1 << 9) - 1));
474         $noinline$assertIntEquals(10, Integer.bitCount((1 << 10) - 1));
475         $noinline$assertIntEquals(11, Integer.bitCount((1 << 11) - 1));
476         $noinline$assertIntEquals(12, Integer.bitCount((1 << 12) - 1));
477         $noinline$assertIntEquals(13, Integer.bitCount((1 << 13) - 1));
478         $noinline$assertIntEquals(14, Integer.bitCount((1 << 14) - 1));
479         $noinline$assertIntEquals(15, Integer.bitCount((1 << 15) - 1));
480         $noinline$assertIntEquals(16, Integer.bitCount((1 << 16) - 1));
481         $noinline$assertIntEquals(17, Integer.bitCount((1 << 17) - 1));
482         $noinline$assertIntEquals(18, Integer.bitCount((1 << 18) - 1));
483         $noinline$assertIntEquals(19, Integer.bitCount((1 << 19) - 1));
484         $noinline$assertIntEquals(20, Integer.bitCount((1 << 20) - 1));
485         $noinline$assertIntEquals(21, Integer.bitCount((1 << 21) - 1));
486         $noinline$assertIntEquals(22, Integer.bitCount((1 << 22) - 1));
487         $noinline$assertIntEquals(23, Integer.bitCount((1 << 23) - 1));
488         $noinline$assertIntEquals(24, Integer.bitCount((1 << 24) - 1));
489         $noinline$assertIntEquals(25, Integer.bitCount((1 << 25) - 1));
490         $noinline$assertIntEquals(26, Integer.bitCount((1 << 26) - 1));
491         $noinline$assertIntEquals(27, Integer.bitCount((1 << 27) - 1));
492         $noinline$assertIntEquals(28, Integer.bitCount((1 << 28) - 1));
493         $noinline$assertIntEquals(29, Integer.bitCount((1 << 29) - 1));
494         $noinline$assertIntEquals(30, Integer.bitCount((1 << 30) - 1));
495         $noinline$assertIntEquals(31, Integer.bitCount((1 << 31) - 1));
496     }
497 
498 
499     /// CHECK-START: void Main.$noinline$testBitCountLong() constant_folding (before)
500     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongBitCount
501 
502     /// CHECK-START: void Main.$noinline$testBitCountLong() constant_folding (after)
503     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongBitCount
$noinline$testBitCountLong()504     private static void $noinline$testBitCountLong() {
505         $noinline$assertLongEquals(63L, Long.bitCount(Long.MAX_VALUE));
506         $noinline$assertLongEquals(1L, Long.bitCount(Long.MIN_VALUE));
507         // 0101... and 1010...
508         $noinline$assertLongEquals(32L, Long.bitCount(0x5555555555555555L));
509         $noinline$assertLongEquals(32L, Long.bitCount(0xAAAAAAAAAAAAAAAAL));
510         // 0000... and 1111...
511         $noinline$assertLongEquals(0L, Long.bitCount(0L));
512         $noinline$assertLongEquals(64L, Long.bitCount(0xFFFFFFFFFFFFFFFFL));
513         $noinline$testBitCountLongFirst32_powerOfTwo();
514         $noinline$testBitCountLongLast32_powerOfTwo();
515         $noinline$testBitCountLongFirst32_powerOfTwoMinusOne();
516         $noinline$testBitCountLongLast32_powerOfTwoMinusOne();
517     }
518 
519     /// CHECK-START: void Main.$noinline$testBitCountLongFirst32_powerOfTwo() constant_folding (before)
520     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongBitCount
521 
522     /// CHECK-START: void Main.$noinline$testBitCountLongFirst32_powerOfTwo() constant_folding (after)
523     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongBitCount
$noinline$testBitCountLongFirst32_powerOfTwo()524     private static void $noinline$testBitCountLongFirst32_powerOfTwo() {
525         $noinline$assertLongEquals(1L, Long.bitCount(1L << 0L));
526         $noinline$assertLongEquals(1L, Long.bitCount(1L << 1L));
527         $noinline$assertLongEquals(1L, Long.bitCount(1L << 2L));
528         $noinline$assertLongEquals(1L, Long.bitCount(1L << 3L));
529         $noinline$assertLongEquals(1L, Long.bitCount(1L << 4L));
530         $noinline$assertLongEquals(1L, Long.bitCount(1L << 5L));
531         $noinline$assertLongEquals(1L, Long.bitCount(1L << 6L));
532         $noinline$assertLongEquals(1L, Long.bitCount(1L << 7L));
533         $noinline$assertLongEquals(1L, Long.bitCount(1L << 8L));
534         $noinline$assertLongEquals(1L, Long.bitCount(1L << 9L));
535         $noinline$assertLongEquals(1L, Long.bitCount(1L << 10L));
536         $noinline$assertLongEquals(1L, Long.bitCount(1L << 11L));
537         $noinline$assertLongEquals(1L, Long.bitCount(1L << 12L));
538         $noinline$assertLongEquals(1L, Long.bitCount(1L << 13L));
539         $noinline$assertLongEquals(1L, Long.bitCount(1L << 14L));
540         $noinline$assertLongEquals(1L, Long.bitCount(1L << 15L));
541         $noinline$assertLongEquals(1L, Long.bitCount(1L << 16L));
542         $noinline$assertLongEquals(1L, Long.bitCount(1L << 17L));
543         $noinline$assertLongEquals(1L, Long.bitCount(1L << 18L));
544         $noinline$assertLongEquals(1L, Long.bitCount(1L << 19L));
545         $noinline$assertLongEquals(1L, Long.bitCount(1L << 20L));
546         $noinline$assertLongEquals(1L, Long.bitCount(1L << 21L));
547         $noinline$assertLongEquals(1L, Long.bitCount(1L << 22L));
548         $noinline$assertLongEquals(1L, Long.bitCount(1L << 23L));
549         $noinline$assertLongEquals(1L, Long.bitCount(1L << 24L));
550         $noinline$assertLongEquals(1L, Long.bitCount(1L << 25L));
551         $noinline$assertLongEquals(1L, Long.bitCount(1L << 26L));
552         $noinline$assertLongEquals(1L, Long.bitCount(1L << 27L));
553         $noinline$assertLongEquals(1L, Long.bitCount(1L << 28L));
554         $noinline$assertLongEquals(1L, Long.bitCount(1L << 29L));
555         $noinline$assertLongEquals(1L, Long.bitCount(1L << 30L));
556     }
557 
558     /// CHECK-START: void Main.$noinline$testBitCountLongLast32_powerOfTwo() constant_folding (before)
559     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongBitCount
560 
561     /// CHECK-START: void Main.$noinline$testBitCountLongLast32_powerOfTwo() constant_folding (after)
562     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongBitCount
$noinline$testBitCountLongLast32_powerOfTwo()563     private static void $noinline$testBitCountLongLast32_powerOfTwo() {
564         $noinline$assertLongEquals(1L, Long.bitCount(1L << 31L));
565         $noinline$assertLongEquals(1L, Long.bitCount(1L << 32L));
566         $noinline$assertLongEquals(1L, Long.bitCount(1L << 33L));
567         $noinline$assertLongEquals(1L, Long.bitCount(1L << 34L));
568         $noinline$assertLongEquals(1L, Long.bitCount(1L << 35L));
569         $noinline$assertLongEquals(1L, Long.bitCount(1L << 36L));
570         $noinline$assertLongEquals(1L, Long.bitCount(1L << 37L));
571         $noinline$assertLongEquals(1L, Long.bitCount(1L << 38L));
572         $noinline$assertLongEquals(1L, Long.bitCount(1L << 39L));
573         $noinline$assertLongEquals(1L, Long.bitCount(1L << 40L));
574         $noinline$assertLongEquals(1L, Long.bitCount(1L << 41L));
575         $noinline$assertLongEquals(1L, Long.bitCount(1L << 42L));
576         $noinline$assertLongEquals(1L, Long.bitCount(1L << 43L));
577         $noinline$assertLongEquals(1L, Long.bitCount(1L << 44L));
578         $noinline$assertLongEquals(1L, Long.bitCount(1L << 45L));
579         $noinline$assertLongEquals(1L, Long.bitCount(1L << 46L));
580         $noinline$assertLongEquals(1L, Long.bitCount(1L << 47L));
581         $noinline$assertLongEquals(1L, Long.bitCount(1L << 48L));
582         $noinline$assertLongEquals(1L, Long.bitCount(1L << 49L));
583         $noinline$assertLongEquals(1L, Long.bitCount(1L << 50L));
584         $noinline$assertLongEquals(1L, Long.bitCount(1L << 51L));
585         $noinline$assertLongEquals(1L, Long.bitCount(1L << 52L));
586         $noinline$assertLongEquals(1L, Long.bitCount(1L << 53L));
587         $noinline$assertLongEquals(1L, Long.bitCount(1L << 54L));
588         $noinline$assertLongEquals(1L, Long.bitCount(1L << 55L));
589         $noinline$assertLongEquals(1L, Long.bitCount(1L << 56L));
590         $noinline$assertLongEquals(1L, Long.bitCount(1L << 57L));
591         $noinline$assertLongEquals(1L, Long.bitCount(1L << 58L));
592         $noinline$assertLongEquals(1L, Long.bitCount(1L << 59L));
593         $noinline$assertLongEquals(1L, Long.bitCount(1L << 60L));
594         $noinline$assertLongEquals(1L, Long.bitCount(1L << 61L));
595         $noinline$assertLongEquals(1L, Long.bitCount(1L << 62L));
596         $noinline$assertLongEquals(1L, Long.bitCount(1L << 63L));
597     }
598 
599     /// CHECK-START: void Main.$noinline$testBitCountLongFirst32_powerOfTwoMinusOne() constant_folding (before)
600     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongBitCount
601 
602     /// CHECK-START: void Main.$noinline$testBitCountLongFirst32_powerOfTwoMinusOne() constant_folding (after)
603     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongBitCount
$noinline$testBitCountLongFirst32_powerOfTwoMinusOne()604     private static void $noinline$testBitCountLongFirst32_powerOfTwoMinusOne() {
605         // We start on `(1L << 2) - 1` (i.e. `3L`) as the other values are already being tested.
606         $noinline$assertLongEquals(2L, Long.bitCount((1L << 2) - 1L));
607         $noinline$assertLongEquals(3L, Long.bitCount((1L << 3) - 1L));
608         $noinline$assertLongEquals(4L, Long.bitCount((1L << 4) - 1L));
609         $noinline$assertLongEquals(5L, Long.bitCount((1L << 5) - 1L));
610         $noinline$assertLongEquals(6L, Long.bitCount((1L << 6) - 1L));
611         $noinline$assertLongEquals(7L, Long.bitCount((1L << 7) - 1L));
612         $noinline$assertLongEquals(8L, Long.bitCount((1L << 8) - 1L));
613         $noinline$assertLongEquals(9L, Long.bitCount((1L << 9) - 1L));
614         $noinline$assertLongEquals(10L, Long.bitCount((1L << 10) - 1L));
615         $noinline$assertLongEquals(11L, Long.bitCount((1L << 11) - 1L));
616         $noinline$assertLongEquals(12L, Long.bitCount((1L << 12) - 1L));
617         $noinline$assertLongEquals(13L, Long.bitCount((1L << 13) - 1L));
618         $noinline$assertLongEquals(14L, Long.bitCount((1L << 14) - 1L));
619         $noinline$assertLongEquals(15L, Long.bitCount((1L << 15) - 1L));
620         $noinline$assertLongEquals(16L, Long.bitCount((1L << 16) - 1L));
621         $noinline$assertLongEquals(17L, Long.bitCount((1L << 17) - 1L));
622         $noinline$assertLongEquals(18L, Long.bitCount((1L << 18) - 1L));
623         $noinline$assertLongEquals(19L, Long.bitCount((1L << 19) - 1L));
624         $noinline$assertLongEquals(20L, Long.bitCount((1L << 20) - 1L));
625         $noinline$assertLongEquals(21L, Long.bitCount((1L << 21) - 1L));
626         $noinline$assertLongEquals(22L, Long.bitCount((1L << 22) - 1L));
627         $noinline$assertLongEquals(23L, Long.bitCount((1L << 23) - 1L));
628         $noinline$assertLongEquals(24L, Long.bitCount((1L << 24) - 1L));
629         $noinline$assertLongEquals(25L, Long.bitCount((1L << 25) - 1L));
630         $noinline$assertLongEquals(26L, Long.bitCount((1L << 26) - 1L));
631         $noinline$assertLongEquals(27L, Long.bitCount((1L << 27) - 1L));
632         $noinline$assertLongEquals(28L, Long.bitCount((1L << 28) - 1L));
633         $noinline$assertLongEquals(29L, Long.bitCount((1L << 29) - 1L));
634         $noinline$assertLongEquals(30L, Long.bitCount((1L << 30) - 1L));
635     }
636 
637     /// CHECK-START: void Main.$noinline$testBitCountLongLast32_powerOfTwoMinusOne() constant_folding (before)
638     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongBitCount
639 
640     /// CHECK-START: void Main.$noinline$testBitCountLongLast32_powerOfTwoMinusOne() constant_folding (after)
641     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongBitCount
$noinline$testBitCountLongLast32_powerOfTwoMinusOne()642     private static void $noinline$testBitCountLongLast32_powerOfTwoMinusOne() {
643         $noinline$assertLongEquals(31L, Long.bitCount((1L << 31) - 1L));
644         $noinline$assertLongEquals(32L, Long.bitCount((1L << 32) - 1L));
645         $noinline$assertLongEquals(33L, Long.bitCount((1L << 33) - 1L));
646         $noinline$assertLongEquals(34L, Long.bitCount((1L << 34) - 1L));
647         $noinline$assertLongEquals(35L, Long.bitCount((1L << 35) - 1L));
648         $noinline$assertLongEquals(36L, Long.bitCount((1L << 36) - 1L));
649         $noinline$assertLongEquals(37L, Long.bitCount((1L << 37) - 1L));
650         $noinline$assertLongEquals(38L, Long.bitCount((1L << 38) - 1L));
651         $noinline$assertLongEquals(39L, Long.bitCount((1L << 39) - 1L));
652         $noinline$assertLongEquals(40L, Long.bitCount((1L << 40) - 1L));
653         $noinline$assertLongEquals(41L, Long.bitCount((1L << 41) - 1L));
654         $noinline$assertLongEquals(42L, Long.bitCount((1L << 42) - 1L));
655         $noinline$assertLongEquals(43L, Long.bitCount((1L << 43) - 1L));
656         $noinline$assertLongEquals(44L, Long.bitCount((1L << 44) - 1L));
657         $noinline$assertLongEquals(45L, Long.bitCount((1L << 45) - 1L));
658         $noinline$assertLongEquals(46L, Long.bitCount((1L << 46) - 1L));
659         $noinline$assertLongEquals(47L, Long.bitCount((1L << 47) - 1L));
660         $noinline$assertLongEquals(48L, Long.bitCount((1L << 48) - 1L));
661         $noinline$assertLongEquals(49L, Long.bitCount((1L << 49) - 1L));
662         $noinline$assertLongEquals(50L, Long.bitCount((1L << 50) - 1L));
663         $noinline$assertLongEquals(51L, Long.bitCount((1L << 51) - 1L));
664         $noinline$assertLongEquals(52L, Long.bitCount((1L << 52) - 1L));
665         $noinline$assertLongEquals(53L, Long.bitCount((1L << 53) - 1L));
666         $noinline$assertLongEquals(54L, Long.bitCount((1L << 54) - 1L));
667         $noinline$assertLongEquals(55L, Long.bitCount((1L << 55) - 1L));
668         $noinline$assertLongEquals(56L, Long.bitCount((1L << 56) - 1L));
669         $noinline$assertLongEquals(57L, Long.bitCount((1L << 57) - 1L));
670         $noinline$assertLongEquals(58L, Long.bitCount((1L << 58) - 1L));
671         $noinline$assertLongEquals(59L, Long.bitCount((1L << 59) - 1L));
672         $noinline$assertLongEquals(60L, Long.bitCount((1L << 60) - 1L));
673         $noinline$assertLongEquals(61L, Long.bitCount((1L << 61) - 1L));
674         $noinline$assertLongEquals(62L, Long.bitCount((1L << 62) - 1L));
675         $noinline$assertLongEquals(63L, Long.bitCount((1L << 63) - 1L));
676     }
677 
678     /// CHECK-START: void Main.$noinline$testDivideUnsignedInt() constant_folding (before)
679     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerDivideUnsigned
680 
681     /// CHECK-START: void Main.$noinline$testDivideUnsignedInt() constant_folding (after)
682     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerDivideUnsigned
$noinline$testDivideUnsignedInt()683     private static void $noinline$testDivideUnsignedInt() {
684         // Positive/Positive division is as normal.
685         $noinline$assertIntEquals(5, Integer.divideUnsigned(10, 2));
686         $noinline$assertIntEquals(0, Integer.divideUnsigned(2, 10));
687         $noinline$assertIntEquals(1, Integer.divideUnsigned(42, 42));
688 
689         // Positive/Negative is 0, as negative numbers are bigger (if taking a look as unsigned).
690         $noinline$assertIntEquals(0, Integer.divideUnsigned(10, -2));
691         $noinline$assertIntEquals(0, Integer.divideUnsigned(2, -10));
692         $noinline$assertIntEquals(0, Integer.divideUnsigned(42, -42));
693         $noinline$assertIntEquals(0, Integer.divideUnsigned(Integer.MAX_VALUE, -1));
694 
695         // Negative/Positive
696         $noinline$assertIntEquals(2147483643, Integer.divideUnsigned(-10, 2));
697         $noinline$assertIntEquals(429496729, Integer.divideUnsigned(-2, 10));
698         $noinline$assertIntEquals(102261125, Integer.divideUnsigned(-42, 42));
699         $noinline$assertIntEquals(1, Integer.divideUnsigned(Integer.MIN_VALUE, Integer.MAX_VALUE));
700         $noinline$assertIntEquals(-1, Integer.divideUnsigned(-1, 1));
701 
702         // Negative/Negative
703         $noinline$assertIntEquals(0, Integer.divideUnsigned(-2, -1));
704         $noinline$assertIntEquals(1, Integer.divideUnsigned(-1, -2));
705         $noinline$assertIntEquals(0, Integer.divideUnsigned(-10, -2));
706         $noinline$assertIntEquals(1, Integer.divideUnsigned(-2, -10));
707 
708         // Special cases where we don't constant fold the intrinsic
709         $noinline$testDivideUnsignedInt_divideByZero();
710     }
711 
712     /// CHECK-START: void Main.$noinline$testDivideUnsignedInt_divideByZero() constant_folding (before)
713     /// CHECK: InvokeStaticOrDirect intrinsic:IntegerDivideUnsigned
714     /// CHECK: InvokeStaticOrDirect intrinsic:IntegerDivideUnsigned
715 
716     /// CHECK-START: void Main.$noinline$testDivideUnsignedInt_divideByZero() constant_folding (after)
717     /// CHECK: InvokeStaticOrDirect intrinsic:IntegerDivideUnsigned
718     /// CHECK: InvokeStaticOrDirect intrinsic:IntegerDivideUnsigned
$noinline$testDivideUnsignedInt_divideByZero()719     private static void $noinline$testDivideUnsignedInt_divideByZero() {
720         try {
721             $noinline$assertIntEquals(0, Integer.divideUnsigned(1, 0));
722             throw new Error("Tried to divide 1 and 0 but didn't get an exception");
723         } catch (ArithmeticException expected) {
724         }
725 
726         try {
727             $noinline$assertIntEquals(0, Integer.divideUnsigned(-1, 0));
728             throw new Error("Tried to divide -1 and 0 but didn't get an exception");
729         } catch (ArithmeticException expected) {
730         }
731     }
732 
733     /// CHECK-START: void Main.$noinline$testDivideUnsignedLong() constant_folding (before)
734     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongDivideUnsigned
735 
736     /// CHECK-START: void Main.$noinline$testDivideUnsignedLong() constant_folding (after)
737     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongDivideUnsigned
$noinline$testDivideUnsignedLong()738     private static void $noinline$testDivideUnsignedLong() {
739         // Positive/Positive division is as normal.
740         $noinline$assertLongEquals(5L, Long.divideUnsigned(10L, 2L));
741         $noinline$assertLongEquals(0L, Long.divideUnsigned(2L, 10L));
742         $noinline$assertLongEquals(1L, Long.divideUnsigned(42L, 42L));
743 
744         // Positive/Negative is 0, as negative numbers are bigger (if taking a look as unsigned).
745         $noinline$assertLongEquals(0L, Long.divideUnsigned(10L, -2L));
746         $noinline$assertLongEquals(0L, Long.divideUnsigned(2L, -10L));
747         $noinline$assertLongEquals(0L, Long.divideUnsigned(42L, -42L));
748         $noinline$assertLongEquals(0L, Long.divideUnsigned(Long.MAX_VALUE, -1L));
749 
750         // Negative/Positive
751         $noinline$assertLongEquals(9223372036854775803L, Long.divideUnsigned(-10L, 2L));
752         $noinline$assertLongEquals(1844674407370955161L, Long.divideUnsigned(-2L, 10L));
753         $noinline$assertLongEquals(439208192231179799L, Long.divideUnsigned(-42L, 42L));
754         $noinline$assertLongEquals(1L, Long.divideUnsigned(Long.MIN_VALUE, Long.MAX_VALUE));
755         $noinline$assertLongEquals(-1L, Long.divideUnsigned(-1L, 1L));
756 
757         // Negative/Negative
758         $noinline$assertLongEquals(0L, Long.divideUnsigned(-2L, -1L));
759         $noinline$assertLongEquals(1L, Long.divideUnsigned(-1L, -2L));
760         $noinline$assertLongEquals(0L, Long.divideUnsigned(-10L, -2L));
761         $noinline$assertLongEquals(1L, Long.divideUnsigned(-2L, -10L));
762 
763         // Special cases where we don't constant fold the intrinsic
764         $noinline$testDivideUnsignedLong_divideByZero();
765     }
766 
767     /// CHECK-START: void Main.$noinline$testDivideUnsignedLong_divideByZero() constant_folding (before)
768     /// CHECK: InvokeStaticOrDirect intrinsic:LongDivideUnsigned
769     /// CHECK: InvokeStaticOrDirect intrinsic:LongDivideUnsigned
770 
771     /// CHECK-START: void Main.$noinline$testDivideUnsignedLong_divideByZero() constant_folding (after)
772     /// CHECK: InvokeStaticOrDirect intrinsic:LongDivideUnsigned
773     /// CHECK: InvokeStaticOrDirect intrinsic:LongDivideUnsigned
$noinline$testDivideUnsignedLong_divideByZero()774     private static void $noinline$testDivideUnsignedLong_divideByZero() {
775         try {
776             $noinline$assertLongEquals(0L, Long.divideUnsigned(1L, 0L));
777             throw new Error("Tried to divide 1 and 0 but didn't get an exception");
778         } catch (ArithmeticException expected) {
779         }
780 
781         try {
782             $noinline$assertLongEquals(0L, Long.divideUnsigned(-1L, 0L));
783             throw new Error("Tried to divide -1 and 0 but didn't get an exception");
784         } catch (ArithmeticException expected) {
785         }
786     }
787 
788     /// CHECK-START: void Main.$noinline$testHighestOneBitInt() constant_folding (before)
789     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerHighestOneBit
790 
791     /// CHECK-START: void Main.$noinline$testHighestOneBitInt() constant_folding (after)
792     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerHighestOneBit
$noinline$testHighestOneBitInt()793     private static void $noinline$testHighestOneBitInt() {
794         $noinline$assertIntEquals(1 << 30, Integer.highestOneBit(Integer.MAX_VALUE));
795         $noinline$assertIntEquals(1 << 31, Integer.highestOneBit(Integer.MIN_VALUE));
796         $noinline$testHighestOneBitInt_powerOfTwo();
797         $noinline$testHighestOneBitInt_powerOfTwoMinusOne();
798     }
799 
800     /// CHECK-START: void Main.$noinline$testHighestOneBitInt_powerOfTwo() constant_folding (before)
801     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerHighestOneBit
802 
803     /// CHECK-START: void Main.$noinline$testHighestOneBitInt_powerOfTwo() constant_folding (after)
804     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerHighestOneBit
$noinline$testHighestOneBitInt_powerOfTwo()805     private static void $noinline$testHighestOneBitInt_powerOfTwo() {
806         $noinline$assertIntEquals(0, Integer.highestOneBit(0));
807         $noinline$assertIntEquals(1 << 0, Integer.highestOneBit(1 << 0));
808         $noinline$assertIntEquals(1 << 1, Integer.highestOneBit(1 << 1));
809         $noinline$assertIntEquals(1 << 2, Integer.highestOneBit(1 << 2));
810         $noinline$assertIntEquals(1 << 3, Integer.highestOneBit(1 << 3));
811         $noinline$assertIntEquals(1 << 4, Integer.highestOneBit(1 << 4));
812         $noinline$assertIntEquals(1 << 5, Integer.highestOneBit(1 << 5));
813         $noinline$assertIntEquals(1 << 6, Integer.highestOneBit(1 << 6));
814         $noinline$assertIntEquals(1 << 7, Integer.highestOneBit(1 << 7));
815         $noinline$assertIntEquals(1 << 8, Integer.highestOneBit(1 << 8));
816         $noinline$assertIntEquals(1 << 9, Integer.highestOneBit(1 << 9));
817         $noinline$assertIntEquals(1 << 10, Integer.highestOneBit(1 << 10));
818         $noinline$assertIntEquals(1 << 11, Integer.highestOneBit(1 << 11));
819         $noinline$assertIntEquals(1 << 12, Integer.highestOneBit(1 << 12));
820         $noinline$assertIntEquals(1 << 13, Integer.highestOneBit(1 << 13));
821         $noinline$assertIntEquals(1 << 14, Integer.highestOneBit(1 << 14));
822         $noinline$assertIntEquals(1 << 15, Integer.highestOneBit(1 << 15));
823         $noinline$assertIntEquals(1 << 16, Integer.highestOneBit(1 << 16));
824         $noinline$assertIntEquals(1 << 17, Integer.highestOneBit(1 << 17));
825         $noinline$assertIntEquals(1 << 18, Integer.highestOneBit(1 << 18));
826         $noinline$assertIntEquals(1 << 19, Integer.highestOneBit(1 << 19));
827         $noinline$assertIntEquals(1 << 20, Integer.highestOneBit(1 << 20));
828         $noinline$assertIntEquals(1 << 21, Integer.highestOneBit(1 << 21));
829         $noinline$assertIntEquals(1 << 22, Integer.highestOneBit(1 << 22));
830         $noinline$assertIntEquals(1 << 23, Integer.highestOneBit(1 << 23));
831         $noinline$assertIntEquals(1 << 24, Integer.highestOneBit(1 << 24));
832         $noinline$assertIntEquals(1 << 25, Integer.highestOneBit(1 << 25));
833         $noinline$assertIntEquals(1 << 26, Integer.highestOneBit(1 << 26));
834         $noinline$assertIntEquals(1 << 27, Integer.highestOneBit(1 << 27));
835         $noinline$assertIntEquals(1 << 28, Integer.highestOneBit(1 << 28));
836         $noinline$assertIntEquals(1 << 29, Integer.highestOneBit(1 << 29));
837         $noinline$assertIntEquals(1 << 30, Integer.highestOneBit(1 << 30));
838         $noinline$assertIntEquals(1 << 31, Integer.highestOneBit(1 << 31));
839     }
840 
841     /// CHECK-START: void Main.$noinline$testHighestOneBitInt_powerOfTwoMinusOne() constant_folding (before)
842     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerHighestOneBit
843 
844     /// CHECK-START: void Main.$noinline$testHighestOneBitInt_powerOfTwoMinusOne() constant_folding (after)
845     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerHighestOneBit
$noinline$testHighestOneBitInt_powerOfTwoMinusOne()846     private static void $noinline$testHighestOneBitInt_powerOfTwoMinusOne() {
847         // We start on `(1 << 2) - 1` (i.e. `3`) as the other values are already being tested.
848         $noinline$assertIntEquals(1 << (2 - 1), Integer.highestOneBit((1 << 2) - 1));
849         $noinline$assertIntEquals(1 << (3 - 1), Integer.highestOneBit((1 << 3) - 1));
850         $noinline$assertIntEquals(1 << (4 - 1), Integer.highestOneBit((1 << 4) - 1));
851         $noinline$assertIntEquals(1 << (5 - 1), Integer.highestOneBit((1 << 5) - 1));
852         $noinline$assertIntEquals(1 << (6 - 1), Integer.highestOneBit((1 << 6) - 1));
853         $noinline$assertIntEquals(1 << (7 - 1), Integer.highestOneBit((1 << 7) - 1));
854         $noinline$assertIntEquals(1 << (8 - 1), Integer.highestOneBit((1 << 8) - 1));
855         $noinline$assertIntEquals(1 << (9 - 1), Integer.highestOneBit((1 << 9) - 1));
856         $noinline$assertIntEquals(1 << (10 - 1), Integer.highestOneBit((1 << 10) - 1));
857         $noinline$assertIntEquals(1 << (11 - 1), Integer.highestOneBit((1 << 11) - 1));
858         $noinline$assertIntEquals(1 << (12 - 1), Integer.highestOneBit((1 << 12) - 1));
859         $noinline$assertIntEquals(1 << (13 - 1), Integer.highestOneBit((1 << 13) - 1));
860         $noinline$assertIntEquals(1 << (14 - 1), Integer.highestOneBit((1 << 14) - 1));
861         $noinline$assertIntEquals(1 << (15 - 1), Integer.highestOneBit((1 << 15) - 1));
862         $noinline$assertIntEquals(1 << (16 - 1), Integer.highestOneBit((1 << 16) - 1));
863         $noinline$assertIntEquals(1 << (17 - 1), Integer.highestOneBit((1 << 17) - 1));
864         $noinline$assertIntEquals(1 << (18 - 1), Integer.highestOneBit((1 << 18) - 1));
865         $noinline$assertIntEquals(1 << (19 - 1), Integer.highestOneBit((1 << 19) - 1));
866         $noinline$assertIntEquals(1 << (20 - 1), Integer.highestOneBit((1 << 20) - 1));
867         $noinline$assertIntEquals(1 << (21 - 1), Integer.highestOneBit((1 << 21) - 1));
868         $noinline$assertIntEquals(1 << (22 - 1), Integer.highestOneBit((1 << 22) - 1));
869         $noinline$assertIntEquals(1 << (23 - 1), Integer.highestOneBit((1 << 23) - 1));
870         $noinline$assertIntEquals(1 << (24 - 1), Integer.highestOneBit((1 << 24) - 1));
871         $noinline$assertIntEquals(1 << (25 - 1), Integer.highestOneBit((1 << 25) - 1));
872         $noinline$assertIntEquals(1 << (26 - 1), Integer.highestOneBit((1 << 26) - 1));
873         $noinline$assertIntEquals(1 << (27 - 1), Integer.highestOneBit((1 << 27) - 1));
874         $noinline$assertIntEquals(1 << (28 - 1), Integer.highestOneBit((1 << 28) - 1));
875         $noinline$assertIntEquals(1 << (29 - 1), Integer.highestOneBit((1 << 29) - 1));
876         $noinline$assertIntEquals(1 << (30 - 1), Integer.highestOneBit((1 << 30) - 1));
877         $noinline$assertIntEquals(1 << (31 - 1), Integer.highestOneBit((1 << 31) - 1));
878     }
879 
880     /// CHECK-START: void Main.$noinline$testHighestOneBitLong() constant_folding (before)
881     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongHighestOneBit
882 
883     /// CHECK-START: void Main.$noinline$testHighestOneBitLong() constant_folding (after)
884     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongHighestOneBit
$noinline$testHighestOneBitLong()885     private static void $noinline$testHighestOneBitLong() {
886         $noinline$assertLongEquals(1L << 62, Long.highestOneBit(Long.MAX_VALUE));
887         $noinline$assertLongEquals(1L << 63, Long.highestOneBit(Long.MIN_VALUE));
888         // We need to do two smaller methods because otherwise we don't compile it due to our
889         // heuristics.
890         $noinline$testHighestOneBitLongFirst32_powerOfTwo();
891         $noinline$testHighestOneBitLongLast32_powerOfTwo();
892         $noinline$testHighestOneBitLongFirst32_powerOfTwoMinusOne();
893         $noinline$testHighestOneBitLongLast32_powerOfTwoMinusOne();
894     }
895 
896     /// CHECK-START: void Main.$noinline$testHighestOneBitLongFirst32_powerOfTwo() constant_folding (before)
897     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongHighestOneBit
898 
899     /// CHECK-START: void Main.$noinline$testHighestOneBitLongFirst32_powerOfTwo() constant_folding (after)
900     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongHighestOneBit
$noinline$testHighestOneBitLongFirst32_powerOfTwo()901     private static void $noinline$testHighestOneBitLongFirst32_powerOfTwo() {
902         $noinline$assertLongEquals(0, Long.highestOneBit(0L));
903         $noinline$assertLongEquals(1L << 0L, Long.highestOneBit(1L << 0L));
904         $noinline$assertLongEquals(1L << 1L, Long.highestOneBit(1L << 1L));
905         $noinline$assertLongEquals(1L << 2L, Long.highestOneBit(1L << 2L));
906         $noinline$assertLongEquals(1L << 3L, Long.highestOneBit(1L << 3L));
907         $noinline$assertLongEquals(1L << 4L, Long.highestOneBit(1L << 4L));
908         $noinline$assertLongEquals(1L << 5L, Long.highestOneBit(1L << 5L));
909         $noinline$assertLongEquals(1L << 6L, Long.highestOneBit(1L << 6L));
910         $noinline$assertLongEquals(1L << 7L, Long.highestOneBit(1L << 7L));
911         $noinline$assertLongEquals(1L << 8L, Long.highestOneBit(1L << 8L));
912         $noinline$assertLongEquals(1L << 9L, Long.highestOneBit(1L << 9L));
913         $noinline$assertLongEquals(1L << 10L, Long.highestOneBit(1L << 10L));
914         $noinline$assertLongEquals(1L << 11L, Long.highestOneBit(1L << 11L));
915         $noinline$assertLongEquals(1L << 12L, Long.highestOneBit(1L << 12L));
916         $noinline$assertLongEquals(1L << 13L, Long.highestOneBit(1L << 13L));
917         $noinline$assertLongEquals(1L << 14L, Long.highestOneBit(1L << 14L));
918         $noinline$assertLongEquals(1L << 15L, Long.highestOneBit(1L << 15L));
919         $noinline$assertLongEquals(1L << 16L, Long.highestOneBit(1L << 16L));
920         $noinline$assertLongEquals(1L << 17L, Long.highestOneBit(1L << 17L));
921         $noinline$assertLongEquals(1L << 18L, Long.highestOneBit(1L << 18L));
922         $noinline$assertLongEquals(1L << 19L, Long.highestOneBit(1L << 19L));
923         $noinline$assertLongEquals(1L << 20L, Long.highestOneBit(1L << 20L));
924         $noinline$assertLongEquals(1L << 21L, Long.highestOneBit(1L << 21L));
925         $noinline$assertLongEquals(1L << 22L, Long.highestOneBit(1L << 22L));
926         $noinline$assertLongEquals(1L << 23L, Long.highestOneBit(1L << 23L));
927         $noinline$assertLongEquals(1L << 24L, Long.highestOneBit(1L << 24L));
928         $noinline$assertLongEquals(1L << 25L, Long.highestOneBit(1L << 25L));
929         $noinline$assertLongEquals(1L << 26L, Long.highestOneBit(1L << 26L));
930         $noinline$assertLongEquals(1L << 27L, Long.highestOneBit(1L << 27L));
931         $noinline$assertLongEquals(1L << 28L, Long.highestOneBit(1L << 28L));
932         $noinline$assertLongEquals(1L << 29L, Long.highestOneBit(1L << 29L));
933         $noinline$assertLongEquals(1L << 30L, Long.highestOneBit(1L << 30L));
934     }
935 
936     /// CHECK-START: void Main.$noinline$testHighestOneBitLongLast32_powerOfTwo() constant_folding (before)
937     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongHighestOneBit
938 
939     /// CHECK-START: void Main.$noinline$testHighestOneBitLongLast32_powerOfTwo() constant_folding (after)
940     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongHighestOneBit
$noinline$testHighestOneBitLongLast32_powerOfTwo()941     private static void $noinline$testHighestOneBitLongLast32_powerOfTwo() {
942         $noinline$assertLongEquals(1L << 31L, Long.highestOneBit(1L << 31L));
943         $noinline$assertLongEquals(1L << 32L, Long.highestOneBit(1L << 32L));
944         $noinline$assertLongEquals(1L << 33L, Long.highestOneBit(1L << 33L));
945         $noinline$assertLongEquals(1L << 34L, Long.highestOneBit(1L << 34L));
946         $noinline$assertLongEquals(1L << 35L, Long.highestOneBit(1L << 35L));
947         $noinline$assertLongEquals(1L << 36L, Long.highestOneBit(1L << 36L));
948         $noinline$assertLongEquals(1L << 37L, Long.highestOneBit(1L << 37L));
949         $noinline$assertLongEquals(1L << 38L, Long.highestOneBit(1L << 38L));
950         $noinline$assertLongEquals(1L << 39L, Long.highestOneBit(1L << 39L));
951         $noinline$assertLongEquals(1L << 40L, Long.highestOneBit(1L << 40L));
952         $noinline$assertLongEquals(1L << 41L, Long.highestOneBit(1L << 41L));
953         $noinline$assertLongEquals(1L << 42L, Long.highestOneBit(1L << 42L));
954         $noinline$assertLongEquals(1L << 43L, Long.highestOneBit(1L << 43L));
955         $noinline$assertLongEquals(1L << 44L, Long.highestOneBit(1L << 44L));
956         $noinline$assertLongEquals(1L << 45L, Long.highestOneBit(1L << 45L));
957         $noinline$assertLongEquals(1L << 46L, Long.highestOneBit(1L << 46L));
958         $noinline$assertLongEquals(1L << 47L, Long.highestOneBit(1L << 47L));
959         $noinline$assertLongEquals(1L << 48L, Long.highestOneBit(1L << 48L));
960         $noinline$assertLongEquals(1L << 49L, Long.highestOneBit(1L << 49L));
961         $noinline$assertLongEquals(1L << 50L, Long.highestOneBit(1L << 50L));
962         $noinline$assertLongEquals(1L << 51L, Long.highestOneBit(1L << 51L));
963         $noinline$assertLongEquals(1L << 52L, Long.highestOneBit(1L << 52L));
964         $noinline$assertLongEquals(1L << 53L, Long.highestOneBit(1L << 53L));
965         $noinline$assertLongEquals(1L << 54L, Long.highestOneBit(1L << 54L));
966         $noinline$assertLongEquals(1L << 55L, Long.highestOneBit(1L << 55L));
967         $noinline$assertLongEquals(1L << 56L, Long.highestOneBit(1L << 56L));
968         $noinline$assertLongEquals(1L << 57L, Long.highestOneBit(1L << 57L));
969         $noinline$assertLongEquals(1L << 58L, Long.highestOneBit(1L << 58L));
970         $noinline$assertLongEquals(1L << 59L, Long.highestOneBit(1L << 59L));
971         $noinline$assertLongEquals(1L << 60L, Long.highestOneBit(1L << 60L));
972         $noinline$assertLongEquals(1L << 61L, Long.highestOneBit(1L << 61L));
973         $noinline$assertLongEquals(1L << 62L, Long.highestOneBit(1L << 62L));
974         $noinline$assertLongEquals(1L << 63L, Long.highestOneBit(1L << 63L));
975     }
976 
977     /// CHECK-START: void Main.$noinline$testHighestOneBitLongFirst32_powerOfTwoMinusOne() constant_folding (before)
978     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongHighestOneBit
979 
980     /// CHECK-START: void Main.$noinline$testHighestOneBitLongFirst32_powerOfTwoMinusOne() constant_folding (after)
981     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongHighestOneBit
$noinline$testHighestOneBitLongFirst32_powerOfTwoMinusOne()982     private static void $noinline$testHighestOneBitLongFirst32_powerOfTwoMinusOne() {
983         // We start on `(1L << 2) - 1` (i.e. `3L`) as the other values are already being tested.
984         $noinline$assertLongEquals(1L << (2 - 1), Long.highestOneBit((1L << 2) - 1L));
985         $noinline$assertLongEquals(1L << (3 - 1), Long.highestOneBit((1L << 3) - 1L));
986         $noinline$assertLongEquals(1L << (4 - 1), Long.highestOneBit((1L << 4) - 1L));
987         $noinline$assertLongEquals(1L << (5 - 1), Long.highestOneBit((1L << 5) - 1L));
988         $noinline$assertLongEquals(1L << (6 - 1), Long.highestOneBit((1L << 6) - 1L));
989         $noinline$assertLongEquals(1L << (7 - 1), Long.highestOneBit((1L << 7) - 1L));
990         $noinline$assertLongEquals(1L << (8 - 1), Long.highestOneBit((1L << 8) - 1L));
991         $noinline$assertLongEquals(1L << (9 - 1), Long.highestOneBit((1L << 9) - 1L));
992         $noinline$assertLongEquals(1L << (10 - 1), Long.highestOneBit((1L << 10) - 1L));
993         $noinline$assertLongEquals(1L << (11 - 1), Long.highestOneBit((1L << 11) - 1L));
994         $noinline$assertLongEquals(1L << (12 - 1), Long.highestOneBit((1L << 12) - 1L));
995         $noinline$assertLongEquals(1L << (13 - 1), Long.highestOneBit((1L << 13) - 1L));
996         $noinline$assertLongEquals(1L << (14 - 1), Long.highestOneBit((1L << 14) - 1L));
997         $noinline$assertLongEquals(1L << (15 - 1), Long.highestOneBit((1L << 15) - 1L));
998         $noinline$assertLongEquals(1L << (16 - 1), Long.highestOneBit((1L << 16) - 1L));
999         $noinline$assertLongEquals(1L << (17 - 1), Long.highestOneBit((1L << 17) - 1L));
1000         $noinline$assertLongEquals(1L << (18 - 1), Long.highestOneBit((1L << 18) - 1L));
1001         $noinline$assertLongEquals(1L << (19 - 1), Long.highestOneBit((1L << 19) - 1L));
1002         $noinline$assertLongEquals(1L << (20 - 1), Long.highestOneBit((1L << 20) - 1L));
1003         $noinline$assertLongEquals(1L << (21 - 1), Long.highestOneBit((1L << 21) - 1L));
1004         $noinline$assertLongEquals(1L << (22 - 1), Long.highestOneBit((1L << 22) - 1L));
1005         $noinline$assertLongEquals(1L << (23 - 1), Long.highestOneBit((1L << 23) - 1L));
1006         $noinline$assertLongEquals(1L << (24 - 1), Long.highestOneBit((1L << 24) - 1L));
1007         $noinline$assertLongEquals(1L << (25 - 1), Long.highestOneBit((1L << 25) - 1L));
1008         $noinline$assertLongEquals(1L << (26 - 1), Long.highestOneBit((1L << 26) - 1L));
1009         $noinline$assertLongEquals(1L << (27 - 1), Long.highestOneBit((1L << 27) - 1L));
1010         $noinline$assertLongEquals(1L << (28 - 1), Long.highestOneBit((1L << 28) - 1L));
1011         $noinline$assertLongEquals(1L << (29 - 1), Long.highestOneBit((1L << 29) - 1L));
1012         $noinline$assertLongEquals(1L << (30 - 1), Long.highestOneBit((1L << 30) - 1L));
1013     }
1014 
1015     /// CHECK-START: void Main.$noinline$testHighestOneBitLongLast32_powerOfTwoMinusOne() constant_folding (before)
1016     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongHighestOneBit
1017 
1018     /// CHECK-START: void Main.$noinline$testHighestOneBitLongLast32_powerOfTwoMinusOne() constant_folding (after)
1019     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongHighestOneBit
$noinline$testHighestOneBitLongLast32_powerOfTwoMinusOne()1020     private static void $noinline$testHighestOneBitLongLast32_powerOfTwoMinusOne() {
1021         $noinline$assertLongEquals(1L << (31 - 1), Long.highestOneBit((1L << 31) - 1L));
1022         $noinline$assertLongEquals(1L << (32 - 1), Long.highestOneBit((1L << 32) - 1L));
1023         $noinline$assertLongEquals(1L << (33 - 1), Long.highestOneBit((1L << 33) - 1L));
1024         $noinline$assertLongEquals(1L << (34 - 1), Long.highestOneBit((1L << 34) - 1L));
1025         $noinline$assertLongEquals(1L << (35 - 1), Long.highestOneBit((1L << 35) - 1L));
1026         $noinline$assertLongEquals(1L << (36 - 1), Long.highestOneBit((1L << 36) - 1L));
1027         $noinline$assertLongEquals(1L << (37 - 1), Long.highestOneBit((1L << 37) - 1L));
1028         $noinline$assertLongEquals(1L << (38 - 1), Long.highestOneBit((1L << 38) - 1L));
1029         $noinline$assertLongEquals(1L << (39 - 1), Long.highestOneBit((1L << 39) - 1L));
1030         $noinline$assertLongEquals(1L << (40 - 1), Long.highestOneBit((1L << 40) - 1L));
1031         $noinline$assertLongEquals(1L << (41 - 1), Long.highestOneBit((1L << 41) - 1L));
1032         $noinline$assertLongEquals(1L << (42 - 1), Long.highestOneBit((1L << 42) - 1L));
1033         $noinline$assertLongEquals(1L << (43 - 1), Long.highestOneBit((1L << 43) - 1L));
1034         $noinline$assertLongEquals(1L << (44 - 1), Long.highestOneBit((1L << 44) - 1L));
1035         $noinline$assertLongEquals(1L << (45 - 1), Long.highestOneBit((1L << 45) - 1L));
1036         $noinline$assertLongEquals(1L << (46 - 1), Long.highestOneBit((1L << 46) - 1L));
1037         $noinline$assertLongEquals(1L << (47 - 1), Long.highestOneBit((1L << 47) - 1L));
1038         $noinline$assertLongEquals(1L << (48 - 1), Long.highestOneBit((1L << 48) - 1L));
1039         $noinline$assertLongEquals(1L << (49 - 1), Long.highestOneBit((1L << 49) - 1L));
1040         $noinline$assertLongEquals(1L << (50 - 1), Long.highestOneBit((1L << 50) - 1L));
1041         $noinline$assertLongEquals(1L << (51 - 1), Long.highestOneBit((1L << 51) - 1L));
1042         $noinline$assertLongEquals(1L << (52 - 1), Long.highestOneBit((1L << 52) - 1L));
1043         $noinline$assertLongEquals(1L << (53 - 1), Long.highestOneBit((1L << 53) - 1L));
1044         $noinline$assertLongEquals(1L << (54 - 1), Long.highestOneBit((1L << 54) - 1L));
1045         $noinline$assertLongEquals(1L << (55 - 1), Long.highestOneBit((1L << 55) - 1L));
1046         $noinline$assertLongEquals(1L << (56 - 1), Long.highestOneBit((1L << 56) - 1L));
1047         $noinline$assertLongEquals(1L << (57 - 1), Long.highestOneBit((1L << 57) - 1L));
1048         $noinline$assertLongEquals(1L << (58 - 1), Long.highestOneBit((1L << 58) - 1L));
1049         $noinline$assertLongEquals(1L << (59 - 1), Long.highestOneBit((1L << 59) - 1L));
1050         $noinline$assertLongEquals(1L << (60 - 1), Long.highestOneBit((1L << 60) - 1L));
1051         $noinline$assertLongEquals(1L << (61 - 1), Long.highestOneBit((1L << 61) - 1L));
1052         $noinline$assertLongEquals(1L << (62 - 1), Long.highestOneBit((1L << 62) - 1L));
1053         $noinline$assertLongEquals(1L << (63 - 1), Long.highestOneBit((1L << 63) - 1L));
1054     }
1055 
1056     /// CHECK-START: void Main.$noinline$testLowestOneBitInt() constant_folding (before)
1057     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerLowestOneBit
1058 
1059     /// CHECK-START: void Main.$noinline$testLowestOneBitInt() constant_folding (after)
1060     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerLowestOneBit
$noinline$testLowestOneBitInt()1061     private static void $noinline$testLowestOneBitInt() {
1062         $noinline$assertIntEquals(1, Integer.lowestOneBit(Integer.MAX_VALUE));
1063         $noinline$assertIntEquals(1 << 31, Integer.lowestOneBit(Integer.MIN_VALUE));
1064         $noinline$testHighestOneBitInt_powerOfTwo();
1065         $noinline$testHighestOneBitInt_powerOfTwoMinusOne();
1066     }
1067 
1068     /// CHECK-START: void Main.$noinline$testLowestOneBitInt_powerOfTwo() constant_folding (before)
1069     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerLowestOneBit
1070 
1071     /// CHECK-START: void Main.$noinline$testLowestOneBitInt_powerOfTwo() constant_folding (after)
1072     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerLowestOneBit
$noinline$testLowestOneBitInt_powerOfTwo()1073     private static void $noinline$testLowestOneBitInt_powerOfTwo() {
1074         $noinline$assertIntEquals(0, Integer.lowestOneBit(0));
1075         $noinline$assertIntEquals(1 << 0, Integer.lowestOneBit(1 << 0));
1076         $noinline$assertIntEquals(1 << 1, Integer.lowestOneBit(1 << 1));
1077         $noinline$assertIntEquals(1 << 2, Integer.lowestOneBit(1 << 2));
1078         $noinline$assertIntEquals(1 << 3, Integer.lowestOneBit(1 << 3));
1079         $noinline$assertIntEquals(1 << 4, Integer.lowestOneBit(1 << 4));
1080         $noinline$assertIntEquals(1 << 5, Integer.lowestOneBit(1 << 5));
1081         $noinline$assertIntEquals(1 << 6, Integer.lowestOneBit(1 << 6));
1082         $noinline$assertIntEquals(1 << 7, Integer.lowestOneBit(1 << 7));
1083         $noinline$assertIntEquals(1 << 8, Integer.lowestOneBit(1 << 8));
1084         $noinline$assertIntEquals(1 << 9, Integer.lowestOneBit(1 << 9));
1085         $noinline$assertIntEquals(1 << 10, Integer.lowestOneBit(1 << 10));
1086         $noinline$assertIntEquals(1 << 11, Integer.lowestOneBit(1 << 11));
1087         $noinline$assertIntEquals(1 << 12, Integer.lowestOneBit(1 << 12));
1088         $noinline$assertIntEquals(1 << 13, Integer.lowestOneBit(1 << 13));
1089         $noinline$assertIntEquals(1 << 14, Integer.lowestOneBit(1 << 14));
1090         $noinline$assertIntEquals(1 << 15, Integer.lowestOneBit(1 << 15));
1091         $noinline$assertIntEquals(1 << 16, Integer.lowestOneBit(1 << 16));
1092         $noinline$assertIntEquals(1 << 17, Integer.lowestOneBit(1 << 17));
1093         $noinline$assertIntEquals(1 << 18, Integer.lowestOneBit(1 << 18));
1094         $noinline$assertIntEquals(1 << 19, Integer.lowestOneBit(1 << 19));
1095         $noinline$assertIntEquals(1 << 20, Integer.lowestOneBit(1 << 20));
1096         $noinline$assertIntEquals(1 << 21, Integer.lowestOneBit(1 << 21));
1097         $noinline$assertIntEquals(1 << 22, Integer.lowestOneBit(1 << 22));
1098         $noinline$assertIntEquals(1 << 23, Integer.lowestOneBit(1 << 23));
1099         $noinline$assertIntEquals(1 << 24, Integer.lowestOneBit(1 << 24));
1100         $noinline$assertIntEquals(1 << 25, Integer.lowestOneBit(1 << 25));
1101         $noinline$assertIntEquals(1 << 26, Integer.lowestOneBit(1 << 26));
1102         $noinline$assertIntEquals(1 << 27, Integer.lowestOneBit(1 << 27));
1103         $noinline$assertIntEquals(1 << 28, Integer.lowestOneBit(1 << 28));
1104         $noinline$assertIntEquals(1 << 29, Integer.lowestOneBit(1 << 29));
1105         $noinline$assertIntEquals(1 << 30, Integer.lowestOneBit(1 << 30));
1106         $noinline$assertIntEquals(1 << 31, Integer.lowestOneBit(1 << 31));
1107     }
1108 
1109     /// CHECK-START: void Main.$noinline$testLowestOneBitInt_powerOfTwoMinusOne() constant_folding (before)
1110     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerLowestOneBit
1111 
1112     /// CHECK-START: void Main.$noinline$testLowestOneBitInt_powerOfTwoMinusOne() constant_folding (after)
1113     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerLowestOneBit
$noinline$testLowestOneBitInt_powerOfTwoMinusOne()1114     private static void $noinline$testLowestOneBitInt_powerOfTwoMinusOne() {
1115         // We start on `(1 << 2) - 1` (i.e. `3`) as the other values are already being tested.
1116         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 2) - 1));
1117         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 3) - 1));
1118         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 4) - 1));
1119         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 5) - 1));
1120         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 6) - 1));
1121         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 7) - 1));
1122         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 8) - 1));
1123         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 9) - 1));
1124         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 10) - 1));
1125         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 11) - 1));
1126         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 12) - 1));
1127         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 13) - 1));
1128         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 14) - 1));
1129         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 15) - 1));
1130         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 16) - 1));
1131         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 17) - 1));
1132         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 18) - 1));
1133         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 19) - 1));
1134         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 20) - 1));
1135         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 21) - 1));
1136         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 22) - 1));
1137         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 23) - 1));
1138         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 24) - 1));
1139         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 25) - 1));
1140         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 26) - 1));
1141         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 27) - 1));
1142         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 28) - 1));
1143         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 29) - 1));
1144         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 30) - 1));
1145         $noinline$assertIntEquals(1, Integer.lowestOneBit((1 << 31) - 1));
1146     }
1147 
1148     /// CHECK-START: void Main.$noinline$testLowestOneBitLong() constant_folding (before)
1149     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongLowestOneBit
1150 
1151     /// CHECK-START: void Main.$noinline$testLowestOneBitLong() constant_folding (after)
1152     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongLowestOneBit
$noinline$testLowestOneBitLong()1153     private static void $noinline$testLowestOneBitLong() {
1154         $noinline$assertLongEquals(1L, Long.lowestOneBit(Long.MAX_VALUE));
1155         $noinline$assertLongEquals(1L << 63, Long.lowestOneBit(Long.MIN_VALUE));
1156         // We need to do two smaller methods because otherwise we don't compile it due to our
1157         // heuristics.
1158         $noinline$testLowestOneBitLongFirst32_powerOfTwo();
1159         $noinline$testLowestOneBitLongLast32_powerOfTwo();
1160         $noinline$testLowestOneBitLongFirst32_powerOfTwoMinusOne();
1161         $noinline$testLowestOneBitLongLast32_powerOfTwoMinusOne();
1162     }
1163 
1164     /// CHECK-START: void Main.$noinline$testLowestOneBitLongFirst32_powerOfTwo() constant_folding (before)
1165     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongLowestOneBit
1166 
1167     /// CHECK-START: void Main.$noinline$testLowestOneBitLongFirst32_powerOfTwo() constant_folding (after)
1168     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongLowestOneBit
$noinline$testLowestOneBitLongFirst32_powerOfTwo()1169     private static void $noinline$testLowestOneBitLongFirst32_powerOfTwo() {
1170         $noinline$assertLongEquals(0L, Long.lowestOneBit(0L));
1171         $noinline$assertLongEquals(1L << 0L, Long.lowestOneBit(1L << 0L));
1172         $noinline$assertLongEquals(1L << 1L, Long.lowestOneBit(1L << 1L));
1173         $noinline$assertLongEquals(1L << 2L, Long.lowestOneBit(1L << 2L));
1174         $noinline$assertLongEquals(1L << 3L, Long.lowestOneBit(1L << 3L));
1175         $noinline$assertLongEquals(1L << 4L, Long.lowestOneBit(1L << 4L));
1176         $noinline$assertLongEquals(1L << 5L, Long.lowestOneBit(1L << 5L));
1177         $noinline$assertLongEquals(1L << 6L, Long.lowestOneBit(1L << 6L));
1178         $noinline$assertLongEquals(1L << 7L, Long.lowestOneBit(1L << 7L));
1179         $noinline$assertLongEquals(1L << 8L, Long.lowestOneBit(1L << 8L));
1180         $noinline$assertLongEquals(1L << 9L, Long.lowestOneBit(1L << 9L));
1181         $noinline$assertLongEquals(1L << 10L, Long.lowestOneBit(1L << 10L));
1182         $noinline$assertLongEquals(1L << 11L, Long.lowestOneBit(1L << 11L));
1183         $noinline$assertLongEquals(1L << 12L, Long.lowestOneBit(1L << 12L));
1184         $noinline$assertLongEquals(1L << 13L, Long.lowestOneBit(1L << 13L));
1185         $noinline$assertLongEquals(1L << 14L, Long.lowestOneBit(1L << 14L));
1186         $noinline$assertLongEquals(1L << 15L, Long.lowestOneBit(1L << 15L));
1187         $noinline$assertLongEquals(1L << 16L, Long.lowestOneBit(1L << 16L));
1188         $noinline$assertLongEquals(1L << 17L, Long.lowestOneBit(1L << 17L));
1189         $noinline$assertLongEquals(1L << 18L, Long.lowestOneBit(1L << 18L));
1190         $noinline$assertLongEquals(1L << 19L, Long.lowestOneBit(1L << 19L));
1191         $noinline$assertLongEquals(1L << 20L, Long.lowestOneBit(1L << 20L));
1192         $noinline$assertLongEquals(1L << 21L, Long.lowestOneBit(1L << 21L));
1193         $noinline$assertLongEquals(1L << 22L, Long.lowestOneBit(1L << 22L));
1194         $noinline$assertLongEquals(1L << 23L, Long.lowestOneBit(1L << 23L));
1195         $noinline$assertLongEquals(1L << 24L, Long.lowestOneBit(1L << 24L));
1196         $noinline$assertLongEquals(1L << 25L, Long.lowestOneBit(1L << 25L));
1197         $noinline$assertLongEquals(1L << 26L, Long.lowestOneBit(1L << 26L));
1198         $noinline$assertLongEquals(1L << 27L, Long.lowestOneBit(1L << 27L));
1199         $noinline$assertLongEquals(1L << 28L, Long.lowestOneBit(1L << 28L));
1200         $noinline$assertLongEquals(1L << 29L, Long.lowestOneBit(1L << 29L));
1201         $noinline$assertLongEquals(1L << 30L, Long.lowestOneBit(1L << 30L));
1202     }
1203 
1204     /// CHECK-START: void Main.$noinline$testLowestOneBitLongLast32_powerOfTwo() constant_folding (before)
1205     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongLowestOneBit
1206 
1207     /// CHECK-START: void Main.$noinline$testLowestOneBitLongLast32_powerOfTwo() constant_folding (after)
1208     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongLowestOneBit
$noinline$testLowestOneBitLongLast32_powerOfTwo()1209     private static void $noinline$testLowestOneBitLongLast32_powerOfTwo() {
1210         $noinline$assertLongEquals(1L << 31L, Long.lowestOneBit(1L << 31L));
1211         $noinline$assertLongEquals(1L << 32L, Long.lowestOneBit(1L << 32L));
1212         $noinline$assertLongEquals(1L << 33L, Long.lowestOneBit(1L << 33L));
1213         $noinline$assertLongEquals(1L << 34L, Long.lowestOneBit(1L << 34L));
1214         $noinline$assertLongEquals(1L << 35L, Long.lowestOneBit(1L << 35L));
1215         $noinline$assertLongEquals(1L << 36L, Long.lowestOneBit(1L << 36L));
1216         $noinline$assertLongEquals(1L << 37L, Long.lowestOneBit(1L << 37L));
1217         $noinline$assertLongEquals(1L << 38L, Long.lowestOneBit(1L << 38L));
1218         $noinline$assertLongEquals(1L << 39L, Long.lowestOneBit(1L << 39L));
1219         $noinline$assertLongEquals(1L << 40L, Long.lowestOneBit(1L << 40L));
1220         $noinline$assertLongEquals(1L << 41L, Long.lowestOneBit(1L << 41L));
1221         $noinline$assertLongEquals(1L << 42L, Long.lowestOneBit(1L << 42L));
1222         $noinline$assertLongEquals(1L << 43L, Long.lowestOneBit(1L << 43L));
1223         $noinline$assertLongEquals(1L << 44L, Long.lowestOneBit(1L << 44L));
1224         $noinline$assertLongEquals(1L << 45L, Long.lowestOneBit(1L << 45L));
1225         $noinline$assertLongEquals(1L << 46L, Long.lowestOneBit(1L << 46L));
1226         $noinline$assertLongEquals(1L << 47L, Long.lowestOneBit(1L << 47L));
1227         $noinline$assertLongEquals(1L << 48L, Long.lowestOneBit(1L << 48L));
1228         $noinline$assertLongEquals(1L << 49L, Long.lowestOneBit(1L << 49L));
1229         $noinline$assertLongEquals(1L << 50L, Long.lowestOneBit(1L << 50L));
1230         $noinline$assertLongEquals(1L << 51L, Long.lowestOneBit(1L << 51L));
1231         $noinline$assertLongEquals(1L << 52L, Long.lowestOneBit(1L << 52L));
1232         $noinline$assertLongEquals(1L << 53L, Long.lowestOneBit(1L << 53L));
1233         $noinline$assertLongEquals(1L << 54L, Long.lowestOneBit(1L << 54L));
1234         $noinline$assertLongEquals(1L << 55L, Long.lowestOneBit(1L << 55L));
1235         $noinline$assertLongEquals(1L << 56L, Long.lowestOneBit(1L << 56L));
1236         $noinline$assertLongEquals(1L << 57L, Long.lowestOneBit(1L << 57L));
1237         $noinline$assertLongEquals(1L << 58L, Long.lowestOneBit(1L << 58L));
1238         $noinline$assertLongEquals(1L << 59L, Long.lowestOneBit(1L << 59L));
1239         $noinline$assertLongEquals(1L << 60L, Long.lowestOneBit(1L << 60L));
1240         $noinline$assertLongEquals(1L << 61L, Long.lowestOneBit(1L << 61L));
1241         $noinline$assertLongEquals(1L << 62L, Long.lowestOneBit(1L << 62L));
1242         $noinline$assertLongEquals(1L << 63L, Long.lowestOneBit(1L << 63L));
1243     }
1244 
1245     /// CHECK-START: void Main.$noinline$testLowestOneBitLongFirst32_powerOfTwoMinusOne() constant_folding (before)
1246     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongLowestOneBit
1247 
1248     /// CHECK-START: void Main.$noinline$testLowestOneBitLongFirst32_powerOfTwoMinusOne() constant_folding (after)
1249     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongLowestOneBit
$noinline$testLowestOneBitLongFirst32_powerOfTwoMinusOne()1250     private static void $noinline$testLowestOneBitLongFirst32_powerOfTwoMinusOne() {
1251         // We start on `(1L << 2) - 1` (i.e. `3L`) as the other values are already being tested.
1252         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 2) - 1L));
1253         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 3) - 1L));
1254         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 4) - 1L));
1255         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 5) - 1L));
1256         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 6) - 1L));
1257         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 7) - 1L));
1258         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 8) - 1L));
1259         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 9) - 1L));
1260         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 10) - 1L));
1261         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 11) - 1L));
1262         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 12) - 1L));
1263         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 13) - 1L));
1264         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 14) - 1L));
1265         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 15) - 1L));
1266         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 16) - 1L));
1267         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 17) - 1L));
1268         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 18) - 1L));
1269         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 19) - 1L));
1270         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 20) - 1L));
1271         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 21) - 1L));
1272         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 22) - 1L));
1273         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 23) - 1L));
1274         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 24) - 1L));
1275         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 25) - 1L));
1276         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 26) - 1L));
1277         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 27) - 1L));
1278         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 28) - 1L));
1279         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 29) - 1L));
1280         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 30) - 1L));
1281     }
1282 
1283     /// CHECK-START: void Main.$noinline$testLowestOneBitLongLast32_powerOfTwoMinusOne() constant_folding (before)
1284     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongLowestOneBit
1285 
1286     /// CHECK-START: void Main.$noinline$testLowestOneBitLongLast32_powerOfTwoMinusOne() constant_folding (after)
1287     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongLowestOneBit
$noinline$testLowestOneBitLongLast32_powerOfTwoMinusOne()1288     private static void $noinline$testLowestOneBitLongLast32_powerOfTwoMinusOne() {
1289         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 31) - 1L));
1290         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 32) - 1L));
1291         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 33) - 1L));
1292         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 34) - 1L));
1293         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 35) - 1L));
1294         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 36) - 1L));
1295         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 37) - 1L));
1296         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 38) - 1L));
1297         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 39) - 1L));
1298         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 40) - 1L));
1299         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 41) - 1L));
1300         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 42) - 1L));
1301         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 43) - 1L));
1302         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 44) - 1L));
1303         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 45) - 1L));
1304         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 46) - 1L));
1305         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 47) - 1L));
1306         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 48) - 1L));
1307         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 49) - 1L));
1308         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 50) - 1L));
1309         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 51) - 1L));
1310         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 52) - 1L));
1311         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 53) - 1L));
1312         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 54) - 1L));
1313         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 55) - 1L));
1314         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 56) - 1L));
1315         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 57) - 1L));
1316         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 58) - 1L));
1317         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 59) - 1L));
1318         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 60) - 1L));
1319         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 61) - 1L));
1320         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 62) - 1L));
1321         $noinline$assertLongEquals(1L, Long.lowestOneBit((1L << 63) - 1L));
1322     }
1323 
1324     /// CHECK-START: void Main.$noinline$testLeadingZerosInt() constant_folding (before)
1325     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerNumberOfLeadingZeros
1326 
1327     /// CHECK-START: void Main.$noinline$testLeadingZerosInt() constant_folding (after)
1328     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerNumberOfLeadingZeros
$noinline$testLeadingZerosInt()1329     private static void $noinline$testLeadingZerosInt() {
1330         $noinline$assertIntEquals(1, Integer.numberOfLeadingZeros(Integer.MAX_VALUE));
1331         $noinline$assertIntEquals(0, Integer.numberOfLeadingZeros(Integer.MIN_VALUE));
1332         $noinline$assertIntEquals(32, Integer.numberOfLeadingZeros(0));
1333         $noinline$assertIntEquals(31, Integer.numberOfLeadingZeros(1 << 0));
1334         $noinline$assertIntEquals(30, Integer.numberOfLeadingZeros(1 << 1));
1335         $noinline$assertIntEquals(29, Integer.numberOfLeadingZeros(1 << 2));
1336         $noinline$assertIntEquals(28, Integer.numberOfLeadingZeros(1 << 3));
1337         $noinline$assertIntEquals(27, Integer.numberOfLeadingZeros(1 << 4));
1338         $noinline$assertIntEquals(26, Integer.numberOfLeadingZeros(1 << 5));
1339         $noinline$assertIntEquals(25, Integer.numberOfLeadingZeros(1 << 6));
1340         $noinline$assertIntEquals(24, Integer.numberOfLeadingZeros(1 << 7));
1341         $noinline$assertIntEquals(23, Integer.numberOfLeadingZeros(1 << 8));
1342         $noinline$assertIntEquals(22, Integer.numberOfLeadingZeros(1 << 9));
1343         $noinline$assertIntEquals(21, Integer.numberOfLeadingZeros(1 << 10));
1344         $noinline$assertIntEquals(20, Integer.numberOfLeadingZeros(1 << 11));
1345         $noinline$assertIntEquals(19, Integer.numberOfLeadingZeros(1 << 12));
1346         $noinline$assertIntEquals(18, Integer.numberOfLeadingZeros(1 << 13));
1347         $noinline$assertIntEquals(17, Integer.numberOfLeadingZeros(1 << 14));
1348         $noinline$assertIntEquals(16, Integer.numberOfLeadingZeros(1 << 15));
1349         $noinline$assertIntEquals(15, Integer.numberOfLeadingZeros(1 << 16));
1350         $noinline$assertIntEquals(14, Integer.numberOfLeadingZeros(1 << 17));
1351         $noinline$assertIntEquals(13, Integer.numberOfLeadingZeros(1 << 18));
1352         $noinline$assertIntEquals(12, Integer.numberOfLeadingZeros(1 << 19));
1353         $noinline$assertIntEquals(11, Integer.numberOfLeadingZeros(1 << 20));
1354         $noinline$assertIntEquals(10, Integer.numberOfLeadingZeros(1 << 21));
1355         $noinline$assertIntEquals(9, Integer.numberOfLeadingZeros(1 << 22));
1356         $noinline$assertIntEquals(8, Integer.numberOfLeadingZeros(1 << 23));
1357         $noinline$assertIntEquals(7, Integer.numberOfLeadingZeros(1 << 24));
1358         $noinline$assertIntEquals(6, Integer.numberOfLeadingZeros(1 << 25));
1359         $noinline$assertIntEquals(5, Integer.numberOfLeadingZeros(1 << 26));
1360         $noinline$assertIntEquals(4, Integer.numberOfLeadingZeros(1 << 27));
1361         $noinline$assertIntEquals(3, Integer.numberOfLeadingZeros(1 << 28));
1362         $noinline$assertIntEquals(2, Integer.numberOfLeadingZeros(1 << 29));
1363         $noinline$assertIntEquals(1, Integer.numberOfLeadingZeros(1 << 30));
1364         $noinline$assertIntEquals(0, Integer.numberOfLeadingZeros(1 << 31));
1365     }
1366 
1367     /// CHECK-START: void Main.$noinline$testLeadingZerosLong() constant_folding (before)
1368     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongNumberOfLeadingZeros
1369 
1370     /// CHECK-START: void Main.$noinline$testLeadingZerosLong() constant_folding (after)
1371     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongNumberOfLeadingZeros
$noinline$testLeadingZerosLong()1372     private static void $noinline$testLeadingZerosLong() {
1373         $noinline$assertIntEquals(1, Long.numberOfLeadingZeros(Long.MAX_VALUE));
1374         $noinline$assertIntEquals(0, Long.numberOfLeadingZeros(Long.MIN_VALUE));
1375         // We need to do two smaller methods because otherwise we don't compile it due to our
1376         // heuristics.
1377         $noinline$testLeadingZerosLongFirst32();
1378         $noinline$testLeadingZerosLongLast32();
1379     }
1380 
1381     /// CHECK-START: void Main.$noinline$testLeadingZerosLongFirst32() constant_folding (before)
1382     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongNumberOfLeadingZeros
1383 
1384     /// CHECK-START: void Main.$noinline$testLeadingZerosLongFirst32() constant_folding (after)
1385     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongNumberOfLeadingZeros
$noinline$testLeadingZerosLongFirst32()1386     private static void $noinline$testLeadingZerosLongFirst32() {
1387         $noinline$assertIntEquals(64, Long.numberOfLeadingZeros(0L));
1388         $noinline$assertIntEquals(63, Long.numberOfLeadingZeros(1L << 0L));
1389         $noinline$assertIntEquals(62, Long.numberOfLeadingZeros(1L << 1L));
1390         $noinline$assertIntEquals(61, Long.numberOfLeadingZeros(1L << 2L));
1391         $noinline$assertIntEquals(60, Long.numberOfLeadingZeros(1L << 3L));
1392         $noinline$assertIntEquals(59, Long.numberOfLeadingZeros(1L << 4L));
1393         $noinline$assertIntEquals(58, Long.numberOfLeadingZeros(1L << 5L));
1394         $noinline$assertIntEquals(57, Long.numberOfLeadingZeros(1L << 6L));
1395         $noinline$assertIntEquals(56, Long.numberOfLeadingZeros(1L << 7L));
1396         $noinline$assertIntEquals(55, Long.numberOfLeadingZeros(1L << 8L));
1397         $noinline$assertIntEquals(54, Long.numberOfLeadingZeros(1L << 9L));
1398         $noinline$assertIntEquals(53, Long.numberOfLeadingZeros(1L << 10L));
1399         $noinline$assertIntEquals(52, Long.numberOfLeadingZeros(1L << 11L));
1400         $noinline$assertIntEquals(51, Long.numberOfLeadingZeros(1L << 12L));
1401         $noinline$assertIntEquals(50, Long.numberOfLeadingZeros(1L << 13L));
1402         $noinline$assertIntEquals(49, Long.numberOfLeadingZeros(1L << 14L));
1403         $noinline$assertIntEquals(48, Long.numberOfLeadingZeros(1L << 15L));
1404         $noinline$assertIntEquals(47, Long.numberOfLeadingZeros(1L << 16L));
1405         $noinline$assertIntEquals(46, Long.numberOfLeadingZeros(1L << 17L));
1406         $noinline$assertIntEquals(45, Long.numberOfLeadingZeros(1L << 18L));
1407         $noinline$assertIntEquals(44, Long.numberOfLeadingZeros(1L << 19L));
1408         $noinline$assertIntEquals(43, Long.numberOfLeadingZeros(1L << 20L));
1409         $noinline$assertIntEquals(42, Long.numberOfLeadingZeros(1L << 21L));
1410         $noinline$assertIntEquals(41, Long.numberOfLeadingZeros(1L << 22L));
1411         $noinline$assertIntEquals(40, Long.numberOfLeadingZeros(1L << 23L));
1412         $noinline$assertIntEquals(39, Long.numberOfLeadingZeros(1L << 24L));
1413         $noinline$assertIntEquals(38, Long.numberOfLeadingZeros(1L << 25L));
1414         $noinline$assertIntEquals(37, Long.numberOfLeadingZeros(1L << 26L));
1415         $noinline$assertIntEquals(36, Long.numberOfLeadingZeros(1L << 27L));
1416         $noinline$assertIntEquals(35, Long.numberOfLeadingZeros(1L << 28L));
1417         $noinline$assertIntEquals(34, Long.numberOfLeadingZeros(1L << 29L));
1418         $noinline$assertIntEquals(33, Long.numberOfLeadingZeros(1L << 30L));
1419     }
1420 
1421     /// CHECK-START: void Main.$noinline$testLeadingZerosLongLast32() constant_folding (before)
1422     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongNumberOfLeadingZeros
1423 
1424     /// CHECK-START: void Main.$noinline$testLeadingZerosLongLast32() constant_folding (after)
1425     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongNumberOfLeadingZeros
$noinline$testLeadingZerosLongLast32()1426     private static void $noinline$testLeadingZerosLongLast32() {
1427         $noinline$assertIntEquals(32, Long.numberOfLeadingZeros(1L << 31L));
1428         $noinline$assertIntEquals(31, Long.numberOfLeadingZeros(1L << 32L));
1429         $noinline$assertIntEquals(30, Long.numberOfLeadingZeros(1L << 33L));
1430         $noinline$assertIntEquals(29, Long.numberOfLeadingZeros(1L << 34L));
1431         $noinline$assertIntEquals(28, Long.numberOfLeadingZeros(1L << 35L));
1432         $noinline$assertIntEquals(27, Long.numberOfLeadingZeros(1L << 36L));
1433         $noinline$assertIntEquals(26, Long.numberOfLeadingZeros(1L << 37L));
1434         $noinline$assertIntEquals(25, Long.numberOfLeadingZeros(1L << 38L));
1435         $noinline$assertIntEquals(24, Long.numberOfLeadingZeros(1L << 39L));
1436         $noinline$assertIntEquals(23, Long.numberOfLeadingZeros(1L << 40L));
1437         $noinline$assertIntEquals(22, Long.numberOfLeadingZeros(1L << 41L));
1438         $noinline$assertIntEquals(21, Long.numberOfLeadingZeros(1L << 42L));
1439         $noinline$assertIntEquals(20, Long.numberOfLeadingZeros(1L << 43L));
1440         $noinline$assertIntEquals(19, Long.numberOfLeadingZeros(1L << 44L));
1441         $noinline$assertIntEquals(18, Long.numberOfLeadingZeros(1L << 45L));
1442         $noinline$assertIntEquals(17, Long.numberOfLeadingZeros(1L << 46L));
1443         $noinline$assertIntEquals(16, Long.numberOfLeadingZeros(1L << 47L));
1444         $noinline$assertIntEquals(15, Long.numberOfLeadingZeros(1L << 48L));
1445         $noinline$assertIntEquals(14, Long.numberOfLeadingZeros(1L << 49L));
1446         $noinline$assertIntEquals(13, Long.numberOfLeadingZeros(1L << 50L));
1447         $noinline$assertIntEquals(12, Long.numberOfLeadingZeros(1L << 51L));
1448         $noinline$assertIntEquals(11, Long.numberOfLeadingZeros(1L << 52L));
1449         $noinline$assertIntEquals(10, Long.numberOfLeadingZeros(1L << 53L));
1450         $noinline$assertIntEquals(9, Long.numberOfLeadingZeros(1L << 54L));
1451         $noinline$assertIntEquals(8, Long.numberOfLeadingZeros(1L << 55L));
1452         $noinline$assertIntEquals(7, Long.numberOfLeadingZeros(1L << 56L));
1453         $noinline$assertIntEquals(6, Long.numberOfLeadingZeros(1L << 57L));
1454         $noinline$assertIntEquals(5, Long.numberOfLeadingZeros(1L << 58L));
1455         $noinline$assertIntEquals(4, Long.numberOfLeadingZeros(1L << 59L));
1456         $noinline$assertIntEquals(3, Long.numberOfLeadingZeros(1L << 60L));
1457         $noinline$assertIntEquals(2, Long.numberOfLeadingZeros(1L << 61L));
1458         $noinline$assertIntEquals(1, Long.numberOfLeadingZeros(1L << 62L));
1459         $noinline$assertIntEquals(0, Long.numberOfLeadingZeros(1L << 63L));
1460     }
1461 
1462     /// CHECK-START: void Main.$noinline$testTrailingZerosInt() constant_folding (before)
1463     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:IntegerNumberOfTrailingZeros
1464 
1465     /// CHECK-START: void Main.$noinline$testTrailingZerosInt() constant_folding (after)
1466     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:IntegerNumberOfTrailingZeros
$noinline$testTrailingZerosInt()1467     private static void $noinline$testTrailingZerosInt() {
1468         $noinline$assertIntEquals(0, Integer.numberOfTrailingZeros(Integer.MAX_VALUE));
1469         $noinline$assertIntEquals(31, Integer.numberOfTrailingZeros(Integer.MIN_VALUE));
1470         $noinline$assertIntEquals(32, Integer.numberOfTrailingZeros(0));
1471         $noinline$assertIntEquals(0, Integer.numberOfTrailingZeros(1 << 0));
1472         $noinline$assertIntEquals(1, Integer.numberOfTrailingZeros(1 << 1));
1473         $noinline$assertIntEquals(2, Integer.numberOfTrailingZeros(1 << 2));
1474         $noinline$assertIntEquals(3, Integer.numberOfTrailingZeros(1 << 3));
1475         $noinline$assertIntEquals(4, Integer.numberOfTrailingZeros(1 << 4));
1476         $noinline$assertIntEquals(5, Integer.numberOfTrailingZeros(1 << 5));
1477         $noinline$assertIntEquals(6, Integer.numberOfTrailingZeros(1 << 6));
1478         $noinline$assertIntEquals(7, Integer.numberOfTrailingZeros(1 << 7));
1479         $noinline$assertIntEquals(8, Integer.numberOfTrailingZeros(1 << 8));
1480         $noinline$assertIntEquals(9, Integer.numberOfTrailingZeros(1 << 9));
1481         $noinline$assertIntEquals(10, Integer.numberOfTrailingZeros(1 << 10));
1482         $noinline$assertIntEquals(11, Integer.numberOfTrailingZeros(1 << 11));
1483         $noinline$assertIntEquals(12, Integer.numberOfTrailingZeros(1 << 12));
1484         $noinline$assertIntEquals(13, Integer.numberOfTrailingZeros(1 << 13));
1485         $noinline$assertIntEquals(14, Integer.numberOfTrailingZeros(1 << 14));
1486         $noinline$assertIntEquals(15, Integer.numberOfTrailingZeros(1 << 15));
1487         $noinline$assertIntEquals(16, Integer.numberOfTrailingZeros(1 << 16));
1488         $noinline$assertIntEquals(17, Integer.numberOfTrailingZeros(1 << 17));
1489         $noinline$assertIntEquals(18, Integer.numberOfTrailingZeros(1 << 18));
1490         $noinline$assertIntEquals(19, Integer.numberOfTrailingZeros(1 << 19));
1491         $noinline$assertIntEquals(20, Integer.numberOfTrailingZeros(1 << 20));
1492         $noinline$assertIntEquals(21, Integer.numberOfTrailingZeros(1 << 21));
1493         $noinline$assertIntEquals(22, Integer.numberOfTrailingZeros(1 << 22));
1494         $noinline$assertIntEquals(23, Integer.numberOfTrailingZeros(1 << 23));
1495         $noinline$assertIntEquals(24, Integer.numberOfTrailingZeros(1 << 24));
1496         $noinline$assertIntEquals(25, Integer.numberOfTrailingZeros(1 << 25));
1497         $noinline$assertIntEquals(26, Integer.numberOfTrailingZeros(1 << 26));
1498         $noinline$assertIntEquals(27, Integer.numberOfTrailingZeros(1 << 27));
1499         $noinline$assertIntEquals(28, Integer.numberOfTrailingZeros(1 << 28));
1500         $noinline$assertIntEquals(29, Integer.numberOfTrailingZeros(1 << 29));
1501         $noinline$assertIntEquals(30, Integer.numberOfTrailingZeros(1 << 30));
1502         $noinline$assertIntEquals(31, Integer.numberOfTrailingZeros(1 << 31));
1503     }
1504 
1505     /// CHECK-START: void Main.$noinline$testTrailingZerosLong() constant_folding (before)
1506     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongNumberOfTrailingZeros
1507 
1508     /// CHECK-START: void Main.$noinline$testTrailingZerosLong() constant_folding (after)
1509     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongNumberOfTrailingZeros
$noinline$testTrailingZerosLong()1510     private static void $noinline$testTrailingZerosLong() {
1511         $noinline$assertIntEquals(0, Long.numberOfTrailingZeros(Long.MAX_VALUE));
1512         $noinline$assertIntEquals(63, Long.numberOfTrailingZeros(Long.MIN_VALUE));
1513         // We need to do two smaller methods because otherwise we don't compile it due to our
1514         // heuristics.
1515         $noinline$testTrailingZerosLongFirst32();
1516         $noinline$testTrailingZerosLongLast32();
1517     }
1518 
1519     /// CHECK-START: void Main.$noinline$testTrailingZerosLongFirst32() constant_folding (before)
1520     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongNumberOfTrailingZeros
1521 
1522     /// CHECK-START: void Main.$noinline$testTrailingZerosLongFirst32() constant_folding (after)
1523     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongNumberOfTrailingZeros
$noinline$testTrailingZerosLongFirst32()1524     private static void $noinline$testTrailingZerosLongFirst32() {
1525         $noinline$assertIntEquals(64, Long.numberOfTrailingZeros(0L));
1526         $noinline$assertIntEquals(0, Long.numberOfTrailingZeros(1L << 0L));
1527         $noinline$assertIntEquals(1, Long.numberOfTrailingZeros(1L << 1L));
1528         $noinline$assertIntEquals(2, Long.numberOfTrailingZeros(1L << 2L));
1529         $noinline$assertIntEquals(3, Long.numberOfTrailingZeros(1L << 3L));
1530         $noinline$assertIntEquals(4, Long.numberOfTrailingZeros(1L << 4L));
1531         $noinline$assertIntEquals(5, Long.numberOfTrailingZeros(1L << 5L));
1532         $noinline$assertIntEquals(6, Long.numberOfTrailingZeros(1L << 6L));
1533         $noinline$assertIntEquals(7, Long.numberOfTrailingZeros(1L << 7L));
1534         $noinline$assertIntEquals(8, Long.numberOfTrailingZeros(1L << 8L));
1535         $noinline$assertIntEquals(9, Long.numberOfTrailingZeros(1L << 9L));
1536         $noinline$assertIntEquals(10, Long.numberOfTrailingZeros(1L << 10L));
1537         $noinline$assertIntEquals(11, Long.numberOfTrailingZeros(1L << 11L));
1538         $noinline$assertIntEquals(12, Long.numberOfTrailingZeros(1L << 12L));
1539         $noinline$assertIntEquals(13, Long.numberOfTrailingZeros(1L << 13L));
1540         $noinline$assertIntEquals(14, Long.numberOfTrailingZeros(1L << 14L));
1541         $noinline$assertIntEquals(15, Long.numberOfTrailingZeros(1L << 15L));
1542         $noinline$assertIntEquals(16, Long.numberOfTrailingZeros(1L << 16L));
1543         $noinline$assertIntEquals(17, Long.numberOfTrailingZeros(1L << 17L));
1544         $noinline$assertIntEquals(18, Long.numberOfTrailingZeros(1L << 18L));
1545         $noinline$assertIntEquals(19, Long.numberOfTrailingZeros(1L << 19L));
1546         $noinline$assertIntEquals(20, Long.numberOfTrailingZeros(1L << 20L));
1547         $noinline$assertIntEquals(21, Long.numberOfTrailingZeros(1L << 21L));
1548         $noinline$assertIntEquals(22, Long.numberOfTrailingZeros(1L << 22L));
1549         $noinline$assertIntEquals(23, Long.numberOfTrailingZeros(1L << 23L));
1550         $noinline$assertIntEquals(24, Long.numberOfTrailingZeros(1L << 24L));
1551         $noinline$assertIntEquals(25, Long.numberOfTrailingZeros(1L << 25L));
1552         $noinline$assertIntEquals(26, Long.numberOfTrailingZeros(1L << 26L));
1553         $noinline$assertIntEquals(27, Long.numberOfTrailingZeros(1L << 27L));
1554         $noinline$assertIntEquals(28, Long.numberOfTrailingZeros(1L << 28L));
1555         $noinline$assertIntEquals(29, Long.numberOfTrailingZeros(1L << 29L));
1556         $noinline$assertIntEquals(30, Long.numberOfTrailingZeros(1L << 30L));
1557         $noinline$assertIntEquals(31, Long.numberOfTrailingZeros(1L << 31L));
1558     }
1559 
1560     /// CHECK-START: void Main.$noinline$testTrailingZerosLongLast32() constant_folding (before)
1561     /// CHECK-DAG: InvokeStaticOrDirect intrinsic:LongNumberOfTrailingZeros
1562 
1563     /// CHECK-START: void Main.$noinline$testTrailingZerosLongLast32() constant_folding (after)
1564     /// CHECK-NOT: InvokeStaticOrDirect intrinsic:LongNumberOfTrailingZeros
$noinline$testTrailingZerosLongLast32()1565     private static void $noinline$testTrailingZerosLongLast32() {
1566         $noinline$assertIntEquals(32, Long.numberOfTrailingZeros(1L << 32L));
1567         $noinline$assertIntEquals(33, Long.numberOfTrailingZeros(1L << 33L));
1568         $noinline$assertIntEquals(34, Long.numberOfTrailingZeros(1L << 34L));
1569         $noinline$assertIntEquals(35, Long.numberOfTrailingZeros(1L << 35L));
1570         $noinline$assertIntEquals(36, Long.numberOfTrailingZeros(1L << 36L));
1571         $noinline$assertIntEquals(37, Long.numberOfTrailingZeros(1L << 37L));
1572         $noinline$assertIntEquals(38, Long.numberOfTrailingZeros(1L << 38L));
1573         $noinline$assertIntEquals(39, Long.numberOfTrailingZeros(1L << 39L));
1574         $noinline$assertIntEquals(40, Long.numberOfTrailingZeros(1L << 40L));
1575         $noinline$assertIntEquals(41, Long.numberOfTrailingZeros(1L << 41L));
1576         $noinline$assertIntEquals(42, Long.numberOfTrailingZeros(1L << 42L));
1577         $noinline$assertIntEquals(43, Long.numberOfTrailingZeros(1L << 43L));
1578         $noinline$assertIntEquals(44, Long.numberOfTrailingZeros(1L << 44L));
1579         $noinline$assertIntEquals(45, Long.numberOfTrailingZeros(1L << 45L));
1580         $noinline$assertIntEquals(46, Long.numberOfTrailingZeros(1L << 46L));
1581         $noinline$assertIntEquals(47, Long.numberOfTrailingZeros(1L << 47L));
1582         $noinline$assertIntEquals(48, Long.numberOfTrailingZeros(1L << 48L));
1583         $noinline$assertIntEquals(49, Long.numberOfTrailingZeros(1L << 49L));
1584         $noinline$assertIntEquals(50, Long.numberOfTrailingZeros(1L << 50L));
1585         $noinline$assertIntEquals(51, Long.numberOfTrailingZeros(1L << 51L));
1586         $noinline$assertIntEquals(52, Long.numberOfTrailingZeros(1L << 52L));
1587         $noinline$assertIntEquals(53, Long.numberOfTrailingZeros(1L << 53L));
1588         $noinline$assertIntEquals(54, Long.numberOfTrailingZeros(1L << 54L));
1589         $noinline$assertIntEquals(55, Long.numberOfTrailingZeros(1L << 55L));
1590         $noinline$assertIntEquals(56, Long.numberOfTrailingZeros(1L << 56L));
1591         $noinline$assertIntEquals(57, Long.numberOfTrailingZeros(1L << 57L));
1592         $noinline$assertIntEquals(58, Long.numberOfTrailingZeros(1L << 58L));
1593         $noinline$assertIntEquals(59, Long.numberOfTrailingZeros(1L << 59L));
1594         $noinline$assertIntEquals(60, Long.numberOfTrailingZeros(1L << 60L));
1595         $noinline$assertIntEquals(61, Long.numberOfTrailingZeros(1L << 61L));
1596         $noinline$assertIntEquals(62, Long.numberOfTrailingZeros(1L << 62L));
1597         $noinline$assertIntEquals(63, Long.numberOfTrailingZeros(1L << 63L));
1598     }
1599 
$noinline$assertIntEquals(int expected, int result)1600     public static void $noinline$assertIntEquals(int expected, int result) {
1601         if (expected != result) {
1602             throw new Error("Expected: " + expected + ", found: " + result);
1603         }
1604     }
1605 
$noinline$assertLongEquals(long expected, long result)1606     public static void $noinline$assertLongEquals(long expected, long result) {
1607         if (expected != result) {
1608             throw new Error("Expected: " + expected + ", found: " + result);
1609         }
1610     }
1611 
$noinline$assertShortEquals(short expected, short result)1612     public static void $noinline$assertShortEquals(short expected, short result) {
1613         if (expected != result) {
1614             throw new Error("Expected: " + expected + ", found: " + result);
1615         }
1616     }
1617 }
1618