A recent patch increased GCC's memory consumption!

gcctest@suse.de gcctest@suse.de
Thu Apr 2 18:27:00 GMT 2009


Hi,

I am a friendly script caring about memory consumption in GCC.  Please
contact jh@suse.cz if something is going wrong.

Comparing memory consumption on compilation of combine.i, insn-attrtab.i,
and generate-3.4.ii I got:


comparing empty function compilation at -O0 level:
    Overall memory needed: 8422k -> 8421k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1436k
    Maximum of released memory in single GGC run: 87k
    Garbage: 219k
    Leak: 1536k
    Overhead: 187k
    GGC runs: 4
    Pre-IPA-Garbage: 209k
    Pre-IPA-Leak: 1539k
    Pre-IPA-Overhead: 186k
    Post-IPA-Garbage: 209k
    Post-IPA-Leak: 1539k
    Post-IPA-Overhead: 186k

comparing empty function compilation at -O0 -g level:
    Overall memory needed: 8446k -> 8445k
    Peak memory use before GGC: 1515k
    Peak memory use after GGC: 1464k
    Maximum of released memory in single GGC run: 87k
    Garbage: 220k
    Leak: 1569k
    Overhead: 191k
    GGC runs: 4
    Pre-IPA-Garbage: 209k
    Pre-IPA-Leak: 1539k
    Pre-IPA-Overhead: 186k
    Post-IPA-Garbage: 209k
    Post-IPA-Leak: 1539k
    Post-IPA-Overhead: 186k

comparing empty function compilation at -O1 level:
    Overall memory needed: 8454k -> 8453k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1436k
    Maximum of released memory in single GGC run: 90k
    Garbage: 222k
    Leak: 1536k
    Overhead: 188k
    GGC runs: 4
    Pre-IPA-Garbage: 209k
    Pre-IPA-Leak: 1539k
    Pre-IPA-Overhead: 186k
    Post-IPA-Garbage: 209k
    Post-IPA-Leak: 1539k
    Post-IPA-Overhead: 186k

comparing empty function compilation at -O2 level:
    Overall memory needed: 8474k -> 8469k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1437k
    Maximum of released memory in single GGC run: 89k
    Garbage: 227k
    Leak: 1537k
    Overhead: 189k
    GGC runs: 5
    Pre-IPA-Garbage: 209k
    Pre-IPA-Leak: 1540k
    Pre-IPA-Overhead: 186k
    Post-IPA-Garbage: 209k
    Post-IPA-Leak: 1540k
    Post-IPA-Overhead: 186k

comparing empty function compilation at -O3 level:
    Overall memory needed: 8474k -> 8473k
    Peak memory use before GGC: 1488k
    Peak memory use after GGC: 1437k
    Maximum of released memory in single GGC run: 89k
    Garbage: 227k
    Leak: 1537k
    Overhead: 189k
    GGC runs: 5
    Pre-IPA-Garbage: 209k
    Pre-IPA-Leak: 1540k
    Pre-IPA-Overhead: 186k
    Post-IPA-Garbage: 209k
    Post-IPA-Leak: 1540k
    Post-IPA-Overhead: 186k

comparing combine.c compilation at -O0 level:
    Overall memory needed: 32426k -> 32425k
    Peak memory use before GGC: 18523k
    Peak memory use after GGC: 18312k
    Maximum of released memory in single GGC run: 1806k
    Garbage: 38624k
    Leak: 7129k
    Overhead: 5699k
    GGC runs: 333
    Pre-IPA-Garbage: 12666k
    Pre-IPA-Leak: 20017k
    Pre-IPA-Overhead: 2751k
    Post-IPA-Garbage: 12666k
    Post-IPA-Leak: 20017k
    Post-IPA-Overhead: 2751k

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 34454k -> 34453k
    Peak memory use before GGC: 20364k
    Peak memory use after GGC: 20148k
    Maximum of released memory in single GGC run: 1815k
    Garbage: 38842k
    Leak: 10414k
    Overhead: 6510k
    GGC runs: 317
    Pre-IPA-Garbage: 12684k
    Pre-IPA-Leak: 22263k
    Pre-IPA-Overhead: 3232k
    Post-IPA-Garbage: 12684k
    Post-IPA-Leak: 22263k
    Post-IPA-Overhead: 3232k

comparing combine.c compilation at -O1 level:
    Overall memory needed: 31778k -> 31777k
    Peak memory use before GGC: 16632k
    Peak memory use after GGC: 16460k
    Maximum of released memory in single GGC run: 1360k
    Garbage: 46251k -> 46250k
    Leak: 7114k
    Overhead: 6331k -> 6331k
    GGC runs: 395
    Pre-IPA-Garbage: 13185k -> 13184k
    Pre-IPA-Leak: 17990k
    Pre-IPA-Overhead: 2666k -> 2666k
    Post-IPA-Garbage: 13185k -> 13184k
    Post-IPA-Leak: 17990k
    Post-IPA-Overhead: 2666k -> 2666k

comparing combine.c compilation at -O2 level:
    Overall memory needed: 32514k -> 32773k
    Peak memory use before GGC: 16749k
    Peak memory use after GGC: 16583k
    Maximum of released memory in single GGC run: 1322k -> 1321k
    Garbage: 60126k -> 60113k
    Leak: 7144k
    Overhead: 8328k -> 8327k
    GGC runs: 455
    Pre-IPA-Garbage: 13328k -> 13326k
    Pre-IPA-Leak: 18033k
    Pre-IPA-Overhead: 2686k -> 2686k
    Post-IPA-Garbage: 13328k -> 13326k
    Post-IPA-Leak: 18033k
    Post-IPA-Overhead: 2686k -> 2686k

comparing combine.c compilation at -O3 level:
    Overall memory needed: 32846k -> 33005k
    Peak memory use before GGC: 16892k
    Peak memory use after GGC: 16660k
    Maximum of released memory in single GGC run: 1636k
    Garbage: 72680k -> 72672k
    Leak: 8445k
    Overhead: 9836k -> 9837k
    GGC runs: 481
    Pre-IPA-Garbage: 13328k -> 13326k
    Pre-IPA-Leak: 18033k
    Pre-IPA-Overhead: 2686k -> 2686k
    Post-IPA-Garbage: 13328k -> 13326k
    Post-IPA-Leak: 18033k
    Post-IPA-Overhead: 2686k -> 2686k

comparing insn-attrtab.c compilation at -O0 level:
    Overall memory needed: 155250k -> 155249k
    Peak memory use before GGC: 64959k
    Peak memory use after GGC: 53884k
    Maximum of released memory in single GGC run: 26945k
    Garbage: 130452k
    Leak: 9534k
    Overhead: 17044k
    GGC runs: 259
    Pre-IPA-Garbage: 41075k
    Pre-IPA-Leak: 56273k
    Pre-IPA-Overhead: 8428k
    Post-IPA-Garbage: 41075k
    Post-IPA-Leak: 56273k
    Post-IPA-Overhead: 8428k

comparing insn-attrtab.c compilation at -O0 -g level:
    Overall memory needed: 156542k -> 156541k
    Peak memory use before GGC: 66224k
    Peak memory use after GGC: 55146k
    Maximum of released memory in single GGC run: 26945k
    Garbage: 130788k
    Leak: 11165k
    Overhead: 17496k
    GGC runs: 252
    Pre-IPA-Garbage: 41083k
    Pre-IPA-Leak: 57797k
    Pre-IPA-Overhead: 8757k
    Post-IPA-Garbage: 41083k
    Post-IPA-Leak: 57797k
    Post-IPA-Overhead: 8757k

comparing insn-attrtab.c compilation at -O1 level:
    Overall memory needed: 132434k -> 132437k
    Peak memory use before GGC: 50565k
    Peak memory use after GGC: 43998k
    Maximum of released memory in single GGC run: 20902k
    Garbage: 181540k
    Leak: 8913k
    Overhead: 25141k
    GGC runs: 299
    Pre-IPA-Garbage: 46301k
    Pre-IPA-Leak: 44095k
    Pre-IPA-Overhead: 7852k
    Post-IPA-Garbage: 46301k
    Post-IPA-Leak: 44095k
    Post-IPA-Overhead: 7852k

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 146898k -> 146893k
    Peak memory use before GGC: 50625k
    Peak memory use after GGC: 45040k
    Maximum of released memory in single GGC run: 17007k
    Garbage: 205438k
    Leak: 16575k
    Overhead: 30623k
    GGC runs: 325
    Pre-IPA-Garbage: 46369k
    Pre-IPA-Leak: 44103k
    Pre-IPA-Overhead: 7861k
    Post-IPA-Garbage: 46369k
    Post-IPA-Leak: 44103k
    Post-IPA-Overhead: 7861k

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 163354k -> 163341k
    Peak memory use before GGC: 62449k
    Peak memory use after GGC: 59479k
    Maximum of released memory in single GGC run: 18460k
    Garbage: 243330k -> 243325k
    Leak: 8937k
    Overhead: 34084k -> 34084k
    GGC runs: 336
    Pre-IPA-Garbage: 46369k
    Pre-IPA-Leak: 44103k
    Pre-IPA-Overhead: 7861k
    Post-IPA-Garbage: 46369k
    Post-IPA-Leak: 44103k
    Post-IPA-Overhead: 7861k

comparing Gerald's testcase PR8361 compilation at -O0 level:
  Overall memory allocated via mmap and sbrk increased from 149007k to 153123k, overall 2.76%
  Peak amount of GGC memory allocated before garbage collecting increased from 81789k to 84851k, overall 3.74%
  Peak amount of GGC memory still allocated after garbage collecting increased from 80979k to 84005k, overall 3.74%
  Amount of produced GGC garbage increased from 199558k to 200311k, overall 0.38%
  Amount of memory still referenced at the end of compilation increased from 51860k to 55317k, overall 6.67%
    Overall memory needed: 149007k -> 153123k
    Peak memory use before GGC: 81789k -> 84851k
    Peak memory use after GGC: 80979k -> 84005k
    Maximum of released memory in single GGC run: 14288k -> 14300k
    Garbage: 199558k -> 200311k
    Leak: 51860k -> 55317k
    Overhead: 28059k -> 28496k
    GGC runs: 452 -> 441
  Amount of produced pre-ipa-GGC garbage increased from 109476k to 110229k, overall 0.69%
  Amount of memory referenced pre-ipa increased from 87516k to 90902k, overall 3.87%
    Pre-IPA-Garbage: 109476k -> 110229k
    Pre-IPA-Leak: 87516k -> 90902k
    Pre-IPA-Overhead: 15207k -> 15638k
  Amount of produced post-ipa-GGC garbage increased from 109476k to 110229k, overall 0.69%
  Amount of memory referenced post-ipa increased from 87516k to 90902k, overall 3.87%
    Post-IPA-Garbage: 109476k -> 110229k
    Post-IPA-Leak: 87516k -> 90902k
    Post-IPA-Overhead: 15207k -> 15638k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
  Overall memory allocated via mmap and sbrk increased from 166543k to 171059k, overall 2.71%
  Peak amount of GGC memory allocated before garbage collecting increased from 95466k to 99246k, overall 3.96%
  Peak amount of GGC memory still allocated after garbage collecting increased from 94520k to 98263k, overall 3.96%
  Amount of memory still referenced at the end of compilation increased from 78317k to 83391k, overall 6.48%
    Overall memory needed: 166543k -> 171059k
    Peak memory use before GGC: 95466k -> 99246k
    Peak memory use after GGC: 94520k -> 98263k
    Maximum of released memory in single GGC run: 14721k -> 14516k
    Garbage: 204513k -> 204717k
    Leak: 78317k -> 83391k
    Overhead: 34615k -> 35306k
    GGC runs: 418 -> 415
  Amount of produced pre-ipa-GGC garbage increased from 109841k to 110594k, overall 0.69%
  Amount of memory referenced pre-ipa increased from 103909k to 107802k, overall 3.75%
    Pre-IPA-Garbage: 109841k -> 110594k
    Pre-IPA-Leak: 103909k -> 107802k
    Pre-IPA-Overhead: 18692k -> 19226k
  Amount of produced post-ipa-GGC garbage increased from 109841k to 110594k, overall 0.69%
  Amount of memory referenced post-ipa increased from 103909k to 107802k, overall 3.75%
    Post-IPA-Garbage: 109841k -> 110594k
    Post-IPA-Leak: 103909k -> 107802k
    Post-IPA-Overhead: 18692k -> 19226k

comparing Gerald's testcase PR8361 compilation at -O1 level:
  Overall memory allocated via mmap and sbrk increased from 104791k to 107974k, overall 3.04%
  Peak amount of GGC memory allocated before garbage collecting increased from 78893k to 82085k, overall 4.05%
  Peak amount of GGC memory still allocated after garbage collecting increased from 78111k to 81263k, overall 4.04%
  Amount of produced GGC garbage increased from 261800k to 262723k, overall 0.35%
  Amount of memory still referenced at the end of compilation increased from 48458k to 52085k, overall 7.48%
    Overall memory needed: 104791k -> 107974k
    Peak memory use before GGC: 78893k -> 82085k
    Peak memory use after GGC: 78111k -> 81263k
    Maximum of released memory in single GGC run: 14230k -> 14130k
    Garbage: 261800k -> 262723k
    Leak: 48458k -> 52085k
    Overhead: 30768k -> 31292k
    GGC runs: 528 -> 522
  Amount of produced pre-ipa-GGC garbage increased from 153270k to 154019k, overall 0.49%
  Amount of memory referenced pre-ipa increased from 81980k to 85583k, overall 4.39%
    Pre-IPA-Garbage: 153270k -> 154019k
    Pre-IPA-Leak: 81980k -> 85583k
    Pre-IPA-Overhead: 19389k -> 19872k
  Amount of produced post-ipa-GGC garbage increased from 153270k to 154019k, overall 0.49%
  Amount of memory referenced post-ipa increased from 81980k to 85583k, overall 4.39%
    Post-IPA-Garbage: 153270k -> 154019k
    Post-IPA-Leak: 81980k -> 85583k
    Post-IPA-Overhead: 19389k -> 19872k

comparing Gerald's testcase PR8361 compilation at -O2 level:
  Overall memory allocated via mmap and sbrk increased from 105259k to 108350k, overall 2.94%
  Peak amount of GGC memory allocated before garbage collecting increased from 79117k to 82250k, overall 3.96%
  Peak amount of GGC memory still allocated after garbage collecting increased from 78326k to 81432k, overall 3.97%
  Amount of produced GGC garbage increased from 317929k to 319225k, overall 0.41%
  Amount of memory still referenced at the end of compilation increased from 48442k to 52137k, overall 7.63%
    Overall memory needed: 105259k -> 108350k
    Peak memory use before GGC: 79117k -> 82250k
    Peak memory use after GGC: 78326k -> 81432k
    Maximum of released memory in single GGC run: 14160k -> 14096k
    Garbage: 317929k -> 319225k
    Leak: 48442k -> 52137k
    Overhead: 37594k -> 38173k
    GGC runs: 607 -> 593
  Amount of produced pre-ipa-GGC garbage increased from 157610k to 158356k, overall 0.47%
  Amount of memory referenced pre-ipa increased from 81448k to 85041k, overall 4.41%
    Pre-IPA-Garbage: 157610k -> 158356k
    Pre-IPA-Leak: 81448k -> 85041k
    Pre-IPA-Overhead: 19859k -> 20325k
  Amount of produced post-ipa-GGC garbage increased from 157610k to 158356k, overall 0.47%
  Amount of memory referenced post-ipa increased from 81448k to 85041k, overall 4.41%
    Post-IPA-Garbage: 157610k -> 158356k
    Post-IPA-Leak: 81448k -> 85041k
    Post-IPA-Overhead: 19859k -> 20325k

comparing Gerald's testcase PR8361 compilation at -O3 level:
  Overall memory allocated via mmap and sbrk increased from 105451k to 108594k, overall 2.98%
  Peak amount of GGC memory allocated before garbage collecting increased from 79117k to 82250k, overall 3.96%
  Peak amount of GGC memory still allocated after garbage collecting increased from 78326k to 81432k, overall 3.97%
  Amount of produced GGC garbage increased from 350674k to 351998k, overall 0.38%
  Amount of memory still referenced at the end of compilation increased from 48447k to 52136k, overall 7.61%
    Overall memory needed: 105451k -> 108594k
    Peak memory use before GGC: 79117k -> 82250k
    Peak memory use after GGC: 78326k -> 81432k
    Maximum of released memory in single GGC run: 14160k -> 14096k
    Garbage: 350674k -> 351998k
    Leak: 48447k -> 52136k
    Overhead: 41126k -> 41684k
    GGC runs: 643 -> 630
  Amount of produced pre-ipa-GGC garbage increased from 157672k to 158418k, overall 0.47%
  Amount of memory referenced pre-ipa increased from 81883k to 85478k, overall 4.39%
    Pre-IPA-Garbage: 157672k -> 158418k
    Pre-IPA-Leak: 81883k -> 85478k
    Pre-IPA-Overhead: 19893k -> 20360k
  Amount of produced post-ipa-GGC garbage increased from 157672k to 158418k, overall 0.47%
  Amount of memory referenced post-ipa increased from 81883k to 85478k, overall 4.39%
    Post-IPA-Garbage: 157672k -> 158418k
    Post-IPA-Leak: 81883k -> 85478k
    Post-IPA-Overhead: 19893k -> 20360k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
    Overall memory needed: 358115k -> 358117k
    Peak memory use before GGC: 76702k
    Peak memory use after GGC: 49081k
    Maximum of released memory in single GGC run: 36523k
    Garbage: 139139k
    Leak: 8223k
    Overhead: 24351k
    GGC runs: 86
    Pre-IPA-Garbage: 13104k
    Pre-IPA-Leak: 20336k
    Pre-IPA-Overhead: 2318k
    Post-IPA-Garbage: 13104k
    Post-IPA-Leak: 20336k
    Post-IPA-Overhead: 2318k

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
    Overall memory needed: 358799k -> 358797k
    Peak memory use before GGC: 77385k
    Peak memory use after GGC: 49765k
    Maximum of released memory in single GGC run: 36507k
    Garbage: 139273k
    Leak: 10219k
    Overhead: 24933k
    GGC runs: 93
    Pre-IPA-Garbage: 13106k
    Pre-IPA-Leak: 20582k
    Pre-IPA-Overhead: 2371k
    Post-IPA-Garbage: 13106k
    Post-IPA-Leak: 20582k
    Post-IPA-Overhead: 2371k

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
    Overall memory needed: 225382k -> 225381k
    Peak memory use before GGC: 72540k
    Peak memory use after GGC: 66333k
    Maximum of released memory in single GGC run: 32083k
    Garbage: 214365k
    Leak: 8163k
    Overhead: 30575k
    GGC runs: 94
    Pre-IPA-Garbage: 45855k
    Pre-IPA-Leak: 63229k
    Pre-IPA-Overhead: 8876k
    Post-IPA-Garbage: 45855k
    Post-IPA-Leak: 63229k
    Post-IPA-Overhead: 8876k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
    Overall memory needed: 491470k -> 491789k
    Peak memory use before GGC: 72541k
    Peak memory use after GGC: 66334k
    Maximum of released memory in single GGC run: 33418k
    Garbage: 255770k
    Leak: 8164k
    Overhead: 38646k
    GGC runs: 103
    Pre-IPA-Garbage: 103136k
    Pre-IPA-Leak: 72023k
    Pre-IPA-Overhead: 14557k
    Post-IPA-Garbage: 103136k
    Post-IPA-Leak: 72023k
    Post-IPA-Overhead: 14557k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
    Overall memory needed: 1021754k -> 1021689k
    Peak memory use before GGC: 135724k
    Peak memory use after GGC: 125553k
    Maximum of released memory in single GGC run: 62483k
    Garbage: 348115k
    Leak: 9720k
    Overhead: 45112k
    GGC runs: 99
    Pre-IPA-Garbage: 103136k
    Pre-IPA-Leak: 72023k
    Pre-IPA-Overhead: 14557k
    Post-IPA-Garbage: 103136k
    Post-IPA-Leak: 72023k
    Post-IPA-Overhead: 14557k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2009-04-01 22:48:10.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2009-04-02 15:12:05.000000000 +0000
@@ -1,3 +1,55 @@
+2009-04-02  Jan Hubicka  <jh@suse.cz>
+
+	* passes.c (init_optimization_passes): Remove two copies of ehcleanup
+	pass.
+
+2009-04-02  H.J. Lu  <hongjiu.lu@intel.com>
+
+	* config/i386/i386.c (ix86_abi): Move initialization to ...
+	(override_options): Here.
+
+2009-04-02  Christian Bruel  <christian.bruel@st.com>
+
+	* config/sh/sh.c (sh_dwarf_register_span): New function.
+	(TARGET_DWARF_REGISTER_SPAN): Define.
+	* config/sh/sh-protos.h (sh_dwarf_register_span): Declare.
+	
+2009-04-02  Ira Rosen  <irar@il.ibm.com>
+
+	PR tree-optimization/39595
+	* tree-vect-slp.c (vect_build_slp_tree): Check that the size of 
+	interleaved loads group is not  greater than the SLP group size.
+
+2009-04-02  Rafael Avila de Espindola  <espindola@google.com>
+
+	* builtins.c (is_builtin_name): New.
+	(called_as_built_in): Use is_builtin_name.
+	* tree.h (is_builtin_name): New.
+	* varasm.c (incorporeal_function_p): Use is_builtin_name
+
+2009-04-02  Andrew Stubbs  <ams@codesourcery.com>
+
+	* config/sh/linux-unwind.h: Disable when inhibit_libc is defined.
+
+2009-04-02  Dodji Seketeli  <dodji@redhat.com>
+
+	PR c++/26693
+	* c-decl.c: (clone_underlying_type): Move this ...
+	* c-common.c (set_underlying_type): ... here.
+	Also, make sure the function properly sets TYPE_STUB_DECL() on
+	the newly created typedef variant type.
+	* c-common.h (is_typedef_decl, set_underlying_type): Declare ...
+	* c-common.c (is_typedef_decl, set_underlying_type): ... new entry points.
+
+2009-04-02  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/37221
+	* tree-flow.h (degenerate_phi_result): Declare.
+	* tree-ssa-dom.c (degenerate_phi_result): Export.
+	* tree-scalar-evolution.c (analyze_initial_condition): If
+	the initial condition is defined by a degenerate PHI node
+	use the degenerate value.
+
 2009-04-01  Eric Botcazou  <ebotcazou@adacore.com>
 
 	PR rtl-optimization/39588
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog.cp	2009-04-01 06:27:27.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/cp/ChangeLog	2009-04-02 15:12:04.000000000 +0000
@@ -1,3 +1,36 @@
+2009-04-02  Dodji Seketeli  <dodji@redhat.com>
+
+	PR c++/26693
+	* decl2.c (grokfield): when a typedef appears in a
+	class, create the typedef variant type node for it.
+	(save_template_attributes): Creating typedef variant type node
+	 here is now useless.
+	* decl.c (grokdeclarator): If the typedef'ed struct/class was
+	anonymous, set the proper type name to all its type variants.
+	(xref_basetypes) : Fixup the variant types after setting
+	TYPE_BINFO on REF.
+	* name-lookup.c (pushdecl_maybe_friend): Reuse the
+	set_underlying_type function to install typedef variant types.
+	* cp-tree.h (MEMBER_TYPES_NEEDING_ACCESS_CHECK): New template accessor
+	macro.
+	(append_type_to_template_for_access_check): New entry points.
+	* semantics.c (check_accessibility_of_qualified_id):
+	When a typedef that is a member of a class appears in a template,
+	add it to the template. It will be ...
+	* class.c (finish_struct_bits): Split type variant fixup into ...
+	(fixup_type_variants): A new entry point.
+	* pt.c (instantiate_class_template, instantiate_template ): ... access
+	checked at template instantiation time.
+	(resolve_type_name_type): The type name should be the name of the
+	main type variant.
+	(retrieve_specialization): Specializations of template typedefs aren't
+	to looked up in DECL_TEMPLATE_INSTANTIATIONS (tmpl).
+	(append_type_to_template_for_access_check): New entry point.
+	(tsubst_decl): For typedefs, build the variant type from the correct
+	original type.
+	(get_class_bindings): Fix function comment.
+	(perform_typedefs_access_check): New entry point.
+
 2009-03-31  Jason Merrill  <jason@redhat.com>
 
 	PR c++/34691


The results can be reproduced by building a compiler with

--enable-gather-detailed-mem-stats targetting x86-64

and compiling preprocessed combine.c or testcase from PR8632 with:

-fmem-report --param=ggc-min-heapsize=1024 --param=ggc-min-expand=1 -Ox -Q

The memory consumption summary appears in the dump after detailed listing
of the places they are allocated in.  Peak memory consumption is actually
computed by looking for maximal value in {GC XXXX -> YYYY} report.

Your testing script.



More information about the Gcc-regression mailing list