Patch for memory blowup

[Mark Mitchell]

I believe I have a patch (attached) for the memory explosions that
occur when using g++ -O2 -Wall with lots of templates.  See for
example:

  http://www.cygnus.com/ml/egcs/1997-Oct/0300.html

This is also mentioned in the FAQ.

The diffs below look longer than they are due to an indentation change
that happened when a set of curly braces went away.  Fred's program:

    #include <stdlib.h>
    #include <iostream.h>
    #include <algorithm>
    #include <vector.h>

    int main()
    {
        vector<int>             int_vec(size_t(5), int(1));
        vector<vector<int> >    int_vec_vec(size_t(7), int_vec);
        vector<vector<vector<int> > > int_vec_vec_vec(size_t(9), int_vec_vec);

        cout << int_vec_vec_vec[3][3][3] << endl;
        cout << "wow" << endl;
    }

which used to use >200M now compiles as gently as without -Wall.  And,
the .s file generated (I checked -O3 -Wall, actually) is precisely the
same as without -Wall.

-- 
Mark Mitchell		mmitchell@usa.net
Stanford University	http://www.stanford.edu

Index: gcc/toplev.c
===================================================================
RCS file: /home/mitchell/Repository/egcs/gcc/toplev.c,v
retrieving revision 1.1.1.4
diff -c -p -r1.1.1.4 toplev.c
*** toplev.c	1997/12/08 07:30:40	1.1.1.4
--- toplev.c	1997/12/12 00:09:17
*************** rest_of_compilation (decl)
*** 3116,3150 ****
  	{
  	  DECL_DEFER_OUTPUT (decl) = 1;
  
! 	  /* If -Wreturn-type, we have to do a bit of compilation.  */
! 	  if (! warn_return_type)
  	    {
  #ifdef DWARF_DEBUGGING_INFO
! 	      /* Generate the DWARF info for the "abstract" instance
! 		 of a function which we may later generate inlined and/or
! 		 out-of-line instances of.  */
! 	      if (write_symbols == DWARF_DEBUG)
! 		{
! 		  set_decl_abstract_flags (decl, 1);
! 		  TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
! 		  set_decl_abstract_flags (decl, 0);
! 		}
  #endif
  #ifdef DWARF2_DEBUGGING_INFO
! 	      /* Generate the DWARF2 info for the "abstract" instance
! 		 of a function which we may later generate inlined and/or
! 		 out-of-line instances of.  */
! 	      if (write_symbols == DWARF2_DEBUG)
! 		{
! 		  set_decl_abstract_flags (decl, 1);
! 		  TIMEVAR (symout_time, dwarf2out_decl (decl));
! 		  set_decl_abstract_flags (decl, 0);
! 		}
! #endif
! 	      TIMEVAR (integration_time, save_for_inline_nocopy (decl));
! 	      RTX_INTEGRATED_P (DECL_SAVED_INSNS (decl)) = inlinable;
! 	      goto exit_rest_of_compilation;
  	    }
  	}
  
        /* If we have to compile the function now, save its rtl and subdecls
--- 3116,3163 ----
  	{
  	  DECL_DEFER_OUTPUT (decl) = 1;
  
! 	  /* If -Wreturn-type, we have to do a bit of compilation.
! 	     However, if we just fall through we will call
! 	     save_for_inline_copying() which results in excessive
! 	     memory use.  Instead, we just want to call
! 	     jump_optimize() to figure out whether or not we can fall
! 	     off the end of the function; we do the minimum amount of
! 	     work necessary to make that safe.  And, we set optimize
! 	     to zero to keep jump_optimize from working too hard.  */
! 	  if (warn_return_type)
  	    {
+ 	      int saved_optimize = optimize;
+ 	      optimize = 0;
+ 	      find_exception_handler_labels ();
+ 	      jump_optimize (get_insns(), 0, 0, 0);
+ 	      optimize = saved_optimize;
+ 	    }
+ 
  #ifdef DWARF_DEBUGGING_INFO
! 	  /* Generate the DWARF info for the "abstract" instance
! 	     of a function which we may later generate inlined and/or
! 	     out-of-line instances of.  */
! 	  if (write_symbols == DWARF_DEBUG)
! 	    {
! 	      set_decl_abstract_flags (decl, 1);
! 	      TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 0));
! 	      set_decl_abstract_flags (decl, 0);
! 	    }
  #endif
  #ifdef DWARF2_DEBUGGING_INFO
! 	  /* Generate the DWARF2 info for the "abstract" instance
! 	     of a function which we may later generate inlined and/or
! 	     out-of-line instances of.  */
! 	  if (write_symbols == DWARF2_DEBUG)
! 	    {
! 	      set_decl_abstract_flags (decl, 1);
! 	      TIMEVAR (symout_time, dwarf2out_decl (decl));
! 	      set_decl_abstract_flags (decl, 0);
  	    }
+ #endif
+ 	  TIMEVAR (integration_time, save_for_inline_nocopy (decl));
+ 	  RTX_INTEGRATED_P (DECL_SAVED_INSNS (decl)) = inlinable;
+ 	  goto exit_rest_of_compilation;
  	}
  
        /* If we have to compile the function now, save its rtl and subdecls