A recent patch increased GCC's memory consumption!

[gcctest at suse dot de]

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:
  Peak amount of GGC memory allocated before garbage collecting increased from 3386k to 3393k, overall 0.21%
  Peak amount of GGC memory still allocated after garbage collecting increased from 3033k to 3040k, overall 0.23%
  Amount of memory still referenced at the end of compilation increased from 3786k to 3794k, overall 0.22%
    Overall memory needed: 8332k -> 8333k
    Peak memory use before GGC: 3386k -> 3393k
    Peak memory use after GGC: 3033k -> 3040k
    Maximum of released memory in single GGC run: 353k
    Garbage: 525k
    Leak: 3786k -> 3794k
    Overhead: 913k -> 914k
    GGC runs: 3

comparing empty function compilation at -O0 -g level:
  Peak amount of GGC memory allocated before garbage collecting increased from 3413k to 3420k, overall 0.21%
  Peak amount of GGC memory still allocated after garbage collecting increased from 3061k to 3068k, overall 0.23%
  Amount of memory still referenced at the end of compilation increased from 3819k to 3827k, overall 0.21%
    Overall memory needed: 8348k -> 8349k
    Peak memory use before GGC: 3413k -> 3420k
    Peak memory use after GGC: 3061k -> 3068k
    Maximum of released memory in single GGC run: 352k
    Garbage: 527k
    Leak: 3819k -> 3827k
    Overhead: 917k -> 918k
    GGC runs: 3

comparing empty function compilation at -O1 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 3386k to 3393k, overall 0.21%
  Peak amount of GGC memory still allocated after garbage collecting increased from 3033k to 3040k, overall 0.23%
  Amount of memory still referenced at the end of compilation increased from 3789k to 3797k, overall 0.22%
    Overall memory needed: 8388k -> 8389k
    Peak memory use before GGC: 3386k -> 3393k
    Peak memory use after GGC: 3033k -> 3040k
    Maximum of released memory in single GGC run: 353k
    Garbage: 530k
    Leak: 3789k -> 3797k
    Overhead: 913k -> 914k
    GGC runs: 3

comparing empty function compilation at -O2 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 3386k to 3393k, overall 0.21%
  Peak amount of GGC memory still allocated after garbage collecting increased from 3034k to 3041k, overall 0.23%
  Amount of memory still referenced at the end of compilation increased from 3790k to 3798k, overall 0.22%
    Overall memory needed: 8404k -> 8405k
    Peak memory use before GGC: 3386k -> 3393k
    Peak memory use after GGC: 3034k -> 3041k
    Maximum of released memory in single GGC run: 352k
    Garbage: 533k
    Leak: 3790k -> 3798k
    Overhead: 914k -> 915k
    GGC runs: 3

comparing empty function compilation at -O3 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 3386k to 3393k, overall 0.21%
  Peak amount of GGC memory still allocated after garbage collecting increased from 3034k to 3041k, overall 0.23%
  Amount of memory still referenced at the end of compilation increased from 3790k to 3798k, overall 0.22%
    Overall memory needed: 8404k -> 8405k
    Peak memory use before GGC: 3386k -> 3393k
    Peak memory use after GGC: 3034k -> 3041k
    Maximum of released memory in single GGC run: 352k
    Garbage: 533k
    Leak: 3790k -> 3798k
    Overhead: 914k -> 915k
    GGC runs: 3

comparing combine.c compilation at -O0 level:
    Overall memory needed: 23760k -> 23769k
    Peak memory use before GGC: 10325k -> 10330k
    Peak memory use after GGC: 9556k -> 9564k
    Maximum of released memory in single GGC run: 1905k
    Garbage: 39063k -> 39056k
    Leak: 8844k -> 8852k
    Overhead: 5685k -> 5686k
    GGC runs: 254

comparing combine.c compilation at -O0 -g level:
    Overall memory needed: 25640k -> 25645k
    Peak memory use before GGC: 11988k -> 11996k
    Peak memory use after GGC: 11348k -> 11356k
    Maximum of released memory in single GGC run: 1516k -> 1515k
    Garbage: 39412k -> 39404k
    Leak: 11737k -> 11746k
    Overhead: 6391k -> 6392k
    GGC runs: 250

comparing combine.c compilation at -O1 level:
    Overall memory needed: 36308k -> 36317k
    Peak memory use before GGC: 18978k -> 18985k
    Peak memory use after GGC: 18787k -> 18794k
    Maximum of released memory in single GGC run: 1370k
    Garbage: 53264k -> 53258k
    Leak: 8899k -> 8907k
    Overhead: 6747k -> 6747k
    GGC runs: 326

comparing combine.c compilation at -O2 level:
  Amount of memory still referenced at the end of compilation increased from 9020k to 9036k, overall 0.18%
    Overall memory needed: 38548k -> 38561k
    Peak memory use before GGC: 19032k -> 19039k
    Peak memory use after GGC: 18843k -> 18850k
    Maximum of released memory in single GGC run: 1404k
    Garbage: 71793k -> 71803k
    Leak: 9020k -> 9036k
    Overhead: 8880k -> 8881k
    GGC runs: 388 -> 387

comparing combine.c compilation at -O3 level:
  Amount of memory still referenced at the end of compilation increased from 9133k to 9146k, overall 0.13%
    Overall memory needed: 41364k -> 41373k
    Peak memory use before GGC: 19276k -> 19283k
    Peak memory use after GGC: 18967k -> 18975k
    Maximum of released memory in single GGC run: 2103k -> 2104k
    Garbage: 93374k -> 93375k
    Leak: 9133k -> 9146k
    Overhead: 11542k -> 11543k
    GGC runs: 417

comparing insn-attrtab.c compilation at -O0 level:
  Amount of memory still referenced at the end of compilation increased from 11334k to 11358k, overall 0.21%
    Overall memory needed: 140352k -> 140365k
    Peak memory use before GGC: 60814k -> 60821k
    Peak memory use after GGC: 34064k -> 34071k
    Maximum of released memory in single GGC run: 34384k
    Garbage: 132285k -> 132274k
    Leak: 11334k -> 11358k
    Overhead: 14975k -> 14976k
    GGC runs: 198 -> 197

comparing insn-attrtab.c compilation at -O0 -g level:
    Overall memory needed: 141592k -> 141605k
    Peak memory use before GGC: 61976k -> 61983k
    Peak memory use after GGC: 35225k -> 35232k
    Maximum of released memory in single GGC run: 34385k
    Garbage: 132506k -> 132509k
    Leak: 13043k -> 13051k
    Overhead: 15372k -> 15373k
    GGC runs: 201 -> 199

comparing insn-attrtab.c compilation at -O1 level:
    Overall memory needed: 151600k -> 151601k
    Peak memory use before GGC: 59311k -> 59319k
    Peak memory use after GGC: 55086k -> 55094k
    Maximum of released memory in single GGC run: 23586k
    Garbage: 217482k -> 217482k
    Leak: 11462k -> 11470k
    Overhead: 25167k -> 25168k
    GGC runs: 229 -> 228

comparing insn-attrtab.c compilation at -O2 level:
    Overall memory needed: 190816k -> 190993k
    Peak memory use before GGC: 59194k -> 59202k
    Peak memory use after GGC: 55147k -> 55155k
    Maximum of released memory in single GGC run: 21338k
    Garbage: 252774k -> 252772k
    Leak: 11457k -> 11465k
    Overhead: 30577k -> 30578k
    GGC runs: 254 -> 253

comparing insn-attrtab.c compilation at -O3 level:
    Overall memory needed: 196528k -> 196513k
    Peak memory use before GGC: 71750k -> 71757k
    Peak memory use after GGC: 65981k -> 65988k
    Maximum of released memory in single GGC run: 22952k -> 22951k
    Garbage: 282144k -> 282143k
    Leak: 11465k -> 11473k
    Overhead: 32375k -> 32376k
    GGC runs: 257 -> 256

comparing Gerald's testcase PR8361 compilation at -O0 level:
    Overall memory needed: 156568k -> 156628k
    Peak memory use before GGC: 91659k -> 91667k
    Peak memory use after GGC: 90740k -> 90747k
    Maximum of released memory in single GGC run: 18002k
    Garbage: 210854k -> 210851k
    Leak: 55672k -> 55680k
    Overhead: 26877k -> 26877k
    GGC runs: 397 -> 395

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
    Overall memory needed: 177312k -> 177680k
    Peak memory use before GGC: 104549k -> 104556k
    Peak memory use after GGC: 103513k -> 103520k
    Maximum of released memory in single GGC run: 18639k -> 18638k
    Garbage: 216705k -> 216710k
    Leak: 79101k -> 79109k
    Overhead: 32845k -> 32846k
    GGC runs: 373

comparing Gerald's testcase PR8361 compilation at -O1 level:
    Overall memory needed: 139139k -> 139146k
    Peak memory use before GGC: 93652k -> 93659k
    Peak memory use after GGC: 92725k -> 92731k
    Maximum of released memory in single GGC run: 17407k
    Garbage: 319589k -> 319598k
    Leak: 55592k -> 55592k
    Overhead: 32823k -> 32823k
    GGC runs: 502

comparing Gerald's testcase PR8361 compilation at -O2 level:
    Overall memory needed: 148603k -> 148630k
    Peak memory use before GGC: 94136k -> 94143k
    Peak memory use after GGC: 93204k -> 93210k
    Maximum of released memory in single GGC run: 17407k -> 17406k
    Garbage: 376015k -> 375987k
    Leak: 56348k -> 56356k
    Overhead: 39009k -> 39011k
    GGC runs: 563 -> 560

comparing Gerald's testcase PR8361 compilation at -O3 level:
    Overall memory needed: 152211k -> 152226k
    Peak memory use before GGC: 95170k -> 95177k
    Peak memory use after GGC: 94095k -> 94102k
    Maximum of released memory in single GGC run: 17828k
    Garbage: 417609k -> 417575k
    Leak: 56666k -> 56674k
    Overhead: 42530k -> 42531k
    GGC runs: 589 -> 588

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
    Overall memory needed: 381001k -> 381010k
    Peak memory use before GGC: 103467k -> 103474k
    Peak memory use after GGC: 59120k -> 59127k
    Maximum of released memory in single GGC run: 50583k
    Garbage: 179674k
    Leak: 8998k -> 9006k
    Overhead: 31652k -> 31653k
    GGC runs: 65

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
    Overall memory needed: 381813k -> 381826k
    Peak memory use before GGC: 104113k -> 104120k
    Peak memory use after GGC: 59766k -> 59774k
    Maximum of released memory in single GGC run: 50583k -> 50582k
    Garbage: 179778k
    Leak: 10766k -> 10775k
    Overhead: 32147k -> 32148k
    GGC runs: 72

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
    Overall memory needed: 294508k -> 294513k
    Peak memory use before GGC: 82809k -> 82816k
    Peak memory use after GGC: 75162k -> 75169k
    Maximum of released memory in single GGC run: 40023k
    Garbage: 236132k
    Leak: 18368k -> 18376k
    Overhead: 32733k -> 32734k
    GGC runs: 72

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
    Overall memory needed: 299908k -> 299825k
    Peak memory use before GGC: 80149k -> 80156k
    Peak memory use after GGC: 75163k -> 75170k
    Maximum of released memory in single GGC run: 33756k -> 33751k
    Garbage: 246185k -> 246181k
    Leak: 18450k -> 18458k
    Overhead: 34956k -> 34956k
    GGC runs: 85

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
    Overall memory needed: 1013244k -> 1012933k
    Peak memory use before GGC: 168790k -> 168797k
    Peak memory use after GGC: 158354k -> 158361k
    Maximum of released memory in single GGC run: 83549k
    Garbage: 356541k -> 356541k
    Leak: 28532k -> 28540k
    Overhead: 46917k -> 46918k
    GGC runs: 69

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2007-08-08 18:26:23.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2007-08-09 10:26:50.000000000 +0000
@@ -1,3 +1,232 @@
+2007-08-08  Chao-ying Fu  <fu@mips.com>
+
+	* tree.def (FIXED_POINT_TYPE): New type.
+	(FIXED_CST): New constant.
+	(FIXED_CONVERT_EXPR): New expr.
+	* doc/c-tree.texi (Types): Document FIXED_POINT_TYPE.
+	(Expressions): Document FIXED_CST and FIXED_CONVERT_EXPR.
+	* tree.h (struct tree_base): Add saturating_flag.
+	Remove one bit of spare for saturating_flag.
+	(NUMERICAL_TYPE_CHECK): Support FIXED_POINT_TYPE.
+	(NON_SAT_FIXED_POINT_TYPE_P, SAT_FIXED_POINT_TYPE_P,
+	FIXED_POINT_TYPE_P): Define.
+	(TYPE_SATURATING): Define.
+	(TREE_FIXED_CST_PTR, TREE_FIXED_CST): Define.
+	(struct tree_fixed_cst): New.
+	(TYPE_IBIT, TYPE_FBIT): Define.
+	(tree_node): Add fixed_cst.
+	(enum tree_index): Add new enumeration values of
+	TI_SAT_SFRACT_TYPE, TI_SAT_FRACT_TYPE, TI_SAT_LFRACT_TYPE,
+	TI_SAT_LLFRACT_TYPE, TI_SAT_USFRACT_TYPE, TI_SAT_UFRACT_TYPE,
+	TI_SAT_ULFRACT_TYPE, TI_SAT_ULLFRACT_TYPE, TI_SFRACT_TYPE,
+	TI_FRACT_TYPE, TI_LFRACT_TYPE, TI_LLFRACT_TYPE, TI_USFRACT_TYPE,
+	TI_UFRACT_TYPE, TI_ULFRACT_TYPE, TI_ULLFRACT_TYPE,
+	TI_SAT_SACCUM_TYPE, TI_SAT_ACCUM_TYPE, TI_SAT_LACCUM_TYPE,
+	TI_SAT_LLACCUM_TYPE, TI_SAT_USACCUM_TYPE, TI_SAT_UACCUM_TYPE,
+	TI_SAT_ULACCUM_TYPE, TI_SAT_ULLACCUM_TYPE, TI_SACCUM_TYPE,
+	TI_ACCUM_TYPE, TI_LACCUM_TYPE, TI_LLACCUM_TYPE, TI_USACCUM_TYPE,
+	TI_UACCUM_TYPE, TI_ULACCUM_TYPE, TI_ULLACCUM_TYPE,
+	TI_QQ_TYPE, TI_HQ_TYPE,_TYPE, TI_SQ_TYPE, TI_DQ_TYPE, TI_TQ_TYPE,
+	TI_UQQ_TYPE, TI_UHQ_TYPE, TI_USQ_TYPE, TI_UDQ_TYPE, TI_UTQ_TYPE,
+	TI_SAT_QQ_TYPE, TI_SAT_HQ_TYPE, TI_SAT_SQ_TYPE, TI_SAT_DQ_TYPE,
+	TI_SAT_TQ_TYPE, TI_SAT_UQQ_TYPE, TI_SAT_UHQ_TYPE, TI_SAT_USQ_TYPE,
+	TI_SAT_UDQ_TYPE, TI_SAT_UTQ_TYPE, TI_HA_TYPE, TI_SA_TYPE, TI_DA_TYPE,
+	TI_TA_TYPE, TI_UHA_TYPE, TI_USA_TYPE, TI_UDA_TYPE, TI_UTA_TYPE,
+	TI_SAT_HA_TYPE, TI_SAT_SA_TYPE, TI_SAT_DA_TYPE, TI_SAT_TA_TYPE,
+	TI_SAT_UHA_TYPE, TI_SAT_USA_TYPE, TI_SAT_UDA_TYPE, TI_SAT_UTA_TYPE.
+	(sat_short_fract_type_node, sat_fract_type_node,
+	sat_long_fract_type_node, sat_long_long_fract_type_node,
+	sat_unsigned_short_fract_type_node, sat_unsigned_fract_type_node,
+	sat_unsigned_long_fract_type_node,
+	sat_unsigned_long_long_fract_type_node, short_fract_type_node,
+	fract_type_node, long_fract_type_node, long_long_fract_type_node,
+	unsigned_short_fract_type_node, unsigned_fract_type_node,
+	unsigned_long_fract_type_node, unsigned_long_long_fract_type_node,
+	sat_short_accum_type_node, sat_accum_type_node,
+	sat_long_accum_type_node, sat_long_long_accum_type_node,
+	sat_unsigned_short_accum_type_node, sat_unsigned_accum_type_node,
+	sat_unsigned_long_accum_type_node,
+	sat_unsigned_long_long_accum_type_node, short_accum_type_node,
+	accum_type_node, long_accum_type_node, long_long_accum_type_node,
+	unsigned_short_accum_type_node, unsigned_accum_type_node,
+	unsigned_long_accum_type_node, unsigned_long_long_accum_type_node,
+	qq_type_node, hq_type_node, sq_type_node, dq_type_node, tq_type_node,
+	uqq_type_node, uhq_type_node, usq_type_node, udq_type_node,
+	utq_type_node, sat_qq_type_node, sat_hq_type_node, sat_sq_type_node,
+	sat_dq_type_node, sat_tq_type_node, sat_uqq_type_node,
+	sat_uhq_type_node, sat_usq_type_node, sat_udq_type_node,
+	sat_utq_type_node, ha_type_node, sa_type_node, da_type_node,
+	ta_type_node, uha_type_node, usa_type_node, uda_type_node,
+	uta_type_node, sat_ha_type_node, sat_sa_type_node, sat_da_type_node,
+	sat_ta_type_node, sat_uha_type_node, sat_usa_type_node,
+	sat_uda_type_node, sat_uta_type_node): New macro.
+	(make_fract_type, make_accum_type): Declare.
+	(make_signed_fract_type, make_unsigned_fract_type,
+	make_sat_signed_fract_type, make_sat_unsigned_fract_type,
+	make_signed_accum_type, make_unsigned_accum_type,
+	make_sat_signed_accum_type, make_sat_unsigned_accum_type,
+	make_or_reuse_signed_fract_type, make_or_reuse_unsigned_fract_type,
+	make_or_reuse_sat_signed_fract_type,
+	make_or_reuse_sat_unsigned_fract_type, make_or_reuse_signed_accum_type,
+	make_or_reuse_unsigned_accum_type, make_or_reuse_sat_signed_accum_type,
+	make_or_reuse_sat_unsigned_accum_type): New macro.
+	(fixed_zerop): Declare.
+	* defaults.h (SHORT_FRACT_TYPE_SIZE, FRACT_TYPE_SIZE,
+	LONG_FRACT_TYPE_SIZE, LONG_LONG_FRACT_TYPE_SIZE,
+	SHORT_ACCUM_TYPE_SIZE, ACCUM_TYPE_SIZE, LONG_ACCUM_TYPE_SIZE,
+	LONG_LONG_ACCUM_TYPE_SIZE): Define.
+	* treestruct.def: Add TS_FIXED_CST.
+	* Makefile.in (c-pretty-print.o): Add dependence on fixed-value.h.
+	(tree.o): Likewise.
+	(tree-dump.o): Likewise.
+	(print-tree.o): Likewise.
+	(tree-pretty-print.o): Likewise.
+	(fold-const.o): Likewise.
+	* tree-complex.c (some_nonzerop): Handle FIXED_CST.
+	* tree-gimple.c (is_gimple_formal_tmp_rhs): Handle FIXED_CST.
+	(is_gimple_min_invariant): Handle FIXED_CST.
+	* stor-layout.c (int_mode_for_mode): Handle MODE_FRACT, MODE_UFRACT,
+	MODE_ACCUM, MODE_UACCUM, MODE_VECTOR_FRACT, MODE_VECTOR_UFRACT,
+	MODE_VECTOR_ACCUM, MODE_VECTOR_UACCUM.
+	(layout_type): Handle FIXED_POINT_TYPE.
+	(make_fract_type, make_accum_type): New functions.
+	* tree-browser.c (browse_tree): Handle FIXED_POINT_TYPE.
+	* tree-dump.c (fixed-value.h): New include.
+	(dump_fixed): New function.
+	(dequeue_and_dump): Handle FIXED_POINT_TYPE and FIXED_CST.
+	* tree-inline.c (remap_type_1): Handle FIXED_POINT_TYPE.
+	(estimate_num_insns_1): Handle FIXED_CST and FIXED_CONVERT_EXPR.
+	* tree-pretty-print.c (fixed-value.h): New include.
+	(dump_generic_node): Handle FIXED_POINT_TYPE, FIXED_CST, and
+	FIXED_CONVERT_EXPR.
+	* tree-scalar-evolution.c (get_scalar_evolution): Handle FIXED_CST.
+	* tree-ssa-loop-im.c (for_each_index): Handle FIXED_CST.
+	* tree-ssa-pre.c (poolify_tree): Handle FIXED_CST.
+	* tree-ssa-reassoc.c (break_up_subtract_bb): We can do reassociation
+	for non-saturating fixed-point types.
+	(reassociate_bb): Likewise.
+	* emit-rtl.c (fixed-value.h): New include.
+	(fconst0, fconst1): New array.
+	(init_emit_once): Initialize fconst0 and fconst1 for fixed-point modes.
+	* tree-vect-generic.c expand_vector_operation): Support
+	MODE_VECTOR_FRACT, MODE_VECTOR_UFRACT, MODE_VECTOR_ACCUM, and
+	MODE_VECTOR_UACCUM.
+	(type_for_widest_vector_mode): Add one parameter for the 
+	saturating flag.
+	Check scalar FRACT, UFRACT, ACCUM, and UACCUM mode to select their
+	vector mode.
+	Pass the satp parameter to type_for_mode for fixed-point types.
+	(expand_vector_operations_1): Pass the saturating flag to
+	type_for_widest_vector_mode.
+	Support MODE_VECTOR_FRACT, MODE_VECTOR_UFRACT, MODE_VECTOR_ACCUM,
+	and MODE_VECTOR_UACCUM.
+	* tree-vect-transform.c (vect_is_simple_cond): Support FIXED_CST.
+	(vectorizable_condition): Likewise.
+	* tree.c (fixed-value.h): New include.
+	(tree_code_size): Support FIXED_CST.
+	(build_fixed): New function.
+	(build_one_cst): Support FIXED_POINT_TYPE for accum types.
+	(fixed_zerop): New function.
+	(tree_node_structure): Support FIXED_CST.
+	(type_contains_placeholder_1): Support FIXED_POINT_TYPE.
+	(build_type_attribute_qual_variant): Handle FIXED_POINT_TYPE.
+	(type_hash_eq): Handle FIXED_POINT_TYPE.
+	(simple_cst_equal): Support FIXED_CST.
+	(iterative_hash_expr): Handle FIXED_CST.
+	(get_unwidened): Make sure type is not FIXED_POINT_TYPE.
+	(get_narrower): Likewise.
+	(variably_modified_type_p): Handle FIXED_POINT_TYPE.
+	(make_or_reuse_fract_type, make_or_reuse_accum_type): New functions.
+	(build_common_tree_nodes_2): Use MAKE_FIXED_TYPE_NODE_FAMILY and
+	MAKE_FIXED_MODE_NODE macros to initialize fixed-point type
+	nodes.
+	(build_vector_type_for_mode): Handle MODE_VECTOR_FRACT,
+	MODE_VECTOR_UFRACT, MODE_VECTOR_ACCUM, MODE_VECTOR_UACCUM.
+	(initializer_zerop): Support FIXED_CST.
+	(walk_tree): Handle FIXED_CST and FIXED_POINT_TYPE.
+	* dwarf2out.c (base_type_die): Use DW_ATE_signed_fixed or
+	DW_ATE_unsigned_fixed to describe FIXED_POINT_TYPE.
+	(is_base_type): Handle FIXED_POINT_TYPE.
+	(add_type_attribute): Handle FIXED_POINT_TYPE.
+	(gen_type_die_with_usage): Handle FIXED_POINT_TYPE.
+	* print-tree.c (fixed-value.h): New include.
+	(print_node_brief): Support FIXED_CST.
+	(print_node): Support FIXED_POINT_TYPE and FIXED_CST.
+	* c-pretty-print.c (fixed-value.h): New include.
+	(pp_c_type_specifier): Handle FIXED_POINT_TYPE.  Need to pass
+	TYPE_SATURATING to c_common_type_for_mode for fixed-point modes.
+	(pp_c_direct_abstract_declarator): Handle FIXED_POINT_TYPE.
+	Support fixed-point types for inner items in VECTOR_TYPE.
+	(pp_c_direct_declarator): Likewise.
+	(pp_c_declarator): Likewise.
+	(pp_c_fixed_constant): New function.
+	(pp_c_constant): Handle FIXED_CST.
+	(pp_c_primary_expression): Likewise.
+	(pp_c_expression): Likewise.
+	* fold-const.c (fixed-value.h): New include.
+	(negate_expr_p): Return true for FIXED_CST.
+	(fold_negate_expr): Support FIXED_CST.
+	(split_tree): Support FIXED_CST.
+	(const_binop): Support FIXED_CST.
+	(fold_convert_const_int_from_fixed): New function to convert from
+	fixed to int.
+	(fold_convert_const_real_from_fixed): New function to convert from
+	fixed to real.
+	(fold_convert_const_fixed_from_fixed): New function to convert from
+	fixed to another fixed.
+	(fold_convert_const_fixed_from_int): New function to convert from
+	int to fixed.
+	(fold_convert_const_fixed_from_real): New function to convert from
+	real to fixed.
+	(fold_convert_const): Support conversions from fixed to int, from
+	fixed to real, from fixed to fixed, from int to fixed, and from real
+	to fixed.
+	(fold_convert): Support FIXED_CST and FIXED_POINT_TYPE.
+	(operand_equal_p): Support FIXED_CST.
+	(make_range): For fixed-point modes, we need to pass the
+	saturating flag as the 2nd parameter.
+	(tree_swap_operands_p): Handle FIXED_CST.
+	(fold_plusminus_mult_expr): For fract modes, we cannot generate
+	constant 1.
+	(fold_unary): Support FIXED_CONVERT_EXPR.
+	(fold_binary): Handle FIXED_CST.
+	Make sure the type is not saturating, before associating operations.
+	Ex: A + B + C, A * B * C, (A1 * C1) +/- (A2 * C2).
+	(tree_expr_nonnegative_warnv_p): Handle FIXED_CST.
+	(fold_negate_const): Support FIXED_CST.
+	(fold_relational_const): Support FIXED_CST.
+	* gimplify.c (omp_firstprivatize_type_sizes): Handle FIXED_POINT_TYPE.
+	(gimplify_expr): Handle FIXED_CST.
+	(gimplify_type_sizes): Handle FIXED_POINT_TYPE.
+	* ipa-prop.c (ipa_callsite_compute_param): Support FIXED_CST.
+	* ipa-type-escape.c (type_to_consider): Handle FIXED_POINT_TYPE.
+	* doc/tm.texi (Type Layout): Document SHORT_FRACT_TYPE_SIZE,
+	FRACT_TYPE_SIZE, LONG_FRACT_TYPE_SIZE, LONG_LONG_FRACT_TYPE_SIZE,
+	SHORT_ACCUM_TYPE_SIZE, ACCUM_TYPE_SIZE, LONG_ACCUM_TYPE_SIZE,
+	LONG_LONG_ACCUM_TYPE_SIZE.
+	* dbxout.c (dbxout_type): Handle FIXED_POINT_TYPE.
+	* c-aux-info.c (gen_type): Handle FIXED_POINT_TYPE.
+	* tree-sra.c (is_sra_scalar_type): Support FIXED_POINT_TYPE.
+	* expmed.c (extract_bit_field): Support MODE_FRACT, MODE_UFRACT,
+	MODE_ACCUM, and MODE_UACCUM.
+	* tree-vectorizer.c (vect_is_simple_reduction): Check for saturating
+	fixed-point types to disable reduction.
+	* explow.c (promote_mode): Support FIXED_POINT_TYPE.
+
+2007-08-08  David Edelsohn  <edelsohn@gnu.org>
+
+	* config/rs6000/x-rs6000: New file.
+	* config/rs6000/darwin.h (CC1_SPEC): Add cc1_cpu.
+	* config/rs6000/rs6000.h (EXTRA_SPECS): Add cc1_cpu.
+	(EXTRA_SPEC_FUNCTIONS): Define.
+	(HAVE_LOCAL_CPU_DETECT): Define.
+	(CC1_CPU_SPEC): Define.
+	* config/rs6000/driver-rs6000.c: New file.
+	* config/rs6000/aix.h (CC1_SPEC): Define.
+	* config/rs6000/sysv4.h (CC1_SPEC): Add cc1_cpu.
+	* config.host: Add x-rs6000 to host_xmake_file if host and target
+	are rs6000 or powerpc.
+
 2007-08-08  Paolo Bonzini <paolo.bonzini@lu.unisi.ch>
 
 	* config/i386/t-crtstuff (CRTSTUFF_T_CFLAGS): Use +=.


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.