< prev index next >

src/share/vm/opto/parse2.cpp

Print this page

        

@@ -411,11 +411,11 @@
 bool Parse::create_jump_tables(Node* key_val, SwitchRange* lo, SwitchRange* hi) {
   // Are jumptables enabled
   if (!UseJumpTables)  return false;
 
   // Are jumptables supported
-  if (!Matcher::has_match_rule(Op_Jump))  return false;
+  if (!Matcher::has_match_rule(Opcodes::Op_Jump))  return false;
 
   // Don't make jump table if profiling
   if (method_data_update())  return false;
 
   // Decide if a guard is needed to lop off big ranges at either (or

@@ -788,11 +788,11 @@
   if (btest != BoolTest::eq && btest != BoolTest::ne) {
     // Only ::eq and ::ne are supported for profile injection.
     return false;
   }
   if (test->is_Cmp() &&
-      test->in(1)->Opcode() == Op_ProfileBoolean) {
+      test->in(1)->Opcode() == Opcodes::Op_ProfileBoolean) {
     ProfileBooleanNode* profile = (ProfileBooleanNode*)test->in(1);
     int false_cnt = profile->false_count();
     int  true_cnt = profile->true_count();
 
     // Counts matching depends on the actual test operation (::eq or ::ne).

@@ -1231,16 +1231,16 @@
 
 
 static Node* extract_obj_from_klass_load(PhaseGVN* gvn, Node* n) {
   Node* ldk;
   if (n->is_DecodeNKlass()) {
-    if (n->in(1)->Opcode() != Op_LoadNKlass) {
+    if (n->in(1)->Opcode() != Opcodes::Op_LoadNKlass) {
       return NULL;
     } else {
       ldk = n->in(1);
     }
-  } else if (n->Opcode() != Op_LoadKlass) {
+  } else if (n->Opcode() != Opcodes::Op_LoadKlass) {
     return NULL;
   } else {
     ldk = n;
   }
   assert(ldk != NULL && ldk->is_Load(), "should have found a LoadKlass or LoadNKlass node");

@@ -1368,16 +1368,16 @@
  *
  */
 Node* Parse::optimize_cmp_with_klass(Node* c) {
   // If this is transformed by the _gvn to a comparison with the low
   // level klass then we may be able to use speculation
-  if (c->Opcode() == Op_CmpP &&
-      (c->in(1)->Opcode() == Op_LoadKlass || c->in(1)->Opcode() == Op_DecodeNKlass) &&
+  if (c->Opcode() == Opcodes::Op_CmpP &&
+      (c->in(1)->Opcode() == Opcodes::Op_LoadKlass || c->in(1)->Opcode() == Opcodes::Op_DecodeNKlass) &&
       c->in(2)->is_Con()) {
     Node* load_klass = NULL;
     Node* decode = NULL;
-    if (c->in(1)->Opcode() == Op_DecodeNKlass) {
+    if (c->in(1)->Opcode() == Opcodes::Op_DecodeNKlass) {
       decode = c->in(1);
       load_klass = c->in(1)->in(1);
     } else {
       load_klass = c->in(1);
     }

@@ -1865,11 +1865,11 @@
     d = precision_rounding(c);
     push( d );
     break;
 
   case Bytecodes::_frem:
-    if (Matcher::has_match_rule(Op_ModF)) {
+    if (Matcher::has_match_rule(Opcodes::Op_ModF)) {
       // Generate a ModF node.
       b = pop();
       a = pop();
       c = _gvn.transform( new ModFNode(0,a,b) );
       d = precision_rounding(c);

@@ -2000,11 +2000,11 @@
     b = _gvn.transform(new NegDNode (a));
     push_pair(b);
     break;
 
   case Bytecodes::_drem:
-    if (Matcher::has_match_rule(Op_ModD)) {
+    if (Matcher::has_match_rule(Opcodes::Op_ModD)) {
       // Generate a ModD node.
       b = pop_pair();
       a = pop_pair();
       // a % b
 
< prev index next >