1981       case Op_ConvI2F:         //   Load but not a following Store
1982         if( n->in(1)->is_Load() &&        // Prior load
1983             n->outcnt() == 1 &&           // Not already shared
1984             n->unique_out()->is_Store() ) // Following store
1985           set_shared(n);       // Force it to be a root
1986         break;
1987       case Op_ReverseBytesI:
1988       case Op_ReverseBytesL:
1989         if( n->in(1)->is_Load() &&        // Prior load
1990             n->outcnt() == 1 )            // Not already shared
1991           set_shared(n);                  // Force it to be a root
1992         break;
1993       case Op_BoxLock:         // Cant match until we get stack-regs in ADLC
1994       case Op_IfFalse:
1995       case Op_IfTrue:
1996       case Op_MachProj:
1997       case Op_MergeMem:
1998       case Op_Catch:
1999       case Op_CatchProj:
2000       case Op_CProj:
2001       case Op_FlagsProj:
2002       case Op_JumpProj:
2003       case Op_JProj:
2004       case Op_NeverBranch:
2005         set_dontcare(n);
2006         break;
2007       case Op_Jump:
2008         mstack.push(n->in(1), Pre_Visit);     // Switch Value (could be shared)
2009         mstack.push(n->in(0), Pre_Visit);     // Visit Control input
2010         continue;                             // while (mstack.is_nonempty())
2011       case Op_StrComp:
2012       case Op_StrEquals:
2013       case Op_StrIndexOf:
2014       case Op_AryEq:
2015       case Op_EncodeISOArray:
2016         set_shared(n); // Force result into register (it will be anyways)
2017         break;
2018       case Op_ConP: {  // Convert pointers above the centerline to NUL
2019         TypeNode *tn = n->as_Type(); // Constants derive from type nodes
2020         const TypePtr* tp = tn->type()->is_ptr();
2021         if (tp->_ptr == TypePtr::AnyNull) {

1981       case Op_ConvI2F:         //   Load but not a following Store
1982         if( n->in(1)->is_Load() &&        // Prior load
1983             n->outcnt() == 1 &&           // Not already shared
1984             n->unique_out()->is_Store() ) // Following store
1985           set_shared(n);       // Force it to be a root
1986         break;
1987       case Op_ReverseBytesI:
1988       case Op_ReverseBytesL:
1989         if( n->in(1)->is_Load() &&        // Prior load
1990             n->outcnt() == 1 )            // Not already shared
1991           set_shared(n);                  // Force it to be a root
1992         break;
1993       case Op_BoxLock:         // Cant match until we get stack-regs in ADLC
1994       case Op_IfFalse:
1995       case Op_IfTrue:
1996       case Op_MachProj:
1997       case Op_MergeMem:
1998       case Op_Catch:
1999       case Op_CatchProj:
2000       case Op_CProj:

2001       case Op_JumpProj:
2002       case Op_JProj:
2003       case Op_NeverBranch:
2004         set_dontcare(n);
2005         break;
2006       case Op_Jump:
2007         mstack.push(n->in(1), Pre_Visit);     // Switch Value (could be shared)
2008         mstack.push(n->in(0), Pre_Visit);     // Visit Control input
2009         continue;                             // while (mstack.is_nonempty())
2010       case Op_StrComp:
2011       case Op_StrEquals:
2012       case Op_StrIndexOf:
2013       case Op_AryEq:
2014       case Op_EncodeISOArray:
2015         set_shared(n); // Force result into register (it will be anyways)
2016         break;
2017       case Op_ConP: {  // Convert pointers above the centerline to NUL
2018         TypeNode *tn = n->as_Type(); // Constants derive from type nodes
2019         const TypePtr* tp = tn->type()->is_ptr();
2020         if (tp->_ptr == TypePtr::AnyNull) {