A recent patch increased GCC's memory consumption in some cases!
gcctest@suse.de
gcctest@suse.de
Wed Sep 5 05:51: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:
Ovarall memory allocated via mmap and sbrk decreased from 8333k to 6952k, overall -19.86%
Peak amount of GGC memory allocated before garbage collecting run decreased from 3397k to 1149k, overall -195.65%
Peak amount of GGC memory still allocated after garbage collecting decreased from 3045k to 1054k, overall -188.90%
Amount of produced GGC garbage decreased from 525k to 239k, overall -119.16%
Amount of memory still referenced at the end of compilation decreased from 3800k to 1067k, overall -255.86%
Overall memory needed: 8333k -> 6952k
Peak memory use before GGC: 3397k -> 1149k
Peak memory use after GGC: 3045k -> 1054k
Maximum of released memory in single GGC run: 352k -> 121k
Garbage: 525k -> 239k
Leak: 3800k -> 1067k
Overhead: 915k -> 145k
GGC runs: 3 -> 4
comparing empty function compilation at -O0 -g level:
Ovarall memory allocated via mmap and sbrk decreased from 8349k to 6972k, overall -19.75%
Peak amount of GGC memory allocated before garbage collecting run decreased from 3424k to 1176k, overall -191.16%
Peak amount of GGC memory still allocated after garbage collecting decreased from 3072k to 1081k, overall -184.18%
Amount of produced GGC garbage decreased from 527k to 242k, overall -117.97%
Amount of memory still referenced at the end of compilation decreased from 3832k to 1100k, overall -248.32%
Overall memory needed: 8349k -> 6972k
Peak memory use before GGC: 3424k -> 1176k
Peak memory use after GGC: 3072k -> 1081k
Maximum of released memory in single GGC run: 352k -> 124k
Garbage: 527k -> 242k
Leak: 3832k -> 1100k
Overhead: 919k -> 150k
GGC runs: 3 -> 4
comparing empty function compilation at -O1 level:
Ovarall memory allocated via mmap and sbrk decreased from 8385k to 7008k, overall -19.65%
Peak amount of GGC memory allocated before garbage collecting run decreased from 3397k to 1149k, overall -195.65%
Peak amount of GGC memory still allocated after garbage collecting decreased from 3045k to 1046k, overall -191.11%
Amount of produced GGC garbage decreased from 527k to 241k, overall -118.11%
Amount of memory still referenced at the end of compilation decreased from 3800k to 1068k, overall -255.72%
Overall memory needed: 8385k -> 7008k
Peak memory use before GGC: 3397k -> 1149k
Peak memory use after GGC: 3045k -> 1046k
Maximum of released memory in single GGC run: 352k -> 116k
Garbage: 527k -> 241k
Leak: 3800k -> 1068k
Overhead: 915k -> 145k
GGC runs: 3
comparing empty function compilation at -O2 level:
Ovarall memory allocated via mmap and sbrk decreased from 8393k to 7012k, overall -19.69%
Peak amount of GGC memory allocated before garbage collecting run decreased from 3397k to 1149k, overall -195.65%
Peak amount of GGC memory still allocated after garbage collecting decreased from 3045k to 1046k, overall -191.11%
Amount of produced GGC garbage decreased from 531k to 245k, overall -116.33%
Amount of memory still referenced at the end of compilation decreased from 3801k to 1069k, overall -255.47%
Overall memory needed: 8393k -> 7012k
Peak memory use before GGC: 3397k -> 1149k
Peak memory use after GGC: 3045k -> 1046k
Maximum of released memory in single GGC run: 352k -> 116k
Garbage: 531k -> 245k
Leak: 3801k -> 1069k
Overhead: 916k -> 146k
GGC runs: 3
comparing empty function compilation at -O3 level:
Ovarall memory allocated via mmap and sbrk decreased from 8393k to 7012k, overall -19.69%
Peak amount of GGC memory allocated before garbage collecting run decreased from 3397k to 1149k, overall -195.65%
Peak amount of GGC memory still allocated after garbage collecting decreased from 3045k to 1046k, overall -191.11%
Amount of produced GGC garbage decreased from 531k to 245k, overall -116.33%
Amount of memory still referenced at the end of compilation decreased from 3801k to 1069k, overall -255.47%
Overall memory needed: 8393k -> 7012k
Peak memory use before GGC: 3397k -> 1149k
Peak memory use after GGC: 3045k -> 1046k
Maximum of released memory in single GGC run: 352k -> 116k
Garbage: 531k -> 245k
Leak: 3801k -> 1069k
Overhead: 916k -> 146k
GGC runs: 3
comparing combine.c compilation at -O0 level:
Ovarall memory allocated via mmap and sbrk decreased from 23757k to 21936k, overall -8.30%
Peak amount of GGC memory allocated before garbage collecting run decreased from 10322k to 8228k, overall -25.45%
Peak amount of GGC memory still allocated after garbage collecting decreased from 9566k to 7568k, overall -26.40%
Amount of memory still referenced at the end of compilation decreased from 8856k to 6124k, overall -44.61%
Overall memory needed: 23757k -> 21936k
Peak memory use before GGC: 10322k -> 8228k
Peak memory use after GGC: 9566k -> 7568k
Maximum of released memory in single GGC run: 1903k -> 1581k
Garbage: 39082k -> 38811k
Leak: 8856k -> 6124k
Overhead: 5782k -> 5013k
GGC runs: 254 -> 372
comparing combine.c compilation at -O0 -g level:
Ovarall memory allocated via mmap and sbrk decreased from 25621k to 23952k, overall -6.97%
Peak amount of GGC memory allocated before garbage collecting run decreased from 11966k to 10058k, overall -18.97%
Peak amount of GGC memory still allocated after garbage collecting decreased from 11331k to 9332k, overall -21.42%
Amount of memory still referenced at the end of compilation decreased from 11682k to 8951k, overall -30.52%
Overall memory needed: 25621k -> 23952k
Peak memory use before GGC: 11966k -> 10058k
Peak memory use after GGC: 11331k -> 9332k
Maximum of released memory in single GGC run: 1516k -> 1875k
Garbage: 39436k -> 39156k
Leak: 11682k -> 8951k
Overhead: 6454k -> 5685k
GGC runs: 249 -> 342
comparing combine.c compilation at -O1 level:
Ovarall memory allocated via mmap and sbrk decreased from 35753k to 33028k, overall -8.25%
Peak amount of GGC memory allocated before garbage collecting run decreased from 18982k to 16974k, overall -11.83%
Peak amount of GGC memory still allocated after garbage collecting decreased from 18792k to 16775k, overall -12.02%
Amount of memory still referenced at the end of compilation decreased from 8995k to 6263k, overall -43.62%
Overall memory needed: 35753k -> 33028k
Peak memory use before GGC: 18982k -> 16974k
Peak memory use after GGC: 18792k -> 16775k
Maximum of released memory in single GGC run: 1378k -> 1379k
Garbage: 52637k -> 52377k
Leak: 8995k -> 6263k
Overhead: 6749k -> 5979k
GGC runs: 321 -> 443
comparing combine.c compilation at -O2 level:
Ovarall memory allocated via mmap and sbrk decreased from 37765k to 35276k, overall -7.06%
Peak amount of GGC memory allocated before garbage collecting run decreased from 19037k to 17082k, overall -11.44%
Peak amount of GGC memory still allocated after garbage collecting decreased from 18847k to 16911k, overall -11.45%
Amount of produced GGC garbage increased from 71156k to 71293k, overall 0.19%
Amount of memory still referenced at the end of compilation decreased from 9326k to 6589k, overall -41.54%
Overall memory needed: 37765k -> 35276k
Peak memory use before GGC: 19037k -> 17082k
Peak memory use after GGC: 18847k -> 16911k
Maximum of released memory in single GGC run: 1389k -> 1334k
Garbage: 71156k -> 71293k
Leak: 9326k -> 6589k
Overhead: 8885k -> 8239k
GGC runs: 382 -> 512
comparing combine.c compilation at -O3 level:
Peak amount of GGC memory allocated before garbage collecting run decreased from 19311k to 17316k, overall -11.52%
Peak amount of GGC memory still allocated after garbage collecting decreased from 18963k to 16965k, overall -11.78%
Amount of memory still referenced at the end of compilation decreased from 9448k to 6708k, overall -40.85%
Overall memory needed: 40497k -> 39852k
Peak memory use before GGC: 19311k -> 17316k
Peak memory use after GGC: 18963k -> 16965k
Maximum of released memory in single GGC run: 2262k -> 2132k
Garbage: 92846k -> 92594k
Leak: 9448k -> 6708k
Overhead: 11515k -> 10669k
GGC runs: 413 -> 542
comparing insn-attrtab.c compilation at -O0 level:
Peak amount of GGC memory allocated before garbage collecting run decreased from 60580k to 58582k, overall -3.41%
Peak amount of GGC memory still allocated after garbage collecting decreased from 34074k to 32075k, overall -6.23%
Amount of memory still referenced at the end of compilation decreased from 11585k to 8613k, overall -34.51%
Overall memory needed: 140105k -> 138388k
Peak memory use before GGC: 60580k -> 58582k
Peak memory use after GGC: 34074k -> 32075k
Maximum of released memory in single GGC run: 34143k -> 34144k
Garbage: 132018k -> 131996k
Leak: 11585k -> 8613k
Overhead: 15587k -> 14817k
GGC runs: 197 -> 300
comparing insn-attrtab.c compilation at -O0 -g level:
Peak amount of GGC memory allocated before garbage collecting run decreased from 61730k to 59731k, overall -3.35%
Peak amount of GGC memory still allocated after garbage collecting decreased from 35223k to 33224k, overall -6.02%
Amount of memory still referenced at the end of compilation decreased from 13261k to 10529k, overall -25.95%
Overall memory needed: 141361k -> 139636k
Peak memory use before GGC: 61730k -> 59731k
Peak memory use after GGC: 35223k -> 33224k
Maximum of released memory in single GGC run: 34144k
Garbage: 132243k -> 131964k
Leak: 13261k -> 10529k
Overhead: 15967k -> 15198k
GGC runs: 200 -> 291
comparing insn-attrtab.c compilation at -O1 level:
Peak amount of GGC memory allocated before garbage collecting run decreased from 59097k to 57094k, overall -3.51%
Peak amount of GGC memory still allocated after garbage collecting decreased from 52850k to 50856k, overall -3.92%
Amount of memory still referenced at the end of compilation decreased from 12480k to 9748k, overall -28.02%
Overall memory needed: 150261k -> 149544k
Peak memory use before GGC: 59097k -> 57094k
Peak memory use after GGC: 52850k -> 50856k
Maximum of released memory in single GGC run: 24232k
Garbage: 212957k -> 212699k
Leak: 12480k -> 9748k
Overhead: 25595k -> 24826k
GGC runs: 223 -> 324
comparing insn-attrtab.c compilation at -O2 level:
Peak amount of GGC memory allocated before garbage collecting run decreased from 59723k to 57737k, overall -3.44%
Peak amount of GGC memory still allocated after garbage collecting decreased from 54429k to 52445k, overall -3.78%
Amount of memory still referenced at the end of compilation decreased from 13562k to 10836k, overall -25.16%
Overall memory needed: 188945k -> 187280k
Peak memory use before GGC: 59723k -> 57737k
Peak memory use after GGC: 54429k -> 52445k
Maximum of released memory in single GGC run: 22887k -> 22942k
Garbage: 254069k -> 254228k
Leak: 13562k -> 10836k
Overhead: 31319k -> 30585k
GGC runs: 250 -> 355
comparing insn-attrtab.c compilation at -O3 level:
Peak amount of GGC memory still allocated after garbage collecting decreased from 65141k to 63142k, overall -3.17%
Amount of memory still referenced at the end of compilation decreased from 13573k to 10841k, overall -25.20%
Overall memory needed: 195937k -> 194308k
Peak memory use before GGC: 71708k -> 69709k
Peak memory use after GGC: 65141k -> 63142k
Maximum of released memory in single GGC run: 23330k -> 23328k
Garbage: 281233k -> 280992k
Leak: 13573k -> 10841k
Overhead: 33117k -> 32353k
GGC runs: 253 -> 355
comparing Gerald's testcase PR8361 compilation at -O0 level:
Amount of memory still referenced at the end of compilation decreased from 55630k to 52902k, overall -5.16%
Overall memory needed: 157015k -> 155087k
Peak memory use before GGC: 91688k -> 89624k
Peak memory use after GGC: 90780k -> 88736k
Maximum of released memory in single GGC run: 18122k -> 18056k
Garbage: 210576k -> 210310k
Leak: 55630k -> 52902k
Overhead: 27201k -> 26438k
GGC runs: 393 -> 419
comparing Gerald's testcase PR8361 compilation at -O0 -g level:
Amount of memory still referenced at the end of compilation decreased from 78499k to 75770k, overall -3.60%
Overall memory needed: 177743k -> 175351k
Peak memory use before GGC: 104297k -> 101933k
Peak memory use after GGC: 103253k -> 100924k
Maximum of released memory in single GGC run: 18632k -> 18267k
Garbage: 216439k -> 216157k
Leak: 78499k -> 75770k
Overhead: 32882k -> 32117k
GGC runs: 373 -> 386
comparing Gerald's testcase PR8361 compilation at -O1 level:
Amount of memory still referenced at the end of compilation decreased from 55526k to 52790k, overall -5.18%
Overall memory needed: 133417k -> 131573k
Peak memory use before GGC: 93458k -> 91652k
Peak memory use after GGC: 92527k -> 90741k
Maximum of released memory in single GGC run: 17307k -> 17316k
Garbage: 317319k -> 317102k
Leak: 55526k -> 52790k
Overhead: 32854k -> 32089k
GGC runs: 498 -> 523
comparing Gerald's testcase PR8361 compilation at -O2 level:
Amount of produced GGC garbage increased from 373682k to 382812k, overall 2.44%
Amount of memory still referenced at the end of compilation decreased from 56724k to 54024k, overall -5.00%
Overall memory needed: 141569k -> 138713k
Peak memory use before GGC: 94176k -> 91932k
Peak memory use after GGC: 93233k -> 90988k
Maximum of released memory in single GGC run: 17304k -> 17317k
Garbage: 373682k -> 382812k
Leak: 56724k -> 54024k
Overhead: 39139k -> 38974k
GGC runs: 560 -> 591
comparing Gerald's testcase PR8361 compilation at -O3 level:
Amount of memory still referenced at the end of compilation decreased from 57113k to 54388k, overall -5.01%
Overall memory needed: 144957k -> 143141k
Peak memory use before GGC: 94981k -> 92850k
Peak memory use after GGC: 93916k -> 91877k
Maximum of released memory in single GGC run: 17716k -> 17669k
Garbage: 413461k -> 413424k
Leak: 57113k -> 54388k
Overhead: 42409k -> 41686k
GGC runs: 583 -> 611
comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
Peak amount of GGC memory still allocated after garbage collecting decreased from 59131k to 57133k, overall -3.50%
Amount of memory still referenced at the end of compilation decreased from 9011k to 6279k, overall -43.51%
Overall memory needed: 381013k -> 379278k
Peak memory use before GGC: 103478k -> 101479k
Peak memory use after GGC: 59131k -> 57133k
Maximum of released memory in single GGC run: 50583k -> 50582k
Garbage: 179673k -> 179391k
Leak: 9011k -> 6279k
Overhead: 31654k -> 30884k
GGC runs: 65 -> 107
comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
Peak amount of GGC memory still allocated after garbage collecting decreased from 59765k to 57766k, overall -3.46%
Amount of memory still referenced at the end of compilation decreased from 10719k to 7987k, overall -34.20%
Overall memory needed: 381837k -> 380098k
Peak memory use before GGC: 104111k -> 102113k
Peak memory use after GGC: 59765k -> 57766k
Maximum of released memory in single GGC run: 50582k -> 50583k
Garbage: 179778k -> 179544k
Leak: 10719k -> 7987k
Overhead: 32119k -> 31350k
GGC runs: 72 -> 112
comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
Amount of memory still referenced at the end of compilation decreased from 18350k to 15618k, overall -17.49%
Overall memory needed: 290081k -> 295172k
Peak memory use before GGC: 82785k -> 80789k
Peak memory use after GGC: 75173k -> 73174k
Maximum of released memory in single GGC run: 40017k -> 40020k
Garbage: 236069k -> 235792k
Leak: 18350k -> 15618k
Overhead: 32718k -> 31949k
GGC runs: 69 -> 105
comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
Overall memory allocated via mmap and sbrk increased from 277853k to 1017628k, overall 266.25%
Peak amount of GGC memory allocated before garbage collecting increased from 80159k to 166802k, overall 108.09%
Peak amount of GGC memory still allocated after garbage collecting increased from 75173k to 156366k, overall 108.01%
Amount of produced GGC garbage increased from 246133k to 368454k, overall 49.70%
Amount of memory still referenced at the end of compilation increased from 18439k to 25861k, overall 40.25%
Overall memory needed: 277853k -> 1017628k
Peak memory use before GGC: 80159k -> 166802k
Peak memory use after GGC: 75173k -> 156366k
Maximum of released memory in single GGC run: 33750k -> 81038k
Garbage: 246133k -> 368454k
Leak: 18439k -> 25861k
Overhead: 34943k -> 46376k
GGC runs: 82 -> 106
comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
Amount of memory still referenced at the end of compilation decreased from 28581k to 25849k, overall -10.57%
Overall memory needed: 1019105k -> 1017464k
Peak memory use before GGC: 168801k -> 166802k
Peak memory use after GGC: 158365k -> 156366k
Maximum of released memory in single GGC run: 83495k -> 83493k
Garbage: 357941k -> 357657k
Leak: 28581k -> 25849k
Overhead: 47049k -> 46279k
GGC runs: 65 -> 100
Head of the ChangeLog is:
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog 2007-09-04 11:53:31.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog 2007-09-05 03:58:47.000000000 +0000
@@ -1,3 +1,181 @@
+2007-09-04 Andrew Pinski <andrew_pinski@playstation.sony.com>
+
+ * config.gcc (powerpc*-*-*): Install
+ spu2vmx.h, vec_types.h, and si2vmx.h headers.
+ * config/rs6000/spu2vmx.h: New header.
+ * config/rs6000/si2vmx.h: New header.
+ * config/rs6000/vec_types.h: New header.
+
+2007-09-05 Ben Elliston <bje@au.ibm.com>
+
+ * varasm.c (initializer_constant_valid_p): Fix comment typo.
+
+2007-09-05 Ben Elliston <bje@au.ibm.com>
+
+ * config/rs6000/ppu_intrinsics.h (__ldarx): Use `Z' constraint,
+ not `m' for *ptrp.
+ (__stdcx): Make asm volatile.
+ (__stwcx, __stdcx): Return only 0 or 1.
+
+2007-09-05 Jan Hubicka <jh@suse.cz>
+
+ Revert:
+
+ 2007-09-04 Jan Hubicka <jh@suse.cz>
+ * tree-tailcall.c (eliminate_tail_call): Expect unrenamed return value.
+
+ 2007-09-04 Richard Guenther <rguenther@suse.de>
+ * tree-ssa-operands.c (add_virtual_operand): Only mark
+ stores as has_volatile_ops if alias information is not available.
+
+2007-09-05 Jakub Jelinek <jakub@redhat.com>
+
+ * config/rs6000/tramp.asm: Include config.h.
+ Check __PIC__ or __pic__ macro instead of SHARED.
+
+ PR rtl-optimization/32300
+ * see.c (see_copy_insn): New function.
+ (see_def_extension_not_merged, see_merge_one_use_extension,
+ see_merge_one_def_extension): Use it. Avoid changing
+ PREV_INSN/NEXT_INSN chains directly, insted emit insns
+ into sequences. Call df_insn_delete on temporary insns
+ that won't be emitted into the insn stream.
+ (rest_of_handle_see): Turn off DF_DEFER_INSN_RESCAN
+ and run df_process_deferred_rescans () before run_fast_dce.
+
+ PR tree-optimization/33017
+ * tree-data-ref.c (split_constant_offset) <case SSA_NAME>: Don't
+ recurse for pure or const function calls.
+
+2007-09-04 Laurynas Biveinis <laurynas.biveinis@gmail.com>
+
+ * c-format.c: Include alloc-pool.h.
+ (check_format_info_main): New argument fwt_alloc. Use allocation
+ pool instead of GC. Remove GC deallocation code.
+ (check_format_arg): Create allocation pool, pass it to
+ check_format_info_main and free it afterwards.
+ * Makefile.in (c-format.o): Add alloc-pool.h dependency.
+
+2007-09-05 Ben Elliston <bje@au.ibm.com>
+
+ * config/rs6000/ppu_intrinsics.h (__protected_stream_count):
+ Rename count macro arugment for clarity.
+ (__protected_unlimited_stream_set): Pass UG=1 to __dcbt_TH1000.
+ (__protected_stream_set): Likewise, pass 0.
+
+2007-09-04 Jan Hubicka <jh@suse.cz>
+
+ * tree-tailcall.c (eliminate_tail_call): Expect unrenamed return value.
+
+2007-09-04 Jan Hubicka <jh@suse.cz>
+
+ * invoke.texi (-finline-small-functions): Document.
+ * ipa-inline.c (cgraph_default_inline_p): Do not use DECL_INLINE
+ when deciding what is inlinable.
+ (cgraph_decide_recursive_inlining): Handle flag_inline_functions.
+ (cgraph_decide_inlining_of_small_function): Handle new flags.
+ (cgraph_decide_inlining_incrementally): Likewise.
+ * opts.c (decode_options): Enable flag_inline_small_functions at -O2
+ * common.opt (finline-small-functions): New.
+ * Makefile.in (build/gengtype.o-warn): Work around PR29478
+
+2007-09-04 Richard Guenther <rguenther@suse.de>
+
+ * tree-ssa-operands.c (add_virtual_operand): Only mark
+ stores as has_volatile_ops if alias information is not available.
+
+2007-09-04 Andrew Haley <aph@redhat.com>
+
+ * config/arm/libgcc-bpabi.ver: Add _Unwind_Backtrace as GCC_4.3.0.
+
+2007-09-04 Andrew Haley <aph@redhat.com>
+
+ * config/arm/libunwind.S (UNWIND_WRAPPER _Unwind_Backtrace): New.
+ * config/arm/unwind-arm.h (__gnu_Unwind_Backtrace): New.
+ * config/arm/unwind-arm.c (__gnu_Unwind_Backtrace): New.
+
+2007-09-04 Emmanuel Thome <Emmanuel.Thome@inria.fr>
+
+ PR c++/14178
+ * common.opt: Mention ABI version 2 in comment.
+
+2007-09-04 Jan Hubicka <jh@suse.cz>
+
+ * optabs.c (debug_optab_libfunc): Update; make available to gdb.
+ (libfunc_entry): New structure.
+ (libfunc_hash): New hashtable.
+ (hash_libfunc): New function.
+ (eq_libfunc): New function.
+ (convert_optab_libfunc): New function.
+ (optab_libfunc): New function.
+ (expand_binop, sign_expand_binop, expand_twoval_binop_libfunc,
+ expand_unop, prepare_cmp_insn, prepare_float_insn, gen_add2_insn,
+ expand_float, expand_fix, new_optab, new_convert_optab):
+ Update for new libfunc API.
+ (init_libfunc, init_integral_libfuncs,
+ init_floating_libfuncs, init_interclass_conv_libfuncs
+ init_intraclass_conv_libfuncs): Remove; reorganize all logic to:
+ (gen_libfunc, gen_int_libfunc, gen_fp_libfunc, gen_int_fp_libfunc,
+ gen_intv_fp_libfunc, gen_interclass_conv_libfunc,
+ gen_int_to_fp_conv_libfunc, gen_ufloat_conv_libfunc,
+ gen_int_to_fp_nondecimal_conv_libfunc, gen_fp_to_int_conv_libfunc,
+ gen_intraclass_conv_libfunc, gen_trunc_conv_libfunc,
+ gen_extend_conv_libfunc): New.
+ (init_one_libfunc): Revamp for hashtables.
+ (set_conv_libfunc): Likewise.
+ (init_optabs): Initialize hashtable; use lazy initialization where
+ possible.
+ * optabs.h (optab_handlers): Move out of GGC.
+ (optab, convert_optab): Move out of GGC; add lazy gen info.
+ (code_to_optab, convert_optab_table, optab_table): Move out of GGC.
+ (optab_libfunc, convert_optab_libfunc): New.
+ * builtins.c (expand_builtin_powi): Update for new API.
+ * expr.c (convert_move): Likewise.
+ * expmed.c (expand_divmod): Likewise.
+
+2007-09-04 Daniel Jacobowitz <dan@codesourcery.com>
+
+ * config/rs6000/rs6000.c (rs6000_stack_info): Allocate space for the
+ GOT pointer only if there is a constant pool. Use the allocated space
+ for SPE also.
+
+2007-09-04 Daniel Jacobowitz <dan@codesourcery.com>
+
+ * config/rs6000/linux-unwind.h (ppc_fallback_frame_state): Correct
+ typo for AltiVec.
+
+2007-09-04 Revital Eres <eres@il.ibm.com>
+ Richard Guenther <rguenther@suse.de>
+ R. Clint Whaley <whaley@cs.utsa.edu>
+
+ * doc/invoke.texi (-fassociative-math, -freciprocal-math):
+ Document new flags.
+ * tree-tailcall.c (process_assignment): Use -fassociative-math
+ when reodering operands of floating-point type.
+ * fold-const.c (fold_comparison, fold_binary): Use
+ -fassociative-math and -freciprocal-math instead of
+ -funsafe-math-optimization flag.
+ * toplev.h (set_unsafe_math_optimizations_flags): Declare function.
+ * tree-ssa-math-opts.c (gate_cse_reciprocals): Use
+ -freciprocal-math instead of -funsafe-math-optimizations.
+ * opts.c (set_fast_math_flags): Set -freciprocal-math and
+ -fassociative-math when -ffast-math is set.
+ (set_unsafe_math_optimizations_flags): New Function
+ to set -freciprocal-math and -fassociative-math when
+ -funsafe-math-optimizations is set.
+ (common_handle_option): Call it.
+ * tree-vectorizer.c (vect_is_simple_reduction): Use
+ -fassociative-math when doing reduction on floats.
+ * loop-unroll.c (analyze_insn_to_expand_var): Use
+ -fassociative-math when expanding an accumulator of type float.
+ * simplify-rtx.c (simplify_binary_operation_1): Use
+ -fassociative-math and -freciprocal-math when reordeing operands
+ of floating-point type.
+ * combine.c (combine_simplify_rtx): Likewise.
+ * tree-ssa-reassoc.c (break_up_subtract_bb, reassociate_bb):
+ Likewise.
+ * common.opt (-fassociative-math, -freciprocal-math): New flags.
+
2007-09-04 Paolo Carlini <pcarlini@suse.de>
PR c++/18608
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog.cp 2007-09-04 11:53:30.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/cp/ChangeLog 2007-09-05 03:58:44.000000000 +0000
@@ -1,3 +1,26 @@
+2007-09-04 Jason Merrill <jason@redhat.com>
+
+ PR c++/31419
+ * call.c (reference_binding): Don't look for user-defined conversions
+ to the same type.
+
+ PR c++/31411
+ * except.c (initialize_handler_parm): Put a CLEANUP_POINT_EXPR inside
+ the MUST_NOT_THROW_EXPR.
+
+2007-09-04 Richard Sandiford <richard@codesourcery.com>
+
+ * decl.c (cp_finish_decl): Call determine_visibility before
+ make_rtl_for_nonlocal_decl.
+
+2007-09-04 Jason Merrill <jason@redhat.com>
+
+ PR c++/14032
+ * pt.c (most_specialized_class): Substitute outer template
+ arguments into the arguments of a member template partial
+ specialization.
+ (strip_innermost_template_args): New fn.
+
2007-09-03 Daniel Jacobowitz <dan@codesourcery.com>
* Make-lang.in (g++spec.o): Remove SHLIB_MULTILIB.
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