SUGGESTED FIX

As per tom, a better solution is:
------- matcher.cpp -------
*** /tmp/sccs.Kma4mN    Wed Oct 18 23:03:52 2006
--- matcher.cpp Wed Oct 18 23:02:05 2006
***************
*** 1137,1149 ****
  // as part of the current match tree.
  static bool match_into_reg( const Node *n, Node *m, Node *control, int i, bool shared ) {
  
-   // make ReverseBytesI/ReverseBytesL match normal when there exists control
-   int n_opcode = n->Opcode();
- 
-   if ((n_opcode  == Op_ReverseBytesI || n_opcode == Op_ReverseBytesL) && control) 
-      return false;
- 
-   
    const Type *t = m->bottom_type();
  
    // 'm' is a constant?  Probably match it as part of this tree.  Most
--- 1137,1142 ----
***************
*** 1626,1631 ****
--- 1619,1630 ----
              n->unique_out()->is_Store() ) // Following store
            set_shared(n);       // Force it to be a root
          break;
+       case Op_ReverseBytesI:
+       case Op_ReverseBytesL:
+         if( n->in(1)->is_Load() &&        // Prior load
+             n->outcnt() == 1 )            // Not already shared
+           set_shared(n);                  // Force it to be a root
+         break;
        case Op_BoxLock:         // Cant match until we get stack-regs in ADLC
        case Op_IfFalse:
        case Op_IfTrue:
                                     

SUGGESTED FIX

------- matcher.cpp -------
*** /tmp/sccs.r9aWo3    Wed Oct 18 16:41:38 2006
--- matcher.cpp Wed Oct 18 16:43:57 2006
***************
*** 1137,1148 ****
  // as part of the current match tree.
  static bool match_into_reg( const Node *n, Node *m, Node *control, int i, bool shared ) {
  
!   // make ReverseBytesI/ReverseBytesL match normal when there exists control
    int n_opcode = n->Opcode();
  
!   if ((n_opcode  == Op_ReverseBytesI || n_opcode == Op_ReverseBytesL) && control) 
       return false;
- 
    
    const Type *t = m->bottom_type();
  
--- 1137,1150 ----
  // as part of the current match tree.
  static bool match_into_reg( const Node *n, Node *m, Node *control, int i, bool shared ) {
  
!   // make ReverseBytesI/ReverseBytesL match normal match tree when there exists control
!   // if it is not shared. This prevents load followed reverse from using spilling stack.
!   // The code here is a workaround, upon 6482634 fixed, it could be removed.
!  
    int n_opcode = n->Opcode();
  
!   if ((n_opcode  == Op_ReverseBytesI || n_opcode == Op_ReverseBytesL) && control && !shared)
       return false;
    
    const Type *t = m->bottom_type();
                                     

EVALUATION

It is caused of the change in match_into_reg:

+   // make ReverseBytesI/ReverseBytesL match normal when there exists control
+   int n_opcode = n->Opcode();
+ 
+   if ((n_opcode  == Op_ReverseBytesI || n_opcode == Op_ReverseBytesL) && control) 
+      return false;
+ 
See Test.java of 6431242. 
The code here is to avoid generating code spilling onto stack, since load followed reverse can use loadI_reversed rule. If without this code, the generated code will first spilling the value to stack then read reversely back and cost more instruction cycles. 

I missed a check of if the code is shared, it is not shared at above condition, return false go through the normal match tree.
                                     

EVALUATION

A simplified test case attached for reproduction.