This is the mail archive of the
gcc-regression@gcc.gnu.org
mailing list for the GCC project.
A recent patch increased GCC's memory consumption!
- From: gcctest at suse dot de
- To: jh at suse dot cz, gcc-regression at gcc dot gnu dot org
- Date: Wed, 23 Jul 2008 17:17:44 +0000
- Subject: A recent patch increased GCC's memory consumption!
Hi,
I am a friendly script caring about memory consumption in GCC. Please
contact jh@suse.cz if something is going wrong.
Comparing memory consumption on compilation of combine.i, insn-attrtab.i,
and generate-3.4.ii I got:
comparing empty function compilation at -O0 level:
Overall memory allocated via mmap and sbrk increased from 8137k to 8472k, overall 4.12%
Peak amount of GGC memory allocated before garbage collecting increased from 1165k to 1409k, overall 20.94%
Peak amount of GGC memory still allocated after garbage collecting increased from 1063k to 1338k, overall 25.87%
Amount of produced GGC garbage increased from 246k to 249k, overall 1.15%
Amount of memory still referenced at the end of compilation increased from 1024k to 1332k, overall 30.08%
Overall memory needed: 8137k -> 8472k
Peak memory use before GGC: 1165k -> 1409k
Peak memory use after GGC: 1063k -> 1338k
Maximum of released memory in single GGC run: 132k -> 172k
Garbage: 246k -> 249k
Leak: 1024k -> 1332k
Overhead: 92k -> 159k
GGC runs: 3
Amount of produced pre-ipa-GGC garbage increased from 235k to 238k, overall 1.23%
Amount of memory referenced pre-ipa increased from 1026k to 1334k, overall 30.01%
Pre-IPA-Garbage: 235k -> 238k
Pre-IPA-Leak: 1026k -> 1334k
Pre-IPA-Overhead: 90k -> 158k
Amount of produced post-ipa-GGC garbage increased from 235k to 238k, overall 1.23%
Amount of memory referenced post-ipa increased from 1026k to 1334k, overall 30.01%
Post-IPA-Garbage: 235k -> 238k
Post-IPA-Leak: 1026k -> 1334k
Post-IPA-Overhead: 90k -> 158k
comparing empty function compilation at -O0 -g level:
Overall memory allocated via mmap and sbrk increased from 8153k to 8504k, overall 4.31%
Peak amount of GGC memory allocated before garbage collecting increased from 1193k to 1436k, overall 20.37%
Peak amount of GGC memory still allocated after garbage collecting increased from 1091k to 1366k, overall 25.21%
Amount of produced GGC garbage increased from 249k to 252k, overall 1.14%
Amount of memory still referenced at the end of compilation increased from 1057k to 1365k, overall 29.14%
Overall memory needed: 8153k -> 8504k
Peak memory use before GGC: 1193k -> 1436k
Peak memory use after GGC: 1091k -> 1366k
Maximum of released memory in single GGC run: 131k -> 175k
Garbage: 249k -> 252k
Leak: 1057k -> 1365k
Overhead: 97k -> 164k
GGC runs: 3
Amount of produced pre-ipa-GGC garbage increased from 235k to 238k, overall 1.23%
Amount of memory referenced pre-ipa increased from 1026k to 1334k, overall 30.01%
Pre-IPA-Garbage: 235k -> 238k
Pre-IPA-Leak: 1026k -> 1334k
Pre-IPA-Overhead: 90k -> 158k
Amount of produced post-ipa-GGC garbage increased from 235k to 238k, overall 1.23%
Amount of memory referenced post-ipa increased from 1026k to 1334k, overall 30.01%
Post-IPA-Garbage: 235k -> 238k
Post-IPA-Leak: 1026k -> 1334k
Post-IPA-Overhead: 90k -> 158k
comparing empty function compilation at -O1 level:
Overall memory allocated via mmap and sbrk increased from 8221k to 8548k, overall 3.98%
Peak amount of GGC memory allocated before garbage collecting increased from 1165k to 1409k, overall 20.94%
Peak amount of GGC memory still allocated after garbage collecting increased from 1063k to 1338k, overall 25.87%
Amount of produced GGC garbage increased from 249k to 252k, overall 1.17%
Amount of memory still referenced at the end of compilation increased from 1024k to 1332k, overall 30.08%
Overall memory needed: 8221k -> 8548k
Peak memory use before GGC: 1165k -> 1409k
Peak memory use after GGC: 1063k -> 1338k
Maximum of released memory in single GGC run: 131k -> 169k
Garbage: 249k -> 252k
Leak: 1024k -> 1332k
Overhead: 93k -> 160k
GGC runs: 3 -> 4
Amount of produced pre-ipa-GGC garbage increased from 235k to 238k, overall 1.22%
Amount of memory referenced pre-ipa increased from 1026k to 1334k, overall 30.01%
Pre-IPA-Garbage: 235k -> 238k
Pre-IPA-Leak: 1026k -> 1334k
Pre-IPA-Overhead: 91k -> 158k
Amount of produced post-ipa-GGC garbage increased from 235k to 238k, overall 1.22%
Amount of memory referenced post-ipa increased from 1026k to 1334k, overall 30.01%
Post-IPA-Garbage: 235k -> 238k
Post-IPA-Leak: 1026k -> 1334k
Post-IPA-Overhead: 91k -> 158k
comparing empty function compilation at -O2 level:
Overall memory allocated via mmap and sbrk increased from 8233k to 8576k, overall 4.17%
Peak amount of GGC memory allocated before garbage collecting increased from 1165k to 1409k, overall 20.94%
Peak amount of GGC memory still allocated after garbage collecting increased from 1064k to 1338k, overall 25.75%
Amount of produced GGC garbage increased from 254k to 257k, overall 1.13%
Amount of memory still referenced at the end of compilation increased from 1024k to 1333k, overall 30.06%
Overall memory needed: 8233k -> 8576k
Peak memory use before GGC: 1165k -> 1409k
Peak memory use after GGC: 1064k -> 1338k
Maximum of released memory in single GGC run: 130k -> 168k
Garbage: 254k -> 257k
Leak: 1024k -> 1333k
Overhead: 94k -> 161k
GGC runs: 3 -> 4
Amount of produced pre-ipa-GGC garbage increased from 235k to 238k, overall 1.22%
Amount of memory referenced pre-ipa increased from 1027k to 1335k, overall 29.99%
Pre-IPA-Garbage: 235k -> 238k
Pre-IPA-Leak: 1027k -> 1335k
Pre-IPA-Overhead: 91k -> 158k
Amount of produced post-ipa-GGC garbage increased from 235k to 238k, overall 1.22%
Amount of memory referenced post-ipa increased from 1027k to 1335k, overall 29.99%
Post-IPA-Garbage: 235k -> 238k
Post-IPA-Leak: 1027k -> 1335k
Post-IPA-Overhead: 91k -> 158k
comparing empty function compilation at -O3 level:
Overall memory allocated via mmap and sbrk increased from 8241k to 8580k, overall 4.11%
Peak amount of GGC memory allocated before garbage collecting increased from 1165k to 1409k, overall 20.94%
Peak amount of GGC memory still allocated after garbage collecting increased from 1064k to 1338k, overall 25.75%
Amount of produced GGC garbage increased from 254k to 257k, overall 1.13%
Amount of memory still referenced at the end of compilation increased from 1024k to 1333k, overall 30.06%
Overall memory needed: 8241k -> 8580k
Peak memory use before GGC: 1165k -> 1409k
Peak memory use after GGC: 1064k -> 1338k
Maximum of released memory in single GGC run: 130k -> 168k
Garbage: 254k -> 257k
Leak: 1024k -> 1333k
Overhead: 94k -> 161k
GGC runs: 3 -> 4
Amount of produced pre-ipa-GGC garbage increased from 235k to 238k, overall 1.22%
Amount of memory referenced pre-ipa increased from 1027k to 1335k, overall 29.99%
Pre-IPA-Garbage: 235k -> 238k
Pre-IPA-Leak: 1027k -> 1335k
Pre-IPA-Overhead: 91k -> 158k
Amount of produced post-ipa-GGC garbage increased from 235k to 238k, overall 1.22%
Amount of memory referenced post-ipa increased from 1027k to 1335k, overall 29.99%
Post-IPA-Garbage: 235k -> 238k
Post-IPA-Leak: 1027k -> 1335k
Post-IPA-Overhead: 91k -> 158k
comparing combine.c compilation at -O0 level:
Peak amount of GGC memory allocated before garbage collecting increased from 18459k to 18853k, overall 2.13%
Peak amount of GGC memory still allocated after garbage collecting increased from 18270k to 18660k, overall 2.13%
Amount of produced GGC garbage increased from 39717k to 39844k, overall 0.32%
Amount of memory still referenced at the end of compilation increased from 5194k to 5766k, overall 11.01%
Overall memory needed: 31513k -> 32048k
Peak memory use before GGC: 18459k -> 18853k
Peak memory use after GGC: 18270k -> 18660k
Maximum of released memory in single GGC run: 1844k -> 1842k
Garbage: 39717k -> 39844k
Leak: 5194k -> 5766k
Overhead: 4761k -> 4991k
GGC runs: 356 -> 340
Amount of produced pre-ipa-GGC garbage increased from 13074k to 13096k, overall 0.17%
Amount of memory referenced pre-ipa increased from 19459k to 20015k, overall 2.86%
Pre-IPA-Garbage: 13074k -> 13096k
Pre-IPA-Leak: 19459k -> 20015k
Pre-IPA-Overhead: 2164k -> 2339k
Amount of produced post-ipa-GGC garbage increased from 13074k to 13096k, overall 0.17%
Amount of memory referenced post-ipa increased from 19459k to 20015k, overall 2.86%
Post-IPA-Garbage: 13074k -> 13096k
Post-IPA-Leak: 19459k -> 20015k
Post-IPA-Overhead: 2164k -> 2339k
comparing combine.c compilation at -O0 -g level:
Peak amount of GGC memory allocated before garbage collecting increased from 20353k to 20746k, overall 1.93%
Peak amount of GGC memory still allocated after garbage collecting increased from 20139k to 20530k, overall 1.94%
Amount of produced GGC garbage increased from 40079k to 40217k, overall 0.35%
Amount of memory still referenced at the end of compilation increased from 8493k to 9040k, overall 6.45%
Overall memory needed: 33461k -> 33996k
Peak memory use before GGC: 20353k -> 20746k
Peak memory use after GGC: 20139k -> 20530k
Maximum of released memory in single GGC run: 1853k -> 1851k
Garbage: 40079k -> 40217k
Leak: 8493k -> 9040k
Overhead: 5583k -> 5812k
GGC runs: 342 -> 325
Amount of produced pre-ipa-GGC garbage increased from 13173k to 13195k, overall 0.17%
Amount of memory referenced pre-ipa increased from 21734k to 22291k, overall 2.56%
Pre-IPA-Garbage: 13173k -> 13195k
Pre-IPA-Leak: 21734k -> 22291k
Pre-IPA-Overhead: 2656k -> 2830k
Amount of produced post-ipa-GGC garbage increased from 13173k to 13195k, overall 0.17%
Amount of memory referenced post-ipa increased from 21734k to 22291k, overall 2.56%
Post-IPA-Garbage: 13173k -> 13195k
Post-IPA-Leak: 21734k -> 22291k
Post-IPA-Overhead: 2656k -> 2830k
comparing combine.c compilation at -O1 level:
Peak amount of GGC memory allocated before garbage collecting increased from 16257k to 16650k, overall 2.42%
Peak amount of GGC memory still allocated after garbage collecting increased from 16095k to 16484k, overall 2.42%
Amount of memory still referenced at the end of compilation increased from 5177k to 5734k, overall 10.74%
Overall memory needed: 30229k -> 30600k
Peak memory use before GGC: 16257k -> 16650k
Peak memory use after GGC: 16095k -> 16484k
Maximum of released memory in single GGC run: 1396k
Garbage: 50462k -> 50469k
Leak: 5177k -> 5734k
Overhead: 5602k -> 5777k
GGC runs: 430 -> 409
Amount of produced pre-ipa-GGC garbage increased from 13919k to 13941k, overall 0.16%
Amount of memory referenced pre-ipa increased from 17100k to 17656k, overall 3.25%
Pre-IPA-Garbage: 13919k -> 13941k
Pre-IPA-Leak: 17100k -> 17656k
Pre-IPA-Overhead: 2114k -> 2288k
Amount of produced post-ipa-GGC garbage increased from 13919k to 13941k, overall 0.16%
Amount of memory referenced post-ipa increased from 17100k to 17656k, overall 3.25%
Post-IPA-Garbage: 13919k -> 13941k
Post-IPA-Leak: 17100k -> 17656k
Post-IPA-Overhead: 2114k -> 2288k
comparing combine.c compilation at -O2 level:
Peak amount of GGC memory allocated before garbage collecting increased from 16354k to 16746k, overall 2.40%
Peak amount of GGC memory still allocated after garbage collecting increased from 16191k to 16580k, overall 2.40%
Amount of memory still referenced at the end of compilation increased from 5207k to 5763k, overall 10.68%
Overall memory needed: 31553k -> 31920k
Peak memory use before GGC: 16354k -> 16746k
Peak memory use after GGC: 16191k -> 16580k
Maximum of released memory in single GGC run: 1333k -> 1334k
Garbage: 66452k -> 66412k
Leak: 5207k -> 5763k
Overhead: 7419k -> 7589k
GGC runs: 506 -> 481
Amount of produced pre-ipa-GGC garbage increased from 14068k to 14090k, overall 0.16%
Amount of memory referenced pre-ipa increased from 17162k to 17718k, overall 3.24%
Pre-IPA-Garbage: 14068k -> 14090k
Pre-IPA-Leak: 17162k -> 17718k
Pre-IPA-Overhead: 2127k -> 2301k
Amount of produced post-ipa-GGC garbage increased from 14068k to 14090k, overall 0.16%
Amount of memory referenced post-ipa increased from 17162k to 17718k, overall 3.24%
Post-IPA-Garbage: 14068k -> 14090k
Post-IPA-Leak: 17162k -> 17718k
Post-IPA-Overhead: 2127k -> 2301k
comparing combine.c compilation at -O3 level:
Peak amount of GGC memory allocated before garbage collecting increased from 16381k to 16770k, overall 2.37%
Peak amount of GGC memory still allocated after garbage collecting increased from 16208k to 16596k, overall 2.39%
Amount of memory still referenced at the end of compilation increased from 5230k to 5782k, overall 10.56%
Overall memory needed: 37273k -> 37664k
Peak memory use before GGC: 16381k -> 16770k
Peak memory use after GGC: 16208k -> 16596k
Maximum of released memory in single GGC run: 2127k -> 2122k
Garbage: 83055k -> 83077k
Leak: 5230k -> 5782k
Overhead: 9047k -> 9220k
GGC runs: 535 -> 513
Amount of produced pre-ipa-GGC garbage increased from 14069k to 14091k, overall 0.16%
Amount of memory referenced pre-ipa increased from 17173k to 17729k, overall 3.24%
Pre-IPA-Garbage: 14069k -> 14091k
Pre-IPA-Leak: 17173k -> 17729k
Pre-IPA-Overhead: 2128k -> 2302k
Amount of produced post-ipa-GGC garbage increased from 14069k to 14091k, overall 0.16%
Amount of memory referenced post-ipa increased from 17173k to 17729k, overall 3.24%
Post-IPA-Garbage: 14069k -> 14091k
Post-IPA-Leak: 17173k -> 17729k
Post-IPA-Overhead: 2128k -> 2302k
comparing insn-attrtab.c compilation at -O0 level:
Peak amount of GGC memory allocated before garbage collecting increased from 65202k to 66309k, overall 1.70%
Peak amount of GGC memory still allocated after garbage collecting increased from 58013k to 58720k, overall 1.22%
Amount of produced GGC garbage increased from 135005k to 135591k, overall 0.43%
Amount of memory still referenced at the end of compilation increased from 6842k to 7596k, overall 11.01%
Overall memory needed: 145709k -> 148404k
Peak memory use before GGC: 65202k -> 66309k
Peak memory use after GGC: 58013k -> 58720k
Maximum of released memory in single GGC run: 28087k -> 28091k
Garbage: 135005k -> 135591k
Leak: 6842k -> 7596k
Overhead: 14460k -> 14872k
GGC runs: 277 -> 259
Amount of memory referenced pre-ipa increased from 60036k to 60539k, overall 0.84%
Pre-IPA-Garbage: 43648k -> 43667k
Pre-IPA-Leak: 60036k -> 60539k
Pre-IPA-Overhead: 7606k -> 7757k
Amount of memory referenced post-ipa increased from 60036k to 60539k, overall 0.84%
Post-IPA-Garbage: 43648k -> 43667k
Post-IPA-Leak: 60036k -> 60539k
Post-IPA-Overhead: 7606k -> 7757k
comparing insn-attrtab.c compilation at -O0 -g level:
Peak amount of GGC memory allocated before garbage collecting increased from 66477k to 67584k, overall 1.67%
Peak amount of GGC memory still allocated after garbage collecting increased from 59286k to 59992k, overall 1.19%
Amount of produced GGC garbage increased from 135524k to 136116k, overall 0.44%
Amount of memory still referenced at the end of compilation increased from 8493k to 9247k, overall 8.87%
Overall memory needed: 147201k -> 149552k
Peak memory use before GGC: 66477k -> 67584k
Peak memory use after GGC: 59286k -> 59992k
Maximum of released memory in single GGC run: 28088k -> 28091k
Garbage: 135524k -> 136116k
Leak: 8493k -> 9247k
Overhead: 14919k -> 15331k
GGC runs: 268 -> 253
Amount of memory referenced pre-ipa increased from 61578k to 62081k, overall 0.82%
Pre-IPA-Garbage: 43706k -> 43724k
Pre-IPA-Leak: 61578k -> 62081k
Pre-IPA-Overhead: 7942k -> 8094k
Amount of memory referenced post-ipa increased from 61578k to 62081k, overall 0.82%
Post-IPA-Garbage: 43706k -> 43724k
Post-IPA-Leak: 61578k -> 62081k
Post-IPA-Overhead: 7942k -> 8094k
comparing insn-attrtab.c compilation at -O1 level:
Peak amount of GGC memory allocated before garbage collecting increased from 53093k to 53459k, overall 0.69%
Peak amount of GGC memory still allocated after garbage collecting increased from 47367k to 47720k, overall 0.75%
Amount of memory still referenced at the end of compilation increased from 6475k to 6978k, overall 7.77%
Overall memory needed: 131673k -> 132000k
Peak memory use before GGC: 53093k -> 53459k
Peak memory use after GGC: 47367k -> 47720k
Maximum of released memory in single GGC run: 23289k
Garbage: 202843k -> 202867k
Leak: 6475k -> 6978k
Overhead: 24012k -> 24163k
GGC runs: 317 -> 298
Amount of memory referenced pre-ipa increased from 48151k to 48654k, overall 1.04%
Pre-IPA-Garbage: 50236k -> 50254k
Pre-IPA-Leak: 48151k -> 48654k
Pre-IPA-Overhead: 7216k -> 7367k
Amount of memory referenced post-ipa increased from 48151k to 48654k, overall 1.04%
Post-IPA-Garbage: 50236k -> 50254k
Post-IPA-Leak: 48151k -> 48654k
Post-IPA-Overhead: 7216k -> 7367k
comparing insn-attrtab.c compilation at -O2 level:
Peak amount of GGC memory allocated before garbage collecting increased from 53766k to 54123k, overall 0.66%
Peak amount of GGC memory still allocated after garbage collecting increased from 48371k to 48728k, overall 0.74%
Amount of memory still referenced at the end of compilation increased from 6483k to 6986k, overall 7.76%
Overall memory needed: 178397k -> 178756k
Peak memory use before GGC: 53766k -> 54123k
Peak memory use after GGC: 48371k -> 48728k
Maximum of released memory in single GGC run: 22125k -> 22127k
Garbage: 239704k -> 239725k
Leak: 6483k -> 6986k
Overhead: 29595k -> 29748k
GGC runs: 351 -> 331
Amount of memory referenced pre-ipa increased from 48156k to 48659k, overall 1.04%
Pre-IPA-Garbage: 50305k -> 50323k
Pre-IPA-Leak: 48156k -> 48659k
Pre-IPA-Overhead: 7223k -> 7374k
Amount of memory referenced post-ipa increased from 48156k to 48659k, overall 1.04%
Post-IPA-Garbage: 50305k -> 50323k
Post-IPA-Leak: 48156k -> 48659k
Post-IPA-Overhead: 7223k -> 7374k
comparing insn-attrtab.c compilation at -O3 level:
Peak amount of GGC memory allocated before garbage collecting increased from 64685k to 65039k, overall 0.55%
Peak amount of GGC memory still allocated after garbage collecting increased from 61817k to 62171k, overall 0.57%
Amount of memory still referenced at the end of compilation increased from 6491k to 6994k, overall 7.75%
Overall memory needed: 186897k -> 187240k
Peak memory use before GGC: 64685k -> 65039k
Peak memory use after GGC: 61817k -> 62171k
Maximum of released memory in single GGC run: 24136k
Garbage: 266354k -> 266382k
Leak: 6491k -> 6994k
Overhead: 31433k -> 31585k
GGC runs: 354 -> 333
Amount of memory referenced pre-ipa increased from 48156k to 48659k, overall 1.04%
Pre-IPA-Garbage: 50305k -> 50323k
Pre-IPA-Leak: 48156k -> 48659k
Pre-IPA-Overhead: 7223k -> 7374k
Amount of memory referenced post-ipa increased from 48156k to 48659k, overall 1.04%
Post-IPA-Garbage: 50305k -> 50323k
Post-IPA-Leak: 48156k -> 48659k
Post-IPA-Overhead: 7223k -> 7374k
comparing Gerald's testcase PR8361 compilation at -O0 level:
Peak amount of GGC memory allocated before garbage collecting increased from 82001k to 83343k, overall 1.64%
Peak amount of GGC memory still allocated after garbage collecting increased from 81184k to 82490k, overall 1.61%
Amount of produced GGC garbage increased from 203809k to 205357k, overall 0.76%
Amount of memory still referenced at the end of compilation increased from 47678k to 49657k, overall 4.15%
Overall memory needed: 147396k -> 148691k
Peak memory use before GGC: 82001k -> 83343k
Peak memory use after GGC: 81184k -> 82490k
Maximum of released memory in single GGC run: 14743k -> 14621k
Garbage: 203809k -> 205357k
Leak: 47678k -> 49657k
Overhead: 25126k -> 26143k
GGC runs: 418 -> 414
Amount of memory referenced pre-ipa increased from 86264k to 88230k, overall 2.28%
Pre-IPA-Garbage: 107843k -> 107822k
Pre-IPA-Leak: 86264k -> 88230k
Pre-IPA-Overhead: 13169k -> 13911k
Amount of memory referenced post-ipa increased from 86264k to 88230k, overall 2.28%
Post-IPA-Garbage: 107843k -> 107822k
Post-IPA-Leak: 86264k -> 88230k
Post-IPA-Overhead: 13169k -> 13911k
comparing Gerald's testcase PR8361 compilation at -O0 -g level:
Peak amount of GGC memory allocated before garbage collecting increased from 95760k to 97292k, overall 1.60%
Peak amount of GGC memory still allocated after garbage collecting increased from 94810k to 96328k, overall 1.60%
Amount of produced GGC garbage increased from 209512k to 210990k, overall 0.71%
Amount of memory still referenced at the end of compilation increased from 74269k to 76251k, overall 2.67%
Overall memory needed: 165136k -> 166247k
Peak memory use before GGC: 95760k -> 97292k
Peak memory use after GGC: 94810k -> 96328k
Maximum of released memory in single GGC run: 14943k -> 14909k
Garbage: 209512k -> 210990k
Leak: 74269k -> 76251k
Overhead: 31811k -> 32832k
GGC runs: 387 -> 385
Amount of memory referenced pre-ipa increased from 102833k to 104800k, overall 1.91%
Pre-IPA-Garbage: 108483k -> 108461k
Pre-IPA-Leak: 102833k -> 104800k
Pre-IPA-Overhead: 16708k -> 17450k
Amount of memory referenced post-ipa increased from 102833k to 104800k, overall 1.91%
Post-IPA-Garbage: 108483k -> 108461k
Post-IPA-Leak: 102833k -> 104800k
Post-IPA-Overhead: 16708k -> 17450k
comparing Gerald's testcase PR8361 compilation at -O1 level:
Peak amount of GGC memory allocated before garbage collecting increased from 79066k to 80338k, overall 1.61%
Peak amount of GGC memory still allocated after garbage collecting increased from 78223k to 79523k, overall 1.66%
Amount of memory still referenced at the end of compilation increased from 44476k to 46431k, overall 4.39%
Overall memory needed: 109039k -> 110117k
Peak memory use before GGC: 79066k -> 80338k
Peak memory use after GGC: 78223k -> 79523k
Maximum of released memory in single GGC run: 14459k -> 14441k
Garbage: 283167k -> 283121k
Leak: 44476k -> 46431k
Overhead: 27890k -> 28634k
GGC runs: 513 -> 505
Amount of memory referenced pre-ipa increased from 82295k to 84262k, overall 2.39%
Pre-IPA-Garbage: 149633k -> 149614k
Pre-IPA-Leak: 82295k -> 84262k
Pre-IPA-Overhead: 16420k -> 17163k
Amount of memory referenced post-ipa increased from 82295k to 84262k, overall 2.39%
Post-IPA-Garbage: 149633k -> 149614k
Post-IPA-Leak: 82295k -> 84262k
Post-IPA-Overhead: 16420k -> 17163k
comparing Gerald's testcase PR8361 compilation at -O2 level:
Peak amount of GGC memory allocated before garbage collecting increased from 79357k to 80430k, overall 1.35%
Peak amount of GGC memory still allocated after garbage collecting increased from 78571k to 79614k, overall 1.33%
Amount of memory still referenced at the end of compilation increased from 44584k to 46551k, overall 4.41%
Overall memory needed: 110107k -> 111549k
Peak memory use before GGC: 79357k -> 80430k
Peak memory use after GGC: 78571k -> 79614k
Maximum of released memory in single GGC run: 14426k -> 14444k
Garbage: 334934k -> 335124k
Leak: 44584k -> 46551k
Overhead: 32756k -> 33522k
GGC runs: 581 -> 572
Amount of memory referenced pre-ipa increased from 82160k to 84126k, overall 2.39%
Pre-IPA-Garbage: 151234k -> 151211k
Pre-IPA-Leak: 82160k -> 84126k
Pre-IPA-Overhead: 16555k -> 17297k
Amount of memory referenced post-ipa increased from 82160k to 84126k, overall 2.39%
Post-IPA-Garbage: 151234k -> 151211k
Post-IPA-Leak: 82160k -> 84126k
Post-IPA-Overhead: 16555k -> 17297k
comparing Gerald's testcase PR8361 compilation at -O3 level:
Peak amount of GGC memory allocated before garbage collecting increased from 80352k to 81700k, overall 1.68%
Peak amount of GGC memory still allocated after garbage collecting increased from 79547k to 80884k, overall 1.68%
Amount of memory still referenced at the end of compilation increased from 44958k to 46948k, overall 4.43%
Overall memory needed: 117823k -> 119713k
Peak memory use before GGC: 80352k -> 81700k
Peak memory use after GGC: 79547k -> 80884k
Maximum of released memory in single GGC run: 14782k -> 14788k
Garbage: 363549k -> 363822k
Leak: 44958k -> 46948k
Overhead: 34977k -> 35784k
GGC runs: 602 -> 594
Amount of memory referenced pre-ipa increased from 82425k to 84400k, overall 2.40%
Pre-IPA-Garbage: 153862k -> 153846k
Pre-IPA-Leak: 82425k -> 84400k
Pre-IPA-Overhead: 16792k -> 17538k
Amount of memory referenced post-ipa increased from 82425k to 84400k, overall 2.40%
Post-IPA-Garbage: 153862k -> 153846k
Post-IPA-Leak: 82425k -> 84400k
Post-IPA-Overhead: 16792k -> 17538k
comparing PR rtl-optimization/28071 testcase compilation at -O0 level:
Peak amount of GGC memory allocated before garbage collecting increased from 100772k to 101152k, overall 0.38%
Peak amount of GGC memory still allocated after garbage collecting increased from 56425k to 56806k, overall 0.68%
Amount of memory still referenced at the end of compilation increased from 6163k to 6622k, overall 7.44%
Overall memory needed: 377341k -> 377733k
Peak memory use before GGC: 100772k -> 101152k
Peak memory use after GGC: 56425k -> 56806k
Maximum of released memory in single GGC run: 50583k -> 50582k
Garbage: 181062k -> 180611k
Leak: 6163k -> 6622k
Overhead: 30560k -> 30732k
GGC runs: 97 -> 88
Amount of produced pre-ipa-GGC garbage increased from 12450k to 12467k, overall 0.14%
Amount of memory referenced pre-ipa increased from 21648k to 21983k, overall 1.55%
Pre-IPA-Garbage: 12450k -> 12467k
Pre-IPA-Leak: 21648k -> 21983k
Pre-IPA-Overhead: 1763k -> 1847k
Amount of produced post-ipa-GGC garbage increased from 12450k to 12467k, overall 0.14%
Amount of memory referenced post-ipa increased from 21648k to 21983k, overall 1.55%
Post-IPA-Garbage: 12450k -> 12467k
Post-IPA-Leak: 21648k -> 21983k
Post-IPA-Overhead: 1763k -> 1847k
comparing PR rtl-optimization/28071 testcase compilation at -O0 -g level:
Peak amount of GGC memory allocated before garbage collecting increased from 101469k to 101851k, overall 0.38%
Peak amount of GGC memory still allocated after garbage collecting increased from 57122k to 57504k, overall 0.67%
Amount of memory still referenced at the end of compilation increased from 8206k to 8667k, overall 5.61%
Overall memory needed: 378113k -> 378693k
Peak memory use before GGC: 101469k -> 101851k
Peak memory use after GGC: 57122k -> 57504k
Maximum of released memory in single GGC run: 50583k
Garbage: 181182k -> 180728k
Leak: 8206k -> 8667k
Overhead: 31145k -> 31318k
GGC runs: 106 -> 95
Amount of produced pre-ipa-GGC garbage increased from 12457k to 12475k, overall 0.14%
Amount of memory referenced pre-ipa increased from 21897k to 22232k, overall 1.53%
Pre-IPA-Garbage: 12457k -> 12475k
Pre-IPA-Leak: 21897k -> 22232k
Pre-IPA-Overhead: 1818k -> 1901k
Amount of produced post-ipa-GGC garbage increased from 12457k to 12475k, overall 0.14%
Amount of memory referenced post-ipa increased from 21897k to 22232k, overall 1.53%
Post-IPA-Garbage: 12457k -> 12475k
Post-IPA-Leak: 21897k -> 22232k
Post-IPA-Overhead: 1818k -> 1901k
comparing PR rtl-optimization/28071 testcase compilation at -O1 level:
Peak amount of GGC memory allocated before garbage collecting increased from 75642k to 75898k, overall 0.34%
Peak amount of GGC memory still allocated after garbage collecting increased from 67586k to 67842k, overall 0.38%
Amount of memory still referenced at the end of compilation increased from 7907k to 8242k, overall 4.24%
Overall memory needed: 383965k -> 384084k
Peak memory use before GGC: 75642k -> 75898k
Peak memory use after GGC: 67586k -> 67842k
Maximum of released memory in single GGC run: 34790k -> 34793k
Garbage: 243308k -> 243329k
Leak: 7907k -> 8242k
Overhead: 30630k -> 30714k
GGC runs: 103 -> 94
Amount of memory referenced pre-ipa increased from 63623k to 63958k, overall 0.53%
Pre-IPA-Garbage: 49523k -> 49540k
Pre-IPA-Leak: 63623k -> 63958k
Pre-IPA-Overhead: 6443k -> 6527k
Amount of memory referenced post-ipa increased from 63623k to 63958k, overall 0.53%
Post-IPA-Garbage: 49523k -> 49540k
Post-IPA-Leak: 63623k -> 63958k
Post-IPA-Overhead: 6443k -> 6527k
comparing PR rtl-optimization/28071 testcase compilation at -O2 level:
Peak amount of GGC memory allocated before garbage collecting increased from 75643k to 75899k, overall 0.34%
Peak amount of GGC memory still allocated after garbage collecting increased from 67587k to 67843k, overall 0.38%
Amount of memory still referenced at the end of compilation increased from 8070k to 8405k, overall 4.15%
Overall memory needed: 322069k -> 320892k
Peak memory use before GGC: 75643k -> 75899k
Peak memory use after GGC: 67587k -> 67843k
Maximum of released memory in single GGC run: 32467k
Garbage: 254865k -> 254882k
Leak: 8070k -> 8405k
Overhead: 33405k -> 33489k
GGC runs: 115 -> 106
Amount of memory referenced pre-ipa increased from 75513k to 75847k, overall 0.44%
Pre-IPA-Garbage: 107518k -> 107535k
Pre-IPA-Leak: 75513k -> 75847k
Pre-IPA-Overhead: 10761k -> 10845k
Amount of memory referenced post-ipa increased from 75513k to 75847k, overall 0.44%
Post-IPA-Garbage: 107518k -> 107535k
Post-IPA-Leak: 75513k -> 75847k
Post-IPA-Overhead: 10761k -> 10845k
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 142468k to 142724k, overall 0.18%
Peak amount of GGC memory still allocated after garbage collecting increased from 129124k to 129380k, overall 0.20%
Amount of memory still referenced at the end of compilation increased from 11049k to 11384k, overall 3.03%
Overall memory needed: 1068165k -> 1068340k
Peak memory use before GGC: 142468k -> 142724k
Peak memory use after GGC: 129124k -> 129380k
Maximum of released memory in single GGC run: 59680k -> 59679k
Garbage: 356314k -> 356330k
Leak: 11049k -> 11384k
Overhead: 38047k -> 38131k
GGC runs: 101 -> 92
Amount of memory referenced pre-ipa increased from 75513k to 75847k, overall 0.44%
Pre-IPA-Garbage: 107518k -> 107535k
Pre-IPA-Leak: 75513k -> 75847k
Pre-IPA-Overhead: 10761k -> 10845k
Amount of memory referenced post-ipa increased from 75513k to 75847k, overall 0.44%
Post-IPA-Garbage: 107518k -> 107535k
Post-IPA-Leak: 75513k -> 75847k
Post-IPA-Overhead: 10761k -> 10845k
Head of the ChangeLog is:
--- /usr/src/SpecTests/sandbox-britten-memory/x86_64/mem-result/ChangeLog 2008-07-22 15:34:08.000000000 +0000
+++ /usr/src/SpecTests/sandbox-britten-memory/gcc/gcc/ChangeLog 2008-07-23 14:04:39.000000000 +0000
@@ -1,3 +1,406 @@
+2008-07-23 Michael Meissner <gnu@the-meissners.org>
+ Karthik Kumar <karthikkumar@gmail.com>
+
+ * attribs.c (file scope): Include c-common.h.
+ (decl_attributes): Add support for #pragma GCC optimize and
+ #pragma GCC option.
+
+ * targhooks.c (default_can_inline_p): New function that is the
+ default for the TARGET_CAN_INLINE_P target hook.
+
+ * targhooks.h (default_can_inline_p): Add declaration.
+
+ * tree.c (cl_optimization_node): New static tree for building
+ OPTIMIZATION_NODE tree.
+ (cl_target_option_node): New static tree for building
+ TARGET_OPTION_NODE tree.
+ (cl_option_hash_table): New hash table for hashing
+ OPTIMIZATION_NODE and TARGET_OPTION_NODE trees.
+ (cl_option_hash_hash): New function to provide the hash value for
+ OPTIMIZATION_NODE and TARGET_OPTION_NODE trees.
+ (cl_option_hash_eq): New function to provide an equality test for
+ OPTIMIZATION_NODE and TARGET_OPTION_NODE trees.
+ (tree_code_size): Add support for OPTIMIZATION_NODE and
+ TARGET_OPTION_NODE trees.
+ (tree_code_structure): Add support for OPTIMIZATION_NODE and
+ TARGET_OPTION_NODE trees.
+ (build_optimization_node): Build a tree that has all of the
+ current optimization options.
+ (build_target_option_node): Build a tree that has the target
+ options that might be changed on a per function basis.
+
+ * tree.h (file scope): Include options.h.
+ (DECL_FUNCTION_SPECIFIC_TARGET): New accessor macro.
+ (DECL_FUNCTION_SPECIFIC_OPTIMIZATION): Ditto.
+ (TREE_OPTIMIZATION): Ditto.
+ (TREE_TARGET_SPECIFIC): Ditto.
+ (struct tree_function_decl): Add fields for remembering the
+ current optimization options and target specific options.
+ (struct tree_optimization_option): New tree variant that remembers
+ the optimization options.
+ (struct tree_target_option): New tree variant that remembers the
+ target specific flags that might change for compiling a particular
+ function.
+ (union tree_node): Include tree_optimization_option and
+ tree_target_option fields.
+ (enum tree_index): Add TI_OPTIMIZATION_DEFAULT,
+ TI_OPTIMIZATION_CURRENT, TI_OPTIMIZATION_COLD,
+ TI_OPTIMIZATION_HOT, TI_TARGET_OPTION_DEFAULT,
+ TI_TARGET_OPTION_CURRENT, TI_CURRENT_OPTION_PRAGMA,
+ TI_CURRENT_OPTIMIZE_PRAGMA entries for saving function specific
+ optimization and target options.
+ (optimization_default_node): New macro to refer to global_trees
+ field.
+ (optimization_current_node): Ditto.
+ (optimization_cold_node): Ditto.
+ (optimization_hot_node): Ditto.
+ (target_option_default_node): Ditto.
+ (target_option_current_node): Ditto.
+ (current_option_pragma): Ditto.
+ (current_optimize_pragma): Ditto.
+
+ * target.h (struct gcc_target): Add valid_option_attribute_p,
+ target_option_save, target_option_restore, target_option_print,
+ target_option_pragma_parse, and can_inline_p hooks.
+
+ * toplev.h (parse_optimize_options): Add declaration.
+ (fast_math_flags_struct_set_p): Ditto.
+
+ * c-cppbuiltin.c (c_cpp_builtins_optimize_pragma): New function to
+ adjust the current __OPTIMIZE__, etc. macros when #pragma GCC
+ optimize is used.
+
+ * ipa-inline.c (cgraph_decide_inlining_of_small_function): Call
+ tree_can_inline_p hook to see if one function can inline another.
+ (cgraph_decide_inlining): Ditto.
+ (cgraph_decide_inlining_incrementally): Ditto.
+
+ * opts.c (decode_options): Add support for running multiple times
+ to allow functions with different target or optimization options
+ than was specified on the command line.
+ (fast_math_flags_struct_set_p): New function that is similar to
+ fast_math_flags_set_p, except it uses the values in the
+ cl_optimization structure instead of global variables.
+
+ * optc-gen.awk: Add support for TargetSave to allow a back end to
+ declare new fields that need to be saved when using function
+ specific options. Include flags.h and target.h in the options.c
+ source. Add support for Save to indicate which options can be set
+ for individual functions. Generate cl_optimize_save,
+ cl_optimize_restore, cl_optimize_print, cl_target_option_save,
+ cl_target_option_restore, cl_target_option_print functions to
+ allow functions to use different optimization or target options.
+
+ * opt-functions.awk (var_type_struct): Return the type used for
+ storing the field in a structure.
+
+ * opth-gen.awk: Add support for TargetSave to allow a back end to
+ declare new fields that need to be saved when using function
+ specific options. Add support for Save to indicate which options
+ can be set for individual functions. Only generate one extern for
+ Mask fields. Generate cl_optimization and cl_target_option
+ structures to remember optimization and target options.
+
+ * treestruct.def (TS_OPTIMIZATION): Add support for garbage
+ collecting new tree nodes.
+ (TS_TARGET_OPTION): Ditto.
+
+ * c-decl.c (merge_decls): Merge function specific target and
+ optimization options.
+
+ * function.c (invoke_set_current_function_hook): If the function
+ uses different optimization options, change the global variables
+ to reflect this.
+
+ * coretypes.h (struct cl_optimization): Add forward reference.
+ (struct cl_target_option): Ditto.
+
+ * c-pragma.c (option_stack): New static vector to remember the
+ current #pragma GCC option stack.
+ (handle_pragma_option): New function to support #pragma GCC option
+ to change target options.
+ (optimize_stack): New static vector to remember the current
+ #pragma GCC optimize stack.
+ (handle_pragma_optimize): New function to support #pragma GCC
+ optimize to change optimization options.
+ (init_pragma): Add support for #pragma GCC optimize and #pragma
+ GCC option.
+
+ * tree.def (OPTIMIZATION_NODE): New tree code for remembering
+ optimization options.
+ (TARGET_OPTION_NODE): New tree code for remembering certain target
+ options.
+
+ * print-tree.c (print_node): Add support for OPTIMIZATION_NODE and
+ TARGET_OPTION_NODE trees.
+
+ * common.opt (-O): Add Optimization flag.
+ (-Os): Ditto.
+ (-fmath-errno): Ditto.
+ (-falign-functions): Add UInteger flag to make sure flag gets full
+ int in cl_optimization structure.
+ (-falign-jumps): Ditto.
+ (-falign-labels): Ditto.
+ (-falign-loops): Ditto.
+ (-fsched-stalled-insns): Ditto.
+ (-fsched-stalled-insns-dep): Ditto.
+
+ * target-def.h (TARGET_VALID_OPTION_ATTRIBUTE_P): Add default
+ definition.
+ (TARGET_OPTION_SAVE): Ditto.
+ (TARGET_OPTION_RESTORE): Ditto.
+ (TARGET_OPTION_PRINT): Ditto.
+ (TARGET_OPTION_PRAGMA_PARSE): Ditto.
+ (TARGET_CAN_INLINE_P): Ditto.
+ (TARGET_INITIALIZER): Add new hooks.
+
+ * tree-inline.c (tree_can_inline_p): New function to determine
+ whether one function can inline another. Check if the functions
+ use compatible optimization options, and also call the backend
+ can_inline_p hook.
+
+ * tree-inline.h (tree_can_inline_p): Add declaration.
+
+ * c-common.c (c_common_attribute): Add support for option and
+ optimize attributes.
+ (handle_option_attribute): Add support for the option attribute to
+ allow the user to specify different target options for compiling a
+ specific function.
+ (handle_optimize_attribute): Add support for the optimize
+ attribute to allow the user to specify different optimization
+ options for compiling a specific function.
+ (handle_hot_attribute): Turn on -O3 optimization for this one
+ function if it isn't the default optimization level.
+ (handle_cold_attribute): Turn on -Os optimization for this one
+ function if it insn't the default optimization.
+ (const_char_p): New const char * typedef.
+ (optimize_args): New static vector to remember the optimization
+ arguments.
+ (parse_optimize_options): New function to set up the optimization
+ arguments from either the optimize attribute or #pragma GCC
+ optimize.
+
+ * c-common.h (c_cpp_builtins_optimize_pragma): Add declaration.
+ (builtin_define_std): Ditto.
+
+ * config.gcc (i[3467]86-*-*): Add i386-c.o to C/C++ languages.
+ Add t-i386 Makefile fragment to add i386-c.o and i386.o
+ dependencies.
+ (x86_64-*-*): Ditto.
+
+ * Makefile.in (TREE_H): Add options.h.
+ (options.o): Add $(TARGET_H) $(FLAGS_H) dependencies.
+
+ * doc/extend.texi (option attribute): Document new attribute.
+ (optimize attribute): Ditto.
+ (hot attribute): Document hot attribute sets -O3.
+ (cold attribute): Document cold attribute sets -Os.
+ (#pragma GCC option): Document new pragma.
+ (#pragma GCC optimize): Ditto.
+
+ * doc/options.texi (TargetSave): Document TargetSave syntax.
+ (UInteger): Document UInteger must be used for certain flags.
+ (Save): Document Save option to create target specific options
+ that can be saved/restored on a function specific context.
+
+ * doc/c-tree.texi (DECL_FUNCTION_SPECIFIC_TARGET): Document new
+ macro.
+ (DECL_FUNCTION_SPECIFIC_OPTIMIZATION): Ditto.
+
+ * doc/tm.texi (TARGET_VALID_OPTION_ATTRIBUTE_P): Document new
+ hook.
+ (TARGET_OPTION_SAVE): Ditto.
+ (TARGET_OPTION_RESTORE): Ditto.
+ (TARGET_OPTION_PRINT): Ditto.
+ (TARGET_OPTION_PRAGMA_PARSE): Ditto.
+ (TARGET_CAN_INLINE_P): Ditto.
+
+ * doc/invoke.texi (-mfpmath=sse+387): Document as an alias for
+ -mfpmath=sse,387.
+ (-mfpmath=both): Ditto.
+
+2008-07-23 Michael Meissner <gnu@the-meissners.org>
+ Karthik Kumar <karthikkumar@gmail.com>
+
+ * config/i386/i386.h (TARGET_ABM): Move switch into
+ ix86_isa_flags.
+ (TARGET_POPCNT): Ditto.
+ (TARGET_SAHF): Ditto.
+ (TARGET_AES): Ditto.
+ (TARGET_PCLMUL): Ditto.
+ (TARGET_CMPXCHG16B): Ditto.
+ (TARGET_RECIP): Move switch into target_flags.
+ (TARGET_FUSED_MADD): Ditto.
+ (ix86_arch_features): Make an unsigned char type.
+ (ix86_tune_features): Ditto.
+ (OVERRIDE_OPTIONS): Add bool argument to override_options call.
+ (TARGET_CPU_CPP_BUILTINS): Move into ix86_target_macros.
+ (REGISTER_TARGET_PRAGMAS): Define, call ix86_register_pragmas.
+
+ * config/i386/i386.opt (arch): New TargetSave field to define
+ fields that need to be saved for function specific option
+ support.
+ (tune): Ditto.
+ (fpmath): Ditto.
+ (branch_cost): Ditto.
+ (ix86_isa_flags_explicit): Ditto.
+ (tune_defaulted): Ditto.
+ (arch_specified): Ditto.
+ (-m128-long-double): Add Save flag to save option for target
+ specific option support.
+ (-m80387): Ditto.
+ (-maccumulate-outgoing-args): Ditto.
+ (-malign-double): Ditto.
+ (-malign-stringops): Ditto.
+ (-mfancy-math-387): Ditto.
+ (-mhard-float): Ditto.
+ (-mieee-fp): Ditto.
+ (-minline-all-stringops): Ditto.
+ (-minline-stringops-dynamically): Ditto.
+ (-mms-bitfields): Ditto.
+ (-mno-align-stringops): Ditto.
+ (-mno-fancy-math-387): Ditto.
+ (-mno-push-args): Ditto.
+ (-mno-red-zone): Ditto.
+ (-mpush-args): Ditto.
+ (-mred-zone): Ditto.
+ (-mrtd): Ditto.
+ (-msseregparm): Ditto.
+ (-mstack-arg-probe): Ditto.
+ (-m32): Ditto.
+ (-m64): Ditto.
+ (-mmmx): Ditto.
+ (-m3dnow): Ditto.
+ (-m3dnowa): Ditto.
+ (-msse): Ditto.
+ (-msse2): Ditto.
+ (-msse3): Ditto.
+ (-msse4.1): Ditto.
+ (-msse4.2): Ditto.
+ (-msse4): Ditto.
+ (-mno-sse4): Ditto.
+ (-msse4a): Ditto.
+ (-msse5): Ditto.
+ (-mrecip): Move flag into target_flags.
+ (-mcld): Ditto.
+ (-mno-fused-madd): Ditto.
+ (-mfused-madd): Ditto.
+ (-mabm): Move flag into ix86_isa_flags.
+ (-mcx16): Ditto.
+ (-mpopcnt): Ditto.
+ (-msahf): Ditto.
+ (-maes): Ditto.
+ (-mpclmul): Ditto.
+
+ * config/i386/i386-c.c: New file for #pragma support.
+ (ix86_target_macros_internal): New function to #define or #undef
+ target macros based when the user uses the #pragma GCC option to
+ change target options.
+ (ix86_pragma_option_parse): New function to add #pragma GCC option
+ support.
+ (ix86_target_macros): Move defining the target macros here from
+ TARGET_CPU_CPP_BUILTINS in i386.h.
+ (ix86_register_pragmas): Register the #pragma GCC option hook. If
+ defined, initialize any subtarget #pragmas.
+
+ * config/i386/darwin.h (REGISTER_SUBTARGET_PRAGMAS): Rename from
+ REGISTER_TARGET_PRAGMAS.
+
+ * config/i386/t-i386: New file for x86 dependencies.
+ (i386.o): Make dependencies mirror the include files used.
+ (i386-c.o): New file, add dependencies.
+
+ * config/i386/i386-protos.h (override_options): Add bool
+ argument.
+ (ix86_valid_option_attribute_tree): Add declaration.
+ (ix86_target_macros): Ditto.
+ (ix86_register_macros): Ditto.
+
+ * config/i386/i386.c (ix86_tune_features): Move initialization of
+ the target masks to initial_ix86_tune_features to allow functions
+ to have different target options. Make type unsigned char,
+ instead of unsigned int.
+ (initial_ix86_tune_features): New static vector to hold processor
+ masks for the tune variables.
+ (ix86_arch_features): Move initialization of the target masks to
+ initial_ix86_arch_features to allow functions to have different
+ target options. Make type unsigned char, instead of unsigned
+ int.
+ (initial_ix86_arch_features): New static vector to hold processor
+ masks for the arch variables.
+ (enum ix86_function_specific_strings): New enum to describe the
+ string options used for attribute((option(...))).
+ (ix86_target_string): New function to return a string that
+ describes the target options.
+ (ix86_debug_options): New function to print the current options in
+ the debugger.
+ (ix86_function_specific_save): New function hook to save the
+ function specific global variables in the cl_target_option
+ structure.
+ (ix86_function_specific_restore): New function hook to restore the
+ function specific variables from the cl_target_option structure to
+ the global variables.
+ (ix86_function_specific_print): New function hook to print the
+ target specific options in the cl_target_option structure.
+ (ix86_valid_option_attribute_p): New function hook to validate
+ attribute((option(...))) arguments.
+ (ix86_valid_option_attribute_tree): New function that is common
+ code between attribute((option(...))) and #pragma GCC option
+ support that parses the options and returns a tree holding the
+ options.
+ (ix86_valid_option_attribute_inner_p): New helper function for
+ ix86_valid_option_attribute_tree.
+ (ix86_can_inline_p): New function hook to decide if one function
+ can inline another on a target specific basis.
+ (ix86_set_current_function); New function hook to switch target
+ options if the user used attribute((option(...))) or #pragma GCC
+ option.
+ (ix86_tune_defaulted): Move to static file scope from
+ override_options.
+ (ix86_arch_specified): Ditto.
+ (OPTION_MASK_ISA_AES_SET): New macro for moving switches into
+ ix86_isa_flags.
+ (OPTION_MASK_ISA_PCLMUL_SET): Ditto.
+ (OPTION_MASK_ISA_ABM_SET): Ditto.
+ (OPTION_MASK_ISA_POPCNT_SET): Ditto.
+ (OPTION_MASK_ISA_CX16_SET): Ditto.
+ (OPTION_MASK_ISA_SAHF_SET): Ditto.
+ (OPTION_MASK_ISA_AES_UNSET): Ditto.
+ (OPTION_MASK_ISA_PCLMUL_UNSET): Ditto.
+ (OPTION_MASK_ISA_ABM_UNSET): Ditto.
+ (OPTION_MASK_ISA_POPCNT_UNSET): Ditto.
+ (OPTION_MASK_ISA_CX16_UNSET): Ditto.
+ (OPTION_MASK_ISA_SAHF_UNSET): Ditto.
+ (struct ptt): Move to static file scope from override_options.
+ (processor_target_table): Ditto.
+ (cpu_names): Ditto.
+ (ix86_handle_option): Add support for options that are now isa
+ options.
+ (override_options): Add support for declaring functions that
+ support different target options than were specified on the
+ command line. Move struct ptt, processor_target_table, cpu_names,
+ ix86_tune_defaulted, ix86_arch_specified to static file scope.
+ Add bool argument. Fix up error messages so the appropriate error
+ is given for either command line or attribute.
+ (ix86_previous_fndecl): New static to remember previous function
+ declaration to see if we need to change target options.
+ (ix86_builtins_isa): New array to record the ISA of each builtin
+ function.
+ (def_builtin): Always create the builtin function, even if the
+ current ISA doesn't support it.
+ (ix86_init_mmx_sse_builtins): Remove TARGET_AES and TARGET_PCLMUL
+ tests for those builtins.
+ (ix86_init_builtins): Remove TARGET_MMX test for calling
+ ix86_init_mmx_sse_builtins.
+ (ix86_expand_builtin): If the current ISA doesn't support a given
+ builtin, signal an error.
+ (TARGET_VALID_OPTION_ATTRIBUTE_P): Set target hook.
+ (TARGET_SET_CURRENT_FUNCTION): Ditto.
+ (TARGET_OPTION_SAVE): Ditto.
+ (TARGET_OPTION_RESTORE): Ditto.
+ (TARGET_OPTION_PRINT): Ditto.
+ (TARGET_CAN_INLINE_P): Ditto.
+
2008-07-22 Rafael Avila de Espindola <espindola@google.com>
* c-typeck.c (build_external_ref): Don't call assemble_external.
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.