--- old/src/share/vm/opto/gcm.cpp	2016-07-11 22:46:24.874453149 +0900
+++ new/src/share/vm/opto/gcm.cpp	2016-07-11 22:46:24.735453635 +0900
@@ -521,17 +521,17 @@
     if (VerifyAliases)  assert(load_alias_idx != Compile::AliasIdxBot, "");
   }
 #endif
-  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Op_StrComp),
+  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Opcodes::Op_StrComp),
          "String compare is only known 'load' that does not conflict with any stores");
-  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Op_StrEquals),
+  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Opcodes::Op_StrEquals),
          "String equals is a 'load' that does not conflict with any stores");
-  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Op_StrIndexOf),
+  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Opcodes::Op_StrIndexOf),
          "String indexOf is a 'load' that does not conflict with any stores");
-  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Op_StrIndexOfChar),
+  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Opcodes::Op_StrIndexOfChar),
          "String indexOfChar is a 'load' that does not conflict with any stores");
-  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Op_AryEq),
+  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Opcodes::Op_AryEq),
          "Arrays equals is a 'load' that does not conflict with any stores");
-  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Op_HasNegatives),
+  assert(load_alias_idx || (load->is_Mach() && load->as_Mach()->ideal_Opcode() == Opcodes::Op_HasNegatives),
          "HasNegatives is a 'load' that does not conflict with any stores");
 
   if (!C->alias_type(load_alias_idx)->is_rewritable()) {
@@ -598,13 +598,13 @@
     // Examine a nearby store to see if it might interfere with our load.
     Node* mem   = worklist_mem.pop();
     Node* store = worklist_store.pop();
-    uint op = store->Opcode();
+    Opcodes op = store->Opcode();
 
     // MergeMems do not directly have anti-deps.
     // Treat them as internal nodes in a forward tree of memory states,
     // the leaves of which are each a 'possible-def'.
     if (store == initial_mem    // root (exclusive) of tree we are searching
-        || op == Op_MergeMem    // internal node of tree we are searching
+        || op == Opcodes::Op_MergeMem    // internal node of tree we are searching
         ) {
       mem = store;   // It's not a possibly interfering store.
       if (store == initial_mem)
@@ -628,7 +628,7 @@
       continue;
     }
 
-    if (op == Op_MachProj || op == Op_Catch)   continue;
+    if (op == Opcodes::Op_MachProj || op == Opcodes::Op_Catch)   continue;
     if (store->needs_anti_dependence_check())  continue;  // not really a store
 
     // Compute the alias index.  Loads and stores with different alias
@@ -646,7 +646,7 @@
         // convention (and from there into a wrapper); it has no
         // _method.  Can't do this optimization for Native calls because
         // they CAN write to Java memory.
-        if (mstore->ideal_Opcode() == Op_CallStaticJava) {
+        if (mstore->ideal_Opcode() == Opcodes::Op_CallStaticJava) {
           assert(mstore->is_MachSafePoint(), "");
           MachSafePointNode* ms = (MachSafePointNode*) mstore;
           assert(ms->is_MachCallJava(), "");
@@ -660,7 +660,7 @@
         // Same for SafePoints: they read/write Raw but only read otherwise.
         // This is basically a workaround for SafePoints only defining control
         // instead of control + memory.
-        if (mstore->ideal_Opcode() == Op_SafePoint)
+        if (mstore->ideal_Opcode() == Opcodes::Op_SafePoint)
           continue;
       } else {
         // Some raw memory, such as the load of "top" at an allocation,
@@ -670,7 +670,7 @@
         // creates a cycle, and will cause a subsequent failure in
         // local scheduling.  (BugId 4919904)
         // (%%% How can a control input be a safepoint and not a projection??)
-        if (mstore->ideal_Opcode() == Op_SafePoint && load->in(0) == mstore)
+        if (mstore->ideal_Opcode() == Opcodes::Op_SafePoint && load->in(0) == mstore)
           continue;
       }
     }
@@ -1227,12 +1227,12 @@
     MachNode* mach = self->is_Mach() ? self->as_Mach() : NULL;
     if (mach) {
       switch (mach->ideal_Opcode()) {
-      case Op_CreateEx:
+      case Opcodes::Op_CreateEx:
         // Don't move exception creation
         early->add_inst(self);
         continue;
         break;
-      case Op_CheckCastPP:
+      case Opcodes::Op_CheckCastPP:
         // Don't move CheckCastPP nodes away from their input, if the input
         // is a rawptr (5071820).
         Node *def = self->in(1);
@@ -1297,7 +1297,7 @@
     // allocatable (hoisting can make a value live longer, leading to
     // anti and output dependency problems which are normally resolved
     // by the register allocator giving everyone a different register).
-    if (mach != NULL && must_clone[mach->ideal_Opcode()])
+    if (mach != NULL && must_clone[static_cast<uint>(mach->ideal_Opcode())])
       try_to_hoist = false;
 
     Block* late = NULL;
@@ -1820,7 +1820,7 @@
   int eidx = end_idx();
   Node *n = get_node(eidx);  // Get ending Node
 
-  int op = n->Opcode();
+  Opcodes op = n->Opcode();
   if (n->is_Mach()) {
     if (n->is_MachNullCheck()) {
       // Can only reach here if called after lcm. The original Op_If is gone,
@@ -1846,25 +1846,25 @@
 
   // Switch on branch type
   switch( op ) {
-  case Op_CountedLoopEnd:
-  case Op_If: {
+  case Opcodes::Op_CountedLoopEnd:
+  case Opcodes::Op_If: {
     assert (i < 2, "just checking");
     // Conditionals pass on only part of their frequency
     float prob  = n->as_MachIf()->_prob;
     assert(prob >= 0.0 && prob <= 1.0, "out of range probability");
     // If succ[i] is the FALSE branch, invert path info
-    if( get_node(i + eidx + 1)->Opcode() == Op_IfFalse ) {
+    if( get_node(i + eidx + 1)->Opcode() == Opcodes::Op_IfFalse ) {
       return 1.0f - prob; // not taken
     } else {
       return prob; // taken
     }
   }
 
-  case Op_Jump:
+  case Opcodes::Op_Jump:
     // Divide the frequency between all successors evenly
     return 1.0f/_num_succs;
 
-  case Op_Catch: {
+  case Opcodes::Op_Catch: {
     const CatchProjNode *ci = get_node(i + eidx + 1)->as_CatchProj();
     if (ci->_con == CatchProjNode::fall_through_index) {
       // Fall-thru path gets the lion's share.
@@ -1875,19 +1875,19 @@
     }
   }
 
-  case Op_Root:
-  case Op_Goto:
+  case Opcodes::Op_Root:
+  case Opcodes::Op_Goto:
     // Pass frequency straight thru to target
     return 1.0f;
 
-  case Op_NeverBranch:
+  case Opcodes::Op_NeverBranch:
     return 0.0f;
 
-  case Op_TailCall:
-  case Op_TailJump:
-  case Op_Return:
-  case Op_Halt:
-  case Op_Rethrow:
+  case Opcodes::Op_TailCall:
+  case Opcodes::Op_TailJump:
+  case Opcodes::Op_Return:
+  case Opcodes::Op_Halt:
+  case Opcodes::Op_Rethrow:
     // Do not push out freq to root block
     return 0.0f;
 
@@ -1904,7 +1904,7 @@
   int eidx = end_idx();
   Node *n = get_node(eidx);  // Get ending Node
 
-  int op = n->Opcode();
+  Opcodes op = n->Opcode();
   if (n->is_Mach()) {
     if (n->is_MachNullCheck()) {
       // In theory, either side can fall-thru, for simplicity sake,
@@ -1916,15 +1916,15 @@
 
   // Switch on branch type
   switch( op ) {
-  case Op_CountedLoopEnd:
-  case Op_If:
+  case Opcodes::Op_CountedLoopEnd:
+  case Opcodes::Op_If:
     return 2;
 
-  case Op_Root:
-  case Op_Goto:
+  case Opcodes::Op_Root:
+  case Opcodes::Op_Goto:
     return 1;
 
-  case Op_Catch: {
+  case Opcodes::Op_Catch: {
     for (uint i = 0; i < _num_succs; i++) {
       const CatchProjNode *ci = get_node(i + eidx + 1)->as_CatchProj();
       if (ci->_con == CatchProjNode::fall_through_index) {
@@ -1934,13 +1934,13 @@
     return 0;
   }
 
-  case Op_Jump:
-  case Op_NeverBranch:
-  case Op_TailCall:
-  case Op_TailJump:
-  case Op_Return:
-  case Op_Halt:
-  case Op_Rethrow:
+  case Opcodes::Op_Jump:
+  case Opcodes::Op_NeverBranch:
+  case Opcodes::Op_TailCall:
+  case Opcodes::Op_TailJump:
+  case Opcodes::Op_Return:
+  case Opcodes::Op_Halt:
+  case Opcodes::Op_Rethrow:
     return 0;
 
   default:
@@ -1956,36 +1956,36 @@
   int eidx = end_idx();
   Node *n = get_node(eidx);  // Get ending Node
 
-  int op = n->Opcode();
+  Opcodes op = n->Opcode();
   if (n->is_Mach()) {
     if (n->is_MachNullCheck()) {
       // In theory, either side can fall-thru, for simplicity sake,
       // let's say only the false branch can now.
-      return get_node(i + eidx + 1)->Opcode() == Op_IfFalse;
+      return get_node(i + eidx + 1)->Opcode() == Opcodes::Op_IfFalse;
     }
     op = n->as_Mach()->ideal_Opcode();
   }
 
   // Switch on branch type
   switch( op ) {
-  case Op_CountedLoopEnd:
-  case Op_If:
-  case Op_Root:
-  case Op_Goto:
+  case Opcodes::Op_CountedLoopEnd:
+  case Opcodes::Op_If:
+  case Opcodes::Op_Root:
+  case Opcodes::Op_Goto:
     return true;
 
-  case Op_Catch: {
+  case Opcodes::Op_Catch: {
     const CatchProjNode *ci = get_node(i + eidx + 1)->as_CatchProj();
     return ci->_con == CatchProjNode::fall_through_index;
   }
 
-  case Op_Jump:
-  case Op_NeverBranch:
-  case Op_TailCall:
-  case Op_TailJump:
-  case Op_Return:
-  case Op_Halt:
-  case Op_Rethrow:
+  case Opcodes::Op_Jump:
+  case Opcodes::Op_NeverBranch:
+  case Opcodes::Op_TailCall:
+  case Opcodes::Op_TailJump:
+  case Opcodes::Op_Return:
+  case Opcodes::Op_Halt:
+  case Opcodes::Op_Rethrow:
     return false;
 
   default:
@@ -2001,9 +2001,9 @@
   int eidx = end_idx();
   Node *n = get_node(eidx);  // Get ending Node
 
-  int op = n->as_Mach()->ideal_Opcode();
+  Opcodes op = n->as_Mach()->ideal_Opcode();
 
-  assert(op == Op_CountedLoopEnd || op == Op_If, "must be a If");
+  assert(op == Opcodes::Op_CountedLoopEnd || op == Opcodes::Op_If, "must be a If");
   assert(num_fall_throughs() == 2, "must be a two way branch block");
 
   // Which successor is ub?
@@ -2015,7 +2015,7 @@
 
   // If ub is the true path, make the proability small, else
   // ub is the false path, and make the probability large
-  bool invert = (get_node(s + eidx + 1)->Opcode() == Op_IfFalse);
+  bool invert = (get_node(s + eidx + 1)->Opcode() == Opcodes::Op_IfFalse);
 
   // Get existing probability
   float p = n->as_MachIf()->_prob;