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/graphite/graphite.exp | 71 ++++++ gcc/testsuite/g++.dg/graphite/id-1.C | 39 ++++ gcc/testsuite/g++.dg/graphite/pr39447.C | 34 +++ gcc/testsuite/g++.dg/graphite/pr41305.C | 332 +++++++++++++++++++++++++++++ gcc/testsuite/g++.dg/graphite/pr41562.C | 18 ++ gcc/testsuite/g++.dg/graphite/pr42130.C | 19 ++ gcc/testsuite/g++.dg/graphite/pr42681.C | 17 ++ gcc/testsuite/g++.dg/graphite/pr42930.C | 55 +++++ gcc/testsuite/g++.dg/graphite/pr43026.C | 51 +++++ 9 files changed, 636 insertions(+) create mode 100644 gcc/testsuite/g++.dg/graphite/graphite.exp create mode 100644 gcc/testsuite/g++.dg/graphite/id-1.C create mode 100644 gcc/testsuite/g++.dg/graphite/pr39447.C create mode 100644 gcc/testsuite/g++.dg/graphite/pr41305.C create mode 100644 gcc/testsuite/g++.dg/graphite/pr41562.C create mode 100644 gcc/testsuite/g++.dg/graphite/pr42130.C create mode 100644 gcc/testsuite/g++.dg/graphite/pr42681.C create mode 100644 gcc/testsuite/g++.dg/graphite/pr42930.C create mode 100644 gcc/testsuite/g++.dg/graphite/pr43026.C (limited to 'gcc/testsuite/g++.dg/graphite') diff --git a/gcc/testsuite/g++.dg/graphite/graphite.exp b/gcc/testsuite/g++.dg/graphite/graphite.exp new file mode 100644 index 000000000..4b359c9b3 --- /dev/null +++ b/gcc/testsuite/g++.dg/graphite/graphite.exp @@ -0,0 +1,71 @@ +# Copyright (C) 2009, 2010 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# . + +# GCC testsuite that uses the `dg.exp' driver. + +# Load support procs. +load_lib g++-dg.exp + +if ![check_effective_target_fgraphite] { + return +} + +# Remove VALUE from LIST_VARIABLE. +proc lremove {list_variable value} { + upvar 1 $list_variable var + set idx [lsearch -exact $var $value] + set var [lreplace $var $idx $idx] +} + +# The default action for a test is 'compile'. Save current default. +global dg-do-what-default +set save-dg-do-what-default ${dg-do-what-default} + +# Initialize `dg'. +dg-init + +set wait_to_run_files [lsort [glob -nocomplain $srcdir/$subdir/*.C ] ] +set scop_files [lsort [glob -nocomplain $srcdir/$subdir/scop-*.C ] ] +set id_files [lsort [glob -nocomplain $srcdir/$subdir/id-*.C ] ] +set run_id_files [lsort [glob -nocomplain $srcdir/$subdir/run-id-*.C ] ] +set interchange_files [lsort [glob -nocomplain $srcdir/$subdir/interchange-*.C ] ] +set block_files [lsort [glob -nocomplain $srcdir/$subdir/block-*.C ] ] + +# Tests to be compiled. +set dg-do-what-default compile +dg-runtest $scop_files "" "-O2 -fgraphite -fdump-tree-graphite-all" +dg-runtest $id_files "" "-O2 -fgraphite-identity -ffast-math" + +# Tests to be run. +set dg-do-what-default run +dg-runtest $run_id_files "" "-O2 -fgraphite-identity" +dg-runtest $interchange_files "" "-O2 -floop-interchange -fno-loop-block -fno-loop-strip-mine -ffast-math -fdump-tree-graphite-all" +dg-runtest $block_files "" "-O2 -floop-block -fno-loop-strip-mine -fno-loop-interchange -ffast-math -fdump-tree-graphite-all" + +# The default action for the rest of the files is 'compile'. +set dg-do-what-default compile +foreach f $scop_files {lremove wait_to_run_files $f} +foreach f $id_files {lremove wait_to_run_files $f} +foreach f $run_id_files {lremove wait_to_run_files $f} +foreach f $interchange_files {lremove wait_to_run_files $f} +foreach f $block_files {lremove wait_to_run_files $f} +dg-runtest $wait_to_run_files "" "-ansi -pedantic-errors" + +# Clean up. +set dg-do-what-default ${save-dg-do-what-default} + +# All done. +dg-finish diff --git a/gcc/testsuite/g++.dg/graphite/id-1.C b/gcc/testsuite/g++.dg/graphite/id-1.C new file mode 100644 index 000000000..5770e905d --- /dev/null +++ b/gcc/testsuite/g++.dg/graphite/id-1.C @@ -0,0 +1,39 @@ +#include + +template class Tensor; +template +class Tensor<1,dim> +{ + public: + explicit Tensor (const bool initialize = true); + Tensor (const Tensor<1,dim> &); + double values[(dim!=0) ? (dim) : 1]; +}; +template +Tensor<1,dim>::Tensor (const Tensor<1,dim> &p) +{ + for (unsigned int i=0; i +class KellyErrorEstimator +{ + struct PerThreadData + { + std::vector > > > psi; + PerThreadData (const unsigned int n_solution_vectors, + const unsigned int n_components, + const unsigned int n_q_points); + }; +}; +template +KellyErrorEstimator::PerThreadData:: +PerThreadData (const unsigned int n_solution_vectors, + const unsigned int n_components, + const unsigned int n_q_points) +{ + for (unsigned int i=0; i; diff --git a/gcc/testsuite/g++.dg/graphite/pr39447.C b/gcc/testsuite/g++.dg/graphite/pr39447.C new file mode 100644 index 000000000..a0d09ec2b --- /dev/null +++ b/gcc/testsuite/g++.dg/graphite/pr39447.C @@ -0,0 +1,34 @@ +/* { dg-options "-O2 -fgraphite-identity" } */ + +struct Point +{ + int line, col; + + Point( int l = -1, int c = 0 ) throw() : line( l ), col( c ) {} + bool operator==( const Point & p ) const throw() + { return ( line == p.line && col == p.col ); } + bool operator<( const Point & p ) const throw() + { return ( line < p.line || ( line == p.line && col < p.col ) ); } +}; + +class Buffer +{ +public: + int characters( const int line ) const throw(); + int pgetc( Point & p ) const throw(); + Point eof() const throw() { return Point( 0, 0 ); } + bool pisvalid( const Point & p ) const throw() + { return ( ( p.col >= 0 && p.col < characters( p.line ) ) || p == eof() ); + } + bool save( Point p1 = Point(), Point p2 = Point() ) const; +}; + +bool Buffer::save( Point p1, Point p2 ) const +{ + if( !this->pisvalid( p1 ) ) p1 = eof(); + if( !this->pisvalid( p2 ) ) p2 = eof(); + for( Point p = p1; p < p2; ) { pgetc( p ); } + return true; +} + + diff --git a/gcc/testsuite/g++.dg/graphite/pr41305.C b/gcc/testsuite/g++.dg/graphite/pr41305.C new file mode 100644 index 000000000..6a30b0e9e --- /dev/null +++ b/gcc/testsuite/g++.dg/graphite/pr41305.C @@ -0,0 +1,332 @@ +// { dg-do compile } +// { dg-options "-O3 -floop-interchange -Wno-conversion-null" } + +void __throw_bad_alloc (); + +template void +swap (_Tp & __a, _Tp __b) +{ + __a = __b; +} + +template struct iterator +{ + typedef _Category iterator_category; +}; + +template struct allocator +{ + typedef __SIZE_TYPE__ size_type; + typedef _Tp pointer; + pointer allocate (size_type) + { + __throw_bad_alloc (); + return __null; + } +}; + +template >class unbounded_array; +template >class vector; +template class scalar_vector; +template struct random_access_iterator_base : public iterator +{ +}; + +template struct promote_traits +{ + typedef __typeof__ ((X ())) promote_type; +}; + +template struct scalar_traits +{ + typedef T const_reference; + typedef T reference; +}; + +template struct type_traits : scalar_traits +{ +}; + +struct dense_proxy_tag +{ +}; + +template struct iterator_base_traits; + +template <> struct iterator_base_traits +{ + template struct iterator_base + { + typedef random_access_iterator_base type; + }; +}; + +template struct iterator_restrict_traits +{ + typedef I1 iterator_category; +}; + +template class storage_array +{ +}; + +template struct unbounded_array : public storage_array > +{ + typedef typename ALLOC::size_type size_type; + typedef T & reference; + typedef T *pointer; + unbounded_array (size_type size, ALLOC = ALLOC ()) : alloc_ (), size_ (size) + { + alloc_.allocate (size_); + } + ~unbounded_array () + { + if (size_) + for (;;); + } + size_type + size () const + { + return size_; + } + reference + operator[] (size_type i) + { + return data_[i]; + } + void + swap (unbounded_array & a) + { + ::swap (size_, a.size_); + } + ALLOC alloc_; + size_type size_; + pointer data_; +}; + +template struct scalar_binary_functor +{ + typedef typename promote_traits ::promote_type result_type; +}; + +template struct scalar_plus : public scalar_binary_functor +{ +}; + +template struct scalar_multiplies : public scalar_binary_functor +{ +}; + +template struct scalar_binary_assign_functor +{ + typedef typename type_traits ::reference argument1_type; + typedef typename type_traits ::const_reference argument2_type; +}; + +template struct scalar_assign : public scalar_binary_assign_functor +{ + typedef typename scalar_binary_assign_functor ::argument1_type argument1_type; + typedef typename scalar_binary_assign_functor ::argument2_type argument2_type; + static const bool computed = false; + static void + apply (argument1_type t1, argument2_type t2) + { + t1 = t2; + } +}; + +template struct vector_expression +{ + typedef E expression_type; + const expression_type & + operator () () const + { + return *static_cast (this); + } +}; + +template class vector_container : public vector_expression +{ +}; + +template struct vector_reference : public vector_expression > +{ + typedef typename E::size_type size_type; + typename E::const_reference const_reference; + typedef E referred_type; + vector_reference (referred_type & e) : e_ (e) + { + } + size_type + size () const + { + return expression ().size (); + } + referred_type & + expression () const + { + return e_; + } + referred_type &e_; +}; + +template struct vector_binary : public vector_expression > +{ + typedef E1 expression1_type; + typedef E2 expression2_type; + typedef typename E1::const_closure_type expression1_closure_type; + typedef typename E2::const_closure_type expression2_closure_type; + typedef typename promote_traits ::promote_type size_type; + typedef typename F::result_type value_type; + + vector_binary (const expression1_type & e1, expression2_type e2) : e1_ (e1), e2_ (e2) + { + } + + size_type + size () const + { + return e1_.size (); + } + + class const_iterator : public iterator_base_traits ::iterator_category>::template iterator_base ::type + { + }; + expression1_closure_type e1_; + expression2_closure_type e2_; +}; + +template struct vector_binary_traits +{ + typedef vector_binary expression_type; + typedef expression_type result_type; +}; + +template typename vector_binary_traits >::result_type +operator + (vector_expression &e1, const vector_expression &e2) +{ + typedef typename vector_binary_traits >::expression_type expression_type; + return expression_type (e1 (), e2 ()); +} + +template struct vector_binary_scalar2 : public vector_expression > +{ + typedef vector_binary_scalar2 self_type; + typedef typename E1::size_type size_type; + typedef typename F::result_type value_type; + typedef self_type const_closure_type; +}; + +template struct vector_binary_scalar2_traits +{ + typedef vector_binary_scalar2 result_type; +}; + +template +typename vector_binary_scalar2_traits >::result_type +operator * (vector_expression , T2) +{ +} + +template struct vector_assign_traits +{ + typedef SC storage_category; +}; + +template