*** old/src/share/vm/opto/matcher.cpp	Mon Aug  4 14:31:49 2014
--- new/src/share/vm/opto/matcher.cpp	Mon Aug  4 14:31:49 2014

*** 303,313 ****
--- 303,313 ----
  
    // Create new ideal node ConP #NULL even if it does exist in old space
    // to avoid false sharing if the corresponding mach node is not used.
    // The corresponding mach node is only used in rare cases for derived
    // pointers.
-   Node* new_ideal_null = ConNode::make(C, TypePtr::NULL_PTR);
  
    // Swap out to old-space; emptying new-space
    Arena *old = C->node_arena()->move_contents(C->old_arena());
  
    // Save debug and profile information for nodes in old space:

*** 1641,1652 ****
--- 1641,1652 ----
    if (shared_node != NULL) {
      return shared_node;
    }
  
    // Build the object to represent this state & prepare for recursive calls
-   MachNode *mach = s->MachNodeGenerator( rule, C );
-   mach->_opnds[0] = s->MachOperGenerator( _reduceOp[rule], C );
    assert( mach->_opnds[0] != NULL, "Missing result operand" );
    Node *leaf = s->_leaf;
    // Check for instruction or instruction chain rule
    if( rule >= _END_INST_CHAIN_RULE || rule < _BEGIN_INST_CHAIN_RULE ) {
      assert(C->node_arena()->contains(s->_leaf) || !has_new_node(s->_leaf),

*** 1754,1770 ****
--- 1754,1770 ----
    if( newrule < NUM_OPERANDS ) {
      // Chain from operand or operand class, may be output of shared node
      assert( 0 <= opnd_class_instance && opnd_class_instance < NUM_OPERANDS,
              "Bad AD file: Instruction chain rule must chain from operand");
      // Insert operand into array of operands for this instruction
-     mach->_opnds[1] = s->MachOperGenerator( opnd_class_instance, C );
  
      ReduceOper( s, newrule, mem, mach );
    } else {
      // Chain from the result of an instruction
      assert( newrule >= _LAST_MACH_OPER, "Do NOT chain from internal operand");
-     mach->_opnds[1] = s->MachOperGenerator( _reduceOp[catch_op], C );
      Node *mem1 = (Node*)1;
      debug_only(Node *save_mem_node = _mem_node;)
      mach->add_req( ReduceInst(s, newrule, mem1) );
      debug_only(_mem_node = save_mem_node;)
    }

*** 1805,1826 ****
--- 1805,1826 ----
      int newrule = newstate->_rule[catch_op];
  
      if( newrule < NUM_OPERANDS ) { // Operand/operandClass or internalOp/instruction?
        // Operand/operandClass
        // Insert operand into array of operands for this instruction
-       mach->_opnds[num_opnds++] = newstate->MachOperGenerator( opnd_class_instance, C );
        ReduceOper( newstate, newrule, mem, mach );
  
      } else {                    // Child is internal operand or new instruction
        if( newrule < _LAST_MACH_OPER ) { // internal operand or instruction?
          // internal operand --> call ReduceInst_Interior
          // Interior of complex instruction.  Do nothing but recurse.
          num_opnds = ReduceInst_Interior( newstate, newrule, mem, mach, num_opnds );
        } else {
          // instruction --> call build operand(  ) to catch result
          //             --> ReduceInst( newrule )
-         mach->_opnds[num_opnds++] = s->MachOperGenerator( _reduceOp[catch_op], C );
          Node *mem1 = (Node*)1;
          debug_only(Node *save_mem_node = _mem_node;)
          mach->add_req( ReduceInst( newstate, newrule, mem1 ) );
          debug_only(_mem_node = save_mem_node;)
        }