Mercurial > jdk8-mips64-public > hotspot / file revision
src/share/vm/opto/regmask.cpp@a6e09d6dd8e5
src/share/vm/opto/regmask.cpp
Wed, 24 Apr 2013 20:55:28 -0400
- author
- dlong
- date
- Wed, 24 Apr 2013 20:55:28 -0400
- changeset 5000
- a6e09d6dd8e5
- parent 4585
- 2c673161698a
- child 6441
- d2907f74462e
- permissions
- -rw-r--r--
8003853: specify offset of IC load in java_to_interp stub
Summary: refactored code to allow platform-specific differences
Reviewed-by: dlong, twisti
Contributed-by: Goetz Lindenmaier <goetz.lindenmaier@sap.com>
1 /*
2 * Copyright (c) 1997, 2013, 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 */
25 #include "precompiled.hpp"
26 #include "opto/compile.hpp"
27 #include "opto/regmask.hpp"
28 #ifdef TARGET_ARCH_MODEL_x86_32
29 # include "adfiles/ad_x86_32.hpp"
30 #endif
31 #ifdef TARGET_ARCH_MODEL_x86_64
32 # include "adfiles/ad_x86_64.hpp"
33 #endif
34 #ifdef TARGET_ARCH_MODEL_sparc
35 # include "adfiles/ad_sparc.hpp"
36 #endif
37 #ifdef TARGET_ARCH_MODEL_zero
38 # include "adfiles/ad_zero.hpp"
39 #endif
40 #ifdef TARGET_ARCH_MODEL_arm
41 # include "adfiles/ad_arm.hpp"
42 #endif
43 #ifdef TARGET_ARCH_MODEL_ppc
44 # include "adfiles/ad_ppc.hpp"
45 #endif
47 #define RM_SIZE _RM_SIZE /* a constant private to the class RegMask */
49 //-------------Non-zero bit search methods used by RegMask---------------------
50 // Find lowest 1, or return 32 if empty
51 int find_lowest_bit( uint32 mask ) {
52 int n = 0;
53 if( (mask & 0xffff) == 0 ) {
54 mask >>= 16;
55 n += 16;
56 }
57 if( (mask & 0xff) == 0 ) {
58 mask >>= 8;
59 n += 8;
60 }
61 if( (mask & 0xf) == 0 ) {
62 mask >>= 4;
63 n += 4;
64 }
65 if( (mask & 0x3) == 0 ) {
66 mask >>= 2;
67 n += 2;
68 }
69 if( (mask & 0x1) == 0 ) {
70 mask >>= 1;
71 n += 1;
72 }
73 if( mask == 0 ) {
74 n = 32;
75 }
76 return n;
77 }
79 // Find highest 1, or return 32 if empty
80 int find_hihghest_bit( uint32 mask ) {
81 int n = 0;
82 if( mask > 0xffff ) {
83 mask >>= 16;
84 n += 16;
85 }
86 if( mask > 0xff ) {
87 mask >>= 8;
88 n += 8;
89 }
90 if( mask > 0xf ) {
91 mask >>= 4;
92 n += 4;
93 }
94 if( mask > 0x3 ) {
95 mask >>= 2;
96 n += 2;
97 }
98 if( mask > 0x1 ) {
99 mask >>= 1;
100 n += 1;
101 }
102 if( mask == 0 ) {
103 n = 32;
104 }
105 return n;
106 }
108 //------------------------------dump-------------------------------------------
110 #ifndef PRODUCT
111 void OptoReg::dump(int r, outputStream *st) {
112 switch (r) {
113 case Special: st->print("r---"); break;
114 case Bad: st->print("rBAD"); break;
115 default:
116 if (r < _last_Mach_Reg) st->print(Matcher::regName[r]);
117 else st->print("rS%d",r);
118 break;
119 }
120 }
121 #endif
124 //=============================================================================
125 const RegMask RegMask::Empty(
126 # define BODY(I) 0,
127 FORALL_BODY
128 # undef BODY
129 0
130 );
132 //=============================================================================
133 bool RegMask::is_vector(uint ireg) {
134 return (ireg == Op_VecS || ireg == Op_VecD || ireg == Op_VecX || ireg == Op_VecY);
135 }
137 int RegMask::num_registers(uint ireg) {
138 switch(ireg) {
139 case Op_VecY:
140 return 8;
141 case Op_VecX:
142 return 4;
143 case Op_VecD:
144 case Op_RegD:
145 case Op_RegL:
146 #ifdef _LP64
147 case Op_RegP:
148 #endif
149 return 2;
150 }
151 // Op_VecS and the rest ideal registers.
152 return 1;
153 }
155 //------------------------------find_first_pair--------------------------------
156 // Find the lowest-numbered register pair in the mask. Return the
157 // HIGHEST register number in the pair, or BAD if no pairs.
158 OptoReg::Name RegMask::find_first_pair() const {
159 verify_pairs();
160 for( int i = 0; i < RM_SIZE; i++ ) {
161 if( _A[i] ) { // Found some bits
162 int bit = _A[i] & -_A[i]; // Extract low bit
163 // Convert to bit number, return hi bit in pair
164 return OptoReg::Name((i<<_LogWordBits)+find_lowest_bit(bit)+1);
165 }
166 }
167 return OptoReg::Bad;
168 }
170 //------------------------------ClearToPairs-----------------------------------
171 // Clear out partial bits; leave only bit pairs
172 void RegMask::clear_to_pairs() {
173 for( int i = 0; i < RM_SIZE; i++ ) {
174 int bits = _A[i];
175 bits &= ((bits & 0x55555555)<<1); // 1 hi-bit set for each pair
176 bits |= (bits>>1); // Smear 1 hi-bit into a pair
177 _A[i] = bits;
178 }
179 verify_pairs();
180 }
182 //------------------------------SmearToPairs-----------------------------------
183 // Smear out partial bits; leave only bit pairs
184 void RegMask::smear_to_pairs() {
185 for( int i = 0; i < RM_SIZE; i++ ) {
186 int bits = _A[i];
187 bits |= ((bits & 0x55555555)<<1); // Smear lo bit hi per pair
188 bits |= ((bits & 0xAAAAAAAA)>>1); // Smear hi bit lo per pair
189 _A[i] = bits;
190 }
191 verify_pairs();
192 }
194 //------------------------------is_aligned_pairs-------------------------------
195 bool RegMask::is_aligned_pairs() const {
196 // Assert that the register mask contains only bit pairs.
197 for( int i = 0; i < RM_SIZE; i++ ) {
198 int bits = _A[i];
199 while( bits ) { // Check bits for pairing
200 int bit = bits & -bits; // Extract low bit
201 // Low bit is not odd means its mis-aligned.
202 if( (bit & 0x55555555) == 0 ) return false;
203 bits -= bit; // Remove bit from mask
204 // Check for aligned adjacent bit
205 if( (bits & (bit<<1)) == 0 ) return false;
206 bits -= (bit<<1); // Remove other halve of pair
207 }
208 }
209 return true;
210 }
212 //------------------------------is_bound1--------------------------------------
213 // Return TRUE if the mask contains a single bit
214 int RegMask::is_bound1() const {
215 if( is_AllStack() ) return false;
216 int bit = -1; // Set to hold the one bit allowed
217 for( int i = 0; i < RM_SIZE; i++ ) {
218 if( _A[i] ) { // Found some bits
219 if( bit != -1 ) return false; // Already had bits, so fail
220 bit = _A[i] & -_A[i]; // Extract 1 bit from mask
221 if( bit != _A[i] ) return false; // Found many bits, so fail
222 }
223 }
224 // True for both the empty mask and for a single bit
225 return true;
226 }
228 //------------------------------is_bound2--------------------------------------
229 // Return TRUE if the mask contains an adjacent pair of bits and no other bits.
230 int RegMask::is_bound_pair() const {
231 if( is_AllStack() ) return false;
233 int bit = -1; // Set to hold the one bit allowed
234 for( int i = 0; i < RM_SIZE; i++ ) {
235 if( _A[i] ) { // Found some bits
236 if( bit != -1 ) return false; // Already had bits, so fail
237 bit = _A[i] & -(_A[i]); // Extract 1 bit from mask
238 if( (bit << 1) != 0 ) { // Bit pair stays in same word?
239 if( (bit | (bit<<1)) != _A[i] )
240 return false; // Require adjacent bit pair and no more bits
241 } else { // Else its a split-pair case
242 if( bit != _A[i] ) return false; // Found many bits, so fail
243 i++; // Skip iteration forward
244 if( i >= RM_SIZE || _A[i] != 1 )
245 return false; // Require 1 lo bit in next word
246 }
247 }
248 }
249 // True for both the empty mask and for a bit pair
250 return true;
251 }
253 static int low_bits[3] = { 0x55555555, 0x11111111, 0x01010101 };
254 //------------------------------find_first_set---------------------------------
255 // Find the lowest-numbered register set in the mask. Return the
256 // HIGHEST register number in the set, or BAD if no sets.
257 // Works also for size 1.
258 OptoReg::Name RegMask::find_first_set(const int size) const {
259 verify_sets(size);
260 for (int i = 0; i < RM_SIZE; i++) {
261 if (_A[i]) { // Found some bits
262 int bit = _A[i] & -_A[i]; // Extract low bit
263 // Convert to bit number, return hi bit in pair
264 return OptoReg::Name((i<<_LogWordBits)+find_lowest_bit(bit)+(size-1));
265 }
266 }
267 return OptoReg::Bad;
268 }
270 //------------------------------clear_to_sets----------------------------------
271 // Clear out partial bits; leave only aligned adjacent bit pairs
272 void RegMask::clear_to_sets(const int size) {
273 if (size == 1) return;
274 assert(2 <= size && size <= 8, "update low bits table");
275 assert(is_power_of_2(size), "sanity");
276 int low_bits_mask = low_bits[size>>2];
277 for (int i = 0; i < RM_SIZE; i++) {
278 int bits = _A[i];
279 int sets = (bits & low_bits_mask);
280 for (int j = 1; j < size; j++) {
281 sets = (bits & (sets<<1)); // filter bits which produce whole sets
282 }
283 sets |= (sets>>1); // Smear 1 hi-bit into a set
284 if (size > 2) {
285 sets |= (sets>>2); // Smear 2 hi-bits into a set
286 if (size > 4) {
287 sets |= (sets>>4); // Smear 4 hi-bits into a set
288 }
289 }
290 _A[i] = sets;
291 }
292 verify_sets(size);
293 }
295 //------------------------------smear_to_sets----------------------------------
296 // Smear out partial bits to aligned adjacent bit sets
297 void RegMask::smear_to_sets(const int size) {
298 if (size == 1) return;
299 assert(2 <= size && size <= 8, "update low bits table");
300 assert(is_power_of_2(size), "sanity");
301 int low_bits_mask = low_bits[size>>2];
302 for (int i = 0; i < RM_SIZE; i++) {
303 int bits = _A[i];
304 int sets = 0;
305 for (int j = 0; j < size; j++) {
306 sets |= (bits & low_bits_mask); // collect partial bits
307 bits = bits>>1;
308 }
309 sets |= (sets<<1); // Smear 1 lo-bit into a set
310 if (size > 2) {
311 sets |= (sets<<2); // Smear 2 lo-bits into a set
312 if (size > 4) {
313 sets |= (sets<<4); // Smear 4 lo-bits into a set
314 }
315 }
316 _A[i] = sets;
317 }
318 verify_sets(size);
319 }
321 //------------------------------is_aligned_set--------------------------------
322 bool RegMask::is_aligned_sets(const int size) const {
323 if (size == 1) return true;
324 assert(2 <= size && size <= 8, "update low bits table");
325 assert(is_power_of_2(size), "sanity");
326 int low_bits_mask = low_bits[size>>2];
327 // Assert that the register mask contains only bit sets.
328 for (int i = 0; i < RM_SIZE; i++) {
329 int bits = _A[i];
330 while (bits) { // Check bits for pairing
331 int bit = bits & -bits; // Extract low bit
332 // Low bit is not odd means its mis-aligned.
333 if ((bit & low_bits_mask) == 0) return false;
334 // Do extra work since (bit << size) may overflow.
335 int hi_bit = bit << (size-1); // high bit
336 int set = hi_bit + ((hi_bit-1) & ~(bit-1));
337 // Check for aligned adjacent bits in this set
338 if ((bits & set) != set) return false;
339 bits -= set; // Remove this set
340 }
341 }
342 return true;
343 }
345 //------------------------------is_bound_set-----------------------------------
346 // Return TRUE if the mask contains one adjacent set of bits and no other bits.
347 // Works also for size 1.
348 int RegMask::is_bound_set(const int size) const {
349 if( is_AllStack() ) return false;
350 assert(1 <= size && size <= 8, "update low bits table");
351 int bit = -1; // Set to hold the one bit allowed
352 for (int i = 0; i < RM_SIZE; i++) {
353 if (_A[i] ) { // Found some bits
354 if (bit != -1)
355 return false; // Already had bits, so fail
356 bit = _A[i] & -_A[i]; // Extract low bit from mask
357 int hi_bit = bit << (size-1); // high bit
358 if (hi_bit != 0) { // Bit set stays in same word?
359 int set = hi_bit + ((hi_bit-1) & ~(bit-1));
360 if (set != _A[i])
361 return false; // Require adjacent bit set and no more bits
362 } else { // Else its a split-set case
363 if (((-1) & ~(bit-1)) != _A[i])
364 return false; // Found many bits, so fail
365 i++; // Skip iteration forward and check high part
366 // The lower 24 bits should be 0 since it is split case and size <= 8.
367 int set = bit>>24;
368 set = set & -set; // Remove sign extension.
369 set = (((set << size) - 1) >> 8);
370 if (i >= RM_SIZE || _A[i] != set)
371 return false; // Require expected low bits in next word
372 }
373 }
374 }
375 // True for both the empty mask and for a bit set
376 return true;
377 }
379 //------------------------------is_UP------------------------------------------
380 // UP means register only, Register plus stack, or stack only is DOWN
381 bool RegMask::is_UP() const {
382 // Quick common case check for DOWN (any stack slot is legal)
383 if( is_AllStack() )
384 return false;
385 // Slower check for any stack bits set (also DOWN)
386 if( overlap(Matcher::STACK_ONLY_mask) )
387 return false;
388 // Not DOWN, so must be UP
389 return true;
390 }
392 //------------------------------Size-------------------------------------------
393 // Compute size of register mask in bits
394 uint RegMask::Size() const {
395 extern uint8 bitsInByte[256];
396 uint sum = 0;
397 for( int i = 0; i < RM_SIZE; i++ )
398 sum +=
399 bitsInByte[(_A[i]>>24) & 0xff] +
400 bitsInByte[(_A[i]>>16) & 0xff] +
401 bitsInByte[(_A[i]>> 8) & 0xff] +
402 bitsInByte[ _A[i] & 0xff];
403 return sum;
404 }
406 #ifndef PRODUCT
407 //------------------------------print------------------------------------------
408 void RegMask::dump(outputStream *st) const {
409 st->print("[");
410 RegMask rm = *this; // Structure copy into local temp
412 OptoReg::Name start = rm.find_first_elem(); // Get a register
413 if (OptoReg::is_valid(start)) { // Check for empty mask
414 rm.Remove(start); // Yank from mask
415 OptoReg::dump(start, st); // Print register
416 OptoReg::Name last = start;
418 // Now I have printed an initial register.
419 // Print adjacent registers as "rX-rZ" instead of "rX,rY,rZ".
420 // Begin looping over the remaining registers.
421 while (1) { //
422 OptoReg::Name reg = rm.find_first_elem(); // Get a register
423 if (!OptoReg::is_valid(reg))
424 break; // Empty mask, end loop
425 rm.Remove(reg); // Yank from mask
427 if (last+1 == reg) { // See if they are adjacent
428 // Adjacent registers just collect into long runs, no printing.
429 last = reg;
430 } else { // Ending some kind of run
431 if (start == last) { // 1-register run; no special printing
432 } else if (start+1 == last) {
433 st->print(","); // 2-register run; print as "rX,rY"
434 OptoReg::dump(last, st);
435 } else { // Multi-register run; print as "rX-rZ"
436 st->print("-");
437 OptoReg::dump(last, st);
438 }
439 st->print(","); // Seperate start of new run
440 start = last = reg; // Start a new register run
441 OptoReg::dump(start, st); // Print register
442 } // End of if ending a register run or not
443 } // End of while regmask not empty
445 if (start == last) { // 1-register run; no special printing
446 } else if (start+1 == last) {
447 st->print(","); // 2-register run; print as "rX,rY"
448 OptoReg::dump(last, st);
449 } else { // Multi-register run; print as "rX-rZ"
450 st->print("-");
451 OptoReg::dump(last, st);
452 }
453 if (rm.is_AllStack()) st->print("...");
454 }
455 st->print("]");
456 }
457 #endif
