*** old/src/share/vm/opto/phaseX.cpp	Tue Sep 15 15:43:35 2015
--- new/src/share/vm/opto/phaseX.cpp	Tue Sep 15 15:43:34 2015

*** 781,791 ****
--- 781,791 ----
  
  //=============================================================================
  //------------------------------PhaseIterGVN-----------------------------------
  // Initialize hash table to fresh and clean for +VerifyOpto
  PhaseIterGVN::PhaseIterGVN( PhaseIterGVN *igvn, const char *dummy ) : PhaseGVN(igvn,dummy), _worklist( ),
!                                                                       _stack(C->unique() >> 1),
!                                                                       _stack(C->live_nodes() >> 1),
                                                                        _delay_transform(false) {
  }
  
  //------------------------------PhaseIterGVN-----------------------------------
  // Initialize with previous PhaseIterGVN info; used by PhaseCCP

*** 798,808 ****
--- 798,812 ----
  
  //------------------------------PhaseIterGVN-----------------------------------
  // Initialize with previous PhaseGVN info from Parser
  PhaseIterGVN::PhaseIterGVN( PhaseGVN *gvn ) : PhaseGVN(gvn),
                                                _worklist(*C->for_igvn()),
                                                _stack(C->unique() >> 1),
+ // TODO: Before incremental inlining it was allocated only once and it was fine. Now that
+ //       the constructor is used in incremental inlining, this consumes too much memory:
+ //                                            _stack(C->live_nodes() >> 1),
+ //       So, as a band-aid, we replace this by:
+                                               _stack(C->comp_arena(), 32),
                                                _delay_transform(false)
  {
    uint max;
  
    // Dead nodes in the hash table inherited from GVN were not treated as

*** 1584,1594 ****
--- 1588,1598 ----
      return new_node;                // Been there, done that, return old answer
    new_node = transform_once(n);     // Check for constant
    _nodes.map( n->_idx, new_node );  // Flag as having been cloned
  
    // Allocate stack of size _nodes.Size()/2 to avoid frequent realloc
!   GrowableArray <Node *> trstack(C->unique() >> 1);
!   GrowableArray <Node *> trstack(C->live_nodes() >> 1);
  
    trstack.push(new_node);           // Process children of cloned node
    while ( trstack.is_nonempty() ) {
      Node *clone = trstack.pop();
      uint cnt = clone->req();