|
17729
|
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 -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 final static int ITERATIONS = 1000000;
|
|
|
107
|
|
|
108 public static void main(String[] args) {
|
|
|
109 int ix = 0x01234567;
|
|
|
110 int iy = 0x89abcdef;
|
|
|
111 MemI imy = new MemI(iy);
|
|
|
112 long lx = 0x0123456701234567L;
|
|
|
113 long ly = 0x89abcdef89abcdefL;
|
|
|
114 MemL lmy = new MemL(ly);
|
|
|
115
|
|
|
116 { // match(Set dst (AndI (XorI src1 minus_1) src2))
|
|
|
117 int z = BMITests.andnl(ix, iy);
|
|
|
118 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
119 int ii = BMITests.andnl(ix, iy);
|
|
|
120 if (ii != z) {
|
|
|
121 throw new Error("andnl with register failed");
|
|
|
122 }
|
|
|
123 }
|
|
|
124 }
|
|
|
125 { // match(Set dst (AndL (XorL src1 minus_1) src2))
|
|
|
126 long z = BMITests.andnq(lx, ly);
|
|
|
127 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
128 long ll = BMITests.andnq(lx, ly);
|
|
|
129 if (ll != z) {
|
|
|
130 throw new Error("andnq with register failed");
|
|
|
131 }
|
|
|
132 }
|
|
|
133 }
|
|
|
134 { // match(Set dst (AndI (XorI src1 minus_1) (LoadI src2)))
|
|
|
135 int z = BMITests.andnl(ix, imy);
|
|
|
136 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
137 int ii = BMITests.andnl(ix, imy);
|
|
|
138 if (ii != z) {
|
|
|
139 throw new Error("andnl with memory failed");
|
|
|
140 }
|
|
|
141 }
|
|
|
142 }
|
|
|
143 { // match(Set dst (AndL (XorL src1 minus_1) (LoadL src2)))
|
|
|
144 long z = BMITests.andnq(lx, lmy);
|
|
|
145 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
146 long ll = BMITests.andnq(lx, lmy);
|
|
|
147 if (ll != z) {
|
|
|
148 throw new Error("andnq with memory failed");
|
|
|
149 }
|
|
|
150 }
|
|
|
151 }
|
|
|
152 { // match(Set dst (AndI (SubI imm_zero src) src))
|
|
|
153 int z = BMITests.blsil(ix);
|
|
|
154 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
155 int ii = BMITests.blsil(ix);
|
|
|
156 if (ii != z) {
|
|
|
157 throw new Error("blsil with register failed");
|
|
|
158 }
|
|
|
159 }
|
|
|
160 }
|
|
|
161 { // match(Set dst (AndL (SubL imm_zero src) src))
|
|
|
162 long z = BMITests.blsiq(lx);
|
|
|
163 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
164 long ll = BMITests.blsiq(lx);
|
|
|
165 if (ll != z) {
|
|
|
166 throw new Error("blsiq with register failed");
|
|
|
167 }
|
|
|
168 }
|
|
|
169 }
|
|
|
170 { // match(Set dst (AndI (SubI imm_zero (LoadI src) ) (LoadI src) ))
|
|
|
171 int z = BMITests.blsil(imy);
|
|
|
172 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
173 int ii = BMITests.blsil(imy);
|
|
|
174 if (ii != z) {
|
|
|
175 throw new Error("blsil with memory failed");
|
|
|
176 }
|
|
|
177 }
|
|
|
178 }
|
|
|
179 { // match(Set dst (AndL (SubL imm_zero (LoadL src) ) (LoadL src) ))
|
|
|
180 long z = BMITests.blsiq(lmy);
|
|
|
181 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
182 long ll = BMITests.blsiq(lmy);
|
|
|
183 if (ll != z) {
|
|
|
184 throw new Error("blsiq with memory failed");
|
|
|
185 }
|
|
|
186 }
|
|
|
187 }
|
|
|
188
|
|
|
189 { // match(Set dst (XorI (AddI src minus_1) src))
|
|
|
190 int z = BMITests.blsmskl(ix);
|
|
|
191 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
192 int ii = BMITests.blsmskl(ix);
|
|
|
193 if (ii != z) {
|
|
|
194 throw new Error("blsmskl with register failed");
|
|
|
195 }
|
|
|
196 }
|
|
|
197 }
|
|
|
198 { // match(Set dst (XorL (AddL src minus_1) src))
|
|
|
199 long z = BMITests.blsmskq(lx);
|
|
|
200 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
201 long ll = BMITests.blsmskq(lx);
|
|
|
202 if (ll != z) {
|
|
|
203 throw new Error("blsmskq with register failed");
|
|
|
204 }
|
|
|
205 }
|
|
|
206 }
|
|
|
207 { // match(Set dst (XorI (AddI (LoadI src) minus_1) (LoadI src) ) )
|
|
|
208 int z = BMITests.blsmskl(imy);
|
|
|
209 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
210 int ii = BMITests.blsmskl(imy);
|
|
|
211 if (ii != z) {
|
|
|
212 throw new Error("blsmskl with memory failed");
|
|
|
213 }
|
|
|
214 }
|
|
|
215 }
|
|
|
216 { // match(Set dst (XorL (AddL (LoadL src) minus_1) (LoadL src) ) )
|
|
|
217 long z = BMITests.blsmskq(lmy);
|
|
|
218 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
219 long ll = BMITests.blsmskq(lmy);
|
|
|
220 if (ll != z) {
|
|
|
221 throw new Error("blsmskq with memory failed");
|
|
|
222 }
|
|
|
223 }
|
|
|
224 }
|
|
|
225
|
|
|
226 { // match(Set dst (AndI (AddI src minus_1) src) )
|
|
|
227 int z = BMITests.blsrl(ix);
|
|
|
228 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
229 int ii = BMITests.blsrl(ix);
|
|
|
230 if (ii != z) {
|
|
|
231 throw new Error("blsrl with register failed");
|
|
|
232 }
|
|
|
233 }
|
|
|
234 }
|
|
|
235 { // match(Set dst (AndL (AddL src minus_1) src) )
|
|
|
236 long z = BMITests.blsrq(lx);
|
|
|
237 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
238 long ll = BMITests.blsrq(lx);
|
|
|
239 if (ll != z) {
|
|
|
240 throw new Error("blsrq with register failed");
|
|
|
241 }
|
|
|
242 }
|
|
|
243 }
|
|
|
244 { // match(Set dst (AndI (AddI (LoadI src) minus_1) (LoadI src) ) )
|
|
|
245 int z = BMITests.blsrl(imy);
|
|
|
246 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
247 int ii = BMITests.blsrl(imy);
|
|
|
248 if (ii != z) {
|
|
|
249 throw new Error("blsrl with memory failed");
|
|
|
250 }
|
|
|
251 }
|
|
|
252 }
|
|
|
253 { // match(Set dst (AndL (AddL (LoadL src) minus_1) (LoadL src)) )
|
|
|
254 long z = BMITests.blsrq(lmy);
|
|
|
255 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
256 long ll = BMITests.blsrq(lmy);
|
|
|
257 if (ll != z) {
|
|
|
258 throw new Error("blsrq with memory failed");
|
|
|
259 }
|
|
|
260 }
|
|
|
261 }
|
|
|
262
|
|
|
263 {
|
|
|
264 int z = BMITests.lzcntl(ix);
|
|
|
265 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
266 int ii = BMITests.lzcntl(ix);
|
|
|
267 if (ii != z) {
|
|
|
268 throw new Error("lzcntl failed");
|
|
|
269 }
|
|
|
270 }
|
|
|
271 }
|
|
|
272 {
|
|
|
273 int z = BMITests.lzcntq(lx);
|
|
|
274 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
275 int ii = BMITests.lzcntq(lx);
|
|
|
276 if (ii != z) {
|
|
|
277 throw new Error("lzcntq failed");
|
|
|
278 }
|
|
|
279 }
|
|
|
280 }
|
|
|
281
|
|
|
282 {
|
|
|
283 int z = BMITests.tzcntl(ix);
|
|
|
284 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
285 int ii = BMITests.tzcntl(ix);
|
|
|
286 if (ii != z) {
|
|
|
287 throw new Error("tzcntl failed");
|
|
|
288 }
|
|
|
289 }
|
|
|
290 }
|
|
|
291 {
|
|
|
292 int z = BMITests.tzcntq(lx);
|
|
|
293 for (int i = 0; i < ITERATIONS; i++) {
|
|
|
294 int ii = BMITests.tzcntq(lx);
|
|
|
295 if (ii != z) {
|
|
|
296 throw new Error("tzcntq failed");
|
|
|
297 }
|
|
|
298 }
|
|
|
299 }
|
|
|
300 }
|
|
|
301 }
|
