A recent patch increased GCC's memory consumption in some cases!
gcctest@suse.de
gcctest@suse.de
Wed May 2 16:09:00 GMT 2007
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 2263k to 2324k, overall 2.70%
Peak amount of GGC memory still allocated after garbage collecting increased from 1952k to 1997k, overall 2.31%
Amount of produced GGC garbage increased from 447k to 479k, overall 7.27%
Amount of memory still referenced at the end of compilation increased from 2285k to 2374k, overall 3.87%
Overall memory needed: 7491k -> 7412k
Peak memory use before GGC: 2263k -> 2324k
Peak memory use after GGC: 1952k -> 1997k
Maximum of released memory in single GGC run: 311k -> 327k
Garbage: 447k -> 479k
Leak: 2285k -> 2374k
Overhead: 456k -> 516k
GGC runs: 3
comparing empty function compilation at -O0 -g level:
Peak amount of GGC memory allocated before garbage collecting increased from 2290k to 2352k, overall 2.71%
Peak amount of GGC memory still allocated after garbage collecting increased from 1979k to 2025k, overall 2.32%
Amount of produced GGC garbage increased from 449k to 482k, overall 7.18%
Amount of memory still referenced at the end of compilation increased from 2318k to 2407k, overall 3.82%
Overall memory needed: 7507k -> 7428k
Peak memory use before GGC: 2290k -> 2352k
Peak memory use after GGC: 1979k -> 2025k
Maximum of released memory in single GGC run: 311k -> 327k
Garbage: 449k -> 482k
Leak: 2318k -> 2407k
Overhead: 461k -> 521k
GGC runs: 3
comparing empty function compilation at -O1 level:
Peak amount of GGC memory allocated before garbage collecting increased from 2263k to 2324k, overall 2.70%
Peak amount of GGC memory still allocated after garbage collecting increased from 1952k to 1997k, overall 2.31%
Amount of produced GGC garbage increased from 452k to 485k, overall 7.19%
Amount of memory still referenced at the end of compilation increased from 2288k to 2376k, overall 3.87%
Overall memory needed: 7527k -> 7516k
Peak memory use before GGC: 2263k -> 2324k
Peak memory use after GGC: 1952k -> 1997k
Maximum of released memory in single GGC run: 311k -> 327k
Garbage: 452k -> 485k
Leak: 2288k -> 2376k
Overhead: 457k -> 517k
GGC runs: 4 -> 3
comparing empty function compilation at -O2 level:
Peak amount of GGC memory allocated before garbage collecting increased from 2263k to 2325k, overall 2.74%
Peak amount of GGC memory still allocated after garbage collecting increased from 1952k to 1997k, overall 2.31%
Amount of produced GGC garbage increased from 455k to 488k, overall 7.17%
Amount of memory still referenced at the end of compilation increased from 2288k to 2376k, overall 3.87%
Overall memory needed: 7555k -> 7524k
Peak memory use before GGC: 2263k -> 2325k
Peak memory use after GGC: 1952k -> 1997k
Maximum of released memory in single GGC run: 311k -> 328k
Garbage: 455k -> 488k
Leak: 2288k -> 2376k
Overhead: 457k -> 517k
GGC runs: 4
comparing empty function compilation at -O3 level:
Peak amount of GGC memory allocated before garbage collecting increased from 2263k to 2325k, overall 2.74%
Peak amount of GGC memory still allocated after garbage collecting increased from 1952k to 1997k, overall 2.31%
Amount of produced GGC garbage increased from 455k to 488k, overall 7.17%
Amount of memory still referenced at the end of compilation increased from 2288k to 2376k, overall 3.87%
Overall memory needed: 7555k -> 7524k
Peak memory use before GGC: 2263k -> 2325k
Peak memory use after GGC: 1952k -> 1997k
Maximum of released memory in single GGC run: 311k -> 328k
Garbage: 455k -> 488k
Leak: 2288k -> 2376k
Overhead: 457k -> 517k
GGC runs: 4
comparing combine.c compilation at -O0 level:
Ovarall memory allocated via mmap and sbrk decreased from 22651k to 17676k, overall -28.15%
Peak amount of GGC memory allocated before garbage collecting run decreased from 9308k to 9015k, overall -3.25%
Peak amount of GGC memory still allocated after garbage collecting decreased from 8827k to 8255k, overall -6.93%
Amount of produced GGC garbage increased from 37622k to 37687k, overall 0.17%
Amount of memory still referenced at the end of compilation increased from 6580k to 7000k, overall 6.37%
Overall memory needed: 22651k -> 17676k
Peak memory use before GGC: 9308k -> 9015k
Peak memory use after GGC: 8827k -> 8255k
Maximum of released memory in single GGC run: 2622k -> 1874k
Garbage: 37622k -> 37687k
Leak: 6580k -> 7000k
Overhead: 5250k -> 4753k
GGC runs: 282 -> 278
comparing combine.c compilation at -O0 -g level:
Ovarall memory allocated via mmap and sbrk decreased from 24619k to 19572k, overall -25.79%
Peak amount of GGC memory allocated before garbage collecting run decreased from 11116k to 10751k, overall -3.40%
Peak amount of GGC memory still allocated after garbage collecting decreased from 10579k to 9975k, overall -6.06%
Amount of memory still referenced at the end of compilation increased from 9473k to 9892k, overall 4.43%
Overall memory needed: 24619k -> 19572k
Peak memory use before GGC: 11116k -> 10751k
Peak memory use after GGC: 10579k -> 9975k
Maximum of released memory in single GGC run: 2595k -> 1558k
Garbage: 38213k -> 38022k
Leak: 9473k -> 9892k
Overhead: 5955k -> 5459k
GGC runs: 271 -> 270
comparing combine.c compilation at -O1 level:
Ovarall memory allocated via mmap and sbrk decreased from 40555k to 29988k, overall -35.24%
Peak amount of GGC memory allocated before garbage collecting run decreased from 19322k to 17844k, overall -8.28%
Peak amount of GGC memory still allocated after garbage collecting decreased from 19127k to 17651k, overall -8.36%
Amount of produced GGC garbage decreased from 57382k to 52532k, overall -9.23%
Amount of memory still referenced at the end of compilation increased from 6609k to 7051k, overall 6.69%
Overall memory needed: 40555k -> 29988k
Peak memory use before GGC: 19322k -> 17844k
Peak memory use after GGC: 19127k -> 17651k
Maximum of released memory in single GGC run: 2077k -> 1450k
Garbage: 57382k -> 52532k
Leak: 6609k -> 7051k
Overhead: 6547k -> 5910k
GGC runs: 352 -> 357
comparing combine.c compilation at -O2 level:
Ovarall memory allocated via mmap and sbrk decreased from 41059k to 34344k, overall -19.55%
Peak amount of GGC memory allocated before garbage collecting run decreased from 19372k to 17874k, overall -8.38%
Peak amount of GGC memory still allocated after garbage collecting decreased from 19179k to 17667k, overall -8.56%
Amount of memory still referenced at the end of compilation increased from 6732k to 7167k, overall 6.45%
Overall memory needed: 41059k -> 34344k
Peak memory use before GGC: 19372k -> 17874k
Peak memory use after GGC: 19179k -> 17667k
Maximum of released memory in single GGC run: 2159k -> 1392k
Garbage: 69376k -> 69072k
Leak: 6732k -> 7167k
Overhead: 8392k -> 7992k
GGC runs: 406 -> 414
comparing combine.c compilation at -O3 level:
Ovarall memory allocated via mmap and sbrk decreased from 45611k to 40692k, overall -12.09%
Peak amount of GGC memory allocated before garbage collecting run decreased from 19484k to 18146k, overall -7.37%
Peak amount of GGC memory still allocated after garbage collecting decreased from 19266k to 17822k, overall -8.10%
Amount of produced GGC garbage increased from 90771k to 94381k, overall 3.98%
Amount of memory still referenced at the end of compilation increased from 6843k to 7279k, overall 6.37%
Overall memory needed: 45611k -> 40692k
Peak memory use before GGC: 19484k -> 18146k
Peak memory use after GGC: 19266k -> 17822k
Maximum of released memory in single GGC run: 3635k -> 3636k
Garbage: 90771k -> 94381k
Leak: 6843k -> 7279k
Overhead: 11439k -> 11263k
GGC runs: 428 -> 443
comparing insn-attrtab.c compilation at -O0 level:
Ovarall memory allocated via mmap and sbrk decreased from 151663k to 92884k, overall -63.28%
Peak amount of GGC memory allocated before garbage collecting run decreased from 69577k to 58836k, overall -18.26%
Peak amount of GGC memory still allocated after garbage collecting decreased from 44191k to 33331k, overall -32.58%
Amount of produced GGC garbage decreased from 133641k to 129388k, overall -3.29%
Amount of memory still referenced at the end of compilation increased from 9583k to 9612k, overall 0.30%
Overall memory needed: 151663k -> 92884k
Peak memory use before GGC: 69577k -> 58836k
Peak memory use after GGC: 44191k -> 33331k
Maximum of released memory in single GGC run: 37379k -> 33675k
Garbage: 133641k -> 129388k
Leak: 9583k -> 9612k
Overhead: 17418k -> 13888k
GGC runs: 216
comparing insn-attrtab.c compilation at -O0 -g level:
Ovarall memory allocated via mmap and sbrk decreased from 153171k to 94124k, overall -62.73%
Peak amount of GGC memory allocated before garbage collecting run decreased from 70739k to 59998k, overall -17.90%
Peak amount of GGC memory still allocated after garbage collecting decreased from 45459k to 34492k, overall -31.80%
Amount of produced GGC garbage decreased from 135123k to 129349k, overall -4.46%
Amount of memory still referenced at the end of compilation increased from 11051k to 11544k, overall 4.46%
Overall memory needed: 153171k -> 94124k
Peak memory use before GGC: 70739k -> 59998k
Peak memory use after GGC: 45459k -> 34492k
Maximum of released memory in single GGC run: 37380k -> 33676k
Garbage: 135123k -> 129349k
Leak: 11051k -> 11544k
Overhead: 17815k -> 14285k
GGC runs: 215 -> 213
comparing insn-attrtab.c compilation at -O1 level:
Ovarall memory allocated via mmap and sbrk decreased from 183279k to 110116k, overall -66.44%
Peak amount of GGC memory allocated before garbage collecting run decreased from 85948k to 63440k, overall -35.48%
Peak amount of GGC memory still allocated after garbage collecting decreased from 80070k to 60815k, overall -31.66%
Amount of produced GGC garbage decreased from 268762k to 233043k, overall -15.33%
Amount of memory still referenced at the end of compilation increased from 9403k to 9732k, overall 3.50%
Overall memory needed: 183279k -> 110116k
Peak memory use before GGC: 85948k -> 63440k
Peak memory use after GGC: 80070k -> 60815k
Maximum of released memory in single GGC run: 32250k -> 25048k
Garbage: 268762k -> 233043k
Leak: 9403k -> 9732k
Overhead: 28313k -> 26091k
GGC runs: 228 -> 244
comparing insn-attrtab.c compilation at -O2 level:
Ovarall memory allocated via mmap and sbrk decreased from 200087k to 169404k, overall -18.11%
Peak amount of GGC memory allocated before garbage collecting run decreased from 87235k to 63584k, overall -37.20%
Peak amount of GGC memory still allocated after garbage collecting decreased from 80140k to 61114k, overall -31.13%
Amount of produced GGC garbage decreased from 302019k to 269075k, overall -12.24%
Amount of memory still referenced at the end of compilation increased from 9401k to 9725k, overall 3.45%
Overall memory needed: 200087k -> 169404k
Peak memory use before GGC: 87235k -> 63584k
Peak memory use after GGC: 80140k -> 61114k
Maximum of released memory in single GGC run: 30040k -> 22146k
Garbage: 302019k -> 269075k
Leak: 9401k -> 9725k
Overhead: 33722k -> 31669k
GGC runs: 248 -> 266
comparing insn-attrtab.c compilation at -O3 level:
Ovarall memory allocated via mmap and sbrk decreased from 200079k to 182268k, overall -9.77%
Peak amount of GGC memory allocated before garbage collecting run decreased from 87249k to 75615k, overall -15.39%
Peak amount of GGC memory still allocated after garbage collecting decreased from 80154k to 71528k, overall -12.06%
Amount of memory still referenced at the end of compilation increased from 9405k to 9729k, overall 3.44%
Overall memory needed: 200079k -> 182268k
Peak memory use before GGC: 87249k -> 75615k
Peak memory use after GGC: 80154k -> 71528k
Maximum of released memory in single GGC run: 30102k -> 24450k
Garbage: 302705k -> 300339k
Leak: 9405k -> 9729k
Overhead: 33928k -> 32926k
GGC runs: 254 -> 267
comparing Gerald's testcase PR8361 compilation at -O0 level:
Ovarall memory allocated via mmap and sbrk decreased from 152987k to 145871k, overall -4.88%
Amount of memory still referenced at the end of compilation increased from 49217k to 51177k, overall 3.98%
Overall memory needed: 152987k -> 145871k
Peak memory use before GGC: 90246k -> 89182k
Peak memory use after GGC: 89353k -> 88299k
Maximum of released memory in single GGC run: 17774k -> 18129k
Garbage: 209978k -> 207129k
Leak: 49217k -> 51177k
Overhead: 24709k -> 23513k
GGC runs: 412 -> 408
comparing Gerald's testcase PR8361 compilation at -O0 -g level:
Ovarall memory allocated via mmap and sbrk decreased from 174771k to 163539k, overall -6.87%
Amount of memory still referenced at the end of compilation increased from 72532k to 74492k, overall 2.70%
Overall memory needed: 174771k -> 163539k
Peak memory use before GGC: 102853k -> 101739k
Peak memory use after GGC: 101834k -> 100731k
Maximum of released memory in single GGC run: 18129k -> 18434k
Garbage: 216510k -> 212808k
Leak: 72532k -> 74492k
Overhead: 30605k -> 29409k
GGC runs: 385 -> 381
comparing Gerald's testcase PR8361 compilation at -O1 level:
Ovarall memory allocated via mmap and sbrk decreased from 150728k to 141579k, overall -6.46%
Amount of memory still referenced at the end of compilation increased from 50296k to 51765k, overall 2.92%
Overall memory needed: 150728k -> 141579k
Peak memory use before GGC: 101899k -> 100523k
Peak memory use after GGC: 100884k -> 99511k
Maximum of released memory in single GGC run: 17236k -> 17479k
Garbage: 347581k -> 342084k
Leak: 50296k -> 51765k
Overhead: 31201k -> 30479k
GGC runs: 531 -> 527
comparing Gerald's testcase PR8361 compilation at -O2 level:
Ovarall memory allocated via mmap and sbrk decreased from 155252k to 147867k, overall -4.99%
Amount of produced GGC garbage increased from 378710k to 388895k, overall 2.69%
Amount of memory still referenced at the end of compilation increased from 51032k to 52844k, overall 3.55%
Overall memory needed: 155252k -> 147867k
Peak memory use before GGC: 102512k -> 101308k
Peak memory use after GGC: 101495k -> 100305k
Maximum of released memory in single GGC run: 17233k -> 17476k
Garbage: 378710k -> 388895k
Leak: 51032k -> 52844k
Overhead: 35520k -> 35877k
GGC runs: 569 -> 577
comparing Gerald's testcase PR8361 compilation at -O3 level:
Ovarall memory allocated via mmap and sbrk decreased from 157080k to 149127k, overall -5.33%
Amount of produced GGC garbage increased from 397752k to 421739k, overall 6.03%
Amount of memory still referenced at the end of compilation increased from 51318k to 53142k, overall 3.55%
Overall memory needed: 157080k -> 149127k
Peak memory use before GGC: 104309k -> 102907k
Peak memory use after GGC: 103276k -> 101887k
Maximum of released memory in single GGC run: 17610k -> 17909k
Garbage: 397752k -> 421739k
Leak: 51318k -> 53142k
Overhead: 37071k -> 38435k
GGC runs: 575 -> 599
comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
Ovarall memory allocated via mmap and sbrk decreased from 344531k to 244568k, overall -40.87%
Peak amount of GGC memory allocated before garbage collecting increased from 80256k to 81018k, overall 0.95%
Peak amount of GGC memory still allocated after garbage collecting increased from 57995k to 58757k, overall 1.31%
Amount of produced GGC garbage increased from 142770k to 144428k, overall 1.16%
Amount of memory still referenced at the end of compilation increased from 7421k to 7724k, overall 4.08%
Overall memory needed: 344531k -> 244568k
Peak memory use before GGC: 80256k -> 81018k
Peak memory use after GGC: 57995k -> 58757k
Maximum of released memory in single GGC run: 43619k -> 44133k
Garbage: 142770k -> 144428k
Leak: 7421k -> 7724k
Overhead: 25956k -> 23300k
GGC runs: 74 -> 79
comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
Ovarall memory allocated via mmap and sbrk decreased from 345431k to 245388k, overall -40.77%
Peak amount of GGC memory allocated before garbage collecting increased from 80902k to 81665k, overall 0.94%
Peak amount of GGC memory still allocated after garbage collecting increased from 58641k to 59403k, overall 1.30%
Amount of produced GGC garbage increased from 143036k to 144537k, overall 1.05%
Amount of memory still referenced at the end of compilation increased from 9188k to 9492k, overall 3.30%
Overall memory needed: 345431k -> 245388k
Peak memory use before GGC: 80902k -> 81665k
Peak memory use after GGC: 58641k -> 59403k
Maximum of released memory in single GGC run: 43608k -> 44122k
Garbage: 143036k -> 144537k
Leak: 9188k -> 9492k
Overhead: 26452k -> 23796k
GGC runs: 84 -> 87
comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
Ovarall memory allocated via mmap and sbrk decreased from 303191k to 243816k, overall -24.35%
Amount of produced GGC garbage decreased from 231144k to 223287k, overall -3.52%
Amount of memory still referenced at the end of compilation increased from 20856k to 20967k, overall 0.53%
Overall memory needed: 303191k -> 243816k
Peak memory use before GGC: 84146k -> 83516k
Peak memory use after GGC: 74847k -> 74900k
Maximum of released memory in single GGC run: 34777k -> 39417k
Garbage: 231144k -> 223287k
Leak: 20856k -> 20967k
Overhead: 33134k -> 29202k
GGC runs: 81
comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
Ovarall memory allocated via mmap and sbrk decreased from 559707k to 264060k, overall -111.96%
Amount of produced GGC garbage decreased from 239608k to 229973k, overall -4.19%
Amount of memory still referenced at the end of compilation increased from 20946k to 21057k, overall 0.53%
Overall memory needed: 559707k -> 264060k
Peak memory use before GGC: 79833k -> 79886k
Peak memory use after GGC: 74847k -> 74900k
Maximum of released memory in single GGC run: 33336k -> 33022k
Garbage: 239608k -> 229973k
Leak: 20946k -> 21057k
Overhead: 35480k -> 31220k
GGC runs: 92 -> 91
comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
Overall memory allocated via mmap and sbrk increased from 1046099k to 1297752k, overall 24.06%
Peak amount of GGC memory allocated before garbage collecting run decreased from 201851k to 190659k, overall -5.87%
Peak amount of GGC memory still allocated after garbage collecting decreased from 190309k to 178175k, overall -6.81%
Amount of produced GGC garbage decreased from 378489k to 363316k, overall -4.18%
Amount of memory still referenced at the end of compilation increased from 46312k to 46424k, overall 0.24%
Overall memory needed: 1046099k -> 1297752k
Peak memory use before GGC: 201851k -> 190659k
Peak memory use after GGC: 190309k -> 178175k
Maximum of released memory in single GGC run: 80846k -> 80667k
Garbage: 378489k -> 363316k
Leak: 46312k -> 46424k
Overhead: 51551k -> 43892k
GGC runs: 72
Head of the ChangeLog is:
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog 2007-04-29 17:39:02.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog 2007-05-02 14:07:52.000000000 +0000
@@ -1,3 +1,230 @@
+2007-05-02 Richard Guenther <rguenther@suse.de>
+
+ PR tree-optimization/31146
+ * tree-ssa-forwprop.c (forward_propagate_addr_expr_1): New
+ argument, single_use_p. If we have a single use that is
+ a conversion to the definition rhs type, propagate that rhs.
+ (forward_propagate_addr_expr): Pass single_use_p argument
+ to forward_propagate_addr_expr_1.
+
+2007-05-01 H.J. Lu <hongjiu.lu@intel.com>
+
+ * config/i386/i386.c (ix86_expand_sse_comi): Remove unused
+ variable.
+
+2007-05-01 Dwarakanath Rajagopal <dwarak.rajagopal@amd.com>
+
+ * doc/invoke.texi: Fix typo, 'AMD Family 10h core' instead of
+ 'AMD Family 10 core'.
+
+2007-05-01 Dwarakanath Rajagopal <dwarak.rajagopal@amd.com>
+
+ * config/i386/i386.c (override_options): Accept k8-sse3, opteron-sse3
+ and athlon64-sse3 as improved versions of k8, opteron and athlon64
+ with SSE3 instruction set support.
+ * doc/invoke.texi: Likewise.
+
+2007-05-01 Dwarakanath Rajagopal <dwarak.rajagopal@amd.com>
+
+ * config/i386/i386.c (override_options): Tuning 32-byte loop
+ alignment for amdfam10 architecture. Increasing the max loop
+ alignment to 24 bytes.
+
+2007-05-01 Kazu Hirata <kazu@codesourcery.com>
+
+ * config/m68k/constraints.md: New.
+ * config/m68k/m68k.h (REG_CLASS_FROM_LETTER,
+ CONST_OK_FOR_LETTER_P, CONST_DOUBLE_OK_FOR_LETTER_P,
+ EXTRA_CONSTRAINT): Remove.
+ * config/m68k/m68k.md: Include constraints.md.
+ * expr.c (expand_expr_real_1): Copy DECL_RTL before using it.
+
+2007-05-01 Ian Lance Taylor <iant@google.com>
+
+ PR tree-optimization/31739
+ * tree-vrp.c (vrp_val_is_max): New static function.
+ (vrp_val_is_min): New static function.
+ (set_value_range_to_value): Use TYPE_{MAX,MIN}_VALUE rather than
+ copying the node.
+ (set_value_range): Use vrp_val_is_{max,min}.
+ (extract_range_from_assert): Likewise.
+ (extract_range_from_binary_expr): Likewise.
+ (extract_range_from_unary_expr): Likewise.
+ (dump_value_range, vrp_meet): Likewise.
+ (vrp_visit_phi_node): Likewise.
+ * tree.c (build_distinct_type_copy): Revert change of 2007-04-27.
+
+2007-05-01 Mark Mitchell <mark@codesourcery.com>
+
+ * config/i386/gmon-sol2.c (size_t): New type.
+ (intptr_t): Likewise.
+ (s_textsize): Declare as size_t.
+ (sbrk): Declare.
+ (monstartup): Use size_t for sizes.
+ (_mcount): Save and restore registers.
+ (internal_mcount): Pass 0 as the first argument to monstartup
+ in 64-bit mode.
+ (moncontrol): Convert pointer to appropriately sized integer
+ before passing to profil.
+
+2007-05-01 Joseph Myers <joseph@codesourcery.com>
+
+ * config/rs6000/darwin-ldouble.c (__gcc_qunord): Define if
+ __NO_FPRS__, not just if _SOFT_DOUBLE.
+ * config/rs6000/libgcc-ppc-glibc.ver (__gcc_qunord): Likewise.
+ * config/rs6000/rs6000.c (rs6000_init_libfuncs): Use __gcc_qunord
+ also for E500 double.
+ * config/rs6000/rs6000.md (buneq, bunge, bungt, bunle, bunlt,
+ suneq, sunge, sungt, sunle, sunlt): Disable for (TARGET_HARD_FLOAT
+ && !TARGET_FPRS).
+
+2007-05-01 Richard Guenther <rguenther@suse.de>
+
+ * tree-ssa-loop-manip.c (ip_normal_pos): Check if last stmt
+ is NULL.
+
+2007-05-01 Joseph Myers <joseph@codesourcery.com>
+
+ * config/rs6000/libgcc-ppc-glibc.ver (__gcc_qgt): Fix typo.
+
+2007-05-01 Jan Hubicka <jh@suse.cz>
+
+ * tree-vectorize.c (vect_is_simple_use): gimple_min_invariant is
+ invariant.
+
+2007-05-01 Jan Hubicka <jh@suse.cz>
+
+ * tree.h (maybe_fold_offset_to_component_ref): Remove.
+ (maybe_fold_offset_to_reference): Declare.
+ * fold-const.c (fold_unary): Do not fold
+ (type *)&A into &A->field_of_type_and_offset_0
+ * tree-ssa-ccp.c (maybe_fold_offset_to_array_ref): When base type
+ size is unknown, give up.
+ (maybe_fold_offset_to_component_ref): Ignore firelds with unknown
+ offsets.
+ (maybe_fold_offset_to_reference): New.
+ (maybe_fold_stmt_indirect): Use it.
+ (fold_stmt_r): Fold (type *)&A+offset into A->field_if_type_and_offset.
+ * gimplify.c (gimplify_conversion): Canonicalize conversions to
+ field references.
+ (gimplify_expr): Likewise for plus_expr.
+
+2007-05-01 Zdenek Dvorak <dvorakz@suse.cz>
+
+ * tree-ssa-loop-ivopts.c (rewrite_use_nonlinear_expr): Use
+ bsi_after_labels. Always insert statements before bsi.
+ * tree-vect-transform.c (vect_create_epilog_for_reduction): Ditto.
+ * predict.c (apply_return_prediction): Check for empty blocks.
+ * cfgexpand.c (lab_rtx_for_bb): New variable.
+ (label_rtx_for_bb): Do not create new tree labels.
+ (expand_gimple_basic_block): Add labels recorded in lab_rtx_for_bb.
+ (tree_expand_cfg): Initialize lab_rtx_for_bb.
+ * tree-cfg.c (build_tree_cfg): Call cleanup_dead_labels after
+ creating edges.
+ (label_for_bb): Add field used.
+ (update_eh_label, main_block_label): Mark the label used.
+ (cleanup_dead_labels): Remove unused labels.
+
+2007-05-01 Richard Guenther <rguenther@suse.de>
+
+ * tree-vrp.c (set_value_range): Do not allocate equiv bitmap
+ if it is not about to be set.
+ (get_value_range): Do not pre-allocate equiv bitmap.
+ (update_value_range): No need to clear equiv field.
+ (add_equivalence): Change prototype to get bitmap pointer.
+ Allocate bitmap here if it is not already.
+ (extract_range_from_assert): Do not allocate bitmap here.
+ Update callers to add_equivalence.
+ (extract_range_from_ssa_name): Likewise.
+ (get_vr_for_comparison): New static helper.
+ (compare_name_with_value): Handle NULL equiv bitmap by
+ peeling the first iteration of the comparison loop.
+ Use get_vr_for_comparison.
+ (compare_names): Handle NULL equiv bitmaps by using fake
+ ones. Use get_vr_for_comparison.
+
+2007-04-30 Brooks Moses <brooks.moses@codesourcery.com>
+
+ * double-int.c (mpz_set_double_int): Moved from
+ tree-ssa-loop-niter.c.
+ (mpz_get_double_int): Likewise; also, add option to wrap
+ out-of-range integers.
+ * double-int.h: New prototypes for above.
+ * tree.c (get_static_type_bounds): Moved from
+ tree-ssa-loop-niter.c; now returns TYPE_MIN_VALUE and
+ TYPE_MAX_VALUE if they exist..
+ * tree.h: New prototype for above.
+ * tree-ssa-loop-niter.c: Adjust mpz_to_double_int and
+ get_type_bounds calls.
+ (mpz_set_double_int): Move to double-int.c.
+ (get_type_bounds): Move to tree.c, rename to
+ get_static_type_bounds.
+ (mpz_to_double_int): Move to double-int.c, rename to
+ mpz_get_double_int.
+
+2007-04-30 Bob Wilson <bob.wilson@acm.org>
+
+ * config/xtensa/lib1funcs.asm (__umodsi3, __modsi3): Rearrange so that
+ DIV0 exception can fall through to a normal return.
+
+2007-04-30 Alexandre Oliva <aoliva@redhat.com>
+
+ PR middle-end/22156
+ Temporarily revert:
+ 2007-04-06 Andreas Tobler <a.tobler@schweiz.org>
+ * tree-sra.c (sra_build_elt_assignment): Initialize min/maxshift.
+ 2007-04-05 Alexandre Oliva <aoliva@redhat.com>
+ * tree-sra.c (try_instantiate_multiple_fields): Needlessly
+ initialize align to silence bogus warning.
+ 2007-04-05 Alexandre Oliva <aoliva@redhat.com>
+ * tree-sra.c (struct sra_elt): Add in_bitfld_block. Remove
+ all_no_warning.
+ (struct sra_walk_fns): Remove use_all parameter from use.
+ (sra_hash_tree): Handle BIT_FIELD_REFs.
+ (sra_elt_hash): Don't hash bitfld blocks.
+ (sra_elt_eq): Skip them in parent compares as well. Handle
+ BIT_FIELD_REFs.
+ (sra_walk_expr): Don't maintain or pass down use_all_p.
+ (scan_use): Remove use_all parameter.
+ (scalarize_use): Likewise. Re-expand assignment to
+ BIT_FIELD_REF of gimple_reg. De-scalarize before input or
+ output, and re-scalarize after output. Don't mark anything
+ for no warning.
+ (scalarize_ldst): Adjust.
+ (scalarize_walk_gimple_modify_statement): Likewise.
+ (build_element_name_1): Handle BIT_FIELD_REFs.
+ (instantiate_element): Don't warn for any element whose parent
+ is used as a whole.
+ (instantiate_missing_elements_1): Return the sra_elt.
+ (canon_type_for_field): New.
+ (try_instantiate_multiple_fields): New.
+ (instantiate_missing_elemnts): Use them.
+ (mark_no_warning): Removed.
+ (generate_one_element_ref): Handle BIT_FIELD_REFs.
+ (REPLDUP, sra_build_elt_assignment): New.
+ (generate_copy_inout): Use them.
+ (generate_element_copy): Likewise. Handle bitfld differences.
+ (generate_element_zero): Don't recurse for blocks. Use
+ sra_build_elt_assignment.
+ (generate_one_element_int): Take elt instead of var. Use
+ sra_build_elt_assignment.
+ (generate_element_init_1): Adjust.
+ (scalarize_use, scalarize_copy): Use REPLDUP.
+ (scalarize_ldst): Move assert before dereference.
+ (dump_sra_elt_name): Handle BIT_FIELD_REFs.
+
+2007-04-30 Andrew Pinski <andrew_pinski@playstation.sony.com>
+
+ PR C++/31721
+ * tree.c (reconstruct_complex_type): Reconstruct a reference
+ correctly.
+ Also use the same mode for the pointer as the old pointer type.
+
+2007-04-30 Francois-Xavier Coudert <coudert@clipper.ens.fr>
+
+ * doc/trouble.texi (Interoperation): Remove note about Ultrix
+ Fortran compiler.
+
2007-04-29 Zdenek Dvorak <dvorakz@suse.cz>
PR rtl-optimization/31676
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