< prev index next >

src/share/vm/opto/c2compiler.cpp

Print this page

        

@@ -29,11 +29,11 @@
 #include "opto/output.hpp"
 #include "opto/runtime.hpp"
 
 // register information defined by ADLC
 extern const char register_save_policy[];
-extern const int  register_save_type[];
+extern const Opcodes register_save_type[];
 
 const char* C2Compiler::retry_no_subsuming_loads() {
   return "retry without subsuming loads";
 }
 const char* C2Compiler::retry_no_escape_analysis() {

@@ -62,11 +62,11 @@
   // Check that runtime and architecture description agree on callee-saved-floats
   bool callee_saved_floats = false;
   for( OptoReg::Name i=OptoReg::Name(0); i<OptoReg::Name(_last_Mach_Reg); i = OptoReg::add(i,1) ) {
     // Is there a callee-saved float or double?
     if( register_save_policy[i] == 'E' /* callee-saved */ &&
-       (register_save_type[i] == Op_RegF || register_save_type[i] == Op_RegD) ) {
+       (register_save_type[i] == Opcodes::Op_RegF || register_save_type[i] == Opcodes::Op_RegD) ) {
       callee_saved_floats = true;
     }
   }
 
   DEBUG_ONLY( Node::init_NodeProperty(); )

@@ -181,242 +181,242 @@
   }
 
   switch (id) {
   case vmIntrinsics::_compressStringC:
   case vmIntrinsics::_compressStringB:
-    if (!Matcher::has_match_rule(Op_StrCompressedCopy)) return false;
+    if (!Matcher::has_match_rule(Opcodes::Op_StrCompressedCopy)) return false;
     break;
   case vmIntrinsics::_inflateStringC:
   case vmIntrinsics::_inflateStringB:
-    if (!Matcher::has_match_rule(Op_StrInflatedCopy)) return false;
+    if (!Matcher::has_match_rule(Opcodes::Op_StrInflatedCopy)) return false;
     break;
   case vmIntrinsics::_compareToL:
   case vmIntrinsics::_compareToU:
   case vmIntrinsics::_compareToLU:
   case vmIntrinsics::_compareToUL:
-    if (!Matcher::match_rule_supported(Op_StrComp)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_StrComp)) return false;
     break;
   case vmIntrinsics::_equalsL:
   case vmIntrinsics::_equalsU:
-    if (!Matcher::match_rule_supported(Op_StrEquals)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_StrEquals)) return false;
     break;
   case vmIntrinsics::_equalsB:
   case vmIntrinsics::_equalsC:
-    if (!Matcher::match_rule_supported(Op_AryEq)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_AryEq)) return false;
     break;
   case vmIntrinsics::_copyMemory:
     if (StubRoutines::unsafe_arraycopy() == NULL) return false;
     break;
   case vmIntrinsics::_encodeISOArray:
   case vmIntrinsics::_encodeByteISOArray:
-    if (!Matcher::match_rule_supported(Op_EncodeISOArray)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_EncodeISOArray)) return false;
     break;
   case vmIntrinsics::_hasNegatives:
-    if (!Matcher::match_rule_supported(Op_HasNegatives))  return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_HasNegatives))  return false;
     break;
   case vmIntrinsics::_bitCount_i:
-    if (!Matcher::match_rule_supported(Op_PopCountI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_PopCountI)) return false;
     break;
   case vmIntrinsics::_bitCount_l:
-    if (!Matcher::match_rule_supported(Op_PopCountL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_PopCountL)) return false;
     break;
   case vmIntrinsics::_numberOfLeadingZeros_i:
-    if (!Matcher::match_rule_supported(Op_CountLeadingZerosI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CountLeadingZerosI)) return false;
     break;
   case vmIntrinsics::_numberOfLeadingZeros_l:
-    if (!Matcher::match_rule_supported(Op_CountLeadingZerosL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CountLeadingZerosL)) return false;
     break;
   case vmIntrinsics::_numberOfTrailingZeros_i:
-    if (!Matcher::match_rule_supported(Op_CountTrailingZerosI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CountTrailingZerosI)) return false;
     break;
   case vmIntrinsics::_numberOfTrailingZeros_l:
-    if (!Matcher::match_rule_supported(Op_CountTrailingZerosL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CountTrailingZerosL)) return false;
     break;
   case vmIntrinsics::_reverseBytes_c:
-    if (!Matcher::match_rule_supported(Op_ReverseBytesUS)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_ReverseBytesUS)) return false;
     break;
   case vmIntrinsics::_reverseBytes_s:
-    if (!Matcher::match_rule_supported(Op_ReverseBytesS)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_ReverseBytesS)) return false;
     break;
   case vmIntrinsics::_reverseBytes_i:
-    if (!Matcher::match_rule_supported(Op_ReverseBytesI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_ReverseBytesI)) return false;
     break;
   case vmIntrinsics::_reverseBytes_l:
-    if (!Matcher::match_rule_supported(Op_ReverseBytesL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_ReverseBytesL)) return false;
     break;
 
   /* CompareAndSwap, Object: */
   case vmIntrinsics::_compareAndSwapObject:
 #ifdef _LP64
-    if ( UseCompressedOops && !Matcher::match_rule_supported(Op_CompareAndSwapN)) return false;
-    if (!UseCompressedOops && !Matcher::match_rule_supported(Op_CompareAndSwapP)) return false;
+    if ( UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_CompareAndSwapN)) return false;
+    if (!UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_CompareAndSwapP)) return false;
 #else
-    if (!Matcher::match_rule_supported(Op_CompareAndSwapP)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndSwapP)) return false;
 #endif
     break;
   case vmIntrinsics::_weakCompareAndSwapObject:
   case vmIntrinsics::_weakCompareAndSwapObjectAcquire:
   case vmIntrinsics::_weakCompareAndSwapObjectRelease:
   case vmIntrinsics::_weakCompareAndSwapObjectVolatile:
 #ifdef _LP64
-    if ( UseCompressedOops && !Matcher::match_rule_supported(Op_WeakCompareAndSwapN)) return false;
-    if (!UseCompressedOops && !Matcher::match_rule_supported(Op_WeakCompareAndSwapP)) return false;
+    if ( UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_WeakCompareAndSwapN)) return false;
+    if (!UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_WeakCompareAndSwapP)) return false;
 #else
-    if (!Matcher::match_rule_supported(Op_WeakCompareAndSwapP)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_WeakCompareAndSwapP)) return false;
 #endif
     break;
   /* CompareAndSwap, Long: */
   case vmIntrinsics::_compareAndSwapLong:
-    if (!Matcher::match_rule_supported(Op_CompareAndSwapL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndSwapL)) return false;
     break;
   case vmIntrinsics::_weakCompareAndSwapLong:
   case vmIntrinsics::_weakCompareAndSwapLongAcquire:
   case vmIntrinsics::_weakCompareAndSwapLongRelease:
   case vmIntrinsics::_weakCompareAndSwapLongVolatile:
-    if (!Matcher::match_rule_supported(Op_WeakCompareAndSwapL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_WeakCompareAndSwapL)) return false;
     break;
 
   /* CompareAndSwap, Int: */
   case vmIntrinsics::_compareAndSwapInt:
-    if (!Matcher::match_rule_supported(Op_CompareAndSwapI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndSwapI)) return false;
     break;
   case vmIntrinsics::_weakCompareAndSwapInt:
   case vmIntrinsics::_weakCompareAndSwapIntAcquire:
   case vmIntrinsics::_weakCompareAndSwapIntRelease:
   case vmIntrinsics::_weakCompareAndSwapIntVolatile:
-    if (!Matcher::match_rule_supported(Op_WeakCompareAndSwapL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_WeakCompareAndSwapL)) return false;
     break;
 
   /* CompareAndSwap, Byte: */
   case vmIntrinsics::_compareAndSwapByte:
-    if (!Matcher::match_rule_supported(Op_CompareAndSwapB)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndSwapB)) return false;
     break;
   case vmIntrinsics::_weakCompareAndSwapByte:
   case vmIntrinsics::_weakCompareAndSwapByteAcquire:
   case vmIntrinsics::_weakCompareAndSwapByteRelease:
   case vmIntrinsics::_weakCompareAndSwapByteVolatile:
-    if (!Matcher::match_rule_supported(Op_WeakCompareAndSwapB)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_WeakCompareAndSwapB)) return false;
     break;
 
   /* CompareAndSwap, Short: */
   case vmIntrinsics::_compareAndSwapShort:
-    if (!Matcher::match_rule_supported(Op_CompareAndSwapS)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndSwapS)) return false;
     break;
   case vmIntrinsics::_weakCompareAndSwapShort:
   case vmIntrinsics::_weakCompareAndSwapShortAcquire:
   case vmIntrinsics::_weakCompareAndSwapShortRelease:
   case vmIntrinsics::_weakCompareAndSwapShortVolatile:
-    if (!Matcher::match_rule_supported(Op_WeakCompareAndSwapS)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_WeakCompareAndSwapS)) return false;
     break;
 
   /* CompareAndExchange, Object: */
   case vmIntrinsics::_compareAndExchangeObjectVolatile:
   case vmIntrinsics::_compareAndExchangeObjectAcquire:
   case vmIntrinsics::_compareAndExchangeObjectRelease:
 #ifdef _LP64
-    if ( UseCompressedOops && !Matcher::match_rule_supported(Op_CompareAndExchangeN)) return false;
-    if (!UseCompressedOops && !Matcher::match_rule_supported(Op_CompareAndExchangeP)) return false;
+    if ( UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_CompareAndExchangeN)) return false;
+    if (!UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_CompareAndExchangeP)) return false;
 #else
-    if (!Matcher::match_rule_supported(Op_CompareAndExchangeP)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndExchangeP)) return false;
 #endif
     break;
 
   /* CompareAndExchange, Long: */
   case vmIntrinsics::_compareAndExchangeLongVolatile:
   case vmIntrinsics::_compareAndExchangeLongAcquire:
   case vmIntrinsics::_compareAndExchangeLongRelease:
-    if (!Matcher::match_rule_supported(Op_CompareAndExchangeL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndExchangeL)) return false;
     break;
 
   /* CompareAndExchange, Int: */
   case vmIntrinsics::_compareAndExchangeIntVolatile:
   case vmIntrinsics::_compareAndExchangeIntAcquire:
   case vmIntrinsics::_compareAndExchangeIntRelease:
-    if (!Matcher::match_rule_supported(Op_CompareAndExchangeI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndExchangeI)) return false;
     break;
 
   /* CompareAndExchange, Byte: */
   case vmIntrinsics::_compareAndExchangeByteVolatile:
   case vmIntrinsics::_compareAndExchangeByteAcquire:
   case vmIntrinsics::_compareAndExchangeByteRelease:
-    if (!Matcher::match_rule_supported(Op_CompareAndExchangeB)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndExchangeB)) return false;
     break;
 
   /* CompareAndExchange, Short: */
   case vmIntrinsics::_compareAndExchangeShortVolatile:
   case vmIntrinsics::_compareAndExchangeShortAcquire:
   case vmIntrinsics::_compareAndExchangeShortRelease:
-    if (!Matcher::match_rule_supported(Op_CompareAndExchangeS)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_CompareAndExchangeS)) return false;
     break;
 
   case vmIntrinsics::_getAndAddByte:
-    if (!Matcher::match_rule_supported(Op_GetAndAddB)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndAddB)) return false;
     break;
   case vmIntrinsics::_getAndAddShort:
-    if (!Matcher::match_rule_supported(Op_GetAndAddS)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndAddS)) return false;
     break;
   case vmIntrinsics::_getAndAddInt:
-    if (!Matcher::match_rule_supported(Op_GetAndAddI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndAddI)) return false;
     break;
   case vmIntrinsics::_getAndAddLong:
-    if (!Matcher::match_rule_supported(Op_GetAndAddL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndAddL)) return false;
     break;
 
   case vmIntrinsics::_getAndSetByte:
-    if (!Matcher::match_rule_supported(Op_GetAndSetB)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndSetB)) return false;
     break;
   case vmIntrinsics::_getAndSetShort:
-    if (!Matcher::match_rule_supported(Op_GetAndSetS)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndSetS)) return false;
     break;
   case vmIntrinsics::_getAndSetInt:
-    if (!Matcher::match_rule_supported(Op_GetAndSetI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndSetI)) return false;
     break;
   case vmIntrinsics::_getAndSetLong:
-    if (!Matcher::match_rule_supported(Op_GetAndSetL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndSetL)) return false;
     break;
   case vmIntrinsics::_getAndSetObject:
 #ifdef _LP64
-    if (!UseCompressedOops && !Matcher::match_rule_supported(Op_GetAndSetP)) return false;
-    if (UseCompressedOops && !Matcher::match_rule_supported(Op_GetAndSetN)) return false;
+    if (!UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_GetAndSetP)) return false;
+    if (UseCompressedOops && !Matcher::match_rule_supported(Opcodes::Op_GetAndSetN)) return false;
     break;
 #else
-    if (!Matcher::match_rule_supported(Op_GetAndSetP)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_GetAndSetP)) return false;
     break;
 #endif
   case vmIntrinsics::_incrementExactI:
   case vmIntrinsics::_addExactI:
-    if (!Matcher::match_rule_supported(Op_OverflowAddI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowAddI)) return false;
     break;
   case vmIntrinsics::_incrementExactL:
   case vmIntrinsics::_addExactL:
-    if (!Matcher::match_rule_supported(Op_OverflowAddL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowAddL)) return false;
     break;
   case vmIntrinsics::_decrementExactI:
   case vmIntrinsics::_subtractExactI:
-    if (!Matcher::match_rule_supported(Op_OverflowSubI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowSubI)) return false;
     break;
   case vmIntrinsics::_decrementExactL:
   case vmIntrinsics::_subtractExactL:
-    if (!Matcher::match_rule_supported(Op_OverflowSubL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowSubL)) return false;
     break;
   case vmIntrinsics::_negateExactI:
-    if (!Matcher::match_rule_supported(Op_OverflowSubI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowSubI)) return false;
     break;
   case vmIntrinsics::_negateExactL:
-    if (!Matcher::match_rule_supported(Op_OverflowSubL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowSubL)) return false;
     break;
   case vmIntrinsics::_multiplyExactI:
-    if (!Matcher::match_rule_supported(Op_OverflowMulI)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowMulI)) return false;
     break;
   case vmIntrinsics::_multiplyExactL:
-    if (!Matcher::match_rule_supported(Op_OverflowMulL)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OverflowMulL)) return false;
     break;
   case vmIntrinsics::_getCallerClass:
     if (SystemDictionary::reflect_CallerSensitive_klass() == NULL) return false;
     break;
   case vmIntrinsics::_onSpinWait:
-    if (!Matcher::match_rule_supported(Op_OnSpinWait)) return false;
+    if (!Matcher::match_rule_supported(Opcodes::Op_OnSpinWait)) return false;
     break;
   case vmIntrinsics::_hashCode:
   case vmIntrinsics::_identityHashCode:
   case vmIntrinsics::_getClass:
   case vmIntrinsics::_dsin:
< prev index next >