*** old/src/share/vm/opto/matcher.cpp	Thu May 15 17:09:30 2014
--- new/src/share/vm/opto/matcher.cpp	Thu May 15 17:09:30 2014

*** 749,759 ****
--- 749,759 ----
          ret_rms      [      ret_edge_cnt].Insert(OptoReg::Name(i+1));
          reth_rms     [     reth_edge_cnt].Insert(OptoReg::Name(i+1));
          tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1));
          tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1));
          halt_rms     [     halt_edge_cnt].Insert(OptoReg::Name(i+1));
-         mproj = new (C) MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegD );
          proj_cnt += 2;          // Skip 2 for doubles
        }
        else if( (i&1) == 1 &&    // Else check for high half of double
                 _register_save_type[i-1] == Op_RegF &&
                 _register_save_type[i  ] == Op_RegF &&

*** 775,785 ****
--- 775,785 ----
          ret_rms      [      ret_edge_cnt].Insert(OptoReg::Name(i+1));
          reth_rms     [     reth_edge_cnt].Insert(OptoReg::Name(i+1));
          tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1));
          tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1));
          halt_rms     [     halt_edge_cnt].Insert(OptoReg::Name(i+1));
-         mproj = new (C) MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegL );
          proj_cnt += 2;          // Skip 2 for longs
        }
        else if( (i&1) == 1 &&    // Else check for high half of long
                 _register_save_type[i-1] == Op_RegI &&
                 _register_save_type[i  ] == Op_RegI &&

*** 790,800 ****
--- 790,800 ----
          tail_jump_rms[tail_jump_edge_cnt] = RegMask::Empty;
          halt_rms     [     halt_edge_cnt] = RegMask::Empty;
          mproj = C->top();
        } else {
          // Make a projection for it off the Start
-         mproj = new (C) MachProjNode( start, proj_cnt++, ret_rms[ret_edge_cnt], _register_save_type[i] );
        }
  
        ret_edge_cnt ++;
        reth_edge_cnt ++;
        tail_call_edge_cnt ++;

*** 843,859 ****
--- 843,859 ----
    // Share frame pointer while making spill ops
    set_shared(fp);
  
    // Compute generic short-offset Loads
  #ifdef _LP64
-   MachNode *spillCP = match_tree(new (C) LoadNNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered));
  #endif
-   MachNode *spillI  = match_tree(new (C) LoadINode(NULL,mem,fp,atp,TypeInt::INT,MemNode::unordered));
-   MachNode *spillL  = match_tree(new (C) LoadLNode(NULL,mem,fp,atp,TypeLong::LONG,MemNode::unordered,false));
-   MachNode *spillF  = match_tree(new (C) LoadFNode(NULL,mem,fp,atp,Type::FLOAT,MemNode::unordered));
-   MachNode *spillD  = match_tree(new (C) LoadDNode(NULL,mem,fp,atp,Type::DOUBLE,MemNode::unordered));
-   MachNode *spillP  = match_tree(new (C) LoadPNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered));
    assert(spillI != NULL && spillL != NULL && spillF != NULL &&
           spillD != NULL && spillP != NULL, "");
    // Get the ADLC notion of the right regmask, for each basic type.
  #ifdef _LP64
    idealreg2regmask[Op_RegN] = &spillCP->out_RegMask();

*** 865,887 ****
--- 865,887 ----
    idealreg2regmask[Op_RegP] = &spillP->out_RegMask();
  
    // Vector regmasks.
    if (Matcher::vector_size_supported(T_BYTE,4)) {
      TypeVect::VECTS = TypeVect::make(T_BYTE, 4);
-     MachNode *spillVectS = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTS));
      idealreg2regmask[Op_VecS] = &spillVectS->out_RegMask();
    }
    if (Matcher::vector_size_supported(T_FLOAT,2)) {
-     MachNode *spillVectD = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTD));
      idealreg2regmask[Op_VecD] = &spillVectD->out_RegMask();
    }
    if (Matcher::vector_size_supported(T_FLOAT,4)) {
-     MachNode *spillVectX = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTX));
      idealreg2regmask[Op_VecX] = &spillVectX->out_RegMask();
    }
    if (Matcher::vector_size_supported(T_FLOAT,8)) {
-     MachNode *spillVectY = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTY));
      idealreg2regmask[Op_VecY] = &spillVectY->out_RegMask();
    }
  }
  
  #ifdef ASSERT

*** 1317,1327 ****
--- 1317,1327 ----
      // any legacy C-killed slots.  Use Fat-Projections to do the killing.
      // Since the max-per-method covers the max-per-call-site and debug info
      // is excluded on the max-per-method basis, debug info cannot land in
      // this killed area.
      uint r_cnt = mcall->tf()->range()->cnt();
-     MachProjNode *proj = new (C) MachProjNode( mcall, r_cnt+10000, RegMask::Empty, MachProjNode::fat_proj );
      if (!RegMask::can_represent_arg(OptoReg::Name(out_arg_limit_per_call-1))) {
        C->record_method_not_compilable_all_tiers("unsupported outgoing calling sequence");
      } else {
        for (int i = begin_out_arg_area; i < out_arg_limit_per_call; i++)
          proj->_rout.Insert(OptoReg::Name(i));

*** 2272,2282 ****
--- 2272,2282 ----
        case Op_CompareAndSwapL:
        case Op_CompareAndSwapP:
        case Op_CompareAndSwapN: {   // Convert trinary to binary-tree
          Node *newval = n->in(MemNode::ValueIn );
          Node *oldval  = n->in(LoadStoreConditionalNode::ExpectedIn);
-         Node *pair = new (C) BinaryNode( oldval, newval );
          n->set_req(MemNode::ValueIn,pair);
          n->del_req(LoadStoreConditionalNode::ExpectedIn);
          break;
        }
        case Op_CMoveD:              // Convert trinary to binary-tree

*** 2287,2330 ****
--- 2287,2330 ----
        case Op_CMoveP: {
          // Restructure into a binary tree for Matching.  It's possible that
          // we could move this code up next to the graph reshaping for IfNodes
          // or vice-versa, but I do not want to debug this for Ladybird.
          // 10/2/2000 CNC.
-         Node *pair1 = new (C) BinaryNode(n->in(1),n->in(1)->in(1));
          n->set_req(1,pair1);
-         Node *pair2 = new (C) BinaryNode(n->in(2),n->in(3));
          n->set_req(2,pair2);
          n->del_req(3);
          break;
        }
        case Op_LoopLimit: {
-         Node *pair1 = new (C) BinaryNode(n->in(1),n->in(2));
          n->set_req(1,pair1);
          n->set_req(2,n->in(3));
          n->del_req(3);
          break;
        }
        case Op_StrEquals: {
-         Node *pair1 = new (C) BinaryNode(n->in(2),n->in(3));
          n->set_req(2,pair1);
          n->set_req(3,n->in(4));
          n->del_req(4);
          break;
        }
        case Op_StrComp:
        case Op_StrIndexOf: {
-         Node *pair1 = new (C) BinaryNode(n->in(2),n->in(3));
          n->set_req(2,pair1);
-         Node *pair2 = new (C) BinaryNode(n->in(4),n->in(5));
          n->set_req(3,pair2);
          n->del_req(5);
          n->del_req(4);
          break;
        }
        case Op_EncodeISOArray: {
          // Restructure into a binary tree for Matching.
-         Node* pair = new (C) BinaryNode(n->in(3), n->in(4));
          n->set_req(3, pair);
          n->del_req(4);
          break;
        }
        default: