1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 8031321
27 * @summary Support BMI1 instructions on x86/x64
28 * @run main/othervm -server -Xbatch -XX:-TieredCompilation -XX:CompileCommand=compileonly,BMITests.* BMI1
29 *
30 */
31
32 class MemI {
33 public int x;
34 public MemI(int x) { this.x = x; }
35 }
36
37 class MemL {
38 public long x;
39 public MemL(long x) { this.x = x; }
40 }
41
42 class BMITests {
43 static int andnl(int src1, int src2) {
44 return ~src1 & src2;
45 }
46 static long andnq(long src1, long src2) {
47 return ~src1 & src2;
48 }
49 static int andnl(int src1, MemI src2) {
50 return ~src1 & src2.x;
51 }
52 static long andnq(long src1, MemL src2) {
53 return ~src1 & src2.x;
54 }
55 static int blsil(int src1) {
56 return src1 & -src1;
57 }
58 static long blsiq(long src1) {
59 return src1 & -src1;
60 }
61 static int blsil(MemI src1) {
62 return src1.x & -src1.x;
63 }
64 static long blsiq(MemL src1) {
65 return src1.x & -src1.x;
66 }
67 static int blsmskl(int src1) {
68 return (src1 - 1) ^ src1;
69 }
70 static long blsmskq(long src1) {
71 return (src1 - 1) ^ src1;
72 }
73 static int blsmskl(MemI src1) {
74 return (src1.x - 1) ^ src1.x;
75 }
76 static long blsmskq(MemL src1) {
77 return (src1.x - 1) ^ src1.x;
78 }
79 static int blsrl(int src1) {
80 return (src1 - 1) & src1;
81 }
82 static long blsrq(long src1) {
83 return (src1 - 1) & src1;
84 }
85 static int blsrl(MemI src1) {
86 return (src1.x - 1) & src1.x;
87 }
88 static long blsrq(MemL src1) {
89 return (src1.x - 1) & src1.x;
90 }
91 static int lzcntl(int src1) {
92 return Integer.numberOfLeadingZeros(src1);
93 }
94 static int lzcntq(long src1) {
95 return Long.numberOfLeadingZeros(src1);
96 }
97 static int tzcntl(int src1) {
98 return Integer.numberOfTrailingZeros(src1);
99 }
100 static int tzcntq(long src1) {
101 return Long.numberOfTrailingZeros(src1);
102 }
103 }
104
105 public class BMI1 {
106 private static void fail() {
107 System.out.println("FAILED");
108 System.exit(97);
109 }
110 private final static int ITERATIONS = 1000000;
111
112 public static void main(String[] args) {
113 int ix = 0x01234567;
114 int iy = 0x89abcdef;
115 MemI imy = new MemI(iy);
116 long lx = 0x0123456701234567L;
117 long ly = 0x89abcdef89abcdefL;
118 MemL lmy = new MemL(ly);
119
120 { // match(Set dst (AndI (XorI src1 minus_1) src2))
121 int z = BMITests.andnl(ix, iy);
122 for (int i = 0; i < ITERATIONS; i++) {
123 int ii = BMITests.andnl(ix, iy);
124 if (ii != z) {
125 fail();
126 }
127 }
128 }
129 { // match(Set dst (AndL (XorL src1 minus_1) src2))
130 long z = BMITests.andnq(lx, ly);
131 for (int i = 0; i < ITERATIONS; i++) {
132 long ll = BMITests.andnq(lx, ly);
133 if (ll != z) {
134 fail();
135 }
136 }
137 }
138 { // match(Set dst (AndI (XorI src1 minus_1) (LoadI src2)))
139 int z = BMITests.andnl(ix, imy);
140 for (int i = 0; i < ITERATIONS; i++) {
141 int ii = BMITests.andnl(ix, imy);
142 if (ii != z) {
143 fail();
144 }
145 }
146 }
147 { // match(Set dst (AndL (XorL src1 minus_1) (LoadL src2)))
148 long z = BMITests.andnq(lx, lmy);
149 for (int i = 0; i < ITERATIONS; i++) {
150 long ll = BMITests.andnq(lx, lmy);
151 if (ll != z) {
152 fail();
153 }
154 }
155 }
156 { // match(Set dst (AndI (SubI imm_zero src) src))
157 int z = BMITests.blsil(ix);
158 for (int i = 0; i < ITERATIONS; i++) {
159 int ii = BMITests.blsil(ix);
160 if (ii != z) {
161 fail();
162 }
163 }
164 }
165 { // match(Set dst (AndL (SubL imm_zero src) src))
166 long z = BMITests.blsiq(lx);
167 for (int i = 0; i < ITERATIONS; i++) {
168 long ll = BMITests.blsiq(lx);
169 if (ll != z) {
170 fail();
171 }
172 }
173 }
174 { // match(Set dst (AndI (SubI imm_zero (LoadI src) ) (LoadI src) ))
175 int z = BMITests.blsil(imy);
176 for (int i = 0; i < ITERATIONS; i++) {
177 int ii = BMITests.blsil(imy);
178 if (ii != z) {
179 fail();
180 }
181 }
182 }
183 { // match(Set dst (AndL (SubL imm_zero (LoadL src) ) (LoadL src) ))
184 long z = BMITests.blsiq(lmy);
185 for (int i = 0; i < ITERATIONS; i++) {
186 long ll = BMITests.blsiq(lmy);
187 if (ll != z) {
188 fail();
189 }
190 }
191 }
192
193 { // match(Set dst (XorI (AddI src minus_1) src))
194 int z = BMITests.blsmskl(ix);
195 for (int i = 0; i < ITERATIONS; i++) {
196 int ii = BMITests.blsmskl(ix);
197 if (ii != z) {
198 fail();
199 }
200 }
201 }
202 { // match(Set dst (XorL (AddL src minus_1) src))
203 long z = BMITests.blsmskq(lx);
204 for (int i = 0; i < ITERATIONS; i++) {
205 long ll = BMITests.blsmskq(lx);
206 if (ll != z) {
207 fail();
208 }
209 }
210 }
211 { // match(Set dst (XorI (AddI (LoadI src) minus_1) (LoadI src) ) )
212 int z = BMITests.blsmskl(imy);
213 for (int i = 0; i < ITERATIONS; i++) {
214 int ii = BMITests.blsmskl(imy);
215 if (ii != z) {
216 fail();
217 }
218 }
219 }
220 { // match(Set dst (XorL (AddL (LoadL src) minus_1) (LoadL src) ) )
221 long z = BMITests.blsmskq(lmy);
222 for (int i = 0; i < ITERATIONS; i++) {
223 long ll = BMITests.blsmskq(lmy);
224 if (ll != z) {
225 fail();
226 }
227 }
228 }
229
230 { // match(Set dst (AndI (AddI src minus_1) src) )
231 int z = BMITests.blsrl(ix);
232 for (int i = 0; i < ITERATIONS; i++) {
233 int ii = BMITests.blsrl(ix);
234 if (ii != z) {
235 fail();
236 }
237 }
238 }
239 { // match(Set dst (AndL (AddL src minus_1) src) )
240 long z = BMITests.blsrq(lx);
241 for (int i = 0; i < ITERATIONS; i++) {
242 long ll = BMITests.blsrq(lx);
243 if (ll != z) {
244 fail();
245 }
246 }
247 }
248 { // match(Set dst (AndI (AddI (LoadI src) minus_1) (LoadI src) ) )
249 int z = BMITests.blsrl(imy);
250 for (int i = 0; i < ITERATIONS; i++) {
251 int ii = BMITests.blsrl(imy);
252 if (ii != z) {
253 fail();
254 }
255 }
256 }
257 { // match(Set dst (AndL (AddL (LoadL src) minus_1) (LoadL src)) )
258 long z = BMITests.blsrq(lmy);
259 for (int i = 0; i < ITERATIONS; i++) {
260 long ll = BMITests.blsrq(lmy);
261 if (ll != z) {
262 fail();
263 }
264 }
265 }
266
267 {
268 int z = BMITests.lzcntl(ix);
269 for (int i = 0; i < ITERATIONS; i++) {
270 int ii = BMITests.lzcntl(ix);
271 if (ii != z) {
272 fail();
273 }
274 }
275 }
276 {
277 int z = BMITests.lzcntq(lx);
278 for (int i = 0; i < ITERATIONS; i++) {
279 int ii = BMITests.lzcntq(lx);
280 if (ii != z) {
281 fail();
282 }
283 }
284 }
285
286 {
287 int z = BMITests.tzcntl(ix);
288 for (int i = 0; i < ITERATIONS; i++) {
289 int ii = BMITests.tzcntl(ix);
290 if (ii != z) {
291 fail();
292 }
293 }
294 }
295 {
296 int z = BMITests.tzcntq(lx);
297 for (int i = 0; i < ITERATIONS; i++) {
298 int ii = BMITests.tzcntq(lx);
299 if (ii != z) {
300 fail();
301 }
302 }
303 }
304 }
305 }