From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/testsuite/g++.dg/tree-ssa/20040317-1.C | 38 ++ gcc/testsuite/g++.dg/tree-ssa/block1.C | 11 + gcc/testsuite/g++.dg/tree-ssa/builtin1.C | 10 + gcc/testsuite/g++.dg/tree-ssa/copyprop-1.C | 31 + gcc/testsuite/g++.dg/tree-ssa/copyprop.C | 739 +++++++++++++++++++++ gcc/testsuite/g++.dg/tree-ssa/dom-invalid.C | 52 ++ gcc/testsuite/g++.dg/tree-ssa/ehcleanup-1.C | 24 + gcc/testsuite/g++.dg/tree-ssa/empty-1.C | 14 + gcc/testsuite/g++.dg/tree-ssa/empty-2.C | 15 + gcc/testsuite/g++.dg/tree-ssa/fold-compare.C | 28 + gcc/testsuite/g++.dg/tree-ssa/fwprop-align.C | 20 + gcc/testsuite/g++.dg/tree-ssa/inline-1.C | 36 + gcc/testsuite/g++.dg/tree-ssa/inline-2.C | 36 + gcc/testsuite/g++.dg/tree-ssa/inline-3.C | 29 + gcc/testsuite/g++.dg/tree-ssa/ivopts-1.C | 18 + gcc/testsuite/g++.dg/tree-ssa/ivopts-2.C | 11 + gcc/testsuite/g++.dg/tree-ssa/new1.C | 42 ++ gcc/testsuite/g++.dg/tree-ssa/nothrow-1.C | 22 + gcc/testsuite/g++.dg/tree-ssa/obj-type-ref.C | 19 + .../g++.dg/tree-ssa/pointer-reference-alias.C | 13 + gcc/testsuite/g++.dg/tree-ssa/pr13146.C | 77 +++ gcc/testsuite/g++.dg/tree-ssa/pr14703.C | 49 ++ gcc/testsuite/g++.dg/tree-ssa/pr14814.C | 20 + gcc/testsuite/g++.dg/tree-ssa/pr15791-1.C | 25 + gcc/testsuite/g++.dg/tree-ssa/pr15791-2.C | 13 + gcc/testsuite/g++.dg/tree-ssa/pr15791-3.C | 13 + gcc/testsuite/g++.dg/tree-ssa/pr15791-4.C | 13 + gcc/testsuite/g++.dg/tree-ssa/pr15791-5.C | 13 + gcc/testsuite/g++.dg/tree-ssa/pr16688.C | 273 ++++++++ gcc/testsuite/g++.dg/tree-ssa/pr17153.C | 17 + gcc/testsuite/g++.dg/tree-ssa/pr17400.C | 53 ++ gcc/testsuite/g++.dg/tree-ssa/pr17517.C | 32 + gcc/testsuite/g++.dg/tree-ssa/pr18178.C | 47 ++ gcc/testsuite/g++.dg/tree-ssa/pr19637.C | 33 + gcc/testsuite/g++.dg/tree-ssa/pr19786.C | 48 ++ gcc/testsuite/g++.dg/tree-ssa/pr19807.C | 30 + gcc/testsuite/g++.dg/tree-ssa/pr19952.C | 24 + gcc/testsuite/g++.dg/tree-ssa/pr20280.C | 63 ++ gcc/testsuite/g++.dg/tree-ssa/pr20458.C | 37 ++ gcc/testsuite/g++.dg/tree-ssa/pr20489.C | 22 + gcc/testsuite/g++.dg/tree-ssa/pr20920.C | 26 + gcc/testsuite/g++.dg/tree-ssa/pr20963.C | 23 + gcc/testsuite/g++.dg/tree-ssa/pr21082.C | 14 + gcc/testsuite/g++.dg/tree-ssa/pr21407.C | 8 + gcc/testsuite/g++.dg/tree-ssa/pr21463.C | 20 + gcc/testsuite/g++.dg/tree-ssa/pr21584-1.C | 38 ++ gcc/testsuite/g++.dg/tree-ssa/pr21584-2.C | 22 + gcc/testsuite/g++.dg/tree-ssa/pr22005.C | 10 + gcc/testsuite/g++.dg/tree-ssa/pr22037.C | 14 + gcc/testsuite/g++.dg/tree-ssa/pr22071.C | 14 + gcc/testsuite/g++.dg/tree-ssa/pr22279.C | 43 ++ gcc/testsuite/g++.dg/tree-ssa/pr22404.C | 15 + gcc/testsuite/g++.dg/tree-ssa/pr22444.C | 141 ++++ gcc/testsuite/g++.dg/tree-ssa/pr22488.C | 33 + gcc/testsuite/g++.dg/tree-ssa/pr22550.C | 28 + gcc/testsuite/g++.dg/tree-ssa/pr22615.C | 28 + gcc/testsuite/g++.dg/tree-ssa/pr23046.C | 11 + gcc/testsuite/g++.dg/tree-ssa/pr23164.C | 16 + gcc/testsuite/g++.dg/tree-ssa/pr23624.C | 8 + gcc/testsuite/g++.dg/tree-ssa/pr23948.C | 19 + gcc/testsuite/g++.dg/tree-ssa/pr24172.C | 11 + gcc/testsuite/g++.dg/tree-ssa/pr24231-1.C | 42 ++ gcc/testsuite/g++.dg/tree-ssa/pr24231-2.C | 41 ++ gcc/testsuite/g++.dg/tree-ssa/pr24231-3.C | 28 + gcc/testsuite/g++.dg/tree-ssa/pr24238.C | 13 + gcc/testsuite/g++.dg/tree-ssa/pr24351-1.C | 24 + gcc/testsuite/g++.dg/tree-ssa/pr24351-2.C | 25 + gcc/testsuite/g++.dg/tree-ssa/pr24351-3.C | 101 +++ gcc/testsuite/g++.dg/tree-ssa/pr24439.C | 10 + gcc/testsuite/g++.dg/tree-ssa/pr25771.C | 33 + gcc/testsuite/g++.dg/tree-ssa/pr26140.C | 15 + gcc/testsuite/g++.dg/tree-ssa/pr26406.C | 14 + gcc/testsuite/g++.dg/tree-ssa/pr26443.C | 20 + gcc/testsuite/g++.dg/tree-ssa/pr26757.C | 44 ++ gcc/testsuite/g++.dg/tree-ssa/pr27090.C | 21 + gcc/testsuite/g++.dg/tree-ssa/pr27283.C | 57 ++ gcc/testsuite/g++.dg/tree-ssa/pr27291.C | 363 ++++++++++ gcc/testsuite/g++.dg/tree-ssa/pr27548.C | 60 ++ gcc/testsuite/g++.dg/tree-ssa/pr27549.C | 79 +++ gcc/testsuite/g++.dg/tree-ssa/pr27830.C | 18 + gcc/testsuite/g++.dg/tree-ssa/pr27894.C | 82 +++ gcc/testsuite/g++.dg/tree-ssa/pr28003.C | 31 + gcc/testsuite/g++.dg/tree-ssa/pr28238.C | 22 + gcc/testsuite/g++.dg/tree-ssa/pr29902.C | 19 + gcc/testsuite/g++.dg/tree-ssa/pr30738.C | 17 + gcc/testsuite/g++.dg/tree-ssa/pr31146-2.C | 24 + gcc/testsuite/g++.dg/tree-ssa/pr31146.C | 16 + gcc/testsuite/g++.dg/tree-ssa/pr31307.C | 40 ++ gcc/testsuite/g++.dg/tree-ssa/pr33593.C | 19 + gcc/testsuite/g++.dg/tree-ssa/pr33604.C | 48 ++ gcc/testsuite/g++.dg/tree-ssa/pr33615-2.C | 20 + gcc/testsuite/g++.dg/tree-ssa/pr33615.C | 20 + gcc/testsuite/g++.dg/tree-ssa/pr34063.C | 25 + gcc/testsuite/g++.dg/tree-ssa/pr34355.C | 27 + gcc/testsuite/g++.dg/tree-ssa/pr35144.C | 30 + gcc/testsuite/g++.dg/tree-ssa/pr36766.C | 31 + gcc/testsuite/g++.dg/tree-ssa/pr37084.C | 16 + gcc/testsuite/g++.dg/tree-ssa/pr37284.C | 17 + gcc/testsuite/g++.dg/tree-ssa/pr37337.C | 37 ++ gcc/testsuite/g++.dg/tree-ssa/pr37356.C | 34 + gcc/testsuite/g++.dg/tree-ssa/pr37393.C | 27 + gcc/testsuite/g++.dg/tree-ssa/pr38104.C | 19 + gcc/testsuite/g++.dg/tree-ssa/pr38572.C | 32 + gcc/testsuite/g++.dg/tree-ssa/pr38632.C | 22 + gcc/testsuite/g++.dg/tree-ssa/pr41186.C | 35 + gcc/testsuite/g++.dg/tree-ssa/pr41275.C | 16 + gcc/testsuite/g++.dg/tree-ssa/pr41428.C | 15 + gcc/testsuite/g++.dg/tree-ssa/pr41905.C | 4 + gcc/testsuite/g++.dg/tree-ssa/pr41906.C | 12 + gcc/testsuite/g++.dg/tree-ssa/pr41961.C | 15 + gcc/testsuite/g++.dg/tree-ssa/pr42337.C | 173 +++++ gcc/testsuite/g++.dg/tree-ssa/pr43411.C | 29 + gcc/testsuite/g++.dg/tree-ssa/pr44706.C | 46 ++ gcc/testsuite/g++.dg/tree-ssa/pr44914.C | 20 + gcc/testsuite/g++.dg/tree-ssa/pr45453.C | 19 + gcc/testsuite/g++.dg/tree-ssa/pr45605.C | 37 ++ gcc/testsuite/g++.dg/tree-ssa/pr46228.C | 23 + gcc/testsuite/g++.dg/tree-ssa/pr46734.C | 34 + gcc/testsuite/g++.dg/tree-ssa/pr46987.C | 22 + gcc/testsuite/g++.dg/tree-ssa/pr47707.C | 29 + gcc/testsuite/g++.dg/tree-ssa/pr49516.C | 86 +++ gcc/testsuite/g++.dg/tree-ssa/pr49911.C | 41 ++ gcc/testsuite/g++.dg/tree-ssa/pr50622.C | 30 + gcc/testsuite/g++.dg/tree-ssa/pr54515.C | 19 + gcc/testsuite/g++.dg/tree-ssa/pr8781.C | 28 + gcc/testsuite/g++.dg/tree-ssa/ptrmemfield.C | 27 + gcc/testsuite/g++.dg/tree-ssa/restrict1.C | 20 + gcc/testsuite/g++.dg/tree-ssa/sra-1.C | 29 + gcc/testsuite/g++.dg/tree-ssa/ssa-cast-1.C | 12 + gcc/testsuite/g++.dg/tree-ssa/ssa-sra-1.C | 61 ++ gcc/testsuite/g++.dg/tree-ssa/ssa-sra-2.C | 52 ++ gcc/testsuite/g++.dg/tree-ssa/ssa-sra-3.C | 83 +++ gcc/testsuite/g++.dg/tree-ssa/ssa-store-ccp-1.C | 19 + gcc/testsuite/g++.dg/tree-ssa/tmmti-2.C | 22 + gcc/testsuite/g++.dg/tree-ssa/tmmti.C | 7 + 135 files changed, 5400 insertions(+) create mode 100644 gcc/testsuite/g++.dg/tree-ssa/20040317-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/block1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/builtin1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/copyprop-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/copyprop.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/dom-invalid.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ehcleanup-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/empty-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/empty-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/fold-compare.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/fwprop-align.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/inline-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/inline-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/inline-3.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ivopts-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ivopts-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/new1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/nothrow-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/obj-type-ref.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pointer-reference-alias.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr13146.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr14703.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr14814.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr15791-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr15791-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr15791-3.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr15791-4.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr15791-5.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr16688.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr17153.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr17400.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr17517.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr18178.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr19637.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr19786.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr19807.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr19952.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr20280.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr20458.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr20489.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr20920.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr20963.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr21082.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr21407.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr21463.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr21584-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr21584-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22005.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22037.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22071.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22279.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22404.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22444.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22488.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22550.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr22615.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr23046.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr23164.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr23624.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr23948.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24172.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24231-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24231-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24231-3.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24238.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24351-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24351-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24351-3.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr24439.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr25771.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr26140.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr26406.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr26443.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr26757.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr27090.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr27283.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr27291.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr27548.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr27549.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr27830.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr27894.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr28003.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr28238.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr29902.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr30738.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr31146-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr31146.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr31307.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr33593.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr33604.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr33615-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr33615.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr34063.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr34355.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr35144.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr36766.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr37084.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr37284.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr37337.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr37356.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr37393.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr38104.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr38572.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr38632.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr41186.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr41275.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr41428.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr41905.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr41906.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr41961.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr42337.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr43411.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr44706.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr44914.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr45453.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr45605.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr46228.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr46734.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr46987.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr47707.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr49516.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr49911.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr50622.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr54515.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr8781.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ptrmemfield.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/restrict1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/sra-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ssa-cast-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ssa-sra-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ssa-sra-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ssa-sra-3.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/ssa-store-ccp-1.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/tmmti-2.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/tmmti.C (limited to 'gcc/testsuite/g++.dg/tree-ssa') diff --git a/gcc/testsuite/g++.dg/tree-ssa/20040317-1.C b/gcc/testsuite/g++.dg/tree-ssa/20040317-1.C new file mode 100644 index 000000000..e2f3dcdce --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/20040317-1.C @@ -0,0 +1,38 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +/* Test provided by Brian Ryner in PR 14511. The alias analyzer was + not handling structures containing arrays properly. In this case, + the static cast was introducing two assignments of the form + + this_6->_vptr.IFoo = &_ZTV4IFoo[2]; + this_4->_vptr.IFoo = &_ZTV3Bar[2]; + + which were not considered to alias each other because the alias + analyzer was not computing a proper pointer to array elements. + Another related bug was the type based alias analyzer not computing + alias relations to _ZTV4IFoo and _ZTV3Bar. Since those variables + are read-only, it was disregarding alias information for them. + So, the memory tags for the two 'this' variables were not being + marked as aliased with these variables. Resulting in the two + assignments not aliasing each other. + + This was causing the optimizers to generate a call to the virtual + method Foo() instead of the overloaded version. */ + +struct IFoo +{ + virtual void Foo() = 0; +}; + +struct Bar : IFoo +{ + void Foo() { } +}; + +int main(int argc, char **argv) +{ + Bar* b = new Bar(); + static_cast(b)->Foo(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/block1.C b/gcc/testsuite/g++.dg/tree-ssa/block1.C new file mode 100644 index 000000000..5573251cb --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/block1.C @@ -0,0 +1,11 @@ +// PR 13764: We were inserting an extra body block in all functions, but +// it's only really necessary for [cd]tors. +// { dg-options "-fdump-tree-gimple" } + +void bar (void) +{ + int a; +} + +// { dg-final { scan-tree-dump-times "\{" 1 "gimple" } } +// { dg-final { cleanup-tree-dump "gimple" } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/builtin1.C b/gcc/testsuite/g++.dg/tree-ssa/builtin1.C new file mode 100644 index 000000000..76813cb8d --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/builtin1.C @@ -0,0 +1,10 @@ +// { dg-do link } + +extern void link_error(); + +int main() +{ + if (! __builtin_constant_p (&"Hello"[0])) + link_error(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/copyprop-1.C b/gcc/testsuite/g++.dg/tree-ssa/copyprop-1.C new file mode 100644 index 000000000..03f6b1207 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/copyprop-1.C @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-options "-O -fdump-tree-dce2" } */ + +/* Verify that we can eliminate the useless conversions to/from + const qualified pointer types + this_2 = o_1; + D.20003_4 = this_2->data_m; + this_5 = D.20003_4; + D.20005_6 = this_5->value; + copyprop should propagate o_1 and D.20003_4 to the loads of data_m + and value. dce removes all traces of this. */ + +struct Data { + int get() const { return value; } + int value; +}; + +struct Object { + int operator[](int i) const { return data_m->get(); } + Data *data_m; +}; + +int foo(Object&o) +{ + return o[0]; +} + +/* Remaining should be two loads. */ + +/* { dg-final { scan-tree-dump-times " = \[^\n\]*;" 2 "dce2" } } */ +/* { dg-final { cleanup-tree-dump "dce2" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/copyprop.C b/gcc/testsuite/g++.dg/tree-ssa/copyprop.C new file mode 100644 index 000000000..5ba193618 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/copyprop.C @@ -0,0 +1,739 @@ +// PR 39548 verify ssa ICE +// +// { dg-do compile { target { lp64 } } } +// { dg-options "-Wno-error -fno-exceptions -fno-tree-vrp -O2 -fprofile-generate -finline-limit=500" } +// + +#include +#include +#include +#include +using namespace std; +template _FIter lower_bound(_FIter, _FIter, _Tp&); +template struct hash { }; +template struct _Hashtable_node { + _Hashtable_node* _M_next; + _Val _M_val; +}; +static const unsigned long __stl_prime_list[] = { 2, 3, 5 }; +inline unsigned long prime(unsigned long __n) { + const unsigned long* __first = __stl_prime_list; + const unsigned long* __last = __stl_prime_list + 29; + const unsigned long* pos = lower_bound(__first, __last, __n); + return pos == __last ? *(__last - 1) : *pos; +} +template struct hashtable { + typedef _Key key_type; + typedef _Val value_type; + typedef _HashFcn hasher; + typedef _EqualKey key_equal; + typedef size_t size_type; + typedef value_type& reference; + typedef _Hashtable_node<_Val> _Node; + typedef typename _Alloc::template rebind::other allocator_type; + allocator_type get_allocator() const { } + typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc; + typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc; + typedef vector<_Node*, _Nodeptr_Alloc> _Vector_type; + _Node_Alloc _M_node_allocator; + void _M_put_node(_Node* __p) { + _M_node_allocator.deallocate(__p, 1); + } + hasher _M_hash; + key_equal _M_equals; + _ExtractKey _M_get_key; + _Vector_type _M_buckets; + size_type _M_num_elements; + hashtable(size_type __n, const _HashFcn& __hf, const _EqualKey& __eql, const allocator_type& __a = allocator_type()) : _M_num_elements(0) { + _M_initialize_buckets(__n); + } + ~hashtable() { clear(); } + reference find_or_insert(const value_type& __obj); + size_type count(const key_type& __key) const { + const size_type __n = _M_bkt_num_key(__key); + size_type __result = 0; + for (const _Node* __cur = _M_buckets[__n]; __cur; __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), __key)) ++__result; + } + size_type erase(const key_type& __key); + void clear(); + size_type _M_next_size(size_type __n) const { return prime(__n); } + void _M_initialize_buckets(size_type __n) { + const size_type __n_buckets = _M_next_size(__n); + _M_buckets.reserve(__n_buckets); + _M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0); + } + size_type _M_bkt_num_key(const key_type& __key) const { + return _M_bkt_num_key(__key, _M_buckets.size()); + } + size_type _M_bkt_num_key(const key_type& __key, size_t __n) const { + return _M_hash(__key) % __n; + } + void _M_delete_node(_Node* __n) { + this->get_allocator().destroy(&__n->_M_val); + _M_put_node(__n); + } +}; +template typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::size_type hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: erase(const key_type& __key) { + const size_type __n = _M_bkt_num_key(__key); + _Node* __first = _M_buckets[__n]; + if (__first) _Node* __cur = __first; +} +template void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: clear() { + for (size_type __i = 0; __i < _M_buckets.size(); ++__i) { + _Node* __cur = _M_buckets[__i]; + while (__cur != 0) { _M_delete_node(__cur); } + } +} +template, class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> > struct hash_map { + typedef hashtable,_Key, _HashFn, _Select1st >, _EqualKey, _Alloc> _Ht; + _Ht _M_ht; + typedef typename _Ht::key_type key_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + typedef typename _Ht::size_type size_type; + typedef typename _Ht::allocator_type allocator_type; + hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) { } + _Tp& operator[](const key_type& __key) { + return _M_ht.find_or_insert(value_type(__key, _Tp())).second; + } + size_type count(const key_type& __key) const { return _M_ht.count(__key); } + size_type erase(const key_type& __key) { + return _M_ht.erase(__key); + } +}; +extern size_t strlen (__const char *__s); +template struct scoped_ptr { + explicit scoped_ptr(C* p = __null) : ptr_(p) { delete ptr_; } + void reset(C* p = __null) { + if (p != ptr_) { delete ptr_; } + } + C& operator*() const {} + C* operator->() const {} + bool operator==(C* p) const { return ptr_ == p; } + bool operator!=(C* p) const { return ptr_ != p; } + C* ptr_; +}; +namespace std { +class strstreambuf : public basic_streambuf > { +}; +class strstream : public basic_iostream { + public: int pcount() const; + char* str(); + strstreambuf _M_buf; +}; +}; +const int INFO = 0, WARNING = 1, ERROR = 2, FATAL = 3, NUM_SEVERITIES = 4; +struct foo_1 { + foo_1(string* str) : str_(str) { } + operator bool() const { + return (__builtin_expect(str_ != __null, 0)); + } + string* str_; +}; +template string* Makefoo_1(const t1& v1, const t2& v2, const char* names) { + strstream ss; + ss << names << " (" << v1 << " vs. " << v2 << ")"; + return new string(ss.str(), ss.pcount()); +} +template inline string* Check_GTImpl(const t1& v1, const t2& v2, const char* names) { + if (v1 > v2) return __null; + else return Makefoo_1(v1, v2, names); +} +struct blah_54 { + blah_54(const char* file, int line, int severity); + ~blah_54(); + ostream& stream() { }; +}; +class blah_0 : public blah_54 { + public: blah_0(const char* file, int line); + blah_0(const char* file, int line, const foo_1& result); +}; +template class dense_hashtable; +template struct dense_hashtable_iterator { + typedef V* pointer; + dense_hashtable_iterator(const dense_hashtable *h, pointer it, pointer it_end, bool advance) : ht(h), pos(it), end(it_end) { + if (advance) advance_past_empty_and_deleted(); + } + pointer operator->() const { } + void advance_past_empty_and_deleted() { + while ( pos != end && (ht->test_empty(*this) || ht->test_deleted(*this)) ) ++pos; + } + const dense_hashtable *ht; + pointer pos, end; +}; +template struct dense_hashtable_const_iterator { + typedef dense_hashtable_iterator iterator; + typedef dense_hashtable_const_iterator const_iterator; + typedef const V& reference; + typedef const V* pointer; + dense_hashtable_const_iterator(const dense_hashtable *h, pointer it, pointer it_end, bool advance) : ht(h), pos(it), end(it_end) { + if (advance) advance_past_empty_and_deleted(); + } + dense_hashtable_const_iterator(const iterator &it) : pos(it.pos), end(it.end) {} + reference operator*() const { return *pos; } + pointer operator->() const {} + void advance_past_empty_and_deleted() { + while ( pos != end && (ht->test_empty(*this) || ht->test_deleted(*this))) ++pos; + } + const_iterator& operator++() { } + bool operator!=(const const_iterator& it) const { } + const dense_hashtable *ht; + pointer pos, end; +}; +template class dense_hashtable { + public: typedef Key key_type; + typedef Value value_type; + typedef HashFcn hasher; + typedef EqualKey key_equal; + typedef size_t size_type; + typedef dense_hashtable_iterator iterator; + typedef dense_hashtable_const_iterator const_iterator; + static const float HT_OCCUPANCY_FLT; + static const float HT_EMPTY_FLT; + static const size_t HT_MIN_BUCKETS = 32; + iterator end() { + return iterator(this, table + num_buckets, table + num_buckets, true); + } + const_iterator end() const { + return const_iterator(this, table + num_buckets, table+num_buckets,true); + } + void set_value(value_type* dst, const value_type& src) { + new(dst) value_type(src); + } + void destroy_buckets(size_type first, size_type last) { + for (; first != last; ++first) table[first].~value_type(); + } + private: void squash_deleted() { + if ( num_deleted ) { + dense_hashtable tmp(*this); + swap(tmp); + } + } + public: void set_deleted_key(const value_type &val) { squash_deleted(); } + bool test_deleted(size_type bucknum) const { + return (use_deleted && num_deleted > 0 && equals(get_key(delval), get_key(table[bucknum]))); + } + bool test_deleted(const const_iterator &it) const { + return (use_deleted && num_deleted > 0 && equals(get_key(delval), get_key(*it))); + } + bool set_deleted(const_iterator &it) { + set_value(const_cast(&(*it)), delval); + } + bool test_empty(size_type bucknum) const { + return equals(get_key(emptyval), get_key(table[bucknum])); + } + bool test_empty(const const_iterator &it) const { + return equals(get_key(emptyval), get_key(*it)); + } + void fill_range_with_empty(value_type* table_start, value_type* table_end) { + uninitialized_fill(table_start, table_end, emptyval); + } + void set_empty(size_type buckstart, size_type buckend) { + destroy_buckets(buckstart, buckend); + fill_range_with_empty(table + buckstart, table + buckend); + } + size_type size() const { + return num_elements - num_deleted; + } + size_type bucket_count() const { } + static const size_type ILLEGAL_BUCKET = size_type(-1); + size_type min_size(size_type num_elts, size_type min_buckets_wanted) { + size_type sz = HT_MIN_BUCKETS; + while ( sz < min_buckets_wanted || num_elts >= sz * enlarge_resize_percent ) sz *= 2; + } + void maybe_shrink() { + if (shrink_threshold > 0 && (num_elements-num_deleted) < shrink_threshold && bucket_count() > HT_MIN_BUCKETS ) { + size_type sz = bucket_count() / 2; + sz /= 2; + dense_hashtable tmp(*this, sz); + swap(tmp); + } + } + void resize_delta(size_type delta, size_type min_buckets_wanted = 0) { + if ( consider_shrink ) maybe_shrink(); + const size_type needed_size = min_size(num_elements + delta, min_buckets_wanted); + if ( needed_size > bucket_count() ) { + const size_type resize_to = min_size(num_elements - num_deleted + delta, min_buckets_wanted); + dense_hashtable tmp(*this, resize_to); + swap(tmp); + } + } + void copy_from(const dense_hashtable &ht, size_type min_buckets_wanted = 0) { + clear(); + const size_type resize_to = min_size(ht.size(), min_buckets_wanted); + num_elements++; + } + explicit dense_hashtable(size_type n = 0, const HashFcn& hf = HashFcn(), const EqualKey& eql = EqualKey(),const ExtractKey& ext = ExtractKey()) : num_deleted(0), use_deleted(false), use_empty(false), delval(), emptyval(), enlarge_resize_percent(HT_OCCUPANCY_FLT), shrink_resize_percent(HT_EMPTY_FLT), table(__null), num_buckets(min_size(0, n)), num_elements(0) { + reset_thresholds(); + } + dense_hashtable(const dense_hashtable& ht, size_type min_buckets_wanted = 0) : num_deleted(0), use_deleted(ht.use_deleted), use_empty(ht.use_empty), delval(ht.delval), emptyval(ht.emptyval), enlarge_resize_percent(ht.enlarge_resize_percent), shrink_resize_percent(ht.shrink_resize_percent), table(__null), num_buckets(0), num_elements(0) { + reset_thresholds(); + copy_from(ht, min_buckets_wanted); + set_value(&emptyval, ht.emptyval); + enlarge_resize_percent = ht.enlarge_resize_percent; + copy_from(ht); + } + ~dense_hashtable() { + if (table) { + destroy_buckets(0, num_buckets); + free(table); + } + } + void swap(dense_hashtable& ht) { + std::swap(equals, ht.equals); + { + value_type tmp; + set_value(&delval, ht.delval); + set_value(&ht.delval, tmp); + set_value(&ht.emptyval, tmp); + } + std::swap(table, ht.table); + std::swap(num_buckets, ht.num_buckets); + reset_thresholds(); + ht.reset_thresholds(); + } + void clear() { + if (table) destroy_buckets(0, num_buckets); + num_buckets = min_size(0,0); + set_empty(0, num_buckets); + } + pair find_position(const key_type &key) const { + const size_type bucket_count_minus_one = bucket_count() - 1; + size_type bucknum = hash(key) & bucket_count_minus_one; + size_type insert_pos = ILLEGAL_BUCKET; + while ( 1 ) { + if ( test_empty(bucknum) ) { + if ( insert_pos == ILLEGAL_BUCKET ) return pair(ILLEGAL_BUCKET, insert_pos); + } + else if ( test_deleted(bucknum) ) { + if ( insert_pos == ILLEGAL_BUCKET ) insert_pos = bucknum; + } + else if ( equals(key, get_key(table[bucknum])) ) { + return pair(bucknum, ILLEGAL_BUCKET); + } + } + } + iterator find(const key_type& key) { + if ( size() == 0 ) return end(); + pair pos = find_position(key); + if ( pos.first == ILLEGAL_BUCKET ) return end(); + return iterator(this, table + pos.first, table + num_buckets, false); + } + const_iterator find(const key_type& key) const { + if ( size() == 0 ) return end(); + pair pos = find_position(key); + if ( pos.first == ILLEGAL_BUCKET ) return end(); + return const_iterator(this, table + pos.first, table+num_buckets, false); + } + size_type count(const key_type &key) const { + pair pos = find_position(key); } + pair insert_noresize(const value_type& obj) { + const pair pos = find_position(get_key(obj)); + if ( pos.first != ILLEGAL_BUCKET) { + return pair(iterator(this, table + pos.first, table + num_buckets, false), false); + } + else { + if ( test_deleted(pos.second) ) { ++num_elements; } + return pair(iterator(this, table + pos.second, table + num_buckets, false), true); + } + } + pair insert(const value_type& obj) { + resize_delta(1); + return insert_noresize(obj); + } + size_type erase(const key_type& key) { + const_iterator pos = find(key); + if ( pos != end() ) { + set_deleted(pos); + } + } + hasher hash; + key_equal equals; + ExtractKey get_key; + size_type num_deleted; + bool use_deleted; + bool use_empty; + value_type delval; + value_type emptyval; + float enlarge_resize_percent; + float shrink_resize_percent; + size_type shrink_threshold; + size_type enlarge_threshold; + value_type *table; + size_type num_buckets; + size_type num_elements; + bool consider_shrink; + void reset_thresholds() { + enlarge_threshold = static_cast(num_buckets * shrink_resize_percent); + } +}; +template<> struct hash { + size_t operator()(long x) const { + } +}; +template<> struct hash { + size_t operator()(unsigned long x) const { + } +}; +template , class EqualKey = equal_to, class Alloc = allocator > class dense_hash_map { + struct SelectKey { + const Key& operator()(const pair& p) const { + return p.first; + } + }; + typedef dense_hashtable, Key, HashFcn, SelectKey, EqualKey, Alloc> ht; + ht rep; + public: typedef typename ht::key_type key_type; + typedef T data_type; + typedef typename ht::value_type value_type; + typedef typename ht::size_type size_type; + typedef typename ht::iterator iterator; + typedef typename ht::const_iterator const_iterator; + iterator end() { + return rep.end(); + } + iterator find(const key_type& key) { return rep.find(key); } + data_type& operator[](const key_type& key) { + iterator it = find(key); + return insert(value_type(key, data_type())).first->second; + } + pair insert(const value_type& obj) { + return rep.insert(obj); + } + void set_deleted_key(const key_type& key) { + rep.set_deleted_key(value_type(key, data_type())); + } + size_type erase(const key_type& key) { return rep.erase(key); } +}; +template , class EqualKey = equal_to, class Alloc = allocator > class dense_hash_set { + struct Identity { + const Value& operator()(const Value& v) const { return v; } + }; + typedef dense_hashtable ht; + ht rep; + public: typedef typename ht::key_type key_type; + typedef typename ht::value_type value_type; + typedef typename ht::size_type size_type; + typedef typename ht::const_iterator iterator; + size_type count(const key_type& key) const { + return rep.count(key); + } + pair insert(const value_type& obj) { + pair p = rep.insert(obj); + } + size_type erase(const key_type& key) { + return rep.erase(key); + } +}; +class linked_ptr_internal { + public: bool depart() { if (next_ == this) return true; } + mutable linked_ptr_internal const* next_; +}; +template class linked_ptr { + public: explicit linked_ptr(T* ptr = __null) { + } + ~linked_ptr() { depart(); } + T& operator*() const { } + T* value_; + linked_ptr_internal link_; + void depart() { + if (link_.depart()) delete value_; + } +}; +class blah_3 { + const char* ptr_; + int length_; + public: blah_3(const char* str) : ptr_(str), length_((str == __null) ? 0 : static_cast(strlen(str))) { } +}; +class blah_5; +class Bitmap { + public: Bitmap(unsigned int size) : array_size_(RequiredArraySize(size)) { } + static unsigned int RequiredArraySize(unsigned int num_bits) { return (num_bits + 31) >> 5; } + unsigned int array_size_; +}; +enum blah_31 { CREATIVE_FORMAT_TEXT_NARROW, kNumblah_31s }; +enum blah_33 { BLACKLISTED }; +template class blah_55; +typedef blah_55 blah_31Set; +enum blah_36 { APPROVAL_STATUS_APPROVED, APPROVAL_STATUS_UNKNOWN }; +enum blah_37 { hahah_INVALID, hahah_KEYWORD }; +template class blah_55 { + public: blah_55(int enum_size); + bool Insert(EnumT x); + const int enum_size_; + Bitmap elements_; +}; +template blah_55::blah_55(int enum_size) :enum_size_(enum_size), elements_(enum_size) { + while (foo_1 _result = Check_GTImpl(1, 0, "enum_size" " " ">" " " "0")) blah_0(".h", 1902, _result).stream(); +}; +enum blah_38 { + ttttttt_9, }; +class blah_46 { + public: blah_46() : hahaha_id_(0), type_(hahah_INVALID), approval_status_(APPROVAL_STATUS_APPROVED) { + } + blah_46(long cid) : hahaha_id_(cid), type_(hahah_INVALID), approval_status_(APPROVAL_STATUS_APPROVED) { + } + long id() const { + return (static_cast(hahaha_id_) << 16) >> 16; + } + static const blah_46 kBlacklistedID; + bool operator == (const blah_46& x) const { return id() == x.id(); } + bool operator < (const blah_46& x) const { return id() < x.id(); } + long hahaha_id_ : 48; + blah_37 type_ : 8; + blah_36 approval_status_ : 4; +}; +template <> struct hash { + size_t operator()(const blah_46 &x) const { + return size_t(x.id()); + } +}; +class blah_57 { + public: blah_57(); + void AddReason(blah_33 reason, const blah_3& debug_str, const blah_46& hahaha_id, bool ); + void set_collects_multiple_reasons(bool t) { } + private: struct foo_3 { + string reject_desc; + }; + foo_3 first_reason_; +}; +template struct foo_5 : public unary_function { + long operator()(const T* p) const { + long id = reinterpret_cast(p); + if (id < 2) return -id; + } +}; +template class DensePtrSet : public dense_hashtable, foo_5, equal_to, allocator > { + public: DensePtrSet() { + this->set_deleted_key(reinterpret_cast(1)); + } + const T* Find(long key) const { + typename DensePtrSet::const_iterator it = this->find(key); + return it != this->end() ? *it : __null; + } +}; +struct foo_7 { + foo_7(bool spell_correction, bool query_broadening, bool previous_query, bool near_aaaaa, bool same_length, float mult, float exp_score) : shengmo_0(spell_correction), shengmo_1(query_broadening), shengmo_2(previous_query), shengmo_3(near_aaaaa), shengmo_4(same_length), multiplier(mult), expansion_score(exp_score) { + } + int CompareSameKeywordMatch(const foo_7& compare) const; + bool shengmo_0, shengmo_1, shengmo_2, shengmo_3, shengmo_4; + float multiplier, expansion_score; +}; +enum blah_41 { + ACP_ECPM_EARLY = 2 }; +struct foo_8 { unsigned int packed_ctr1; }; +struct foo_9 { foo_9() {}}; +class blah_16; +class blah_17; +class foo_12 { public: foo_12() {} + unsigned long hahaha_id() const {} + unsigned int qbb_score() const {} + private: static const vector hmmmmh_4; + long hahaha_id_ : 40; +}; +class foo_13 { + public: typedef dense_hash_map BestMap; + foo_13() { best_rrrrrrr_.set_deleted_key(-1); } + void erase(long ad_group_id) { + best_rrrrrrr_.erase(ad_group_id); + } + typedef BestMap::iterator iterator; + typedef BestMap::const_iterator const_iterator; + const_iterator begin() const { } + iterator end() { return best_rrrrrrr_.end(); } + iterator find(long ad_group_id) { return best_rrrrrrr_.find(ad_group_id); } + const foo_12& GetMatch(const_iterator it) const {} + void hmmmmh_27(long ad_group_id, const foo_12& addme); + private: BestMap best_rrrrrrr_; + vector rrrrrrr_buffer_; +}; +struct foo_10 : public dense_hash_set {}; +class foo_9Set : public DensePtrSet {}; +typedef map foo_6Data; +typedef hash_map > RejectedAdGroupMap; +enum blah_43 {}; +class foo_14 { + public: foo_14(const unsigned int, const blah_16*, const int*); + bool GathersMultipleRejectionReasons() const; + void hmmmmh_30(blah_46 hahaha_id, blah_38 type); + const foo_7* Insertfoo_6(const blah_46 hahaha_id, bool shengmo_0, bool shengmo_1, bool shengmo_2, bool shengmo_3, bool shengmo_4_rewrite, float multiplier, float context_score); + void hmmmmh_7(blah_46 hahaha_id, blah_38 type); + foo_9* Insertfoo_9(); + bool hmmmmh_8(long ad_group_id, const foo_12 &entry); + void hmmmmh_9(long ad_group_id); + foo_13::iterator hmmmmh_0(long ad_group_id); + bool hmmmmh_8(long ad_group_id, foo_13::iterator best, const foo_12& entry); + void hmmmmh_5(const blah_46 hahaha_id); + void hmmmmh_29(const blah_46 hahaha_id); + bool hmmmmh_12(const blah_46 hahaha_id) const; + bool hmmmmh_13(const blah_46 hahaha_id) const; + const foo_9* Getfoo_9(const blah_46 hahaha_id) const; + bool Gathersfoo_9() const {} + const foo_10* rrrrrrr_type_data() const {} + const foo_10* negative_rrrrrrr_type_data() const {} + const foo_10* positive_rrrrrrr_type_data() const {} + const foo_9Set* kw_info_set() const { } + const foo_6Data* rewrite_data() const {} + const vector& query_rectangles() const {} + void hmmmmh_14(); + void AddQueryRectangle(const blah_17& query_rectangle); + void hmmmmh_15(long ad_group_id, const blah_46 hahaha_id, blah_33 reject_class, const char* reject_desc = __null); + void hmmmmh_16(const vector& rejected_sssr_ids); + void Copy(const foo_14& cmi); + void hmmmmh_10(); + private: const blah_16* ad_request_; + const int* cr_query_; + blah_43 gather_flags_; + vector query_rectangles_; + foo_10 rrrrrrr_type_data_; + foo_9Set kw_info_set_; + foo_6Data rewrite_data_; + scoped_ptr rejected_sssr_map_; + foo_13 ad_group_rrrrrrr_data_; + vector geo_hahaha_; + bool geo_hahaha_is_sorted_; + foo_10 negative_rrrrrrr_type_data_, positive_rrrrrrr_type_data_; + scoped_ptr extra_hahaha_set_; + int dimension_id_; + blah_31Set creative_formats_; + scoped_ptr > near_aaaaa_rrrrrrr_fps_; + blah_41 comparison_policy_; + blah_46 next_virtual_hahaha_id_; + vector* sub_queries_; + bool allow_only_whitelisted_customers_, automatic_hahaha_rrrrrrr_; + scoped_ptr kw_arena_, expanded_rrrrrrr_arena_; +}; +class blah_19 { + void hmmmmh_3(); + enum blah_45 {}; +}; +void blah_19::hmmmmh_3() {} +class blah_16 { + public: int near_aaaaa_rrrrrrr_fps_size() const {} + unsigned long near_aaaaa_rrrrrrr_fps(int i) const {} +}; +class blah_21 { + protected: blah_21(char* first_block, const size_t block_size, bool align_to_page); + void* GetMemoryFallback(const size_t size, const int align); + void* GetMemory(const size_t size, const int align) { + if ( size > 0 && size < remaining_ && align == 1 ) { + last_alloc_ = freestart_; + } + return GetMemoryFallback(size, align); + } + char* freestart_; + char* last_alloc_; + size_t remaining_; +}; +class blah_5 : blah_21 { + public: char* Alloc(const size_t size) { + return reinterpret_cast(GetMemory(size, 1)); + } +}; +class blah_25 { + public: virtual ~blah_25(); +}; +class blah_17 : blah_25 { }; +void Fillfoo_8(const foo_12& x2, struct foo_8* out) { + out->packed_ctr1 = x2.qbb_score(); +} +const vector foo_12::hmmmmh_4; +foo_14::foo_14(const unsigned int gather_flags, const blah_16* ad_request, const int* cr_query): ad_request_(ad_request), cr_query_(cr_query), gather_flags_(static_cast(gather_flags)), geo_hahaha_is_sorted_(false), dimension_id_(0), creative_formats_(kNumblah_31s), comparison_policy_(ACP_ECPM_EARLY), sub_queries_(new vector()), allow_only_whitelisted_customers_(false), automatic_hahaha_rrrrrrr_(false) { + hmmmmh_10(); +} +void foo_14::hmmmmh_5(const blah_46 hahaha_id) { + negative_rrrrrrr_type_data_.insert(hahaha_id); +} +void foo_14::hmmmmh_7(blah_46 hahaha_id, blah_38 type) { } +foo_13::iterator foo_14::hmmmmh_0( long ad_group_id) { + return ad_group_rrrrrrr_data_.find(ad_group_id); +} +bool foo_14::hmmmmh_8(long ad_group_id, foo_13::iterator best, const foo_12& entry) { + rejected_sssr_map_->erase(ad_group_id); + ad_group_rrrrrrr_data_.hmmmmh_27(ad_group_id, entry); +} +bool foo_14::hmmmmh_8(long ad_group_id, const foo_12& entry) { + foo_13::iterator best = hmmmmh_0(ad_group_id); +} +void foo_14::hmmmmh_9(long ad_group_id) { + ad_group_rrrrrrr_data_.erase(ad_group_id); +} +void foo_14::hmmmmh_10() { + if (near_aaaaa_rrrrrrr_fps_ != __null) { + blah_54(".cc", 226, WARNING).stream() << ""; + for (int j = 0; + j < ad_request_->near_aaaaa_rrrrrrr_fps_size(); j++) { + near_aaaaa_rrrrrrr_fps_->insert(ad_request_->near_aaaaa_rrrrrrr_fps(j)); + } + } +} +const foo_7* foo_14::Insertfoo_6(const blah_46 hahaha_id, bool shengmo_0, bool shengmo_1, bool shengmo_2, bool shengmo_3, bool shengmo_4_rewrite, float multiplier, float context_score) { + if (rrrrrrr_type_data_.count(hahaha_id) > 0) return __null; + foo_7* new_info = new(expanded_rrrrrrr_arena_->Alloc(sizeof(foo_7))) foo_7(shengmo_0,shengmo_1, shengmo_2, shengmo_3, shengmo_4_rewrite, multiplier, context_score); + pair status = rewrite_data_.insert( make_pair(hahaha_id, new_info)); + foo_7* inserted = status.first->second; + if (!status.second) { + if (inserted->CompareSameKeywordMatch(*new_info) < 0) *inserted = *new_info; + } +} +foo_9* foo_14::Insertfoo_9() { + foo_9* info = new(kw_arena_->Alloc(sizeof(foo_9))) foo_9; + if (Gathersfoo_9()) kw_info_set_.insert(info); + creative_formats_.Insert(CREATIVE_FORMAT_TEXT_NARROW); +} +bool foo_14::hmmmmh_12(const blah_46 hahaha_id) const { + if (rrrrrrr_type_data_.count(hahaha_id)) return true; +} +bool foo_14::hmmmmh_13(const blah_46 hahaha_id) const { + if (positive_rrrrrrr_type_data_.count(hahaha_id)) return true; +} +const foo_9* foo_14::Getfoo_9(const blah_46 hahaha_id) const { + if (Gathersfoo_9()) return kw_info_set_.Find(hahaha_id.id()); + static int occurrences_383 = 0, occurrences_mod_n_383 = 0; + if (++occurrences_mod_n_383 > 1000) occurrences_mod_n_383 -= 1000; +} +void foo_14::hmmmmh_15(long ad_group_id, const blah_46 hahaha_id, blah_33 reject_class, const char* reject_desc) { + if (rejected_sssr_map_ == __null) { + blah_54("a.cc", 413, ERROR).stream() << "re NULL"; + rejected_sssr_map_.reset(new RejectedAdGroupMap); + } + if (rejected_sssr_map_->count(ad_group_id) == 0) { + blah_57* ad_rejection = new blah_57(); + ad_rejection->set_collects_multiple_reasons( GathersMultipleRejectionReasons()); + (*rejected_sssr_map_)[ad_group_id] = linked_ptr(ad_rejection); + } + blah_57& ad_rejection = *(*rejected_sssr_map_)[ad_group_id]; + ad_rejection.AddReason(reject_class, reject_desc, hahaha_id, false); +} +void foo_14::hmmmmh_16(const vector& rejected_sssr_ids) { + for (vector::const_iterator it = rejected_sssr_ids.begin(); + it != rejected_sssr_ids.end(); ++it) { + ad_group_rrrrrrr_data_.erase(*it); + for (foo_13::const_iterator it = ad_group_rrrrrrr_data_.begin(); + it != ad_group_rrrrrrr_data_.end(); ++it) { + hmmmmh_15(it->first, ad_group_rrrrrrr_data_.GetMatch(it).hahaha_id(), BLACKLISTED); + } + } + hmmmmh_30(blah_46::kBlacklistedID, ttttttt_9); +} +void foo_14::Copy(const foo_14& cmi) { + rrrrrrr_type_data_ = *cmi.rrrrrrr_type_data(); + negative_rrrrrrr_type_data_ = *cmi.negative_rrrrrrr_type_data(); + positive_rrrrrrr_type_data_ = *cmi.positive_rrrrrrr_type_data(); + if (cmi.Gathersfoo_9()) { + kw_info_set_ = *cmi.kw_info_set(); + rewrite_data_ = *cmi.rewrite_data(); + } + hmmmmh_14(); + for (int i = 0; i < cmi.query_rectangles().size(); + ++i) AddQueryRectangle(cmi.query_rectangles()[i]); +} +void foo_13::hmmmmh_27(long ad_group_id, const foo_12& addme) { + int& best_index = best_rrrrrrr_[ad_group_id]; + rrrrrrr_buffer_.push_back(addme); +} +void foo_14::hmmmmh_29(const blah_46 hahaha_id) { + if (extra_hahaha_set_ != __null) extra_hahaha_set_->erase(hahaha_id); +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/dom-invalid.C b/gcc/testsuite/g++.dg/tree-ssa/dom-invalid.C new file mode 100644 index 000000000..5513d3650 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/dom-invalid.C @@ -0,0 +1,52 @@ +// PR tree-optimization/39557 +// invalid post-dom info leads to infinite loop +// { dg-do run } +// { dg-options "-Wall -fno-exceptions -O2 -fprofile-use -fno-rtti" } + +struct C +{ + virtual const char *bar () const; +}; + +struct D +{ + D () : d1 (0) { } + C *d2[4]; + int d1; + inline const C & baz (int i) const { return *d2[i]; } +}; + +struct E +{ + unsigned char e1[2]; + D e2; + bool foo () const { return (e1[1] & 1) != 0; } + virtual const char *bar () const __attribute__ ((noinline)); +}; + +const char * +C::bar () const +{ + return 0; +} + +C c; + +const char * +E::bar () const +{ + const char *e = __null; + if (foo () && (e = c.C::bar ())) + return e; + for (int i = 0, n = e2.d1; i < n; i++) + if ((e = e2.baz (i).C::bar ())) + return e; + return e; +} + +int +main () +{ + E e; + e.bar (); +} // { dg-message "note: file" "" } diff --git a/gcc/testsuite/g++.dg/tree-ssa/ehcleanup-1.C b/gcc/testsuite/g++.dg/tree-ssa/ehcleanup-1.C new file mode 100644 index 000000000..8dfaa52b6 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/ehcleanup-1.C @@ -0,0 +1,24 @@ +// { dg-options "-O2 -fdump-tree-ehcleanup1-details" } +extern void can_throw (); +class a +{ +public: + ~a () + { + if (0) + can_throw (); + } +}; +void +t (void) +{ + class a a; + can_throw (); +} +// We ought to remove implicit cleanup, since destructor is empty. +// { dg-final { scan-tree-dump-times "Empty EH handler" 1 "ehcleanup1" } } +// +// And as a result also contained control flow. +// { dg-final { scan-tree-dump-times "Removing unreachable" 2 "ehcleanup1" } } +// +// { dg-final { cleanup-tree-dump "ehcleanup1" } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/empty-1.C b/gcc/testsuite/g++.dg/tree-ssa/empty-1.C new file mode 100644 index 000000000..6a6e452be --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/empty-1.C @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +struct S {}; +S bar (const S &a) +{ + S s; + s = a; + return s; +} + +/* Test whether memcpy call has been optimized out. */ +/* { dg-final { scan-tree-dump-times "memcpy" 0 "optimized"} } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/empty-2.C b/gcc/testsuite/g++.dg/tree-ssa/empty-2.C new file mode 100644 index 000000000..01b77b4fb --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/empty-2.C @@ -0,0 +1,15 @@ +// PR c++/45307 +// { dg-options "-fdump-tree-gimple -fdump-tree-optimized -O" } + +struct fallible_t { }; +const fallible_t fallible = fallible_t(); + +void t(void) +{ +} + +// { dg-final { scan-tree-dump-not "fallible" "gimple" } } +// Whole constructor should be optimized away. +// { dg-final { scan-tree-dump-not "int" "optimized" } } +// { dg-final { cleanup-tree-dump "gimple" } } +// { dg-final { cleanup-tree-dump "optimized" } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/fold-compare.C b/gcc/testsuite/g++.dg/tree-ssa/fold-compare.C new file mode 100644 index 000000000..2b4c41103 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/fold-compare.C @@ -0,0 +1,28 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +struct ExtentsBase { + ExtentsBase() : startx_(), endx_() { } + ExtentsBase(const ExtentsBase &b) { + *this = b; + } + + const ExtentsBase & operator=(const ExtentsBase &b) { + if (this != &b) { + startx_ = b.startx_; + } + return *this; + } + + int startx_; + int endx_; +}; + +int f(const ExtentsBase &e1) { + ExtentsBase my_extents = e1; + return my_extents.startx_; +} + +/* { dg-final { scan-tree-dump-not "&my_extents" "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ + diff --git a/gcc/testsuite/g++.dg/tree-ssa/fwprop-align.C b/gcc/testsuite/g++.dg/tree-ssa/fwprop-align.C new file mode 100644 index 000000000..69f260216 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/fwprop-align.C @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-forwprop2" } */ + +struct A +{ + void foo () + { + } +}; + +int main() +{ + void (A::* const p)() = & A::foo; + A a; + (a.*p)(); +} + +/* We should eliminate the check if p points to a virtual function. */ +/* { dg-final { scan-tree-dump-times "& 1" 0 "forwprop2" } } */ +/* { dg-final { cleanup-tree-dump "forwprop2" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/inline-1.C b/gcc/testsuite/g++.dg/tree-ssa/inline-1.C new file mode 100644 index 000000000..95b7d0609 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/inline-1.C @@ -0,0 +1,36 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-einline" } */ +/* { dg-add-options bind_pic_locally } */ + +namespace std { + extern "C" void puts(const char *s); +} + +template void +foreach (T b, T e, void (*ptr)(E)) +{ + for (; b != e; b++) + ptr(*b); +} + +void +inline_me (char *x) +{ + std::puts(x); +} + +static void +inline_me_too (char *x) +{ + std::puts(x); +} + +int main(int argc, char **argv) +{ + foreach (argv, argv + argc, inline_me); + foreach (argv, argv + argc, inline_me_too); +} + +/* { dg-final { scan-tree-dump-times "Inlining void inline_me\\(" 1 "einline"} } */ +/* { dg-final { scan-tree-dump-times "Inlining void inline_me_too\\(" 1 "einline"} } */ +/* { dg-final { cleanup-tree-dump "einline" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/inline-2.C b/gcc/testsuite/g++.dg/tree-ssa/inline-2.C new file mode 100644 index 000000000..656cba031 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/inline-2.C @@ -0,0 +1,36 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-einline" } */ +/* { dg-add-options bind_pic_locally } */ + +namespace std { + extern "C" void puts(const char *s); +} + +template void +foreach (T b, T e, E ptr) +{ + for (; b != e; b++) + ptr(*b); +} + +void +inline_me (char *x) +{ + std::puts(x); +} + +static void +inline_me_too (char *x) +{ + std::puts(x); +} + +int main(int argc, char **argv) +{ + foreach (argv, argv + argc, inline_me); + foreach (argv, argv + argc, inline_me_too); +} + +/* { dg-final { scan-tree-dump-times "Inlining void inline_me\\(" 1 "einline"} } */ +/* { dg-final { scan-tree-dump-times "Inlining void inline_me_too\\(" 1 "einline"} } */ +/* { dg-final { cleanup-tree-dump "einline" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/inline-3.C b/gcc/testsuite/g++.dg/tree-ssa/inline-3.C new file mode 100644 index 000000000..f01f26caf --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/inline-3.C @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-einline" } */ +/* { dg-add-options bind_pic_locally } */ + +#include + +void foo(const char *s); + +void +inline_me (char *x) +{ + foo(x); +} + +static void +inline_me_too (char *x) +{ + foo(x); +} + +int main(int argc, char **argv) +{ + std::for_each (argv, argv + argc, inline_me); + std::for_each (argv, argv + argc, inline_me_too); +} + +/* { dg-final { scan-tree-dump-times "Inlining void inline_me\\(" 1 "einline"} } */ +/* { dg-final { scan-tree-dump-times "Inlining void inline_me_too\\(" 1 "einline"} } */ +/* { dg-final { cleanup-tree-dump "einline" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/ivopts-1.C b/gcc/testsuite/g++.dg/tree-ssa/ivopts-1.C new file mode 100644 index 000000000..0eaa0fb25 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/ivopts-1.C @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-ivopts" } */ + +struct Foo { + Foo() : s(1) {} + int s; +}; +void foo(Foo&); +void bar(void) +{ + Foo x[4]; + foo(x[0]); +} + +/* { dg-final { scan-tree-dump-not "-&x" "ivopts" } } */ +/* { dg-final { scan-tree-dump-not "offset: (4294967292|0x0f+fc)" "ivopts" } } */ +/* { dg-final { scan-tree-dump-not "&x\\\[5\\\]" "ivopts" } } */ +/* { dg-final { cleanup-tree-dump "ivopts" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/ivopts-2.C b/gcc/testsuite/g++.dg/tree-ssa/ivopts-2.C new file mode 100644 index 000000000..908299d98 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/ivopts-2.C @@ -0,0 +1,11 @@ +/* { dg-do compile { target { i?86-*-* x86_64-*-* } } } */ +/* { dg-options "-O2 -fdump-tree-ivopts-details" } */ + +void test (int *b, int *e, int stride) + { + for (int *p = b; p != e; p += stride) + *p = 1; + } + +/* { dg-final { scan-tree-dump-times "PHI setVisible(); +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pointer-reference-alias.C b/gcc/testsuite/g++.dg/tree-ssa/pointer-reference-alias.C new file mode 100644 index 000000000..777656d59 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pointer-reference-alias.C @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-O1 -fdump-tree-optimized" } */ + +int f(int *a) +{ + int &b = *a; + b = 0; + return *a; +} + +/* There should be only one dereferencing of a. */ +/* { dg-final { scan-tree-dump-times "\\*a" 1 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr13146.C b/gcc/testsuite/g++.dg/tree-ssa/pr13146.C new file mode 100644 index 000000000..22baf03d3 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr13146.C @@ -0,0 +1,77 @@ +/* { dg-do link } */ +/* { dg-options "-O -fstrict-aliasing" } */ + +class first +{ +public: + double d; + int f1; +}; + +class middle : public first +{ +}; + +class second : public middle +{ +public: + int f2; + short a; +}; + +class third +{ +public: + char a; + char b; +}; + +class multi: public third, public second +{ +public: + short s; + /* The following field used to be of type char but that causes + class multi to effectively get alias-set zero which we end + up not optimizing because of the fix for PR44164. */ + int f3; +}; + +extern void link_error (); + +void +foo (first *s1, second *s2) +{ + s1->f1 = 0; + s2->f2 = 0; + s1->f1++; + s2->f2++; + s1->f1++; + s2->f2++; + if (s1->f1 != 2) + link_error (); +} + +void +bar (first *s1, multi *s3) +{ + s1->f1 = 0; + s3->f3 = 0; + s1->f1++; + s3->f3++; + s1->f1++; + s3->f3++; + if (s1->f1 != 2) + link_error (); +} + + +int +main() +{ + first a; + second b; + multi c; + foo (&a, &b); + bar (&a, &c); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr14703.C b/gcc/testsuite/g++.dg/tree-ssa/pr14703.C new file mode 100644 index 000000000..58705277e --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr14703.C @@ -0,0 +1,49 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized -fno-ipa-reference" } */ +#include + +namespace { +template class fib { + public: + static const unsigned long long value = fib::value + fib::value; +}; + +template <> class fib<0> { + public: + static const unsigned long long value = 1; +}; + +template <> class fib<1> { + public: + static const unsigned long long value = 1; +}; + +template inline unsigned long long fibconst() +{ + return fibconst() + fibconst(); +} + +template <> inline unsigned long long fibconst<0>() +{ + return 1ull; +} + +template <> inline unsigned long long fibconst<1>() +{ + return 1ull; +} + +template <> inline unsigned long long fibconst<2>() +{ + return 2ull; +} + +} + +int main() +{ + ::std::cerr << "fib<90>::value == " << fib<90>::value << "\n"; + ::std::cerr << "fibcst<90>() == " << fibconst<90>() << "\n"; +} +// { dg-final { scan-tree-dump-not "fibconst" "optimized" } } +// { dg-final { cleanup-tree-dump "optimized" } } diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr14814.C b/gcc/testsuite/g++.dg/tree-ssa/pr14814.C new file mode 100644 index 000000000..59e3c9bc9 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr14814.C @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-forwprop2" } */ + +class YY { public: + YY(const YY &v) { e[0] = v.e[0]; e[1] = v.e[1]; e[2] = v.e[2]; } + double &y() { return e[1]; } + double e[3]; }; + +class XX { public: + YY direction() const { return v; } + YY v; }; + +int foo(XX& r) { + if (r.direction().y() < 0.000001) return 0; + return 1; } + +/* { dg-final { scan-tree-dump-times "&this" 0 "forwprop2" } } */ +/* { dg-final { scan-tree-dump-times "&r" 0 "forwprop2" } } */ +/* { dg-final { cleanup-tree-dump "forwprop2" } } */ + diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr15791-1.C b/gcc/testsuite/g++.dg/tree-ssa/pr15791-1.C new file mode 100644 index 000000000..68f14adad --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr15791-1.C @@ -0,0 +1,25 @@ +/* { dg-do link } */ + +void link_error (); + +int main () +{ + struct { int b[2]; } x; + int b[2]; + if (&b[1] != &b[1]) + link_error (); + if (&b[0] != b) + link_error (); + if (b == &b[2]) + link_error (); + if (b != b) + link_error (); + if (&x.b[1] == &x.b[0]) + link_error (); + if (x.b != &x.b[0]) + link_error (); + if (&x.b[1] == x.b) + link_error (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr15791-2.C b/gcc/testsuite/g++.dg/tree-ssa/pr15791-2.C new file mode 100644 index 000000000..fb8cbbe4c --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr15791-2.C @@ -0,0 +1,13 @@ +/* { dg-do link } */ +/* { dg-options "" } */ + +void link_error (); +struct a {}; +int main () +{ + struct a b[2]; + if (&b[0] == &b[1]) + link_error (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr15791-3.C b/gcc/testsuite/g++.dg/tree-ssa/pr15791-3.C new file mode 100644 index 000000000..2fd03e2e0 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr15791-3.C @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-fdump-tree-gimple" } */ + +int f(int i, unsigned j) +{ + int b[2]; + if (&b[i] == &b[j]) + return 1; + return 0; +} + +/* { dg-final { scan-tree-dump-times "i == j" 0 "gimple" } } */ +/* { dg-final { cleanup-tree-dump "gimple" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr15791-4.C b/gcc/testsuite/g++.dg/tree-ssa/pr15791-4.C new file mode 100644 index 000000000..82be2e33a --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr15791-4.C @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-fdump-tree-gimple" } */ + +int f(int i, int j) +{ + int b[2][2]; + if (&b[1][i] == &b[0][j]) + return 1; + return 0; +} + +/* { dg-final { scan-tree-dump-times "i == j" 0 "gimple" } } */ +/* { dg-final { cleanup-tree-dump "gimple" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr15791-5.C b/gcc/testsuite/g++.dg/tree-ssa/pr15791-5.C new file mode 100644 index 000000000..06ce523a7 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr15791-5.C @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-fdump-tree-gimple" } */ + +int foo(int i, int j) +{ + char g[16]; + if (&g[i] == &g[j]) + return 1; + return 0; +} + +/* { dg-final { scan-tree-dump-times "i == j" 1 "gimple" } } */ +/* { dg-final { cleanup-tree-dump "gimple" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr16688.C b/gcc/testsuite/g++.dg/tree-ssa/pr16688.C new file mode 100644 index 000000000..ce88bc2b2 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr16688.C @@ -0,0 +1,273 @@ +/* PR 16688. Test provided by Wolfgang Bangerth. The alias analyzer + was aborting when trying to group aliases. */ + +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +template +struct iterator_traits; + +template +struct iterator_traits<_Tp*> { + typedef _Tp& reference; +}; + +template struct NI { + _Iterator current; + + typedef typename iterator_traits<_Iterator>::reference reference; + + NI() { } + + NI(const _Iterator& __i) : current(__i) { } + + reference operator*() const { return *current; } + + NI& operator++() { return *this; } + + const _Iterator& base() const { return current; } +}; + +template +inline int +operator-(const NI<_IteratorL>& __lhs, + const NI<_IteratorR>& __rhs) +{ return __lhs.base() - __rhs.base(); } + + +template +inline _OI +__copy_aux(_II __first, _II __last, _OI __result) +{ + struct __copy { + static _OI + copy(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, ++__first) + *__result = *__first; + return __result; + } + }; + + return __copy::copy(__first, __last, __result); +} + +struct __copy_normal +{ + template + static _OI + copy_n(_II __first, _II __last, _OI __result) + { + return __copy_aux(__first, __last, __result); + } +}; +template +inline _OutputIterator +copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result) +{ + return __copy_normal::copy_n(__first, __last, __result); +} + +template +void uninitialized_fill_n(T,U,V); + + +template +struct _Vector_base { + struct _Vector_impl { + _Tp* start; + _Tp* finish; + _Tp* end_of_storage; + _Vector_impl() : start(0), finish(0), end_of_storage(0) + { } + } impl; + + _Vector_base(unsigned __n) { + impl.start = allocate(__n); + impl.finish = impl.start; + impl.end_of_storage = impl.start + __n; + } + + ~_Vector_base() { + deallocate(impl.start, + impl.end_of_storage - impl.start); + } + + _Tp* allocate(unsigned __n); + + void deallocate(_Tp* __p, unsigned __n); + + NI<_Tp*> begin() { return NI<_Tp*> (impl.start); } +}; + + +template +struct vector : _Vector_base<_Tp> +{ + vector(int __n) + : _Vector_base<_Tp>(__n) + { + uninitialized_fill_n(this->impl.start, __n, _Tp()); + } +}; + + + +struct Tensor +{ + Tensor (); + Tensor (const Tensor &); + + double values[2]; +}; + + +inline +Tensor::Tensor (const Tensor &p) +{ + for (unsigned int i=0; i<2; ++i) + values[i] = p.values[i]; +} + + +struct TriaAccessor +{ + typedef void * AccessorData; + + void copy_from (const TriaAccessor &); + void operator = (const TriaAccessor *); + + TriaAccessor & operator = (const TriaAccessor &); + + bool operator == (const TriaAccessor &) const; + + bool operator != (const TriaAccessor &) const; + void operator ++ (); + + int state () const; + bool used () const; + + int present_level; + int present_index; + int** levels; +}; + +inline int TriaAccessor::state () const { + if ((present_level>=0) && (present_index>=0)) + return 0; + else + if ((present_level==-1) && (present_index==-1)) + return 1; + else + return 2; +} + + +inline +void TriaAccessor::operator ++ () { + ++this->present_index; + + while (this->present_index >= + static_cast(*this->levels[this->present_level])) + { + ++this->present_level; + this->present_index = 0; + + if (this->present_level >= static_cast(1)) + { + + this->present_level = this->present_index = -1; + return; + } + } +} + +struct MGDoFObjectAccessor : TriaAccessor {}; + + + +struct TriaRawIterator +{ + TriaRawIterator (); + + TriaRawIterator (const TriaRawIterator &); + TriaRawIterator (const MGDoFObjectAccessor &a); + const MGDoFObjectAccessor & operator * () const; + + MGDoFObjectAccessor & operator * (); + const MGDoFObjectAccessor * operator -> () const; + + MGDoFObjectAccessor * operator -> (); + + TriaRawIterator & operator = (const TriaRawIterator &); + + bool operator == (const TriaRawIterator &) const; + bool operator != (const TriaRawIterator &) const; + bool operator < (const TriaRawIterator &) const; + MGDoFObjectAccessor accessor; + + TriaRawIterator & operator ++ (); +}; + +struct TriaIterator : TriaRawIterator +{ + TriaIterator (); + + TriaIterator (const TriaIterator &i); + + TriaIterator & + operator = (const TriaIterator &); + + TriaIterator & + operator = (const TriaRawIterator &); +}; + + +inline +TriaRawIterator::TriaRawIterator (const TriaRawIterator &i) : + accessor (i.accessor) {} + +inline +TriaIterator::TriaIterator (const TriaIterator &i) : + TriaRawIterator (static_cast(i)) {} + +inline +TriaRawIterator & TriaRawIterator::operator ++ () { + while (++accessor, (this->accessor.state() == 0)) + if (this->accessor.used() == true) + return *this; + return *this; +} + +struct Comp { + Comp (const Tensor &dir) : dir(dir) {} + + bool operator () (const TriaIterator &c1, const TriaIterator &c2) const; + const Tensor dir; +}; + + +template +void x1(Iter first, Iter last, int i, Comp comp) +{ + x1(Iter(), last, i, comp); +} + +template +inline void x2(Iter first, Iter last, Comp comp) +{ + if (first.base() != last.base()) + x1(first, last, (last - first), comp); +} + +void downstream_dg (const Tensor& direction) +{ + vector ordered_cells(13); + const Comp comparator(direction); + + TriaIterator begin, end; + + copy (begin, end, ordered_cells.begin()); + x2 (ordered_cells.begin(), ordered_cells.begin(), comparator); +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr17153.C b/gcc/testsuite/g++.dg/tree-ssa/pr17153.C new file mode 100644 index 000000000..658225e6e --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr17153.C @@ -0,0 +1,17 @@ +/* The alias analyzer was marking RETVAL non-addressable, but RETVAL + is a special variable that's available across different functions. */ +void foo(const char*); + +struct A {}; + +struct B : A +{ + B(){} + B bar() + { + foo(__PRETTY_FUNCTION__); + return B(); + } +}; + +B b=B().bar(); diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr17400.C b/gcc/testsuite/g++.dg/tree-ssa/pr17400.C new file mode 100644 index 000000000..a6619a84f --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr17400.C @@ -0,0 +1,53 @@ +// Test PR 17400. Test case provided by Serge Belyshev. + +/* { dg-do compile } */ +/* { dg-options "-O1" } */ + + +void inc (int &); +bool dec_test (int &); + +struct A +{ + int c; + + friend void AddRef (A * p) + { + inc (p->c); + } + + friend void Release (A * p) + { + if(dec_test (p->c)) + delete p; + } +}; + +struct B +{ + B (A *p) : obj(p) + { + AddRef (obj); + } + + ~B() + { + Release (obj); + } + + void swap (B &rhs) + { + A * tmp = obj; + obj = rhs.obj; + rhs.obj = tmp; + } + + A *obj; +}; + +void bar (A *p1, A* p2) +{ + B px (p1); + B px2 (p2); + px.swap (px2); +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr17517.C b/gcc/testsuite/g++.dg/tree-ssa/pr17517.C new file mode 100644 index 000000000..bcd5e91db --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr17517.C @@ -0,0 +1,32 @@ +// Test PR 17517. Test case provided by Serge Belyshev. + + /* { dg-do compile } */ + /* { dg-options "-O2" } */ + + +extern void foo (); + +struct Ptr { + int * ptr; + Ptr () { ptr = 0; } + ~Ptr() { delete ptr; } + Ptr &operator= (int * p) { ptr = p; return *this; } +}; + +int *new_checker () { foo (); return 0; } + +void pipe (int c) +{ + Ptr checker; + + foo (); + for (;;) + { + switch (c) + { + case '-': + checker = new_checker (); + break; + } + } +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr18178.C b/gcc/testsuite/g++.dg/tree-ssa/pr18178.C new file mode 100644 index 000000000..9223e8323 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr18178.C @@ -0,0 +1,47 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-vrp1" } */ + +// Define this to see it work. +// #define WORK_WORK_WORK + +#define THIRD + +#ifdef THIRD +#define FIRST i < 0 || +#define ORIG int +#define CAST +#else + +#define FIRST +#ifdef WORK_WORK_WORK +#define ORIG unsigned int +#define CAST +#else +#define ORIG int +#define CAST (unsigned) +#endif // WORK_WORK_WORK + +#endif // THIRD + +struct array +{ + const ORIG len; + int *data; +}; + +extern void call (ORIG); + +void doit (array *a) +{ + for (ORIG i = 0; i < a->len; ++i) + { + if (FIRST CAST (i) >= CAST (a->len)) + throw 5; + call (a->data[i]); + } +} + +/* VRP should remove all but 1 if() in the loop. */ + +/* { dg-final { scan-tree-dump-times "if " 1 "vrp1"} } */ +/* { dg-final { cleanup-tree-dump "vrp1" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr19637.C b/gcc/testsuite/g++.dg/tree-ssa/pr19637.C new file mode 100644 index 000000000..2d1dcceba --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr19637.C @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-dom1" } */ + +#include + +struct Foo { + Foo() { i[0] = 1; } + int i[2]; +}; + +int foo_char(void) +{ + int i[2]; + new (reinterpret_cast(i)) Foo(); + return reinterpret_cast(i)->i[0]; +} + +int foo_void(void) +{ + int i[2]; + new (reinterpret_cast(i)) Foo(); + return reinterpret_cast(i)->i[0]; +} + +int foo_void_offset(void) +{ + int i[2]; + new (reinterpret_cast(&i[0])) Foo(); + return reinterpret_cast(&i[0])->i[0]; +} + +/* { dg-final { scan-tree-dump-times "return 1;" 3 "dom1" } } */ +/* { dg-final { cleanup-tree-dump "dom1" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr19786.C b/gcc/testsuite/g++.dg/tree-ssa/pr19786.C new file mode 100644 index 000000000..faaecdfd9 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr19786.C @@ -0,0 +1,48 @@ +// { dg-do run } +/* { dg-options "-O2" } */ + +// We used to get alias grouping wrong on this one, hoisting accesses +// to the vector's end out of the loop. + +#include +#include + +struct A +{ + double unused; // If I remove it => it works. + std::vector v; + + A() : v(1) {} +}; + +inline // If not inline => it works. +A g() +{ + A r; + r.v.resize(2); + r.v[0] = 1; + + while (!r.v.empty() && r.v.back() == 0) + r.v.pop_back(); + + return r; +} + +A f(const A &a) +{ + if (a.v.empty()) return a; + if (a.v.empty()) return a; + + // A z = g(); return z; // If I return like this => it works. + return g(); +} + +int main() +{ + A a; + A b; + A r = f(a); + assert(r.v.size() != 0); + + return 0; +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr19807.C b/gcc/testsuite/g++.dg/tree-ssa/pr19807.C new file mode 100644 index 000000000..bba79a9d1 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr19807.C @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-options "-O -fdump-tree-optimized" } */ + +int a[4]; +int *x, *y, *z; + +void foo(void) +{ + x = &a[3] - 1; + y = &a[1] + 1; + z = 1 + &a[1]; +} + +void bar(int i) +{ + x = &a[i] - 1; + y = &a[i] + 1; + z = 1 + &a[i]; +} + +/* { dg-final { scan-tree-dump-times "&a\\\[2\\\]" 3 "optimized" } } */ + +/* We want &a[D.bla + 1] and &a[D.foo - 1] in the final code, but + tuples mean that the offset is calculated in a separate instruction. + Simply test for the existence of +1 and -1 once, which also ensures + the above. If the addition/subtraction would be applied to the + pointer we would instead see +-4 (or 8, depending on sizeof(int)). */ +/* { dg-final { scan-tree-dump-times "\\\+ -1;" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "\\\+ 1;" 1 "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr19952.C b/gcc/testsuite/g++.dg/tree-ssa/pr19952.C new file mode 100644 index 000000000..54589a294 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr19952.C @@ -0,0 +1,24 @@ +/* PR 19952 */ +/* { dg-do compile } */ +/* { dg-options "-ftree-vectorize -O2" } */ + +int i; + +struct A +{ + ~A() { ++i; } +}; + +struct B +{ + A a; +}; + +void foo() +{ + for (int i=0; i<2; ++i) + { + B *p; + if (p) p->~B(); + } +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr20280.C b/gcc/testsuite/g++.dg/tree-ssa/pr20280.C new file mode 100644 index 000000000..ec4dad706 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr20280.C @@ -0,0 +1,63 @@ +// PR c++/20280 + +// { dg-do compile } + +// Gimplification of the COND_EXPR used to fail because it had an +// addressable type, and create_tmp_var rejected that. + +struct A +{ + ~A(); +}; + +struct B : A {}; + +A& foo(); + +void bar(bool b) +{ + (B&) (b ? foo() : foo()); +} + +// Make sure bit-fields and addressable types don't cause crashes. +// These were not in the original bug report. + +// Added by Alexandre Oliva + +// Copyright 2005 Free Software Foundation + +struct X +{ + long i : 32, j, k : 32; +}; + +void g(long&); +void h(const long&); + +void f(X &x, bool b) +{ + (b ? x.i : x.j) = 1; + (b ? x.j : x.k) = 2; + (b ? x.i : x.k) = 3; + + (void)(b ? x.i : x.j); + (void)(b ? x.i : x.k); + (void)(b ? x.j : x.k); + + g (b ? x.i : x.j); // { dg-error "cannot bind bitfield" } + g (b ? x.i : x.k); // { dg-error "cannot bind bitfield" } + g (b ? x.j : x.k); // { dg-error "cannot bind bitfield" } + + // It's not entirely clear whether these should be accepted. The + // conditional expressions are lvalues for sure, and 8.5.3/5 exempts + // lvalues for bit-fields, but it's not clear that conditional + // expressions that are lvalues and that have at least one possible + // result that is a bit-field lvalue meets this condition. + h (b ? x.i : x.j); + h (b ? x.i : x.k); + h (b ? x.j : x.k); + + (long &)(b ? x.i : x.j); // { dg-error "address of bit-field" } + (long &)(b ? x.i : x.k); // { dg-error "address of bit-field" } + (long &)(b ? x.j : x.k); // { dg-error "address of bit-field" } +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr20458.C b/gcc/testsuite/g++.dg/tree-ssa/pr20458.C new file mode 100644 index 000000000..d4e7d1a1a --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr20458.C @@ -0,0 +1,37 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +/* The tail call optimization would inapproriately tail call the + destructors due to not recognizing a call clobbered variable */ +namespace std +{ + class locale + { + public: + locale(); + ~locale(); + }; +} + +struct B +{ + std::locale _M_buf_locale; + virtual ~B() {} +}; + +struct C : public B +{ + char *s; +}; + +void foo () +{ + C c; +} + +int main() +{ + foo (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr20489.C b/gcc/testsuite/g++.dg/tree-ssa/pr20489.C new file mode 100644 index 000000000..0a1a569d2 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr20489.C @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +struct A +{ + ~A(); +}; + +/* If we don't create SFT's for the "empty" structure A, bad things + will happen, and we will fail verification. */ +struct B +{ + int i; + A a; + + void foo() {} +}; + +void bar() +{ + B().foo(); +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr20920.C b/gcc/testsuite/g++.dg/tree-ssa/pr20920.C new file mode 100644 index 000000000..02edd2827 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr20920.C @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +/* This was causing a failure in the out of SSA pass because VRP was + trying to insert assertions for SSA names that flow through + abnormal edges. */ +void f(int) __attribute__((__noreturn__)); +int d(const char *); +char * j (); + +char * +foo (int x) +{ + char *path = __null; + try + { + path = j (); + if (path != __null) + if (d (path) != 0) + f (127); + f (127); + } + catch (...) { } + + return path; +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr20963.C b/gcc/testsuite/g++.dg/tree-ssa/pr20963.C new file mode 100644 index 000000000..d8f91e1be --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr20963.C @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +/* This was causing PRE to insert the value of the ADDR variable, to + remove the invariant cast but in doing so, it was creating a + non-invariant expression out of the invariant one, causing a later + failure in PRE. */ +struct sMCB { + unsigned char type; +}; + +extern void foo (void); +unsigned char mem_readb(char *pt) __attribute__((nothrow)); + +void DOS_FreeProcessMemory(unsigned short pspseg) { + while (1) { + if (pspseg) + foo (); + char *addr = (char*)(&((sMCB*)0)->type); + if (mem_readb(addr)==0x5a) break; + } +}; + diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr21082.C b/gcc/testsuite/g++.dg/tree-ssa/pr21082.C new file mode 100644 index 000000000..d6c2fa1d2 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr21082.C @@ -0,0 +1,14 @@ +/* { dg-do link } */ +/* { dg-options "-fstrict-overflow" } */ + +void link_error(); + +int a[4]; +__INTPTR_TYPE__ b, c; + +int main() +{ + if (&a[b] - &a[c] != b - c) + link_error(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr21407.C b/gcc/testsuite/g++.dg/tree-ssa/pr21407.C new file mode 100644 index 000000000..561dc707a --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr21407.C @@ -0,0 +1,8 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +extern "C" void abort(void); +struct T1 {int a, b; virtual void f(){}}; +struct T : T1 { struct T1 w; int b; }; +void foo (struct T1 *p) { struct T *q = dynamic_cast(p); if (q->b != 2) abort (); } +/* We shouldn't kill the store to c.b, because foo uses it. */ +int main () { struct T c; c.b = 2; foo (&c); return 0; } diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr21463.C b/gcc/testsuite/g++.dg/tree-ssa/pr21463.C new file mode 100644 index 000000000..6d6ee93ba --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr21463.C @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-O -fdump-tree-phiopt1" } */ + +template static inline const T &ref_max(const T &a, const T &b) +{ return a static inline const T &ref_min(const T &a, const T &b) +{ return a struct foo_t { + T a0, a1; + T bar_ref(const T b, const T c) { + return ref_max(ref_min(a0, c), ref_min(ref_max(a1, c), b)); + } +}; + +template struct foo_t; + +/* { dg-final { scan-tree-dump-times "MIN_EXPR" 2 "phiopt1" } } */ +/* { dg-final { scan-tree-dump-times "MAX_EXPR" 2 "phiopt1" } } */ +/* { dg-final { cleanup-tree-dump "phiopt1" } } */ diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr21584-1.C b/gcc/testsuite/g++.dg/tree-ssa/pr21584-1.C new file mode 100644 index 000000000..2c96d1027 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr21584-1.C @@ -0,0 +1,38 @@ +extern "C" { + +extern char *strcpy (char *__restrict __dest, __const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern char *foo (char *__restrict __s) throw (); +} + +class cset { +public: + cset(); + int operator()(unsigned char) const; +private: + char v[(127 * 2 + 1)+1]; +}; + +inline int cset::operator()(unsigned char c) const +{ + return v[c]; +} + +extern cset csspace; + +void baz() +{ + char *vec; + char buf[512]; + + char *p = buf; + while (csspace(*p)) + p++; + + if (*p != '#' && (p = foo(buf)) != 0) { + vec = new char[10+ 1]; + strcpy(vec, p); + } +} + diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr21584-2.C b/gcc/testsuite/g++.dg/tree-ssa/pr21584-2.C new file mode 100644 index 000000000..6246e8d4c --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr21584-2.C @@ -0,0 +1,22 @@ +extern char *strcpy (char *__restrict __dest, __const char *__restrict __src); + +extern char *foo (void); +extern void *malloc(__SIZE_TYPE__) __attribute__((malloc)); + +char v[100]; + +void baz() +{ + char *vec; + char buf[512]; + + char *p = buf; + while (v[(*p)]) + p++; + + if (*p != '#' && (p = foo()) != 0) { + strcpy ((char*)malloc(10), p); + } +} + + diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr22005.C b/gcc/testsuite/g++.dg/tree-ssa/pr22005.C new file mode 100644 index 000000000..cdaac2b88 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr22005.C @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +struct cl_string +{ + union{ int i; }; + cl_string (); +}; +struct cl_print_univpoly_flags { cl_string univpoly_varname; }; +struct cl_print_flags: cl_print_univpoly_flags {int i;}; +cl_print_flags default_print_flags; diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr22037.C b/gcc/testsuite/g++.dg/tree-ssa/pr22037.C new file mode 100644 index 000000000..11fc1b038 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/pr22037.C @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +extern double sqrt (double) throw (); + +void foo(double& d, int n) +{ + double e=0; + for(int i=0; i struct pair + { + _T1 first; + _T2 second; + pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) { } + }; +} +namespace __gnu_internal +{ + typedef char __one; + template __one __test_type(int _Tp::*); +} +namespace std +{ + template struct ___is_pod + { + enum { __value = (sizeof(__gnu_internal::__test_type<_Tp>(0))!= sizeof(__gnu_internal::__one)) }; + }; + template struct iterator + { }; + template struct iterator_traits + { + typedef typename _Iterator::difference_type difference_type; + }; + template class reverse_iterator : public iterator::iterator_category, typename iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::reference> + { + typedef _Iterator iterator_type; + typedef typename iterator_traits<_Iterator>::difference_type difference_type; + typedef typename iterator_traits<_Iterator>::reference reference; + reverse_iterator operator+(difference_type __n) const {} + reverse_iterator& operator+=(difference_type __n) { } + reference operator[](difference_type __n) const { } + }; +} +namespace __gnu_cxx +{ + template class __pool; + template