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!


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 -> 218k
    Leak: 1222k
    Overhead: 136k -> 136k
    GGC runs: 4
    Pre-IPA-Garbage: 207k -> 207k
    Pre-IPA-Leak: 1224k -> 1224k
    Pre-IPA-Overhead: 135k -> 135k
    Post-IPA-Garbage: 207k -> 207k
    Post-IPA-Leak: 1224k -> 1224k
    Post-IPA-Overhead: 135k -> 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 -> 220k
    Leak: 1254k
    Overhead: 141k -> 141k
    GGC runs: 4
    Pre-IPA-Garbage: 207k -> 207k
    Pre-IPA-Leak: 1224k -> 1224k
    Pre-IPA-Overhead: 135k -> 135k
    Post-IPA-Garbage: 207k -> 207k
    Post-IPA-Leak: 1224k -> 1224k
    Post-IPA-Overhead: 135k -> 135k

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

comparing empty function compilation at -O2 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 -> 226k
    Leak: 1222k
    Overhead: 138k -> 138k
    GGC runs: 4
    Pre-IPA-Garbage: 207k -> 207k
    Pre-IPA-Leak: 1225k -> 1225k
    Pre-IPA-Overhead: 135k -> 135k
    Post-IPA-Garbage: 207k -> 207k
    Post-IPA-Leak: 1225k -> 1225k
    Post-IPA-Overhead: 135k -> 135k

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

comparing combine.c compilation at -O0 level:
    Overall memory needed: 32044k
    Peak memory use before GGC: 18032k
    Peak memory use after GGC: 17774k
    Maximum of released memory in single GGC run: 1866k
    Garbage: 39944k -> 39943k
    Leak: 5639k
    Overhead: 5267k -> 5266k
    GGC runs: 339
    Pre-IPA-Garbage: 12582k -> 12581k
    Pre-IPA-Leak: 19385k -> 19385k
    Pre-IPA-Overhead: 2624k -> 2623k
    Post-IPA-Garbage: 12582k -> 12581k
    Post-IPA-Leak: 19385k -> 19385k
    Post-IPA-Overhead: 2624k -> 2623k

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 34056k
    Peak memory use before GGC: 19957k
    Peak memory use after GGC: 19629k
    Maximum of released memory in single GGC run: 1875k
    Garbage: 40247k -> 40245k
    Leak: 8928k
    Overhead: 6084k -> 6083k
    GGC runs: 322
    Pre-IPA-Garbage: 12681k -> 12680k
    Pre-IPA-Leak: 21658k -> 21658k
    Pre-IPA-Overhead: 3114k -> 3113k
    Post-IPA-Garbage: 12681k -> 12680k
    Post-IPA-Leak: 21658k -> 21658k
    Post-IPA-Overhead: 3114k -> 3113k

comparing combine.c compilation at -O1 level:
    Overall memory needed: 31020k
    Peak memory use before GGC: 15689k
    Peak memory use after GGC: 15518k
    Maximum of released memory in single GGC run: 1366k
    Garbage: 47216k -> 47222k
    Leak: 5624k
    Overhead: 6045k -> 6102k
    GGC runs: 404
    Pre-IPA-Garbage: 13457k -> 13457k
    Pre-IPA-Leak: 16877k -> 16876k
    Pre-IPA-Overhead: 2530k -> 2532k
    Post-IPA-Garbage: 13457k -> 13457k
    Post-IPA-Leak: 16877k -> 16876k
    Post-IPA-Overhead: 2530k -> 2532k

comparing combine.c compilation at -O2 level:
    Overall memory needed: 31880k -> 31868k
    Peak memory use before GGC: 15780k
    Peak memory use after GGC: 15621k
    Maximum of released memory in single GGC run: 1326k
    Garbage: 61217k -> 61239k
    Leak: 5800k
    Overhead: 7951k -> 8186k
    GGC runs: 473 -> 474
    Pre-IPA-Garbage: 13632k -> 13631k
    Pre-IPA-Leak: 16953k -> 16952k
    Pre-IPA-Overhead: 2551k -> 2554k
    Post-IPA-Garbage: 13632k -> 13631k
    Post-IPA-Leak: 16953k -> 16952k
    Post-IPA-Overhead: 2551k -> 2554k

comparing combine.c compilation at -O3 level:
  Amount of produced GGC garbage increased from 76604k to 76737k, overall 0.17%
    Overall memory needed: 36832k -> 36664k
    Peak memory use before GGC: 15924k
    Peak memory use after GGC: 15720k
    Maximum of released memory in single GGC run: 1820k -> 1818k
    Garbage: 76604k -> 76737k
    Leak: 5674k -> 5676k
    Overhead: 9633k -> 10029k
    GGC runs: 508
    Pre-IPA-Garbage: 13633k -> 13632k
    Pre-IPA-Leak: 16964k -> 16963k
    Pre-IPA-Overhead: 2552k -> 2555k
    Post-IPA-Garbage: 13633k -> 13632k
    Post-IPA-Leak: 16964k -> 16963k
    Post-IPA-Overhead: 2552k -> 2555k

comparing insn-attrtab.c compilation at -O0 level:
    Overall memory needed: 158232k
    Peak memory use before GGC: 65873k
    Peak memory use after GGC: 53242k
    Maximum of released memory in single GGC run: 28569k
    Garbage: 134336k -> 134335k
    Leak: 7489k
    Overhead: 16158k -> 16157k
    GGC runs: 265
    Pre-IPA-Garbage: 39229k -> 39228k
    Pre-IPA-Leak: 55908k -> 55907k
    Pre-IPA-Overhead: 8653k -> 8653k
    Post-IPA-Garbage: 39229k -> 39228k
    Post-IPA-Leak: 55908k -> 55907k
    Post-IPA-Overhead: 8653k -> 8653k

comparing insn-attrtab.c compilation at -O0 -g level:
    Overall memory needed: 159532k
    Peak memory use before GGC: 67147k
    Peak memory use after GGC: 54514k
    Maximum of released memory in single GGC run: 28569k
    Garbage: 134815k -> 134814k
    Leak: 9140k
    Overhead: 16613k -> 16613k
    GGC runs: 258
    Pre-IPA-Garbage: 39285k -> 39285k
    Pre-IPA-Leak: 57449k -> 57449k
    Pre-IPA-Overhead: 8989k -> 8988k
    Post-IPA-Garbage: 39285k -> 39285k
    Post-IPA-Leak: 57449k -> 57449k
    Post-IPA-Overhead: 8989k -> 8988k

comparing insn-attrtab.c compilation at -O1 level:
    Overall memory needed: 134892k -> 134888k
    Peak memory use before GGC: 50247k
    Peak memory use after GGC: 43080k
    Maximum of released memory in single GGC run: 23393k
    Garbage: 184506k -> 184506k
    Leak: 6871k
    Overhead: 25327k -> 25327k
    GGC runs: 305
    Pre-IPA-Garbage: 45206k -> 45205k
    Pre-IPA-Leak: 43436k -> 43436k
    Pre-IPA-Overhead: 8052k -> 8052k
    Post-IPA-Garbage: 45206k -> 45205k
    Post-IPA-Leak: 43436k -> 43436k
    Post-IPA-Overhead: 8052k -> 8052k

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 150264k -> 150260k
    Peak memory use before GGC: 50279k
    Peak memory use after GGC: 43994k
    Maximum of released memory in single GGC run: 22010k
    Garbage: 216414k -> 216414k
    Leak: 6879k
    Overhead: 30822k -> 31033k
    GGC runs: 340
    Pre-IPA-Garbage: 45283k -> 45283k
    Pre-IPA-Leak: 43442k -> 43441k
    Pre-IPA-Overhead: 8061k -> 8061k
    Post-IPA-Garbage: 45283k -> 45283k
    Post-IPA-Leak: 43442k -> 43441k
    Post-IPA-Overhead: 8061k -> 8061k

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 163980k -> 163956k
    Peak memory use before GGC: 61578k
    Peak memory use after GGC: 58454k
    Maximum of released memory in single GGC run: 24307k -> 24308k
    Garbage: 246737k -> 246737k
    Leak: 6886k
    Overhead: 34267k -> 34484k
    GGC runs: 343
    Pre-IPA-Garbage: 45283k -> 45283k
    Pre-IPA-Leak: 43442k -> 43441k
    Pre-IPA-Overhead: 8061k -> 8061k
    Post-IPA-Garbage: 45283k -> 45283k
    Post-IPA-Leak: 43442k -> 43441k
    Post-IPA-Overhead: 8061k -> 8061k

comparing Gerald's testcase PR8361 compilation at -O0 level:
    Overall memory needed: 150422k -> 150439k
    Peak memory use before GGC: 82283k
    Peak memory use after GGC: 81468k
    Maximum of released memory in single GGC run: 16450k
    Garbage: 212659k -> 212604k
    Leak: 49808k -> 49791k
    Overhead: 27261k -> 27190k
    GGC runs: 424
    Pre-IPA-Garbage: 114097k -> 114063k
    Pre-IPA-Leak: 87309k -> 87272k
    Pre-IPA-Overhead: 14978k -> 14907k
    Post-IPA-Garbage: 114097k -> 114063k
    Post-IPA-Leak: 87309k -> 87272k
    Post-IPA-Overhead: 14978k -> 14907k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
    Overall memory needed: 167982k -> 167979k
    Peak memory use before GGC: 95772k
    Peak memory use after GGC: 94820k
    Maximum of released memory in single GGC run: 16877k
    Garbage: 218309k -> 218255k
    Leak: 76370k -> 76354k
    Overhead: 33925k -> 33854k
    GGC runs: 394
    Pre-IPA-Garbage: 114719k -> 114685k
    Pre-IPA-Leak: 103824k -> 103786k
    Pre-IPA-Overhead: 18481k -> 18410k
    Post-IPA-Garbage: 114719k -> 114685k
    Post-IPA-Leak: 103824k -> 103786k
    Post-IPA-Overhead: 18481k -> 18410k

comparing Gerald's testcase PR8361 compilation at -O1 level:
    Overall memory needed: 112082k -> 112087k
    Peak memory use before GGC: 82325k -> 82327k
    Peak memory use after GGC: 81502k
    Maximum of released memory in single GGC run: 16685k
    Garbage: 291497k -> 291481k
    Leak: 46593k -> 46577k
    Overhead: 32300k -> 32524k
    GGC runs: 515 -> 516
    Pre-IPA-Garbage: 167344k -> 167293k
    Pre-IPA-Leak: 86076k -> 86056k
    Pre-IPA-Overhead: 20471k -> 20417k
    Post-IPA-Garbage: 167344k -> 167293k
    Post-IPA-Leak: 86076k -> 86056k
    Post-IPA-Overhead: 20471k -> 20417k

comparing Gerald's testcase PR8361 compilation at -O2 level:
    Overall memory needed: 115374k -> 115379k
    Peak memory use before GGC: 83778k
    Peak memory use after GGC: 82799k
    Maximum of released memory in single GGC run: 16656k
    Garbage: 345533k -> 345554k
    Leak: 46539k -> 46522k
    Overhead: 38274k -> 39172k
    GGC runs: 580
    Pre-IPA-Garbage: 171551k -> 171501k
    Pre-IPA-Leak: 86381k -> 86360k
    Pre-IPA-Overhead: 20956k -> 20913k
    Post-IPA-Garbage: 171551k -> 171501k
    Post-IPA-Leak: 86381k -> 86360k
    Post-IPA-Overhead: 20956k -> 20913k

comparing Gerald's testcase PR8361 compilation at -O3 level:
    Overall memory needed: 122734k -> 122747k
    Peak memory use before GGC: 84478k
    Peak memory use after GGC: 83419k
    Maximum of released memory in single GGC run: 16656k
    Garbage: 376951k -> 376979k
    Leak: 46523k -> 46507k
    Overhead: 41481k -> 42468k
    GGC runs: 615
    Pre-IPA-Garbage: 171637k -> 171586k
    Pre-IPA-Leak: 87063k -> 87043k
    Pre-IPA-Overhead: 21011k -> 20967k
    Post-IPA-Garbage: 171637k -> 171586k
    Post-IPA-Leak: 87063k -> 87043k
    Post-IPA-Overhead: 21011k -> 20967k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
    Overall memory needed: 368861k -> 368859k
    Peak memory use before GGC: 78451k
    Peak memory use after GGC: 49385k
    Maximum of released memory in single GGC run: 38763k
    Garbage: 147530k -> 147530k
    Leak: 6511k
    Overhead: 24890k -> 24890k
    GGC runs: 87
    Pre-IPA-Garbage: 13630k -> 13630k
    Pre-IPA-Leak: 20190k -> 20190k
    Pre-IPA-Overhead: 2242k -> 2241k
    Post-IPA-Garbage: 13630k -> 13630k
    Post-IPA-Leak: 20190k -> 20190k
    Post-IPA-Overhead: 2242k -> 2241k

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
    Overall memory needed: 369637k -> 369635k
    Peak memory use before GGC: 79148k
    Peak memory use after GGC: 50082k
    Maximum of released memory in single GGC run: 38748k
    Garbage: 147632k -> 147631k
    Leak: 8553k
    Overhead: 25474k -> 25474k
    GGC runs: 93
    Pre-IPA-Garbage: 13638k -> 13637k
    Pre-IPA-Leak: 20439k -> 20439k
    Pre-IPA-Overhead: 2296k -> 2296k
    Post-IPA-Garbage: 13638k -> 13637k
    Post-IPA-Leak: 20439k -> 20439k
    Post-IPA-Overhead: 2296k -> 2296k

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
    Overall memory needed: 227772k -> 227600k
    Peak memory use before GGC: 71433k
    Peak memory use after GGC: 63951k
    Maximum of released memory in single GGC run: 35392k
    Garbage: 227182k -> 227182k
    Leak: 7088k
    Overhead: 30868k -> 30868k
    GGC runs: 98
    Pre-IPA-Garbage: 52164k -> 52164k
    Pre-IPA-Leak: 62151k -> 62150k
    Pre-IPA-Overhead: 9038k -> 9038k
    Post-IPA-Garbage: 52164k -> 52164k
    Post-IPA-Leak: 62151k -> 62150k
    Post-IPA-Overhead: 9038k -> 9038k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
    Overall memory needed: 375840k -> 376668k
    Peak memory use before GGC: 71433k
    Peak memory use after GGC: 63952k
    Maximum of released memory in single GGC run: 36706k
    Garbage: 255525k -> 255525k
    Leak: 6910k
    Overhead: 36963k -> 36964k
    GGC runs: 109
    Pre-IPA-Garbage: 112377k -> 112377k
    Pre-IPA-Leak: 73071k -> 73071k
    Pre-IPA-Overhead: 15517k -> 15517k
    Post-IPA-Garbage: 112377k -> 112377k
    Post-IPA-Leak: 73071k -> 73071k
    Post-IPA-Overhead: 15517k -> 15517k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
    Overall memory needed: 1025124k -> 1024168k
    Peak memory use before GGC: 138535k
    Peak memory use after GGC: 125812k
    Maximum of released memory in single GGC run: 62503k
    Garbage: 366892k -> 366892k
    Leak: 9422k
    Overhead: 45306k -> 45579k
    GGC runs: 106
    Pre-IPA-Garbage: 112377k -> 112377k
    Pre-IPA-Leak: 73071k -> 73071k
    Pre-IPA-Overhead: 15517k -> 15517k
    Post-IPA-Garbage: 112377k -> 112377k
    Post-IPA-Leak: 73071k -> 73071k
    Post-IPA-Overhead: 15517k -> 15517k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2008-09-09 02:54:09.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2008-09-09 19:17:05.000000000 +0000
@@ -1,3 +1,153 @@
+2008-09-09  Sebastian Pop  <sebastian.pop@amd.com>
+
+	PR tree-optimization/37375
+	* tree-scalar-evolution.c (scev_info_str): Add field instantiated_below.
+	(new_scev_info_str, eq_scev_info, find_var_scev_info,
+	set_scalar_evolution, get_scalar_evolution, get_instantiated_value,
+	set_instantiated_value): Pass instantiated_below.
+	(analyze_scalar_evolution_1, analyze_scalar_evolution): Update calls to
+	above functions.
+	(instantiate_scev_1, instantiate_scev): Pass a basic block above which the
+	definitions are not instantiated.
+
+	* tree-scalar-evolution.h (instantiate_scev): Update declaration.
+	(block_before_loop): New.
+	* tree-data-ref.c (dr_analyze_indices): Update uses of instantiate_scev.
+	* graphite.c (block_before_scop): New.
+	(loop_affine_expr, stmt_simple_for_scop_p, harmful_stmt_in_bb): Pass a 
+	basic block, not a loop for determining the parameters.
+	(scopdet_edge_info, build_scops_1): Do not pass outermost loop in the
+	scop.
+	(idx_record_params, find_params_in_bb, find_scop_parameters,
+	build_loop_iteration_domains, add_conditions_to_domain): Update calls 
+	to instantiate_scev.
+
+	* Makefile.in (cfgloopmanip.o): Add missing dependency on TREE_FLOW_H.
+
+2008-09-09  Vladimir Makarov  <vmakarov@redhat.com>
+
+	PR rtl-opt/37333
+	
+	* ira-build.c (ira_create_allocno): Setup frequency to 0.
+
+	* ira-color.c (update_conflict_hard_regno_costs): Remove assert.
+	Check zero freq and increase if necessary.
+
+2008-09-09  Vladimir Makarov  <vmakarov@redhat.com>
+
+	* ira-conflicts.c (process_regs_for_copy): Check that the hard
+	regno is in the right range.  Add comments.
+
+2008-09-09  Rainer Orth  <ro@TechFak.Uni-Bielefeld.DE>
+
+	* Makefile.in (mips-tfile.o-warn): Don't error out on mips-tfile.c
+	warnings.
+	* mips-tfile.c (copy_object): Cast alloca result to int *.
+	* mips-tdump.c (print_symbol): Cast xmalloc return values to
+	proper types.
+	Rename class to sclass.
+	(read_tfile): Cast read_seek return values to proper types.
+	Cast xcalloc return value to proper type.
+
+2008-09-09  Rainer Orth  <ro@TechFak.Uni-Bielefeld.DE>
+
+	* config/sol2.h (REGISTER_TARGET_PRAGMAS): Move ...
+	* config/i386/sol2.h (REGISTER_SUBTARGET_PRAGMAS): ... here.
+	* config/sparc/sol2.h (REGISTER_TARGET_PRAGMAS): ... and here.
+
+2008-09-09  Jan Hubicka  <jh@suse.cz>
+
+	* profile.c (is_edge_inconsistent): Add debug output; ignore negative count
+	on fake edges.
+	(is_inconsistent): Add debug output.
+
+2008-09-09  Andrey Belevantsev  <abel@ispras.ru>
+
+	* haifa-sched.c (advance_one_cycle): Do not print '\n' before printing
+	dump message.
+	(choose_ready): When first insn is chosen from the ready list, also
+	dump it.
+
+2008-09-09  Andrey Belevantsev  <abel@ispras.ru>
+
+        PR rtl-optimization/37360
+	* haifa-sched.c (max_issue): Do not assert that we never issue more
+	insns than issue_rate.  Add comment.
+	
+2008-09-09  Richard Guenther  <rguenther@suse.de>
+
+	* tree-cfg.c (verify_types_in_gimple_op): Remove.
+	(verify_types_in_gimple_call): Rename to ...
+	(verify_gimple_call): ... this.  Enhance.
+	(verify_types_in_gimple_cond): Remove.
+	(verify_gimple_comparison): New function ...
+	(verify_types_in_gimple_assign): ... split out from here.
+	(verify_types_in_gimple_return): Rename to ...
+	(verify_gimple_return): ... this.  Enhance.
+	(verify_types_in_gimple_switch): Rename to ...
+	(verify_gimple_switch): ... this.  Enhance.
+	(verify_gimple_goto): New function.
+	(verify_types_in_gimple_phi): Rename to ...
+	(verify_gimple_phi): ... this.  Enhance.
+	(verify_types_in_gimple_stmt): Adjust calls to helper functions.
+	Fold in single-statement cases from verify_types_in_gimple_seq_2.
+	(verify_types_in_gimple_seq_2): Remove cases handled in
+	verify_types_in_gimple_stmt.
+
+2008-09-09  Bernd Schmidt  <bernd.schmidt@analog.com>
+
+	* config/bfin/bfin.c (n_regs_to_save): New static variable.
+	(push_multiple_operation, pop_multiple_operation): Set it.
+	(workaround_rts_anomaly): New function.
+	(workaround_speculation): New function, broken out of bfin_reorg.
+	(bfin_reorg): Call the new functions.
+
+2008-09-09  Richard Guenther  <rguenther@suse.de>
+
+	PR middle-end/37354
+	PR middle-end/30165
+	* gimplify.c (gimplify_conversion): Change conversions of
+	non-register type to VIEW_CONVERT_EXPRs.
+	(gimplify_addr_expr): If we need to make the operand
+	addressable make sure to use a properly initialized
+	temporary for that so it gets a valid gimple store.
+
+2008-09-09  Aldy Hernandez  <aldyh@redhat.com>
+
+	* function.h (struct function): Add function_start_locus.
+	* cfgexpand.c (gimple_expand_cfg): Use it.
+	* c-parser.c (c_parser_declaration_or_fndef): Set it.
+
+2008-09-09  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/37433
+	* tree-ssa-ccp.c (ccp_fold): Properly guard folding of
+	function calls.
+
+2008-09-09  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/37387
+	* tree-ssa-ifcombine.c (ifcombine_iforif): Convert the name
+	and bits to a common type.
+
+2008-09-09  Nick Clifton  <nickc@redhat.com>
+
+	* config/v850/v850.md (return): Restore frame size restriction.
+
+2008-09-09  Paolo Bonzini  <bonzini@gnu.org>
+
+	* c-common.c (c_expand_decl): Remove.
+	* c-common.h (anon_aggr_type_p): Remove prototype.
+	(DECL_ANON_UNION_ELEMS): Remove.
+	* c-objc-common.h (LANG_HOOKS_EXPAND_DECL): Remove.
+	* c-decl.c (anon_aggr_type_p): Remove.
+	* langhooks-def.h (LANG_HOOKS_EXPAND_DECL): Remove.
+	(LANG_HOOKS_INITIALIZER): Remove LANG_HOOKS_EXPAND_DECL.
+	* langhooks.h (struct lang_hooks): Remove expand_decl.
+	* langhooks.c (lhd_expand_decl): Remove.
+	* stmt.c (expand_anon_union_decl): Remove.
+	* tree.h (expand_anon_union_decl): Remove prototype.
+
 2008-08-09  Andy Hutchinson  <hutchinsonandy@aim.com>
 
 	PR target/36609
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog.cp	2008-09-09 02:54:09.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/cp/ChangeLog	2008-09-09 19:17:03.000000000 +0000
@@ -1,3 +1,9 @@
+2008-09-09  Paolo Bonzini  <bonzini@gnu.org>
+
+	* cp-objcp-common.h (LANG_HOOKS_EXPAND_DECL): Remove.
+	* cp-tree.h: Don't mention DECL_ANON_UNION_ELEMS.
+	* semantics.c (anon_aggr_type_p): Remove.
+
 2008-09-06  Jason Merrill  <jason@redhat.com>
 
 	PR c++/37302


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]