Lines Matching refs:shift
451 // Masking off the high bits of a unsigned-shift-right is not
456 int shift = t12->get_con();
457 shift &= BitsPerJavaInteger - 1; // semantics of Java shifts
458 int mask = max_juint >> shift;
509 int shift = t12->get_con();
510 shift &= BitsPerJavaInteger-1; // semantics of Java shifts
511 const int sign_bits_mask = ~right_n_bits(BitsPerJavaInteger - shift);
515 // Use zero-fill shift instead
579 // Masking off the high bits of a unsigned-shift-right is not
584 int shift = t12->get_con();
585 shift &= BitsPerJavaLong - 1; // semantics of Java shifts
586 jlong mask = max_julong >> shift;
620 int shift = t12->get_con();
621 shift &= BitsPerJavaLong - 1; // semantics of Java shifts
622 const jlong sign_bits_mask = ~(((jlong)CONST64(1) << (jlong)(BitsPerJavaLong - shift)) -1);
626 // Use zero-fill shift instead
639 const TypeInt *ti = phase->type( in(2) )->isa_int(); // shift count is an int
651 const int con = t2->get_con() & ( BitsPerInt - 1 ); // masked shift count
653 if ( con == 0 ) return NULL; // let Identity() handle 0 shift count
726 uint shift = r2->get_con();
727 shift &= BitsPerJavaInteger-1; // semantics of Java shifts
729 if (shift == 0) return t1;
731 // If the shift is a constant, shift the bounds of the type,
735 if (((lo << shift) >> shift) == lo &&
736 ((hi << shift) >> shift) == hi) {
738 return TypeInt::make((jint)lo << (jint)shift,
739 (jint)hi << (jint)shift,
745 return TypeInt::make( (jint)r1->get_con() << (jint)shift );
751 const TypeInt *ti = phase->type( in(2) )->isa_int(); // shift count is an int
763 const int con = t2->get_con() & ( BitsPerLong - 1 ); // masked shift count
765 if ( con == 0 ) return NULL; // let Identity() handle 0 shift count
835 uint shift = r2->get_con();
836 shift &= BitsPerJavaLong - 1; // semantics of Java shifts
838 if (shift == 0) return t1;
840 // If the shift is a constant, shift the bounds of the type,
844 if (((lo << shift) >> shift) == lo &&
845 ((hi << shift) >> shift) == hi) {
847 return TypeLong::make((jlong)lo << (jint)shift,
848 (jlong)hi << (jint)shift,
854 return TypeLong::make( (jlong)r1->get_con() << (jint)shift );
870 uint shift = t2->get_con();
871 shift &= BitsPerJavaInteger-1; // semantics of Java shifts
873 int lo = (-1 << (BitsPerJavaInteger - shift-1)); // FFFF8000
893 int shift = t2->get_con();
894 shift &= BitsPerJavaInteger-1; // semantics of Java shifts
896 if ( shift == 0 ) return NULL; // let Identity() handle 0 shift count
899 // Such expressions arise normally from shift chains like (byte)(x >> 24).
906 // Convert to "(x >> shift) & (mask >> shift)"
908 return new (phase->C) AndINode(shr_nomask, phase->intcon( maskbits >> shift));
915 if( shift == 16 &&
940 if( shift == 24 &&
979 // If the shift is a constant, just shift the bounds of the type.
980 // For example, if the shift is 31, we just propagate sign bits.
982 uint shift = r2->get_con();
983 shift &= BitsPerJavaInteger-1; // semantics of Java shifts
985 if (shift == 0) return t1;
989 jint lo = (jint)r1->_lo >> (jint)shift;
990 jint hi = (jint)r1->_hi >> (jint)shift;
995 if (shift == BitsPerJavaInteger-1) {
1006 // Signed shift right
1013 const TypeInt *ti = phase->type( in(2) )->isa_int(); // shift count is an int
1041 // If the shift is a constant, just shift the bounds of the type.
1042 // For example, if the shift is 63, we just propagate sign bits.
1044 uint shift = r2->get_con();
1045 shift &= (2*BitsPerJavaInteger)-1; // semantics of Java shifts
1047 if (shift == 0) return t1;
1051 jlong lo = (jlong)r1->_lo >> (jlong)shift;
1052 jlong hi = (jlong)r1->_hi >> (jlong)shift;
1057 if (shift == (2*BitsPerJavaInteger)-1) {
1104 if ( con == 0 ) return NULL; // let Identity() handle a 0 shift count
1105 // We'll be wanting the right-shift amount as a mask of that many bits
1145 mask2 >>= con; // *signed* shift downward (high-order zeroes do not help)
1190 uint shift = r2->get_con();
1191 shift &= BitsPerJavaInteger-1; // semantics of Java shifts
1193 if (shift == 0) return t1;
1195 jint lo = (juint)r1->_lo >> (juint)shift;
1196 jint hi = (juint)r1->_hi >> (juint)shift;
1202 jint neg_hi = (juint)-1 >> (juint)shift;
1203 jint pos_lo = (juint) 0 >> (juint)shift;
1206 hi = MAX2(neg_hi, pos_hi); // == -1 >>> shift;
1212 if (shift == BitsPerJavaInteger-1) {
1227 // return TypeInt::make( ((uint32)o->const_oop() + o->_offset) >> shift );
1232 // return TypeInt::make( ((uint32)o->const_oop() + o->_offset) >> shift );
1241 const TypeInt *ti = phase->type( in(2) )->isa_int(); // shift count is an int
1250 if ( con == 0 ) return NULL; // let Identity() handle a 0 shift count
1251 // note: mask computation below does not work for 0 shift count
1252 // We'll be wanting the right-shift amount as a mask of that many bits
1278 mask2 >>= con; // *signed* shift downward (high-order zeroes do not help)
1319 uint shift = r2->get_con();
1320 shift &= BitsPerJavaLong - 1; // semantics of Java shifts
1322 if (shift == 0) return t1;
1324 jlong lo = (julong)r1->_lo >> (juint)shift;
1325 jlong hi = (julong)r1->_hi >> (juint)shift;
1331 jlong neg_hi = (julong)-1 >> (juint)shift;
1332 jlong pos_lo = (julong) 0 >> (juint)shift;
1336 //hi = MAX2(neg_hi, pos_hi); // == -1 >>> shift;
1343 if (shift == BitsPerJavaLong - 1) {