A recent patch increased GCC's memory consumption!

gcctest@suse.de gcctest@suse.de
Tue Mar 31 12:57:00 GMT 2009


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 allocated via mmap and sbrk increased from 8209k to 8421k, overall 2.58%
  Peak amount of GGC memory allocated before garbage collecting increased from 1289k to 1488k, overall 15.44%
  Peak amount of GGC memory still allocated after garbage collecting increased from 1216k to 1436k, overall 18.09%
  Amount of produced GGC garbage increased from 217k to 219k, overall 1.07%
  Amount of memory still referenced at the end of compilation increased from 1219k to 1536k, overall 25.97%
    Overall memory needed: 8209k -> 8421k
    Peak memory use before GGC: 1289k -> 1488k
    Peak memory use after GGC: 1216k -> 1436k
    Maximum of released memory in single GGC run: 138k -> 87k
    Garbage: 217k -> 219k
    Leak: 1219k -> 1536k
    Overhead: 136k -> 187k
    GGC runs: 3 -> 4
  Amount of produced pre-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced pre-ipa increased from 1222k to 1539k, overall 25.91%
    Pre-IPA-Garbage: 207k -> 209k
    Pre-IPA-Leak: 1222k -> 1539k
    Pre-IPA-Overhead: 135k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced post-ipa increased from 1222k to 1539k, overall 25.91%
    Post-IPA-Garbage: 207k -> 209k
    Post-IPA-Leak: 1222k -> 1539k
    Post-IPA-Overhead: 135k -> 186k

comparing empty function compilation at -O0 -g level:
  Peak amount of GGC memory allocated before garbage collecting increased from 1317k to 1515k, overall 15.03%
  Peak amount of GGC memory still allocated after garbage collecting increased from 1243k to 1464k, overall 17.78%
  Amount of produced GGC garbage increased from 218k to 220k, overall 1.07%
  Amount of memory still referenced at the end of compilation increased from 1252k to 1569k, overall 25.29%
    Overall memory needed: 8453k -> 8445k
    Peak memory use before GGC: 1317k -> 1515k
    Peak memory use after GGC: 1243k -> 1464k
    Maximum of released memory in single GGC run: 133k -> 87k
    Garbage: 218k -> 220k
    Leak: 1252k -> 1569k
    Overhead: 141k -> 191k
    GGC runs: 4
  Amount of produced pre-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced pre-ipa increased from 1222k to 1539k, overall 25.91%
    Pre-IPA-Garbage: 207k -> 209k
    Pre-IPA-Leak: 1222k -> 1539k
    Pre-IPA-Overhead: 135k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced post-ipa increased from 1222k to 1539k, overall 25.91%
    Post-IPA-Garbage: 207k -> 209k
    Post-IPA-Leak: 1222k -> 1539k
    Post-IPA-Overhead: 135k -> 186k

comparing empty function compilation at -O1 level:
  Overall memory allocated via mmap and sbrk increased from 8237k to 8453k, overall 2.62%
  Peak amount of GGC memory allocated before garbage collecting increased from 1289k to 1488k, overall 15.44%
  Peak amount of GGC memory still allocated after garbage collecting increased from 1216k to 1436k, overall 18.09%
  Amount of produced GGC garbage increased from 219k to 222k, overall 1.04%
  Amount of memory still referenced at the end of compilation increased from 1219k to 1536k, overall 25.97%
    Overall memory needed: 8237k -> 8453k
    Peak memory use before GGC: 1289k -> 1488k
    Peak memory use after GGC: 1216k -> 1436k
    Maximum of released memory in single GGC run: 133k -> 90k
    Garbage: 219k -> 222k
    Leak: 1219k -> 1536k
    Overhead: 137k -> 188k
    GGC runs: 4
  Amount of produced pre-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced pre-ipa increased from 1222k to 1539k, overall 25.90%
    Pre-IPA-Garbage: 207k -> 209k
    Pre-IPA-Leak: 1222k -> 1539k
    Pre-IPA-Overhead: 135k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced post-ipa increased from 1222k to 1539k, overall 25.90%
    Post-IPA-Garbage: 207k -> 209k
    Post-IPA-Leak: 1222k -> 1539k
    Post-IPA-Overhead: 135k -> 186k

comparing empty function compilation at -O2 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 1289k to 1488k, overall 15.44%
  Peak amount of GGC memory still allocated after garbage collecting increased from 1216k to 1437k, overall 18.17%
  Amount of produced GGC garbage increased from 225k to 227k, overall 1.03%
  Amount of memory still referenced at the end of compilation increased from 1220k to 1537k, overall 25.96%
    Overall memory needed: 8453k -> 8473k
    Peak memory use before GGC: 1289k -> 1488k
    Peak memory use after GGC: 1216k -> 1437k
    Maximum of released memory in single GGC run: 136k -> 89k
    Garbage: 225k -> 227k
    Leak: 1220k -> 1537k
    Overhead: 138k -> 189k
    GGC runs: 4 -> 5
  Amount of produced pre-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced pre-ipa increased from 1223k to 1540k, overall 25.90%
    Pre-IPA-Garbage: 207k -> 209k
    Pre-IPA-Leak: 1223k -> 1540k
    Pre-IPA-Overhead: 135k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced post-ipa increased from 1223k to 1540k, overall 25.90%
    Post-IPA-Garbage: 207k -> 209k
    Post-IPA-Leak: 1223k -> 1540k
    Post-IPA-Overhead: 135k -> 186k

comparing empty function compilation at -O3 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 1289k to 1488k, overall 15.44%
  Peak amount of GGC memory still allocated after garbage collecting increased from 1216k to 1437k, overall 18.17%
  Amount of produced GGC garbage increased from 225k to 227k, overall 1.03%
  Amount of memory still referenced at the end of compilation increased from 1220k to 1537k, overall 25.96%
    Overall memory needed: 8453k -> 8473k
    Peak memory use before GGC: 1289k -> 1488k
    Peak memory use after GGC: 1216k -> 1437k
    Maximum of released memory in single GGC run: 136k -> 89k
    Garbage: 225k -> 227k
    Leak: 1220k -> 1537k
    Overhead: 138k -> 189k
    GGC runs: 4 -> 5
  Amount of produced pre-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced pre-ipa increased from 1223k to 1540k, overall 25.90%
    Pre-IPA-Garbage: 207k -> 209k
    Pre-IPA-Leak: 1223k -> 1540k
    Pre-IPA-Overhead: 135k -> 186k
  Amount of produced post-ipa-GGC garbage increased from 207k to 209k, overall 1.12%
  Amount of memory referenced post-ipa increased from 1223k to 1540k, overall 25.90%
    Post-IPA-Garbage: 207k -> 209k
    Post-IPA-Leak: 1223k -> 1540k
    Post-IPA-Overhead: 135k -> 186k

comparing combine.c compilation at -O0 level:
  Overall memory allocated via mmap and sbrk increased from 31989k to 33073k, overall 3.39%
  Peak amount of GGC memory allocated before garbage collecting increased from 18016k to 19146k, overall 6.27%
  Peak amount of GGC memory still allocated after garbage collecting increased from 17807k to 18940k, overall 6.36%
  Amount of produced GGC garbage increased from 38927k to 39257k, overall 0.85%
  Amount of memory still referenced at the end of compilation increased from 5798k to 7129k, overall 22.95%
    Overall memory needed: 31989k -> 33073k
    Peak memory use before GGC: 18016k -> 19146k
    Peak memory use after GGC: 17807k -> 18940k
    Maximum of released memory in single GGC run: 1831k -> 1830k
    Garbage: 38927k -> 39257k
    Leak: 5798k -> 7129k
    Overhead: 5545k -> 5777k
    GGC runs: 338 -> 331
  Amount of produced pre-ipa-GGC garbage increased from 12215k to 12797k, overall 4.77%
  Amount of memory referenced pre-ipa increased from 19353k to 20692k, overall 6.92%
    Pre-IPA-Garbage: 12215k -> 12797k
    Pre-IPA-Leak: 19353k -> 20692k
    Pre-IPA-Overhead: 2557k -> 2807k
  Amount of produced post-ipa-GGC garbage increased from 12215k to 12797k, overall 4.77%
  Amount of memory referenced post-ipa increased from 19353k to 20692k, overall 6.92%
    Post-IPA-Garbage: 12215k -> 12797k
    Post-IPA-Leak: 19353k -> 20692k
    Post-IPA-Overhead: 2557k -> 2807k

comparing combine.c compilation at -O0 -g level:
  Overall memory allocated via mmap and sbrk increased from 34009k to 35105k, overall 3.22%
  Peak amount of GGC memory allocated before garbage collecting increased from 19886k to 20988k, overall 5.54%
  Peak amount of GGC memory still allocated after garbage collecting increased from 19663k to 20776k, overall 5.66%
  Amount of produced GGC garbage increased from 39138k to 39475k, overall 0.86%
  Amount of memory still referenced at the end of compilation increased from 9087k to 10415k, overall 14.61%
    Overall memory needed: 34009k -> 35105k
    Peak memory use before GGC: 19886k -> 20988k
    Peak memory use after GGC: 19663k -> 20776k
    Maximum of released memory in single GGC run: 1841k -> 1839k
    Garbage: 39138k -> 39475k
    Leak: 9087k -> 10415k
    Overhead: 6363k -> 6588k
    GGC runs: 320 -> 315
  Amount of produced pre-ipa-GGC garbage increased from 12233k to 12816k, overall 4.76%
  Amount of memory referenced pre-ipa increased from 21626k to 22939k, overall 6.07%
    Pre-IPA-Garbage: 12233k -> 12816k
    Pre-IPA-Leak: 21626k -> 22939k
    Pre-IPA-Overhead: 3047k -> 3289k
  Amount of produced post-ipa-GGC garbage increased from 12233k to 12816k, overall 4.76%
  Amount of memory referenced post-ipa increased from 21626k to 22939k, overall 6.07%
    Post-IPA-Garbage: 12233k -> 12816k
    Post-IPA-Leak: 21626k -> 22939k
    Post-IPA-Overhead: 3047k -> 3289k

comparing combine.c compilation at -O1 level:
  Overall memory allocated via mmap and sbrk increased from 30601k to 31817k, overall 3.97%
  Peak amount of GGC memory allocated before garbage collecting increased from 15684k to 16815k, overall 7.21%
  Peak amount of GGC memory still allocated after garbage collecting increased from 15511k to 16643k, overall 7.30%
  Amount of produced GGC garbage increased from 46454k to 46852k, overall 0.86%
  Amount of memory still referenced at the end of compilation increased from 5778k to 7114k, overall 23.12%
    Overall memory needed: 30601k -> 31817k
    Peak memory use before GGC: 15684k -> 16815k
    Peak memory use after GGC: 15511k -> 16643k
    Maximum of released memory in single GGC run: 1340k -> 1390k
    Garbage: 46454k -> 46852k
    Leak: 5778k -> 7114k
    Overhead: 6143k -> 6390k
    GGC runs: 403 -> 394
  Amount of produced pre-ipa-GGC garbage increased from 13039k to 13630k, overall 4.53%
  Amount of memory referenced pre-ipa increased from 16848k to 18183k, overall 7.93%
    Pre-IPA-Garbage: 13039k -> 13630k
    Pre-IPA-Leak: 16848k -> 18183k
    Pre-IPA-Overhead: 2469k -> 2720k
  Amount of produced post-ipa-GGC garbage increased from 13039k to 13630k, overall 4.53%
  Amount of memory referenced post-ipa increased from 16848k to 18183k, overall 7.93%
    Post-IPA-Garbage: 13039k -> 13630k
    Post-IPA-Leak: 16848k -> 18183k
    Post-IPA-Overhead: 2469k -> 2720k

comparing combine.c compilation at -O2 level:
  Overall memory allocated via mmap and sbrk increased from 31645k to 33101k, overall 4.60%
  Peak amount of GGC memory allocated before garbage collecting increased from 15830k to 16970k, overall 7.20%
  Peak amount of GGC memory still allocated after garbage collecting increased from 15670k to 16802k, overall 7.22%
  Amount of produced GGC garbage increased from 60423k to 60713k, overall 0.48%
  Amount of memory still referenced at the end of compilation increased from 5808k to 7150k, overall 23.11%
    Overall memory needed: 31645k -> 33101k
    Peak memory use before GGC: 15830k -> 16970k
    Peak memory use after GGC: 15670k -> 16802k
    Maximum of released memory in single GGC run: 1351k -> 1352k
    Garbage: 60423k -> 60713k
    Leak: 5808k -> 7150k
    Overhead: 8198k -> 8427k
    GGC runs: 467 -> 454
  Amount of produced pre-ipa-GGC garbage increased from 13181k to 13771k, overall 4.48%
  Amount of memory referenced pre-ipa increased from 16929k to 18265k, overall 7.89%
    Pre-IPA-Garbage: 13181k -> 13771k
    Pre-IPA-Leak: 16929k -> 18265k
    Pre-IPA-Overhead: 2489k -> 2740k
  Amount of produced post-ipa-GGC garbage increased from 13181k to 13771k, overall 4.48%
  Amount of memory referenced post-ipa increased from 16929k to 18265k, overall 7.89%
    Post-IPA-Garbage: 13181k -> 13771k
    Post-IPA-Leak: 16929k -> 18265k
    Post-IPA-Overhead: 2489k -> 2740k

comparing combine.c compilation at -O3 level:
  Overall memory allocated via mmap and sbrk increased from 32233k to 33341k, overall 3.44%
  Peak amount of GGC memory allocated before garbage collecting increased from 15984k to 17054k, overall 6.69%
  Peak amount of GGC memory still allocated after garbage collecting increased from 15749k to 16830k, overall 6.86%
  Amount of memory still referenced at the end of compilation increased from 7176k to 8510k, overall 18.59%
    Overall memory needed: 32233k -> 33341k
    Peak memory use before GGC: 15984k -> 17054k
    Peak memory use after GGC: 15749k -> 16830k
    Maximum of released memory in single GGC run: 1637k -> 1636k
    Garbage: 73270k -> 73204k
    Leak: 7176k -> 8510k
    Overhead: 9702k -> 9887k
    GGC runs: 497 -> 481
  Amount of produced pre-ipa-GGC garbage increased from 13181k to 13771k, overall 4.48%
  Amount of memory referenced pre-ipa increased from 16929k to 18265k, overall 7.89%
    Pre-IPA-Garbage: 13181k -> 13771k
    Pre-IPA-Leak: 16929k -> 18265k
    Pre-IPA-Overhead: 2489k -> 2740k
  Amount of produced post-ipa-GGC garbage increased from 13181k to 13771k, overall 4.48%
  Amount of memory referenced post-ipa increased from 16929k to 18265k, overall 7.89%
    Post-IPA-Garbage: 13181k -> 13771k
    Post-IPA-Leak: 16929k -> 18265k
    Post-IPA-Overhead: 2489k -> 2740k

comparing insn-attrtab.c compilation at -O0 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 64851k to 65278k, overall 0.66%
  Peak amount of GGC memory still allocated after garbage collecting increased from 53783k to 54202k, overall 0.78%
  Amount of produced GGC garbage increased from 128371k to 130788k, overall 1.88%
  Amount of memory still referenced at the end of compilation increased from 8360k to 9534k, overall 14.04%
    Overall memory needed: 155297k -> 155589k
    Peak memory use before GGC: 64851k -> 65278k
    Peak memory use after GGC: 53783k -> 54202k
    Maximum of released memory in single GGC run: 26838k -> 26945k
    Garbage: 128371k -> 130788k
    Leak: 8360k -> 9534k
    Overhead: 16863k -> 17084k
    GGC runs: 262 -> 258
  Amount of produced pre-ipa-GGC garbage increased from 36903k to 41128k, overall 11.45%
  Amount of memory referenced pre-ipa increased from 55351k to 56618k, overall 2.29%
    Pre-IPA-Garbage: 36903k -> 41128k
    Pre-IPA-Leak: 55351k -> 56618k
    Pre-IPA-Overhead: 8222k -> 8456k
  Amount of produced post-ipa-GGC garbage increased from 36903k to 41128k, overall 11.45%
  Amount of memory referenced post-ipa increased from 55351k to 56618k, overall 2.29%
    Post-IPA-Garbage: 36903k -> 41128k
    Post-IPA-Leak: 55351k -> 56618k
    Post-IPA-Overhead: 8222k -> 8456k

comparing insn-attrtab.c compilation at -O0 -g level:
  Peak amount of GGC memory allocated before garbage collecting increased from 66128k to 66543k, overall 0.63%
  Peak amount of GGC memory still allocated after garbage collecting increased from 55061k to 55465k, overall 0.73%
  Amount of produced GGC garbage increased from 128696k to 131123k, overall 1.89%
  Amount of memory still referenced at the end of compilation increased from 10011k to 11165k, overall 11.53%
    Overall memory needed: 156581k -> 156869k
    Peak memory use before GGC: 66128k -> 66543k
    Peak memory use after GGC: 55061k -> 55465k
    Maximum of released memory in single GGC run: 26838k -> 26946k
    Garbage: 128696k -> 131123k
    Leak: 10011k -> 11165k
    Overhead: 17319k -> 17536k
    GGC runs: 257 -> 252
  Amount of produced pre-ipa-GGC garbage increased from 36911k to 41136k, overall 11.45%
  Amount of memory referenced pre-ipa increased from 56892k to 58142k, overall 2.20%
    Pre-IPA-Garbage: 36911k -> 41136k
    Pre-IPA-Leak: 56892k -> 58142k
    Pre-IPA-Overhead: 8557k -> 8786k
  Amount of produced post-ipa-GGC garbage increased from 36911k to 41136k, overall 11.45%
  Amount of memory referenced post-ipa increased from 56892k to 58142k, overall 2.20%
    Post-IPA-Garbage: 36911k -> 41136k
    Post-IPA-Leak: 56892k -> 58142k
    Post-IPA-Overhead: 8557k -> 8786k

comparing insn-attrtab.c compilation at -O1 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 49848k to 50567k, overall 1.44%
  Peak amount of GGC memory still allocated after garbage collecting increased from 43292k to 44000k, overall 1.64%
  Amount of produced GGC garbage increased from 178949k to 181785k, overall 1.58%
  Amount of memory still referenced at the end of compilation increased from 7736k to 8913k, overall 15.21%
    Overall memory needed: 133309k -> 132465k
    Peak memory use before GGC: 49848k -> 50567k
    Peak memory use after GGC: 43292k -> 44000k
    Maximum of released memory in single GGC run: 23087k -> 20902k
    Garbage: 178949k -> 181785k
    Leak: 7736k -> 8913k
    Overhead: 24924k -> 25161k
    GGC runs: 299
  Amount of produced pre-ipa-GGC garbage increased from 42194k to 46515k, overall 10.24%
  Amount of memory referenced pre-ipa increased from 42949k to 44164k, overall 2.83%
    Pre-IPA-Garbage: 42194k -> 46515k
    Pre-IPA-Leak: 42949k -> 44164k
    Pre-IPA-Overhead: 7641k -> 7876k
  Amount of produced post-ipa-GGC garbage increased from 42194k to 46515k, overall 10.24%
  Amount of memory referenced post-ipa increased from 42949k to 44164k, overall 2.83%
    Post-IPA-Garbage: 42194k -> 46515k
    Post-IPA-Leak: 42949k -> 44164k
    Post-IPA-Overhead: 7641k -> 7876k

comparing insn-attrtab.c compilation at -O2 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 49813k to 50626k, overall 1.63%
  Peak amount of GGC memory still allocated after garbage collecting increased from 44951k to 45042k, overall 0.20%
  Amount of produced GGC garbage increased from 202596k to 205684k, overall 1.52%
  Amount of memory still referenced at the end of compilation increased from 15399k to 16575k, overall 7.64%
    Overall memory needed: 148657k -> 147133k
    Peak memory use before GGC: 49813k -> 50626k
    Peak memory use after GGC: 44951k -> 45042k
    Maximum of released memory in single GGC run: 18102k -> 17007k
    Garbage: 202596k -> 205684k
    Leak: 15399k -> 16575k
    Overhead: 30421k -> 30649k
    GGC runs: 326 -> 325
  Amount of produced pre-ipa-GGC garbage increased from 42262k to 46583k, overall 10.22%
  Amount of memory referenced pre-ipa increased from 42956k to 44172k, overall 2.83%
    Pre-IPA-Garbage: 42262k -> 46583k
    Pre-IPA-Leak: 42956k -> 44172k
    Pre-IPA-Overhead: 7650k -> 7885k
  Amount of produced post-ipa-GGC garbage increased from 42262k to 46583k, overall 10.22%
  Amount of memory referenced post-ipa increased from 42956k to 44172k, overall 2.83%
    Post-IPA-Garbage: 42262k -> 46583k
    Post-IPA-Leak: 42956k -> 44172k
    Post-IPA-Overhead: 7650k -> 7885k

comparing insn-attrtab.c compilation at -O3 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 61633k to 62451k, overall 1.33%
  Peak amount of GGC memory still allocated after garbage collecting increased from 58663k to 59481k, overall 1.39%
  Amount of produced GGC garbage increased from 240476k to 243592k, overall 1.30%
  Amount of memory still referenced at the end of compilation increased from 7762k to 8937k, overall 15.13%
    Overall memory needed: 164629k -> 164757k
    Peak memory use before GGC: 61633k -> 62451k
    Peak memory use after GGC: 58663k -> 59481k
    Maximum of released memory in single GGC run: 24089k -> 18461k
    Garbage: 240476k -> 243592k
    Leak: 7762k -> 8937k
    Overhead: 33890k -> 34116k
    GGC runs: 338 -> 336
  Amount of produced pre-ipa-GGC garbage increased from 42262k to 46583k, overall 10.22%
  Amount of memory referenced pre-ipa increased from 42956k to 44172k, overall 2.83%
    Pre-IPA-Garbage: 42262k -> 46583k
    Pre-IPA-Leak: 42956k -> 44172k
    Pre-IPA-Overhead: 7650k -> 7885k
  Amount of produced post-ipa-GGC garbage increased from 42262k to 46583k, overall 10.22%
  Amount of memory referenced post-ipa increased from 42956k to 44172k, overall 2.83%
    Post-IPA-Garbage: 42262k -> 46583k
    Post-IPA-Leak: 42956k -> 44172k
    Post-IPA-Overhead: 7650k -> 7885k

comparing Gerald's testcase PR8361 compilation at -O0 level:
  Amount of memory still referenced at the end of compilation increased from 51651k to 51860k, overall 0.40%
    Overall memory needed: 149156k -> 148122k
    Peak memory use before GGC: 81836k -> 80916k
    Peak memory use after GGC: 81023k -> 80110k
    Maximum of released memory in single GGC run: 14705k -> 14425k
    Garbage: 200213k -> 199359k
    Leak: 51651k -> 51860k
    Overhead: 27478k -> 27946k
    GGC runs: 411 -> 451
  Amount of produced pre-ipa-GGC garbage increased from 109676k to 110153k, overall 0.43%
    Pre-IPA-Garbage: 109676k -> 110153k
    Pre-IPA-Leak: 87149k -> 86538k
    Pre-IPA-Overhead: 14609k -> 15181k
  Amount of produced post-ipa-GGC garbage increased from 109676k to 110153k, overall 0.43%
    Post-IPA-Garbage: 109676k -> 110153k
    Post-IPA-Leak: 87149k -> 86538k
    Post-IPA-Overhead: 14609k -> 15181k

comparing Gerald's testcase PR8361 compilation at -O0 -g level:
    Overall memory needed: 167212k -> 165958k
    Peak memory use before GGC: 95416k -> 94647k
    Peak memory use after GGC: 94471k -> 93709k
    Maximum of released memory in single GGC run: 14897k -> 15100k
    Garbage: 205232k -> 204369k
    Leak: 78505k -> 78354k
    Overhead: 34164k -> 34511k
    GGC runs: 384 -> 418
  Amount of produced pre-ipa-GGC garbage increased from 110041k to 110518k, overall 0.43%
    Pre-IPA-Garbage: 110041k -> 110518k
    Pre-IPA-Leak: 103668k -> 103028k
    Pre-IPA-Overhead: 18114k -> 18676k
  Amount of produced post-ipa-GGC garbage increased from 110041k to 110518k, overall 0.43%
    Post-IPA-Garbage: 110041k -> 110518k
    Post-IPA-Leak: 103668k -> 103028k
    Post-IPA-Overhead: 18114k -> 18676k

comparing Gerald's testcase PR8361 compilation at -O1 level:
  Amount of memory still referenced at the end of compilation increased from 48118k to 48446k, overall 0.68%
    Overall memory needed: 104299k -> 104776k
    Peak memory use before GGC: 79795k -> 78815k
    Peak memory use after GGC: 79004k -> 78028k
    Maximum of released memory in single GGC run: 14368k -> 14455k
    Garbage: 265045k -> 261881k
    Leak: 48118k -> 48446k
    Overhead: 30532k -> 30760k
    GGC runs: 491 -> 529
    Pre-IPA-Garbage: 153114k -> 153197k
    Pre-IPA-Leak: 82623k -> 81956k
    Pre-IPA-Overhead: 18853k -> 19367k
    Post-IPA-Garbage: 153114k -> 153197k
    Post-IPA-Leak: 82623k -> 81956k
    Post-IPA-Overhead: 18853k -> 19367k

comparing Gerald's testcase PR8361 compilation at -O2 level:
  Amount of memory still referenced at the end of compilation increased from 48143k to 48450k, overall 0.64%
    Overall memory needed: 104719k -> 105168k
    Peak memory use before GGC: 79886k -> 78934k
    Peak memory use after GGC: 79093k -> 78135k
    Maximum of released memory in single GGC run: 14371k -> 14449k
    Garbage: 319248k -> 318095k
    Leak: 48143k -> 48450k
    Overhead: 37087k -> 37596k
    GGC runs: 565 -> 606
  Amount of produced pre-ipa-GGC garbage increased from 156986k to 157545k, overall 0.36%
    Pre-IPA-Garbage: 156986k -> 157545k
    Pre-IPA-Leak: 81975k -> 81413k
    Pre-IPA-Overhead: 19245k -> 19838k
  Amount of produced post-ipa-GGC garbage increased from 156986k to 157545k, overall 0.36%
    Post-IPA-Garbage: 156986k -> 157545k
    Post-IPA-Leak: 81975k -> 81413k
    Post-IPA-Overhead: 19245k -> 19838k

comparing Gerald's testcase PR8361 compilation at -O3 level:
  Amount of memory still referenced at the end of compilation increased from 48163k to 48455k, overall 0.61%
    Overall memory needed: 105083k -> 105408k
    Peak memory use before GGC: 79886k -> 78934k
    Peak memory use after GGC: 79093k -> 78135k
    Maximum of released memory in single GGC run: 14371k -> 14449k
    Garbage: 350786k -> 350740k
    Leak: 48163k -> 48455k
    Overhead: 40447k -> 41146k
    GGC runs: 596 -> 643
  Amount of produced pre-ipa-GGC garbage increased from 157048k to 157607k, overall 0.36%
    Pre-IPA-Garbage: 157048k -> 157607k
    Pre-IPA-Leak: 82412k -> 81848k
    Pre-IPA-Overhead: 19280k -> 19873k
  Amount of produced post-ipa-GGC garbage increased from 157048k to 157607k, overall 0.36%
    Post-IPA-Garbage: 157048k -> 157607k
    Post-IPA-Leak: 82412k -> 81848k
    Post-IPA-Overhead: 19280k -> 19873k

comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
  Amount of memory still referenced at the end of compilation increased from 7236k to 8223k, overall 13.64%
    Overall memory needed: 362427k -> 358169k
    Peak memory use before GGC: 78666k -> 76702k
    Peak memory use after GGC: 49600k -> 49081k
    Maximum of released memory in single GGC run: 37952k -> 36523k
    Garbage: 142896k -> 140421k
    Leak: 7236k -> 8223k
    Overhead: 25331k -> 24579k
    GGC runs: 87 -> 86
  Amount of produced pre-ipa-GGC garbage increased from 12169k to 13179k, overall 8.30%
  Amount of memory referenced pre-ipa increased from 20189k to 20665k, overall 2.36%
    Pre-IPA-Garbage: 12169k -> 13179k
    Pre-IPA-Leak: 20189k -> 20665k
    Pre-IPA-Overhead: 2241k -> 2350k
  Amount of produced post-ipa-GGC garbage increased from 12169k to 13179k, overall 8.30%
  Amount of memory referenced post-ipa increased from 20189k to 20665k, overall 2.36%
    Post-IPA-Garbage: 12169k -> 13179k
    Post-IPA-Leak: 20189k -> 20665k
    Post-IPA-Overhead: 2241k -> 2350k

comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
  Amount of memory still referenced at the end of compilation increased from 9278k to 10219k, overall 10.14%
    Overall memory needed: 363223k -> 358845k
    Peak memory use before GGC: 79363k -> 77385k
    Peak memory use after GGC: 50297k -> 49765k
    Maximum of released memory in single GGC run: 37936k -> 36507k
    Garbage: 142961k -> 140554k
    Leak: 9278k -> 10219k
    Overhead: 25914k -> 25161k
    GGC runs: 93
  Amount of produced pre-ipa-GGC garbage increased from 12171k to 13181k, overall 8.30%
  Amount of memory referenced pre-ipa increased from 20437k to 20911k, overall 2.32%
    Pre-IPA-Garbage: 12171k -> 13181k
    Pre-IPA-Leak: 20437k -> 20911k
    Pre-IPA-Overhead: 2295k -> 2403k
  Amount of produced post-ipa-GGC garbage increased from 12171k to 13181k, overall 8.30%
  Amount of memory referenced post-ipa increased from 20437k to 20911k, overall 2.32%
    Post-IPA-Garbage: 12171k -> 13181k
    Post-IPA-Leak: 20437k -> 20911k
    Post-IPA-Overhead: 2295k -> 2403k

comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 72350k to 72761k, overall 0.57%
  Peak amount of GGC memory still allocated after garbage collecting increased from 66141k to 66552k, overall 0.62%
  Amount of produced GGC garbage increased from 214749k to 215300k, overall 0.26%
  Amount of memory still referenced at the end of compilation increased from 7613k to 8163k, overall 7.22%
    Overall memory needed: 226369k -> 225901k
    Peak memory use before GGC: 72350k -> 72761k
    Peak memory use after GGC: 66141k -> 66552k
    Maximum of released memory in single GGC run: 32063k -> 32083k
    Garbage: 214749k -> 215300k
    Leak: 7613k -> 8163k
    Overhead: 30605k -> 30610k
    GGC runs: 95 -> 96
  Amount of produced pre-ipa-GGC garbage increased from 45532k to 46590k, overall 2.32%
  Amount of memory referenced pre-ipa increased from 62930k to 63488k, overall 0.89%
    Pre-IPA-Garbage: 45532k -> 46590k
    Pre-IPA-Leak: 62930k -> 63488k
    Pre-IPA-Overhead: 8724k -> 8911k
  Amount of produced post-ipa-GGC garbage increased from 45532k to 46590k, overall 2.32%
  Amount of memory referenced post-ipa increased from 62930k to 63488k, overall 0.89%
    Post-IPA-Garbage: 45532k -> 46590k
    Post-IPA-Leak: 62930k -> 63488k
    Post-IPA-Overhead: 8724k -> 8911k

comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
  Peak amount of GGC memory allocated before garbage collecting increased from 72351k to 72761k, overall 0.57%
  Peak amount of GGC memory still allocated after garbage collecting increased from 66142k to 66552k, overall 0.62%
  Amount of produced GGC garbage increased from 256350k to 256906k, overall 0.22%
  Amount of memory still referenced at the end of compilation increased from 7614k to 8164k, overall 7.22%
    Overall memory needed: 492809k -> 495741k
    Peak memory use before GGC: 72351k -> 72761k
    Peak memory use after GGC: 66142k -> 66552k
    Maximum of released memory in single GGC run: 33399k -> 33418k
    Garbage: 256350k -> 256906k
    Leak: 7614k -> 8164k
    Overhead: 38675k -> 38682k
    GGC runs: 105 -> 104
  Amount of produced pre-ipa-GGC garbage increased from 102815k to 103873k, overall 1.03%
  Amount of memory referenced pre-ipa increased from 71658k to 72280k, overall 0.87%
    Pre-IPA-Garbage: 102815k -> 103873k
    Pre-IPA-Leak: 71658k -> 72280k
    Pre-IPA-Overhead: 14333k -> 14592k
  Amount of produced post-ipa-GGC garbage increased from 102815k to 103873k, overall 1.03%
  Amount of memory referenced post-ipa increased from 71658k to 72280k, overall 0.87%
    Post-IPA-Garbage: 102815k -> 103873k
    Post-IPA-Leak: 71658k -> 72280k
    Post-IPA-Overhead: 14333k -> 14592k

comparing PR rtl-optimization/28071 testcase compilation at -O3 -fno-tree-pre -fno-tree-fre level:
  Peak amount of GGC memory allocated before garbage collecting increased from 135542k to 135945k, overall 0.30%
  Peak amount of GGC memory still allocated after garbage collecting increased from 125371k to 125774k, overall 0.32%
  Amount of produced GGC garbage increased from 347813k to 348859k, overall 0.30%
  Amount of memory still referenced at the end of compilation increased from 9097k to 9720k, overall 6.85%
    Overall memory needed: 1021565k -> 1021697k
    Peak memory use before GGC: 135542k -> 135945k
    Peak memory use after GGC: 125371k -> 125774k
    Maximum of released memory in single GGC run: 62793k -> 62907k
    Garbage: 347813k -> 348859k
    Leak: 9097k -> 9720k
    Overhead: 44904k -> 45148k
    GGC runs: 101
  Amount of produced pre-ipa-GGC garbage increased from 102815k to 103873k, overall 1.03%
  Amount of memory referenced pre-ipa increased from 71658k to 72280k, overall 0.87%
    Pre-IPA-Garbage: 102815k -> 103873k
    Pre-IPA-Leak: 71658k -> 72280k
    Pre-IPA-Overhead: 14333k -> 14592k
  Amount of produced post-ipa-GGC garbage increased from 102815k to 103873k, overall 1.03%
  Amount of memory referenced post-ipa increased from 71658k to 72280k, overall 0.87%
    Post-IPA-Garbage: 102815k -> 103873k
    Post-IPA-Leak: 71658k -> 72280k
    Post-IPA-Overhead: 14333k -> 14592k

Head of the ChangeLog is:

--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog	2009-03-08 19:37:50.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog	2009-03-31 09:44:28.000000000 +0000
@@ -1,3 +1,1682 @@
+2009-03-31  Ayal Zaks  <zaks@il.ibm.com>
+
+	* modulo-sched.c (sms_schedule_by_order): Pass the actual
+	schedulable rows to compute_split_row.
+
+2009-03-31  Ben Elliston  <bje@au.ibm.com>
+
+	PR target/31635
+	* config/rs6000/rs6000.c (rs6000_handle_option): Handle
+	OPT_mvrsave.
+
+2009-03-31  Alan Modra  <amodra@bigpond.net.au>
+
+	* doc/invoke.texi (RS/6000 and PowerPC Options):Document mtls-markers.
+	* configure.ac (HAVE_AS_TLS_MARKERS): New gas feature check.
+	* configure: Regenerate.
+	* config.in: Regenerate.
+	* config/rs6000/rs6000.opt (mtls-markers): Add.
+	* config/rs6000/rs6000.h (TARGET_TLS_MARKERS): Define.
+	* config/rs6000/rs6000.md (tls_gd_aix, tls_gd_sysv): Add splitter.
+	(tls_ld_aix, tls_ld_sysv): Likewise.
+	(tls_gd, tls_gd_call_aix, tls_gd_call_sysv): New insns.
+	(tls_ld, tls_ld_call_aix, tls_ld_call_sysv): Likewise.
+
+2009-03-31  Alan Modra  <amodra@bigpond.net.au>
+
+	* config/spu/spu.c (spu_expand_prologue): Delete redundant code.
+
+2009-03-30  Jan Hubicka  <jh@suse.cz>
+
+	* tree-eh.c (make_eh_edges): Set probability 100% to first edge
+	out of RESX.
+	(tree_remove_unreachable_handlers): Cleanup EH predecestor
+	detection and label handling.
+
+2009-03-30  Vladimir Makarov  <vmakarov@redhat.com>
+
+	* ira-int.h (ira_allocno): Rename left_conflicts_num to
+	left_conflicts_size.
+	(ALLOCNO_LEFT_CONFLICTS_NUM): Rename to
+	ALLOCNO_LEFT_CONFLICTS_SIZE.
+
+	* ira-color.c (allocno_spill_priority, push_allocno_to_stack,
+	remove_allocno_from_bucket_and_push,
+	allocno_spill_priority_compare, push_allocnos_to_stack,
+	setup_allocno_available_regs_num): Use ALLOCNO_LEFT_CONFLICTS_SIZE
+	instead of ALLOCNO_LEFT_CONFLICTS_NUM.
+	(setup_allocno_left_conflicts_num): Ditto.  Rename to
+	setup_allocno_left_conflicts_size.
+	(put_allocno_into_bucket): Use ALLOCNO_LEFT_CONFLICTS_SIZE
+	instead of ALLOCNO_LEFT_CONFLICTS_NUM and
+	setup_allocno_left_conflicts_size instead of
+	setup_allocno_left_conflicts_num.
+
+	* ira-build.c (ira_create_allocno): Use
+	ALLOCNO_LEFT_CONFLICTS_SIZE instead of
+	ALLOCNO_LEFT_CONFLICTS_NUM.
+		
+2009-03-30  Vladimir Makarov  <vmakarov@redhat.com>
+
+	* reload.c (push_reload, find_dummy_reload): Use df_get_live_out
+	instead of DF_LR_OUT.
+
+	* ira-lives.c (process_bb_node_lives): Ditto.
+
+	* ira-color.c (ira_loop_edge_freq): Use df_get_live_{out,in}
+	instead of DF_LR_{OUT,IN}.
+
+	* ira-emit.c (generate_edge_moves, add_ranges_and_copies): Ditto.
+
+	* ira-build.c (create_bb_allocnos, create_loop_allocnos): Ditto.
+
+2009-03-30  Jan Hubicka  <jh@suse.cz>
+
+	* except.c (label_to_region_map): Fix thinko.
+
+2009-03-30  Steve Ellcey  <sje@cup.hp.com>
+
+	PR middle-end/38237
+	* tree.h (tree_find_value): New declaration.
+	* tree.c (tree_find_value): New function.
+	* varasm.c (assemble_external): Avoid duplicate entries on lists.
+
+2009-03-30  Jakub Jelinek  <jakub@redhat.com>
+
+	PR debug/39563
+	* c-decl.c (struct c_binding): Add locus field.
+	(bind): Add locus argument, set locus field from it.
+	(pop_scope): For b->nested VAR_DECL or FUNCTION_DECL,
+	add a DECL_EXTERNAL copy of b->decl to current BLOCK_VARS.
+	(push_file_scope, pushtag, pushdecl, pushdecl_top_level,
+	implicitly_declare, undeclared_variable, lookup_label,
+	declare_label, c_make_fname_decl, c_builtin_function,
+	c_builtin_function_ext_scope, store_parm_decls_newstyle): Adjust
+	bind callers.
+
+2008-03-30  H.J. Lu  <hongjiu.lu@intel.com>
+
+	PR target/38781
+	* config/i386/i386.c (classify_argument): Check total size of
+	structure.
+
+2009-03-30  Martin Jambor  <mjambor@suse.cz>
+
+	* ipa-prop.h (jump_func_type): Rename IPA_UNKNOWN, IPA_CONST,
+	IPA_CONST_MEMBER_PTR, and IPA_PASS_THROUGH to IPA_JF_UNKNOWN,
+	IPA_JF_CONST, IPA_JF_CONST_MEMBER_PTR, and IPA_JF_PASS_THROUGH
+	respectively.
+
+	* tree-dfa.c (get_ref_base_and_extent): Return -1 maxsize if
+	seen_variable_array_ref while also traversing a union.
+
+	* tree-inline.c (optimize_inline_calls): Do not call
+	cgraph_node_remove_callees.
+	* cgraphbuild.c (remove_cgraph_callee_edges): New function.
+	(pass_remove_cgraph_callee_edges): New variable.
+	* passes.c (init_optimization_passes): Add
+	pass_remove_cgraph_callee_edges after early inlining and before all
+	late intraprocedural passes.
+
+	* omp-low.c (expand_omp_taskreg): Always set current_function_decl.
+
+2009-03-30  Paolo Bonzini  <bonzini@gnu.org>
+
+	* config/sparc/sparc.md (*nand<V64mode>_vis, *nand<V32mode>_vis):
+	Fix typos in names.
+
+2009-03-30  Paolo Bonzini  <bonzini@gnu.org>
+
+        * combine.c (simplify_comparison): Use have_insn_for.
+        * dojump.c (do_jump): Likewise.
+
+2009-03-30  Paolo Bonzini  <bonzini@gnu.org>
+
+	* config/sparc/sparc.c (sparc_compare_emitted): Remove.
+	(gen_compare_reg, emit_v9_brxx_insn): Handle MODE_CC
+	sparc_compare_op0 like sparc_compare_emitted used to be handled.
+	(sparc_expand_compare_and_swap_12): Set sparc_compare_op0
+	instead of sparc_compare_emitted.
+	* config/sparc/sparc.h (sparc_compare_emitted): Remove.
+	* config/sparc/sparc.md (stack_protect_test): Set sparc_compare_op0
+	instead of sparc_compare_emitted.
+
+2009-03-30  Paolo Bonzini  <bonzini@gnu.org>
+
+	* bb-reorder.c (partition_hot_cold_basic_blocks): Do not
+	enter/exit cfglayout mode.
+	(pass_partition_block): Require it.
+	* combine.c (find_single_use, reg_dead_at_p): Use CFG.
+	(combine_instructions): Track basic blocks instead of labels.
+	(update_cfg_for_uncondjump): New.
+	(try_combine): Use it.  Update jumps after rescanning.
+	(pass_combine): Require PROP_cfglayout.
+	* passes.c (pass_outof_cfg_layout_mode): Move after regmove.
+
+2009-03-30  Paolo Bonzini  <bonzini@gnu.org>
+
+        * cfglayout.c (pass_into_cfg_layout_mode, pass_outof_cfg_layout_mode):
+        Provide/destroy PROP_cfglayout respectively.
+        * gcse.c (pass_jump_bypass, pass_gcse): Require it.
+        * tree-pass.h (PROP_cfglayout): New.
+
+2009-03-30  Paolo Bonzini  <bonzini@gnu.org>
+
+	* fold-const.c (const_binop, fold_convert_const_real_from_fixed,
+	fold_convert_const_fixed_from_fixed,
+	fold_convert_const_fixed_from_int,
+	fold_convert_const_fixed_from_real, fold_negate_const): Do not
+	set TREE_CONSTANT_OVERFLOW.
+	* tree.def: Remove mention of TREE_CONSTANT_OVERFLOW.
+	* tree.h (TREE_CONSTANT_OVERFLOW): Delete.
+
+2009-03-30  Ira Rosen  <irar@il.ibm.com>
+
+	* tree-vect-loop-manip.c: New file.
+	* tree-vectorizer.c: Update documentation and included files.
+	(vect_loop_location): Make extern.
+	(rename_use_op): Move to tree-vect-loop-manip.c
+	(rename_variables_in_bb, rename_variables_in_loop, 
+	slpeel_update_phis_for_duplicate_loop, 
+	slpeel_update_phi_nodes_for_guard1,
+	slpeel_update_phi_nodes_for_guard2, slpeel_make_loop_iterate_ntimes,
+	slpeel_tree_duplicate_loop_to_edge_cfg, slpeel_add_loop_guard,
+	slpeel_can_duplicate_loop_p, slpeel_verify_cfg_after_peeling,
+	set_prologue_iterations, slpeel_tree_peel_loop_to_edge, 
+	find_loop_location): Likewise.
+	(new_stmt_vec_info): Move to tree-vect-stmts.c.
+	(init_stmt_vec_info_vec, free_stmt_vec_info_vec, free_stmt_vec_info,
+	get_vectype_for_scalar_type, vect_is_simple_use,
+	supportable_widening_operation, supportable_narrowing_operation):
+	Likewise.
+	(bb_in_loop_p): Move to tree-vect-loop.c.
+	(new_loop_vec_info, destroy_loop_vec_info, 
+	reduction_code_for_scalar_code, report_vect_op, 
+	vect_is_simple_reduction, vect_is_simple_iv_evolution): Likewise.
+	(vect_can_force_dr_alignment_p): Move to tree-vect-data-refs.c.
+	(vect_supportable_dr_alignment): Likewise.
+	* tree-vectorizer.h (tree-data-ref.h): Include.
+	(vect_loop_location): Declare.
+	Reorganize function declarations according to the new file structure.
+	* tree-vect-loop.c: New file.
+	* tree-vect-analyze.c: Remove. Move functions to tree-vect-data-refs.c, 
+	tree-vect-stmts.c, tree-vect-slp.c, tree-vect-loop.c.
+	* tree-vect-data-refs.c: New file.
+	* tree-vect-patterns.c (timevar.h): Don't include.
+	* tree-vect-stmts.c: New file.
+	* tree-vect-transform.c: Remove. Move functions to tree-vect-stmts.c, 
+	tree-vect-slp.c, tree-vect-loop.c.
+	* Makefile.in (OBJS-common): Remove tree-vect-analyze.o and 
+	tree-vect-transform.o. Add tree-vect-data-refs.o, tree-vect-stmts.o, 
+	tree-vect-loop.o, tree-vect-loop-manip.o, tree-vect-slp.o.
+	(tree-vect-analyze.o): Remove.
+	(tree-vect-transform.o): Likewise.
+	(tree-vect-data-refs.o): Add rule.
+	(tree-vect-stmts.o, tree-vect-loop.o, tree-vect-loop-manip.o, 
+	tree-vect-slp.o): Likewise.
+	(tree-vect-patterns.o): Remove redundant dependencies.
+	(tree-vectorizer.o): Likewise.
+	* tree-vect-slp.c: New file.
+
+2009-03-30  Ralf Wildenhues  <Ralf.Wildenhues@gmx.de>
+
+	* optc-gen.awk: Warn if an option flag has multiple different
+	help strings.
+
+2009-03-30  Sebastian Pop  <sebastian.pop@amd.com>
+
+	* doc/invoke.texi (-floop-interchange, -floop-strip-mine,
+	-floop-block): Document dependences on PPL, CLooG and Graphite.
+
+2009-03-30  Joseph Myers  <joseph@codesourcery.com>
+
+	PR rtl-optimization/323
+	* c-common.c (c_fully_fold, convert_and_check,
+	c_common_truthvalue_conversion): Handle EXCESS_PRECISION_EXPR.
+	(c_fully_fold_internal): Disallow EXCESS_PRECISION_EXPR.
+	* c-common.def (EXCESS_PRECISION_EXPR): New.
+	* c-cppbuiltin.c (builtin_define_float_constants): Define
+	constants with enough digits for long double.
+	* c-lex.c (interpret_float): Interpret constant with excess
+	precision where appropriate.
+	* c-opts.c (c_common_post_options): Set
+	flag_excess_precision_cmdline.  Give an error for
+	-fexcess-precision=standard for C++ for processors where the
+	option is significant.
+	* c-parser.c (c_parser_conditional_expression): Handle excess
+	precision in condition.
+	* c-typeck.c (convert_arguments): Handle arguments with excess
+	precision.
+	(build_unary_op): Move excess precision outside operation.
+	(build_conditional_expr): Likewise.
+	(build_compound_expr): Likewise.
+	(build_c_cast): Do cast on operand of EXCESS_PRECISION_EXPR.
+	(build_modify_expr): Handle excess precision in RHS.
+	(convert_for_assignment): Handle excess precision in converted
+	value.
+	(digest_init, output_init_element, process_init_element): Handle
+	excess precision in initializer.
+	(c_finish_return): Handle excess precision in return value.
+	(build_binary_op): Handle excess precision in operands and add
+	excess precision as needed for operation.
+	* common.opt (-fexcess-precision=): New option.
+	* config/i386/i386.h (X87_ENABLE_ARITH, X87_ENABLE_FLOAT): New.
+	* config/i386/i386.md (float<SSEMODEI24:mode><X87MODEF:mode>2):
+	For standard excess precision, output explicit conversion to and
+	truncation from XFmode.
+	(*float<SSEMODEI24:mode><X87MODEF:mode>2_1,
+	*float<SSEMODEI24:mode><X87MODEF:mode>2_i387_with_temp,
+	*float<SSEMODEI24:mode><X87MODEF:mode>2_i387, two unnamed
+	define_splits, floatdi<X87MODEF:mode>2_i387_with_xmm, two unnamed
+	define_splits, *floatunssi<mode>2_1, two unnamed define_splits,
+	floatunssi<mode>2, add<mode>3, sub<mode>3, mul<mode>3, divdf3,
+	divsf3, *fop_<mode>_comm_i387, *fop_<mode>_1_i387,
+	*fop_<MODEF:mode>_2_i387, *fop_<MODEF:mode>_3_i387,
+	*fop_df_4_i387, *fop_df_5_i387, *fop_df_6_i387, two unnamed
+	define_splits, sqrt<mode>2): Disable where appropriate for
+	standard excess precision.
+	* convert.c (convert_to_real): Do not shorten arithmetic to type
+	for which excess precision would be used.
+	* defaults.h (TARGET_FLT_EVAL_METHOD_NON_DEFAULT): Define.
+	* doc/invoke.texi (-fexcess-precision=): Document option.
+	(-mfpmath=): Correct index entry.
+	* flags.h (enum excess_precision, flag_excess_precision_cmdline,
+	flag_excess_precision): New.
+	* langhooks.c (lhd_post_options): Set
+	flag_excess_precision_cmdline.
+	* opts.c (common_handle_option): Handle -fexcess-precision=.
+	* toplev.c (flag_excess_precision_cmdline, flag_excess_precision,
+	init_excess_precision): New.
+	(lang_dependent_init_target): Call init_excess_precision.
+	* tree.c (excess_precision_type): New.
+	* tree.h (excess_precision_type): Declare.
+
+2009-03-30  Joseph Myers  <joseph@codesourcery.com>
+
+	PR c/35235
+	* c-typeck.c (build_component_ref): Do not copy qualifiers from
+	non-lvalue to component.
+
+2009-03-29  Joseph Myers  <joseph@codesourcery.com>
+
+	PR preprocessor/34695
+	* Makefile.in (c-opts.o): Depend on c-tree.h.
+	* c-common.c: Move down include of diagnostic.h.
+	(done_lexing, c_cpp_error): New.
+	* c-common.h (done_lexing): Declare.
+	* c-decl.c (c_write_global_declarations): Don't check cpp_errors
+	(parse_in).
+	* c-opts.c: Include c-tree.h.
+	(c_common_init_options): Set preprocessor error callback.
+	(c_common_handle_option): Do not set preprocessor
+	inhibit_warnings, warnings_are_errors, warn_system_headers,
+	pedantic_errors or inhibit_warnings flags.
+	(c_common_post_options): Do not check cpp_errors (parse_in).
+	(c_common_finish): Do not output dependencies if there were
+	errors.  Do not check return value of cpp_finish.
+	* c-ppoutput.c (pp_file_change): Set input_location.
+	* c-tree.h (c_cpp_error): Declare.
+	* diagnostic.c (diagnostic_set_info_translated): Also initialize
+	override_column.
+	(diagnostic_build_prefix): Check override_column.
+	* diagnostic.h (diagnostic_info): Add override_column field.
+	(diagnostic_override_column): Define.
+
+2009-03-28  Paolo Bonzini  <bonzini@gnu.org>
+
+	* c-common.c (c_expand_expr, c_staticp): Remove.
+	* c-common.def (COMPOUND_LITERAL_EXPR): Delete.
+	* c-common.h (emit_local_var, c_staticp, COMPOUND_LITERAL_EXPR_DECL,
+	COMPOUND_LITERAL_EXPR_DECL_EXPR): Remove.
+	* c-gimplify.c (gimplify_compound_literal_expr,
+	optimize_compound_literals_in_ctor): Remove.
+	(c_gimplify_expr): Remove COMPOUND_LITERAL_EXPR handling.
+	* c-objc-common.h (LANG_HOOKS_STATICP): Remove.
+	* c-semantics.c (emit_local_var): Remove.
+
+	* langhooks-def.h (lhd_expand_expr): Remove.
+	* langhooks.c (lhd_expand_expr): Remove.
+	* langhooks.h (LANG_HOOKS_DEF): Remove LANG_HOOKS_EXPAND_EXPR.
+
+	* expr.c (expand_expr_real_1): Move COMPOUND_LITERAL_EXPR
+	handling from c-semantics.c; don't call into langhook.
+	(expand_expr_addr_expr_1): Check that we don't get non-GENERIC trees.
+	* gimplify.c (gimplify_compound_literal_expr,
+	optimize_compound_literals_in_ctor): Move from c-gimplify.c.
+	(gimplify_init_constructor): Call optimize_compound_literals_in_ctor.
+	(gimplify_modify_expr_rhs, gimplify_expr): Handle COMPOUND_LITERAL_EXPR
+	as was done in c-gimplify.c.
+	* tree.c (staticp): Move COMPOUND_LITERAL_EXPR handling from c_staticp.
+	* tree.h (COMPOUND_LITERAL_EXPR_DECL, COMPOUND_LITERAL_EXPR_DECL_EXPR):
+	Move from c-common.h.
+	* tree.def (COMPOUND_LITERAL_EXPR): Move from c-common.def.
+
+	* tree.c (staticp): Do not call langhook.
+	* langhooks.c (lhd_staticp): Delete.
+	* langhooks-def.h (lhd_staticp): Delete prototype.
+	(LANG_HOOKS_STATICP): Delete.
+	(LANG_HOOKS_INITIALIZER): Delete LANG_HOOKS_STATICP.
+
+	* doc/c-tree.texi (Expression nodes): Refer to DECL_EXPRs
+	instead of DECL_STMTs.
+
+2009-03-29  Joseph Myers  <joseph@codesourcery.com>
+
+	PR c/456
+	PR c/5675
+	PR c/19976
+	PR c/29116
+	PR c/31871
+	PR c/35198
+	* builtins.c (fold_builtin_sincos): Build COMPOUND_EXPR in
+	void_type_node.
+	(fold_call_expr): Return a NOP_EXPR from folding rather than the
+	contained expression.
+	* c-common.c (c_fully_fold, c_fully_fold_internal, c_save_expr): New.
+	(c_common_truthvalue_conversion): Use c_save_expr.  Do not fold
+	conditional expressions for C.
+	(decl_constant_value_for_optimization): Move from
+ 	decl_constant_value_for_broken_optimization in c-typeck.c.  Check
+	whether optimizing and that the expression is a VAR_DECL not of
+	array type instead of doing such checks in the caller.  Do not
+	check pedantic.  Call gcc_unreachable for C++.
+	* c-common.def (C_MAYBE_CONST_EXPR): New.
+	* c-common.h (c_fully_fold, c_save_expr,
+	decl_constant_value_for_optimization): New prototypes.
+	(C_MAYBE_CONST_EXPR_PRE, C_MAYBE_CONST_EXPR_EXPR,
+	C_MAYBE_CONST_EXPR_INT_OPERANDS, C_MAYBE_CONST_EXPR_NON_CONST,
+	EXPR_INT_CONST_OPERANDS): Define.
+	* c-convert.c (convert): Strip nops from expression.
+	* c-decl.c (groktypename): Take extra parameters expr and
+	expr_const_operands.  Update call to grokdeclarator.
+	(start_decl): Update call to grokdeclarator.  Add statement for
+	expressions used in type of decl.
+	(grokparm): Update call to grokdeclarator.
+	(push_parm_decl): Update call to grokdeclarator.
+	(build_compound_literal): Add parameter non_const and build a
+	C_MAYBE_COSNT_EXPR if applicable.
+	(grokdeclarator): Take extra parameters expr and
+	expr_const_operands.  Track expressions used in declaration
+	specifiers and declarators.  Fold array sizes and track whether
+	they are constant expressions and whether they are integer
+	constant expressions.
+	(parser_xref_tag): Set expr and expr_const_operands fields in
+	return value.
+	(grokfield): Update call to grokdeclarator.
+	(start_function): Update call to grokdeclarator.
+	(build_null_declspecs): Set expr and expr_const_operands fields in
+	return value.
+	(declspecs_add_type): Handle expressions in typeof specifiers.
+	* c-parser.c (c_parser_declspecs): Set expr and
+	expr_const_operands fields for declaration specifiers.
+	(c_parser_enum_specifier): Likewise.
+	(c_parser_struct_or_union_specifier): Likewise.
+	(c_parser_typeof_specifier): Likewise.  Update call to
+	groktypename.  Fold expression as needed.  Return expressions with
+	type instead of adding statements.
+	(c_parser_attributes): Update calls to c_parser_expr_list.
+	(c_parser_statement_after_labels): Fold expression before passing
+	to objc_build_throw_stmt.
+	(c_parser_condition): Fold expression.
+	(c_parser_asm_operands): Fold expression.
+	(c_parser_conditional_expression): Use c_save_expr.  Update call
+	to build_conditional_expr.
+	(c_parser_alignof_expression): Update call to groktypename.
+	(c_parser_postfix_expression): Preserve C_MAYBE_CONST_EXPR as
+	original_code.  Fold expression argument of va_arg.  Create
+	C_MAYBE_CONST_EXPR to preserve side effects of expressions in type
+	argument to va_arg.  Update calls to groktypename.  Fold array
+	index for offsetof.  Verify that first argument to
+	__builtin_choose_expr has integer type.
+	(c_parser_postfix_expression_after_paren_type): Update calls to
+	groktypename and build_compound_literal.  Handle expressions with
+	side effects in type name.
+	(c_parser_postfix_expression_after_primary): Update call to
+	c_parser_expr_list.  Set original_code for calls to
+	__builtin_constant_p.
+	(c_parser_expr_list): Take extra parameter fold_p.  Fold
+	expressions if requested.
+	(c_parser_objc_type_name): Update call to groktypename.
+	(c_parser_objc_synchronized_statement): Fold expression.
+	(c_parser_objc_receiver): Fold expression.
+	(c_parser_objc_keywordexpr): Update call to c_parser_expr_list.
+	(c_parser_omp_clause_num_threads, c_parser_omp_clause_schedule,
+	c_parser_omp_atomic, c_parser_omp_for_loop): Fold expressions.
+	* c-tree.h (CONSTRUCTOR_NON_CONST): Define.
+	(struct c_typespec): Add elements expr and expr_const_operands.
+	(struct c_declspecs): Add elements expr and expr_const_operands.
+	(groktypename, build_conditional_expr, build_compound_literal):
+	Update prototypes.
+	(in_late_binary_op): Declare.
+	* c-typeck.c (note_integer_operands): New function.
+	(in_late_binary_op): New variable.
+	(decl_constant_value_for_broken_optimization): Move to c-common.c
+	and rename to decl_constant_value_for_optimization.
+	(default_function_array_conversion): Do not strip nops.
+	(default_conversion): Do not call
+	decl_constant_value_for_broken_optimization.
+	(build_array_ref): Do not fold result.
+	(c_expr_sizeof_expr): Fold operand.  Use C_MAYBE_CONST_EXPR for
+	result when operand is a VLA.
+	(c_expr_sizeof_type): Update call to groktypename.  Handle
+	expressions included in type name.  Use C_MAYBE_CONST_EXPR for
+	result when operand names a VLA type.
+	(build_function_call): Update call to build_compound_literal.
+	Only fold result for calls to __builtin_* functions.  Strip
+	NOP_EXPR from INTEGER_CST returned from such functions.  Fold
+	the function designator.
+	(convert_arguments): Fold arguments.  Update call to
+	convert_for_assignment.
+	(build_unary_op): Handle increment and decrement of
+	C_MAYBE_CONST_EXPR.  Move lvalue checks for increment and
+	decrement earlier.  Fold operand of increment and decrement.
+	Handle address of C_MAYBE_CONST_EXPR.  Only fold expression being
+	built for integer operand.  Wrap returns that are INTEGER_CSTs
+	without being integer constant expressions or that have integer
+	constant operands without being INTEGER_CSTs.
+	(lvalue_p): Handle C_MAYBE_CONST_EXPR.
+	(build_conditional_expr): Add operand ifexp_bcp.  Track whether
+	result is an integer constant expression or can be used in
+	unevaluated parts of one and avoid folding and wrap as
+	appropriate.  Fold operands before possibly doing -Wsign-compare
+	warnings.
+	(build_compound_expr): Wrap result for C99 if operands can be used
+	in integer constant expressions.
+	(build_c_cast): Update call to digest_init.  Do not ignore
+	overflow from casting floating-point constants to integers.  Wrap
+	results that could be confused with integer constant expressions,
+	null pointer constants or floating-point constants.
+	(c_cast_expr): Update call to groktypename.  Handle expressions
+	included in type name.
+	(build_modify_expr): Handle modifying a C_MAYBE_CONST_EXPR.  Fold
+	lhs inside possible SAVE_EXPR.  Fold RHS before assignment.
+	Update calls to convert_for_assignment.
+	(convert_for_assignment): Take new parameter
+	null_pointer_constant.  Do not strip nops or call
+	decl_constant_value_for_broken_optimization.  Set
+	in_late_binary_op for conversions to boolean.
+	(store_init_value): Update call to digest_init.
+	(digest_init): Take new parameter null_pointer_constant.  Do not
+	call decl_constant_value_for_broken_optimization.  pedwarn for
+	initializers not constant expressions.  Update calls to
+	convert_for_assignment.
+	(constructor_nonconst): New.
+	(struct constructor_stack): Add nonconst element.
+	(really_start_incremental_init, push_init_level, pop_init_level):
+	Handle constructor_nonconst and nonconst element.
+	(set_init_index): Call constant_expression_warning for array
+	designators.
+	(output_init_element): Fold value.  Set constructor_nonconst as
+	applicable.  pedwarn for initializers not constant expressions.
+	Update call to digest_init.  Call constant_expression_warning
+	where constant initializers are required.
+	(process_init_element): Use c_save_expr.
+	(c_finish_goto_ptr): Fold expression.
+	(c_finish_return): Fold return value.  Update call to
+	convert_for_assignment.
+	(c_start_case): Fold switch expression.
+	(c_process_expr_stmt): Fold expression.
+	(c_finish_stmt_expr): Create C_MAYBE_CONST_EXPR as needed to
+	ensure statement expression is not evaluated in constant expression.
+	(build_binary_op): Track whether results are integer constant
+	expressions or may occur in such, disable folding and wrap results
+	as applicable.  Fold operands for -Wsign-compare warnings unless
+	in_late_binary_op.
+	(c_objc_common_truthvalue_conversion): Handle results folded to
+	integer constants that are not integer constant expressions.
+	* doc/extend.texi: Document when typeof operands are evaluated,
+	that condition of __builtin_choose_expr is an integer constant
+	expression, and more about use of __builtin_constant_p in
+	initializers.
+
+2009-03-29  Richard Guenther  <rguenther@suse.de>
+
+	* tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Properly
+	propagate addresses of array references.
+
+2009-03-29  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* regmove.c (perhaps_ends_bb_p): Remove.
+	(optimize_reg_copy_1): Don't call perhaps_ends_bb_p.  Get basic block
+	from INSN and check that the main loop stays within that basic block.
+	(optimize_reg_copy_1, optimize_reg_copy_3, fixup_match_2): Likewise.
+	(regmove_forward_pass): Split out from regmove_optimize.  Use
+	FOR_EACH_BB and FOR_BB_INSNS instead of traversing the insns stream.
+	(regmove_backward_pass): Split out from regmove_optimize.  Use
+	FOR_EACH_BB_REVERSE and FOR_BB_INSNS_REVERS_SAFE.
+	(regmove_optimize): Simplify.
+
+2009-03-29  H.J. Lu  <hongjiu.lu@intel.com>
+
+	PR target/39545
+	* config/i386/i386.c (classify_argument): Ignore flexible array
+	member in struct and warn ABI change.
+
+2009-03-29  H.J. Lu  <hongjiu.lu@intel.com>
+
+	* config/i386/i386-protos.h (ix86_agi_dependent): New.
+
+	* config/i386/i386.c (ix86_agi_dependent): Rewrite.
+	(ix86_adjust_cost): Updated.
+
+2009-03-29  Jan Hubicka  <jh@suse.cz>
+
+	PR middle-end/28850
+	* tree-pass.h (pass_cleanup_eh): New function.
+	(remove_unreachable_regions): Break code handling RTL
+	to rtl_remove_unreachable_regions; remove ERT_MUST_NOT_THROW
+	that can not be reached by runtime.
+	(can_be_reached_by_runtime): New function.
+	(label_to_region_map): New function.
+	(num_eh_regions): New function.
+	(rtl_remove_unreachable_regions): New function.
+	(convert_from_eh_region_ranges): Call rtl_remove_unreachable_regions.
+	(remove_eh_region): New function.
+	* except.h: Include sbitmap and vecprim.
+	(remove_eh_region, remove_unreachable_regions, label_to_region_map,
+	num_eh_regions): Declare.
+	* passes.c (init_optimization_passes): Schedule cleanup_eh.
+	* Makefile.in (EXCEPT_H): New; replace all uses of except.h by it.
+	* tree-eh.c (tree_remove_unreachable_handlers): New function.
+	(tree_empty_eh_handler_p): New function.
+	(cleanup_empty_eh): New function.
+	(cleanup_eh): New function.
+	(pass_cleanup_eh): New function.
+
+2009-03-29  Jan Hubicka  <jh@suse.cz>
+
+	* except.c (verify_eh_tree): Fix handling of fun!=cfun; be ready
+	for removed regions.
+
+2009-03-29  Jan Hubicka  <jh@suse.cz>
+
+	* except.c (dump_eh_tree): Dump all datastructures.
+
+2009-03-29  Jan Hubicka  <jh@suse.cz>
+
+	* except.c (duplicate_eh_regions_0): Handle AKA bitmap.
+	(duplicate_eh_regions_1): Likewise.
+	(duplicate_eh_regions): Likewise; cleanup code gorwing the region
+	vector; call EH verification.
+	(foreach_reachable_handler, can_throw_internal_1, can_throw_external_1):
+	Be ready for region being removed.
+
+2009-03-29  Jan Hubicka  <jh@suse.cz>
+
+	* bitmap.c (bitmap_last_set_bit): New function.
+	* bitmap.h (bitmap_last_set_bit): Declare.
+
+2009-03-29  David Ayers  <ayers@fsfe.org>
+
+	PR objc/27377
+	* c-typeck.c (build_conditional_expr): Emit ObjC warnings
+	by calling objc_compare_types and surpress warnings about
+	incompatible C pointers that are compatible ObjC pointers.
+	
+2009-03-29  Adam Nemet  <anemet@caviumnetworks.com>
+
+	* cgraphbuild.c (build_cgraph_edges, rebuild_cgraph_edges): Don't
+	call initialize_inline_failed.
+	(initialize_inline_failed): Move it from here ...
+	* cgraph.c (initialize_inline_failed): ... to here.
+	(cgraph_create_edge): Call initialize_inline_failed rather than
+	setting inline_failed directly.
+
+2009-03-29  Ben Elliston  <bje@au.ibm.com>
+
+	PR target/32542
+	* sysv4.opt (msdata): Improve comment.
+	* linux64.h (ASM_SPEC32): Do not pass -memb when -msdata is given.
+	* sysv4.h (SVR4_ASM_SPEC): Likewise.
+
+2009-03-29  Ben Elliston  <bje@au.ibm.com>
+
+	PR target/30451
+	* config/rs6000/rs6000.md (*movti_ppc64): Correct the order of
+	load and store attributes.
+
+2009-03-29  Ben Elliston  <bje@au.ibm.com>
+
+	* config/i386/i386.c (enum ix86_builtins): Add IX86_BUILTIN_HUGE_VALQ.
+	(ix86_init_builtins): Add built-in function __builtin_huge_valq.
+	(ix86_expand_builtin): Handle IX86_BUILTIN_HUGE_VALQ.
+	* doc/extend.texi (X86 Built-in Functions): Add index entries for
+	__builtin_infq and __builtin_huge_valq.
+
+2009-03-28  Anatoly Sokolov  <aesok@post.ru>
+
+	* config/avr/avr.c (avr_mcu_t): Add atmega8c1, atmega16c1 and
+	atmega8m1 devices.
+	* config/avr/avr.h (LINK_SPEC, CRT_BINUTILS_SPECS): (Ditto.).
+	* config/avr/t-avr (MULTILIB_MATCHES): (Ditto.)
+
+2009-03-28  Xinliang David Li  <davidxl@google.com>
+
+	* tree-ssa-ccp.c (ccp_finalize): Add dbg_count support. 
+	(do_dbg_cnt): New function.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	Merge from pretty-ipa:
+
+	2009-03-27  Jan Hubicka  <jh@suse.cz>
+
+	* cgraph.c (dump_cgraph_node): Add replace output flag by process.
+	* tree-pass.h (function_called_by_processed_nodes_p): Declare.
+	* passes.c (function_called_by_processed_nodes_p): New.
+	* ipa-pure-const.c (check_call): Fix handling of operands.
+	(analyze_function): Dump debug output for skipped bodies.
+	(local_pure_const): Use function_called_by_processed_nodes_p.
+	* dwarf2out.c (reference_to_unused): Use output.
+	* passes.c (do_per_function_toporder): Likewise.
+
+	2008-11-12  Jan Hubicka  <jh@suse.cz>
+
+	* tree-pass.h (pass_fixup_cfg, pass_local_pure_const): Declare.
+	* ipa-pure-const.c (funct_state_d): Add can throw field; make
+	state_set_in_source enum
+	(check_decl): Ignore memory tags; do not set fake looping flags;
+	dump diagnostics.
+	(check_operand, check_tree, check_rhs_var, check_lhs_var,
+	get_asm_expr_operands, scan_function_op, scan_function_stmt): Remove.
+	(check_call, analyze_function): Rewrite.
+	(check_stmt): New.
+	(add_new_function): Update call of analyze_function.
+	(generate_summary): Add call of analyze_function.
+	(propagate): Propagate can_throw; handle state_set_in_source correctly.
+	(local_pure_const): New function.
+	(pass_local_pure_const): New pass.
+	* ipa-inline.c (inline_transform): Set after_inlining.
+	* tree-eh.c (stmt_can_throw_external): New.
+	* tree-optimize.c (execute_fixup_cfg): Do not set after_inlining;
+	work with aliasing built.
+	* tree-flow.h (stmt_can_throw_external): New.
+	* passes.c (init_optimization_passes): Schedule fixup_cfg pass early;
+	and local pure/const pass in early and late optimization queue.
+
+2009-03-28  Martin Jambor  <mjambor@suse.cz>
+
+	* fold-const.c (get_pointer_modulus_and_residue): New parameter
+	allow_func_align.
+	(fold_binary): Allow function decl aligment consideration is the
+	second argument is integer constant one.
+	* tree-ssa-forwprop.c (simplify_bitwise_and): New function.
+	(tree_ssa_forward_propagate_single_use_vars): Handle assing statements
+	with BIT_AND_EXPR on the RHS by calling simplify_bitwise_and.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	* dwarf2out.c (dwarf2out_begin_prologue): Use crtl->nothrow
+	* tree-eh.c (stmt_could_throw_p): Remove check for WEAK decls.
+	* function.h (rtl_data): Add nothrow flag.
+	* except.c (set_nothrow_function_flags): Use crtl->nothrow;
+	set DECL_NOTHROW for AVAILABLE functions.
+
+2009-03-28  Jakub Jelinek  <jakub@redhat.com>
+
+	* config/rs6000/rs6000-c.c (rs6000_macro_to_expand): If macro
+	following vector keyword has expansion starting with pixel or bool
+	keyword, expand vector to __vector and pixel or bool to __pixel or
+	__bool.
+
+	PR c++/39554
+	* opts.c (warning_disallowed_functions, warn_disallowed_functions,
+	warn_if_disallowed_function_p): Removed.
+	(common_handle_option): Don't handle OPT_Wdisallowed_function_list_.
+	* c-parser.c (c_parser_postfix_expression_after_primary): Don't call
+	warning_if_disallowed_function_p.
+	* flags.h (warn_if_disallowed_function_p,
+	warn_disallowed_functions): Removed.
+	* common.opt (Wdisallowed-function-list=): Removed.
+	* doc/invoke.texi (-Wdisallowed-function-list=): Removed.
+
+2009-03-28  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/38723
+	* tree-ssa-pre.c (compute_avail): Add all default definitions to
+	the entry block.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	* tree-ssa-structalias.c (ipa_pta_execute): Fix bogus node->analyzed
+	test introduced by my previous patch.
+
+2009-03-28  Richard Guenther  <rguenther@suse.de>
+
+	* tree-ssa-copy.c (copy_prop_visit_phi_node): Do not leave
+	the PHIs value undefined.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	* tree-pass.h (pass_fixup_cfg): New pass.
+	* ipa-inline.c (inline_transform): Set
+	always_inline_functions_inlined/after_inlining.
+	* tree-optimize.c (execute_fixup_cfg): Do not set them here.
+	(pass_fixup_cfg): New pass.
+	* passes.c (init_optimization_passes): Add fixup_cfg.
+
+2009-03-28  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/38458
+	* tree-ssa-copy.c (copy_prop_visit_phi_node): For the first
+	argument use the arguments copy-of value.
+
+2009-03-28  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/38180
+	* tree-ssa-ccp.c (get_default_value): Simplify.
+	(likely_value): Likewise.
+	(surely_varying_stmt_p): Properly handle VOP case.
+	(ccp_initialize): Likewise.
+	(ccp_fold): Handle propagating through *&.
+	(fold_const_aggregate_ref): Also handle decls.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	* cgraph.c (dump_cgraph_node): Add replace output flag by process.
+	* cgraph.h (cgraph_node): Likewise.
+	* cgraphunit.c (cgraph_process_new_functions): Set process flag.
+	(cgraph_reset_node): Use process flag.
+	(cgraph_mark_functions_to_output): Likewise.
+	(cgraph_expand_function): Likewise.
+	(cgraph_expand_all_functions): Likewise.
+	(cgraph_output_in_order): Likewise.
+	* dwarf2out.c (reference_to_unused): Likewise.
+	* passes.c do_per_function_toporder): Likewise.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	Bring from lto-branch:
+
+	2008-09-03  Doug Kwan  <dougkwan@google.com>
+
+	* cgraphbuild.c (initialize_inline_failed): Use cgraph_inline_failed_t
+	enums instead of reason strings.
+	* cgraph.c (cgraph_create_edge): Same.
+	(cgraph_inline_failed_string): New function.
+	* cgraph.h (cgraph_inline_failed_t): New enum type.
+	(cgraph_inline_failed_string): New prototype.
+	(struct cgraph_edge): Change type of INLINED_FAILED from constant
+	char pointer to cgraph_inline_failed_t.
+	(cgraph_inline_p): Adjust prototype to use cgraph_inline_failed_t.
+	(cgraph_default_inline_p): Ditto.
+	* gcc/cgraphunit.c (cgraph_inline_p): Change type of parameter REASON
+	to cgraph_inline_failed_t pointer.
+	* cif-code.def: New file.
+	* ipa-inline.c (cgraph_mark_inline_edge): Use an enum instead of a
+	reason string.
+	(cgraph_check_inline_limits): Change type of REASON to pointer to
+	cgraph_inline_failed_t.  Replace reason strings with enums.
+	(cgraph_default_inline_p): Ditto.
+	(cgraph_recursive_inlining_p): Ditto.
+	(update_caller_keys): Change type of FAILED_REASON to
+	cgraph_inline_failed_t.
+	(cgraph_set_inline_failed): Change type of REASON to pointer to
+	cgraph_inline_failed_t.  Call cgraph_inline_failed_string to
+	convert enums to strings for text output.
+	(cgraph_decide_inlining_of_small_function): Change FAILED_REASON
+	to be of type cgraph_inline_failed_t.  Replace reason strings with
+	enums.  Call cgraph_inline_failed_string to covert enums
+	to strings for text output.
+	(cgraph_decide_inlining): Replace reason strings with enums.
+	(cgraph_decide_inlining_incrementally): Change type of FAILED_REASON
+	to cgraph_inline_failed_t type.  Call cgraph_inline_failed_string
+	for text output.
+	* tree-inline.c (expand_call_inline): Change type of REASON
+	to cgraph_inline_failed_t.  Replace reason strings with enums.
+	Call cgraph_inline_failed_string for text output.
+	* Makefile.in (CGRAPH_H): Add cif-code.def to dependencies.
+	(cgraph.o): Ditto.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	* cgraph.c (cgraph_node, cgraph_remove_node, dump_cgraph_node,
+	cgraph_clone_node): Remove master clone handling.
+	(cgraph_is_master_clone, cgraph_master_clone): Remove.
+	* cgraph.h (master_clone): Remove.
+	(cgraph_is_master_clone, cgraph_master_clone): Remove.
+	* ipa-type-escape.c (type_escape_execute): Remove use of master clone.
+	(tree-ssa-structalias.c (ipa_pta_execute): Likewise.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	* cgraph.c (cgraph_function_body_availability): Functions declared
+	inline are always safe to assume that it is not going to be replaced.
+
+2009-03-28  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/38513
+	* tree-ssa-pre.c (eliminate): Remove redundant stores.
+	* tree-ssa-sccvn.c (copy_reference_ops_from_ref): Handle
+	EXC_PTR_EXPR and FILTER_EXPR.
+	(get_ref_from_reference_ops): Likewise.
+
+2009-03-28  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/38968
+	* tree-vect-analyze.c (vect_compute_data_ref_alignment):
+	Use FLOOR_MOD_EXPR to compute misalignment.
+
+2009-03-28  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/37795
+	* tree.h (combine_comparisons): Declare.
+	* fold-const.c (combine_comparisons): Export.
+	* tree-ssa-ifcombine.c (ifcombine_ifandif): Optimize two successive
+	comparisons.
+	(ifcombine_iforif): Use combine_comparisons.
+
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+	* tree-eh.c (inlinable_call_p): New function.
+	(make_eh_edges): Use it.
+	(verify_eh_edges): Use it.
+	(stmt_can_throw_external, stmt_can_throw_internal): Use it.
+	* except.c (reachable_next_level): Add inlinable_function argument
+	(sjlj_find_directly_reachable_regions): Update.
+	(add_reachable_handler): Do not set saw_any_handlers.
+	(reachable_next_level): Handle MUST_NOT_THROW more curefully.
+	(foreach_reachable_handler, can_throw_internal_1, can_throw_external_1):
+	Add new inlinable call parameter.
+	(can_throw_internal, can_throw_external): Update.
+	* except.h (can_throw_internal_1, can_throw_external_1,
+	foreach_reachable_handler): Update declaration.
+
+2009-03-28  Joseph Myers  <joseph@codesourcery.com>
+
+	* config/arm/t-arm-coff, config/h8300/coff.h,
+	config/i386/i386-aout.h, config/i386/i386-coff.h,
+	config/libgloss.h, config/m68k/coff.h, config/m68k/m68k-aout.h,
+	config/pdp11/2bsd.h, config/rs6000/aix41.h,
+	config/rs6000/aix41.opt, config/rs6000/t-newas, config/sh/coff.h,
+	fix-header.c, fixproto, gen-protos.c, protoize.c, scan-decls.c,
+	scan-types.sh, scan.c, scan.h, sort-protos, sys-protos.h,
+	sys-types.h: Remove.
+	* Makefile.in: Remove protoize and fixproto support and references
+	in comments.
+	(SYSCALLS.c.X-warn, TARGET_GETGROUPS_T, STMP_FIXPROTO,
+	PROTOIZE_INSTALL_NAME, UNPROTOIZE_INSTALL_NAME, FIXPROTO_DEFINES):
+	Remove.
+	(ALL_HOST_OBJS): Remove $(PROTO_OBJS).
+	(MOSTLYCLEANFILES): Remove protoize$(exeext) and
+	unprotoize$(exeext).
+	(rest.encap): Don't depend on $(STMP_FIXPROTO)
+	(.PHONY): Don't depend on proto.
+	(libgcc-support): Don't depend on $(STMP_FIXPROTO).
+	(proto, PROTO_OBJS, protoize$(exeext), unprotoize$(exeext),
+	protoize.o, unprotoize.o, SYSCALLS.c.X, test-protoize-simple,
+	deduced.h, GEN_PROTOS_OBJS, build/gen-protos$(build_exeext),
+	build/gen-protos.o, build/scan.o, xsys-protos.h,
+	build/fix-header$(build_exeext), build/fix-header.o,
+	build/scan-decls.o, fixhdr.ready, stmp-fixproto,
+	stmp-install-fixproto): Remove.
+	(mostlyclean): Don't remove xsys-protos.hT, SYSCALLS.c.X,
+	SYSCALLS.c or fixproto files.
+	(install-common): Don't install protoize.
+	(install-headers-tar, install-headers-cpio, install-headers-cp):
+	Don't depend on $(STMP_FIXPROTO).
+	(install-mkheaders): Don't depend on $(STMP_FIXPROTO).  Don't
+	install fixproto files or write out fixproto settings.
+	(uninstall): Don't uninstall protoize.
+	* config.gcc (use_fixproto): Remove.
+	(arm-*-coff*, armel-*-coff*, h8300-*-*, i[34567]86-*-aout*,
+	i[34567]86-*-coff*, m68k-*-aout*, m68k-*-coff*, pdp11-*-bsd,
+	rs6000-ibm-aix4.[12]*, powerpc-ibm-aix4.[12]*, sh-*-*): Remove.
+	* config/m32r/t-linux (STMP_FIXPROTO): Remove.
+	* config/m68k/m68k.c: Remove M68K_TARGET_COFF-conditional code.
+	* config/mips/t-iris (FIXPROTO_DEFINES): Remove.
+	* config/pa/t-pa-hpux (FIXPROTO_DEFINES): Remove.
+	* config/pdp11/pdp11.c: Remove TWO_BSD-conditional code.
+	* config/t-svr4 (FIXPROTO_DEFINES): Remove.
+	* config/t-vxworks (STMP_FIXPROTO): Remove.
+	* configure.ac (AC_TYPE_GETGROUPS, TARGET_GETGROUPS_T,
+	STMP_FIXPROTO): Remove.
+	* config.in, configure: Regenerate.
+	* crtstuff.c (gid_t, uid_t): Don't undefine.
+	* doc/install.texi: Change m68k-coff to m68k-elf in example.
+	(arm-*-coff, arm-*-aout: Remove target entries.
+	(*-ibm-aix*): Mention removal of support for AIX 4.2 and older.
+	Remove mention of AIX 4.1.
+	(m68k-*-*): Remove mention of m68k-*-aout and m68k-*-coff*.
+	* doc/invoke.texi (Running Protoize): Remove.
+	* doc/trouble.texi (Actual Bugs): Remove mention of fixproto.
+	(Protoize Caveats): Remove.
+	* tsystem.h: Update comments on headers assumed to exist.
+
+2009-03-27  Vladimir Makarov  <vmakarov@redhat.com>
+
+	* genautomata.c: Add a new year to the copyright.  Add a new
+	reference.
+	(struct insn_reserv_decl): Add comments for member bypass_list.
+	(find_bypass): Remove.
+	(insert_bypass): New.
+	(process_decls): Use insert_bypass.
+	(output_internal_insn_latency_func): Output all bypasses with the
+	same input insn in one switch case.
+
+	* rtl.def (define_bypass): Describe bypass choice.
+	* doc/md.texi (define_bypass): Ditto.
+
+2009-03-27  Richard Guenther  <rguenther@suse.de>
+
+	* gimplify.c (mark_addressable): Export.
+	* tree-flow.h (mark_addressable): Declare.
+	* tree-ssa-loop-manip.c (create_iv): Mark the base addressable.
+	* tree-ssa.c (verify_phi_args): Verify that address taken
+	variables have TREE_ADDRESSABLE set.
+
+2009-03-27  Richard Guenther  <rguenther@suse.de>
+
+	* fold-const.c (build_fold_addr_expr_with_type_1): Rename back to ...
+	(build_fold_addr_expr_with_type): ... this.  Remove in_fold handling.
+	Do not mark decls TREE_ADDRESSABLE.
+	(build_fold_addr_expr): Adjust.
+	(fold_addr_expr): Remove.
+	(fold_unary): Use build_fold_addr_expr.
+	(fold_comparison): Likewise.
+	(split_address_to_core_and_offset): Likewise.
+	* coverage.c (tree_coverage_counter_addr): Mark the array decl
+	TREE_ADDRESSABLE.
+	* gimplify.c (mark_addressable): Do not exclude RESULT_DECLs.
+	(gimplify_modify_expr_to_memcpy): Mark source and destination
+	addressable.
+	* omp-low.c (create_omp_child_function): Mark the object decl
+	TREE_ADDRESSABLE.
+	(lower_rec_input_clauses): Mark the var we take the address of
+	TREE_ADDRESSABLE.
+	(lower_omp_taskreg): Mark the sender decl TREE_ADDRESSABLE.
+
+2009-03-27  H.J. Lu  <hongjiu.lu@intel.com>
+
+	PR middle-end/39315
+	* cfgexpand.c (expand_one_stack_var_at): Change alignment
+	limit to MAX_SUPPORTED_STACK_ALIGNMENT.
+
+2009-03-27  Richard Guenther  <rguenther@suse.de>
+
+	PR tree-optimization/39120


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