This is the mail archive of the gcc-regression@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

A recent patch increased GCC's memory consumption in some cases!


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: 8184k
    Peak memory use before GGC: 1291k
    Peak memory use after GGC: 1217k
    Maximum of released memory in single GGC run: 134k
    Garbage: 218k
    Leak: 1221k
    Overhead: 136k
    GGC runs: 4
    Pre-IPA-Garbage: 207k
    Pre-IPA-Leak: 1224k
    Pre-IPA-Overhead: 135k
    Post-IPA-Garbage: 207k
    Post-IPA-Leak: 1224k
    Post-IPA-Overhead: 135k

comparing empty function compilation at -O0 -g level:
    Overall memory needed: 8428k
    Peak memory use before GGC: 1319k
    Peak memory use after GGC: 1245k
    Maximum of released memory in single GGC run: 133k
    Garbage: 220k
    Leak: 1254k
    Overhead: 141k
    GGC runs: 4
    Pre-IPA-Garbage: 207k
    Pre-IPA-Leak: 1224k
    Pre-IPA-Overhead: 135k
    Post-IPA-Garbage: 207k
    Post-IPA-Leak: 1224k
    Post-IPA-Overhead: 135k

comparing empty function compilation at -O1 level:
    Overall memory needed: 8240k
    Peak memory use before GGC: 1291k
    Peak memory use after GGC: 1217k
    Maximum of released memory in single GGC run: 134k
    Garbage: 221k
    Leak: 1221k
    Overhead: 137k
    GGC runs: 4
    Pre-IPA-Garbage: 207k
    Pre-IPA-Leak: 1224k
    Pre-IPA-Overhead: 135k
    Post-IPA-Garbage: 207k
    Post-IPA-Leak: 1224k
    Post-IPA-Overhead: 135k

comparing empty function compilation at -O2 level:
    Overall memory needed: 8452k
    Peak memory use before GGC: 1291k
    Peak memory use after GGC: 1218k
    Maximum of released memory in single GGC run: 135k
    Garbage: 226k
    Leak: 1221k
    Overhead: 138k
    GGC runs: 4
    Pre-IPA-Garbage: 207k
    Pre-IPA-Leak: 1224k
    Pre-IPA-Overhead: 135k
    Post-IPA-Garbage: 207k
    Post-IPA-Leak: 1224k
    Post-IPA-Overhead: 135k

comparing empty function compilation at -O3 level:
    Overall memory needed: 8456k
    Peak memory use before GGC: 1291k
    Peak memory use after GGC: 1218k
    Maximum of released memory in single GGC run: 135k
    Garbage: 226k
    Leak: 1221k
    Overhead: 138k
    GGC runs: 4
    Pre-IPA-Garbage: 207k
    Pre-IPA-Leak: 1224k
    Pre-IPA-Overhead: 135k
    Post-IPA-Garbage: 207k
    Post-IPA-Leak: 1224k
    Post-IPA-Overhead: 135k

comparing combine.c compilation at -O0 level:
    Overall memory needed: 32044k
    Peak memory use before GGC: 18004k -> 17988k
    Peak memory use after GGC: 17791k -> 17775k
    Maximum of released memory in single GGC run: 1824k
    Garbage: 39162k -> 39167k
    Leak: 5792k -> 5775k
    Overhead: 5267k -> 5267k
    GGC runs: 337
    Pre-IPA-Garbage: 12430k
    Pre-IPA-Leak: 19386k
    Pre-IPA-Overhead: 2624k
    Post-IPA-Garbage: 12430k
    Post-IPA-Leak: 19386k
    Post-IPA-Overhead: 2624k

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 34072k -> 34068k
    Peak memory use before GGC: 19910k -> 19893k
    Peak memory use after GGC: 19647k -> 19631k
    Maximum of released memory in single GGC run: 1833k
    Garbage: 39450k -> 39452k
    Leak: 9082k -> 9064k
    Overhead: 6084k -> 6084k
    GGC runs: 320
    Pre-IPA-Garbage: 12529k
    Pre-IPA-Leak: 21659k
    Pre-IPA-Overhead: 3114k
    Post-IPA-Garbage: 12529k
    Post-IPA-Leak: 21659k
    Post-IPA-Overhead: 3114k

comparing combine.c compilation at -O1 level:
    Overall memory needed: 30792k -> 30800k
    Peak memory use before GGC: 15651k
    Peak memory use after GGC: 15482k
    Maximum of released memory in single GGC run: 1379k -> 1380k
    Garbage: 46605k -> 46637k
    Leak: 5775k -> 5747k
    Overhead: 6087k -> 6088k
    GGC runs: 401 -> 402
    Pre-IPA-Garbage: 13169k
    Pre-IPA-Leak: 16872k
    Pre-IPA-Overhead: 2532k
    Post-IPA-Garbage: 13169k
    Post-IPA-Leak: 16872k
    Post-IPA-Overhead: 2532k

comparing combine.c compilation at -O2 level:
    Overall memory needed: 31632k -> 31488k
    Peak memory use before GGC: 15794k
    Peak memory use after GGC: 15633k
    Maximum of released memory in single GGC run: 1357k -> 1356k
    Garbage: 60655k -> 60681k
    Leak: 5960k -> 5922k
    Overhead: 8146k -> 8146k
    GGC runs: 470
    Pre-IPA-Garbage: 13336k
    Pre-IPA-Leak: 16952k
    Pre-IPA-Overhead: 2553k
    Post-IPA-Garbage: 13336k
    Post-IPA-Leak: 16952k
    Post-IPA-Overhead: 2553k

comparing combine.c compilation at -O3 level:
    Overall memory needed: 31928k -> 31924k
    Peak memory use before GGC: 15828k -> 15800k
    Peak memory use after GGC: 15669k -> 15641k
    Maximum of released memory in single GGC run: 1794k -> 1786k
    Garbage: 76097k -> 76131k
    Leak: 5825k -> 5802k
    Overhead: 9935k -> 9935k
    GGC runs: 506
    Pre-IPA-Garbage: 13336k
    Pre-IPA-Leak: 16960k
    Pre-IPA-Overhead: 2554k
    Post-IPA-Garbage: 13336k
    Post-IPA-Leak: 16960k
    Post-IPA-Overhead: 2554k

comparing insn-attrtab.c compilation at -O0 level:
  Amount of produced GGC garbage increased from 103735k to 130817k, overall 26.11%
  Amount of memory still referenced at the end of compilation decreased from 35563k to 8487k, overall -319.02%
    Overall memory needed: 157640k -> 157712k
    Peak memory use before GGC: 65310k -> 65221k
    Peak memory use after GGC: 53354k -> 53266k
    Maximum of released memory in single GGC run: 16211k -> 27424k
    Garbage: 103735k -> 130817k
    Leak: 35563k -> 8487k
    Overhead: 16157k -> 16158k
    GGC runs: 251 -> 263
    Pre-IPA-Garbage: 38224k
    Pre-IPA-Leak: 55908k
    Pre-IPA-Overhead: 8653k
    Post-IPA-Garbage: 38224k
    Post-IPA-Leak: 55908k
    Post-IPA-Overhead: 8653k

comparing insn-attrtab.c compilation at -O0 -g level:
  Amount of produced GGC garbage increased from 104215k to 131296k, overall 25.99%
  Amount of memory still referenced at the end of compilation decreased from 37213k to 10137k, overall -267.07%
    Overall memory needed: 158920k -> 158984k
    Peak memory use before GGC: 66584k -> 66495k
    Peak memory use after GGC: 54626k -> 54538k
    Maximum of released memory in single GGC run: 16212k -> 27424k
    Garbage: 104215k -> 131296k
    Leak: 37213k -> 10137k
    Overhead: 16613k -> 16613k
    GGC runs: 245 -> 255
    Pre-IPA-Garbage: 38281k
    Pre-IPA-Leak: 57449k
    Pre-IPA-Overhead: 8989k
    Post-IPA-Garbage: 38281k
    Post-IPA-Leak: 57449k
    Post-IPA-Overhead: 8989k

comparing insn-attrtab.c compilation at -O1 level:
  Amount of produced GGC garbage increased from 180876k to 181087k, overall 0.12%
    Overall memory needed: 134668k -> 134572k
    Peak memory use before GGC: 50384k -> 50194k
    Peak memory use after GGC: 43482k -> 43288k
    Maximum of released memory in single GGC run: 22952k
    Garbage: 180876k -> 181087k
    Leak: 8074k -> 7864k
    Overhead: 25327k -> 25327k
    GGC runs: 302
    Pre-IPA-Garbage: 43202k
    Pre-IPA-Leak: 43434k
    Pre-IPA-Overhead: 8052k
    Post-IPA-Garbage: 43202k
    Post-IPA-Leak: 43434k
    Post-IPA-Overhead: 8052k

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 149892k -> 149800k
    Peak memory use before GGC: 50361k -> 50193k
    Peak memory use after GGC: 44450k -> 44276k
    Maximum of released memory in single GGC run: 21565k
    Garbage: 212770k -> 212970k
    Leak: 8059k -> 7870k
    Overhead: 31009k -> 31010k
    GGC runs: 334
    Pre-IPA-Garbage: 43275k
    Pre-IPA-Leak: 43440k
    Pre-IPA-Overhead: 8061k
    Post-IPA-Garbage: 43275k
    Post-IPA-Leak: 43440k
    Post-IPA-Overhead: 8061k

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 164900k -> 164692k
    Peak memory use before GGC: 61989k -> 61818k
    Peak memory use after GGC: 58889k -> 58717k
    Maximum of released memory in single GGC run: 23713k
    Garbage: 243015k -> 243211k
    Leak: 8067k -> 7878k
    Overhead: 34452k -> 34453k
    GGC runs: 338 -> 340
    Pre-IPA-Garbage: 43275k
    Pre-IPA-Leak: 43440k
    Pre-IPA-Overhead: 8061k
    Post-IPA-Garbage: 43275k
    Post-IPA-Leak: 43440k
    Post-IPA-Overhead: 8061k

comparing Gerald's testcase PR8361 compilation at -O0 level:
    Overall memory needed: 150603k -> 150598k
    Peak memory use before GGC: 82073k -> 82069k
    Peak memory use after GGC: 81237k -> 81233k
    Maximum of released memory in single GGC run: 15776k
    Garbage: 206460k -> 206465k
    Leak: 50844k -> 50840k
    Overhead: 27261k
    GGC runs: 417
    Pre-IPA-Garbage: 112337k -> 112342k
    Pre-IPA-Leak: 87316k -> 87311k
    Pre-IPA-Overhead: 14978k
    Post-IPA-Garbage: 112337k -> 112342k
    Post-IPA-Leak: 87316k -> 87311k
    Post-IPA-Overhead: 14978k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
    Overall memory needed: 168099k -> 168102k
    Peak memory use before GGC: 95767k
    Peak memory use after GGC: 94819k
    Maximum of released memory in single GGC run: 16204k
    Garbage: 212150k -> 212155k
    Leak: 77406k -> 77402k
    Overhead: 33925k -> 33925k
    GGC runs: 389
    Pre-IPA-Garbage: 112959k -> 112963k
    Pre-IPA-Leak: 103831k -> 103826k
    Pre-IPA-Overhead: 18481k
    Post-IPA-Garbage: 112959k -> 112963k
    Post-IPA-Leak: 103831k -> 103826k
    Post-IPA-Overhead: 18481k

comparing Gerald's testcase PR8361 compilation at -O1 level:
    Overall memory needed: 110809k -> 110801k
    Peak memory use before GGC: 82822k -> 82818k
    Peak memory use after GGC: 81998k -> 81994k
    Maximum of released memory in single GGC run: 16084k -> 16085k
    Garbage: 285910k -> 285946k
    Leak: 47479k -> 47469k
    Overhead: 32504k -> 32504k
    GGC runs: 509
    Pre-IPA-Garbage: 163112k -> 163116k
    Pre-IPA-Leak: 86583k -> 86579k
    Pre-IPA-Overhead: 20472k
    Post-IPA-Garbage: 163112k -> 163116k
    Post-IPA-Leak: 86583k -> 86579k
    Post-IPA-Overhead: 20472k

comparing Gerald's testcase PR8361 compilation at -O2 level:
    Overall memory needed: 112305k -> 112309k
    Peak memory use before GGC: 84296k -> 84292k
    Peak memory use after GGC: 83457k -> 83453k
    Maximum of released memory in single GGC run: 16069k -> 16070k
    Garbage: 340013k -> 340010k
    Leak: 47518k -> 47508k
    Overhead: 39048k -> 39046k
    GGC runs: 576
    Pre-IPA-Garbage: 167129k -> 167132k
    Pre-IPA-Leak: 86920k -> 86916k
    Pre-IPA-Overhead: 20965k
    Post-IPA-Garbage: 167129k -> 167132k
    Post-IPA-Leak: 86920k -> 86916k
    Post-IPA-Overhead: 20965k

comparing Gerald's testcase PR8361 compilation at -O3 level:
    Overall memory needed: 112697k -> 112681k
    Peak memory use before GGC: 84912k -> 84909k
    Peak memory use after GGC: 84071k -> 84068k
    Maximum of released memory in single GGC run: 16069k -> 16070k
    Garbage: 371367k -> 371379k
    Leak: 47521k -> 47511k
    Overhead: 42270k -> 42270k
    GGC runs: 608
    Pre-IPA-Garbage: 167209k -> 167213k
    Pre-IPA-Leak: 87592k -> 87588k
    Pre-IPA-Overhead: 21020k
    Post-IPA-Garbage: 167209k -> 167213k
    Post-IPA-Leak: 87592k -> 87588k
    Post-IPA-Overhead: 21020k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
  Peak amount of GGC memory allocated before garbage collecting run decreased from 81897k to 78517k, overall -4.30%
  Peak amount of GGC memory still allocated after garbage collecting decreased from 52831k to 49452k, overall -6.83%
  Amount of produced GGC garbage increased from 141349k to 144652k, overall 2.34%
  Amount of memory still referenced at the end of compilation decreased from 10656k to 7109k, overall -49.89%
    Overall memory needed: 371204k -> 368355k
    Peak memory use before GGC: 81897k -> 78517k
    Peak memory use after GGC: 52831k -> 49452k
    Maximum of released memory in single GGC run: 38169k -> 38186k
    Garbage: 141349k -> 144652k
    Leak: 10656k -> 7109k
    Overhead: 24891k -> 24890k
    GGC runs: 86 -> 87
    Pre-IPA-Garbage: 12562k
    Pre-IPA-Leak: 20190k
    Pre-IPA-Overhead: 2242k
    Post-IPA-Garbage: 12562k
    Post-IPA-Leak: 20190k
    Post-IPA-Overhead: 2242k

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
  Peak amount of GGC memory allocated before garbage collecting run decreased from 82594k to 79214k, overall -4.27%
  Peak amount of GGC memory still allocated after garbage collecting decreased from 53528k to 50148k, overall -6.74%
  Amount of produced GGC garbage increased from 141450k to 144753k, overall 2.34%
  Amount of memory still referenced at the end of compilation decreased from 12698k to 9151k, overall -38.76%
    Overall memory needed: 372104k -> 369139k
    Peak memory use before GGC: 82594k -> 79214k
    Peak memory use after GGC: 53528k -> 50148k
    Maximum of released memory in single GGC run: 38154k -> 38171k
    Garbage: 141450k -> 144753k
    Leak: 12698k -> 9151k
    Overhead: 25474k -> 25474k
    GGC runs: 92 -> 93
    Pre-IPA-Garbage: 12570k
    Pre-IPA-Leak: 20439k
    Pre-IPA-Overhead: 2296k
    Post-IPA-Garbage: 12570k
    Post-IPA-Leak: 20439k
    Post-IPA-Overhead: 2296k

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
  Amount of produced GGC garbage increased from 219628k to 224294k, overall 2.12%
  Amount of memory still referenced at the end of compilation decreased from 11158k to 6492k, overall -71.86%
    Overall memory needed: 229996k -> 229072k
    Peak memory use before GGC: 73624k -> 72455k
    Peak memory use after GGC: 66143k -> 64974k
    Maximum of released memory in single GGC run: 34721k -> 34722k
    Garbage: 219628k -> 224294k
    Leak: 11158k -> 6492k
    Overhead: 30799k
    GGC runs: 97
  Amount of produced pre-ipa-GGC garbage increased from 48349k to 49664k, overall 2.72%
    Pre-IPA-Garbage: 48349k -> 49664k
    Pre-IPA-Leak: 63525k -> 62210k
    Pre-IPA-Overhead: 8965k
  Amount of produced post-ipa-GGC garbage increased from 48349k to 49664k, overall 2.72%
    Post-IPA-Garbage: 48349k -> 49664k
    Post-IPA-Leak: 63525k -> 62210k
    Post-IPA-Overhead: 8965k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
  Amount of produced GGC garbage increased from 247883k to 252276k, overall 1.77%
  Amount of memory still referenced at the end of compilation decreased from 10980k to 6586k, overall -66.70%
    Overall memory needed: 362208k -> 360996k
    Peak memory use before GGC: 73624k -> 72456k
    Peak memory use after GGC: 66143k -> 64975k
    Maximum of released memory in single GGC run: 36043k
    Garbage: 247883k -> 252276k
    Leak: 10980k -> 6586k
    Overhead: 36877k -> 36877k
    GGC runs: 106 -> 107
    Pre-IPA-Garbage: 109693k -> 109694k
    Pre-IPA-Leak: 73929k -> 73927k
    Pre-IPA-Overhead: 15408k
    Post-IPA-Garbage: 109693k -> 109694k
    Post-IPA-Leak: 73929k -> 73927k
    Post-IPA-Overhead: 15408k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
    Overall memory needed: 1024248k -> 1024504k
    Peak memory use before GGC: 139561k -> 139559k
    Peak memory use after GGC: 126838k -> 126837k
    Maximum of released memory in single GGC run: 62381k -> 62384k
    Garbage: 365724k -> 365731k
    Leak: 6759k -> 6752k
    Overhead: 45401k
    GGC runs: 105
    Pre-IPA-Garbage: 109693k -> 109694k
    Pre-IPA-Leak: 73929k -> 73927k
    Pre-IPA-Overhead: 15408k
    Post-IPA-Garbage: 109693k -> 109694k
    Post-IPA-Leak: 73929k -> 73927k
    Post-IPA-Overhead: 15408k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2008-09-23 03:39:10.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2008-09-23 20:14:03.000000000 +0000
@@ -1,3 +1,79 @@
+2008-09-23  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* alias.c (find_base_value): Use FIND_BASE_TERM.
+	* doc/tm.texi (FIND_BASE_TERM): Update documentation.
+
+2008-09-23  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* config/i386/i386.c: Include cselib.h.
+	(ix86_pic_register_p): New function.
+	(ix86_delegitimize_address): Use it to check for the PIC register.
+
+2008-09-23  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* doc/tm.texi (FIND_BASE_TERM): Expand documentation.
+	* config/i386/i386.c (ix86_find_base_term): Don't check for
+	SYMBOL_REF and LABEL_REF.
+
+2008-09-23  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* config/i386/i386.c (ix86_delegitimize_address): Wrap the
+	constant PLUS in a CONST.
+
+2008-09-23  Kai Tietz  <kai.tietz@onevision.com>
+
+	*config/i386/i386.c (ix86_function_ok_for_sibcall): Correct
+	check for sibcall support for w64.
+
+2008-09-23  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* c-ppoutput.c (cb_used_define): Do nothing for a builtin node.
+
+2008-09-23  Aldy Hernandez  <aldyh@redhat.com>
+
+	* c-tree.h: Add argument to c_objc_common_truthvalue_conversion,
+	parser_build_binary_op.
+	* c-decl.c (build_enumerator): Pass location to build_binary_op.
+	* c-typeck.c (build_array_ref): Same.
+	(parser_build_unary_op): New location argument.
+	(pointer_diff): Pass location to build_binary_op,
+	c_objc_common_truthvalue_conversion.
+	(build_modify_expr): Same.
+	(build_unary_op): New location argument.
+	(build_binary_op): New location argument.
+	(c_objc_common_truthvalue_conversion): Pass location to
+	c_*common_truthvalue_conversion.
+	* c-convert.c (convert): Same.
+	* c-common.c (binary_op_error): New location argument.
+	(pointer_int_sum): Pass location to build_binary_op.
+	(c_common_truthvalue_conversion): New location argument.
+	(warn_for_sign_compare): Same.
+	* c-common.h: Add location argument to c_common_truthvalue_conversion,
+	binary_op_error, build_binary_op, warn_for_sign_compare.
+	* c-parser.c (c_parser_condition): Pass location to
+	c_*common_truthvalue_conversion.
+	(c_parser_conditional_expression): Save condition's location and pass
+	it on down.
+	(c_parser_binary_expression): Same, but for the binary operator's
+	location.
+	(c_parser_omp_for_loop): Pass location to
+	c_objc_common_truthvalue_conversion.
+
+2008-09-23  Martin Jambor  <mjambor@suse.cz>
+
+	* cgraph.c (cgraph_free_edge): Use sizeof(*e).
+	(cgraph_node_remove_callees): New temporary f.  Hold the next item
+	in f when looping.
+	(cgraph_node_remove_callers): Likewise.
+
+	* ipa-prop.c (ipa_edge_removal_hook): Use ATTRIBUTE_UNUSED.
+	(ipa_node_removal_hook): Likewise.
+
+	* doc/gimple.texi (gimple_copy_call_skip_args): Changed to
+	gimple_call_copy_skip_args and moved to the gimple_call section.
+	* gimple.c (gimple_copy_call_skip_args): Renamed to
+	gimple_call_copy_skip_args.  Changed al users.
+
 2008-09-22  Vladimir Makarov  <vmakarov@redhat.com>
 
 	* ira-color.c (start_allocno_priorities): Rename to
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog.cp	2008-09-18 07:35:17.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/cp/ChangeLog	2008-09-23 20:14:01.000000000 +0000
@@ -1,3 +1,36 @@
+2008-09-23  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/37533
+	* semantics.c (finish_omp_for): If processing_template_decl, just build
+	MODIFY_EXPR for init instead of calling cp_build_modify_expr.
+
+2008-09-23  Aldy Hernandez  <aldyh@redhat.com>
+
+	* typeck.c (build_array_ref): Pass location to cp_build_binary_op.
+	(get_member_function_from_ptrfunc): Same.
+	(build_x_binary_op): Same.
+	(build_binary_op): Same.
+	(cp_build_binary_op): New location argument.
+	(pointer_diff): Pass location to cp_build_binary_op.
+	(cp_truthvalue_conversion): Pass location to build_binary_op.
+	(convert_ptrmem): Pass location to cp_build_binary_op.
+	(cp_build_modify_expr): Same.
+	(build_ptrmemfunc): Same.
+	* init.c (expand_cleanup_for_base): Pass location to
+	c_common_truthvalue_conversion.
+	(build_new_1): Pass location to cp_build_binary_op.
+	(build_vec_delete_1): Pass location to *build_binary_op,
+	c_common_truthvalue_conversion.
+	(build_vec_init): Same.
+	(build_delete): Same.
+	* decl.c (compute_array_index_type): Same.
+	* call.c (build_new_op): Same.
+	* rtti.c (build_dynamic_cast_1): Same.
+	* cp-tree.h: Add argument to cp_build_binary_op.
+	* semantics.c (handle_omp_for_class_iterator): Pass location to
+	*build_binary_op, c_common_truthvalue_conversion.
+	* decl2.c (get_guard_cond): Same.
+
 2008-09-17  Richard Guenther  <rguenther@suse.de>
 
 	PR c++/22374


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.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]