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/torture/pr44357.C | 228 +++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 gcc/testsuite/g++.dg/torture/pr44357.C (limited to 'gcc/testsuite/g++.dg/torture/pr44357.C') diff --git a/gcc/testsuite/g++.dg/torture/pr44357.C b/gcc/testsuite/g++.dg/torture/pr44357.C new file mode 100644 index 000000000..3380350e8 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr44357.C @@ -0,0 +1,228 @@ +/* { dg-do compile } */ +extern "C" +{ + typedef long unsigned int size_t; +} +namespace llvm +{ + namespace dont_use + { + template < typename T > double is_class_helper (...); + } + template < typename T > struct is_class + { + public:enum + { value = sizeof (char) == sizeof (dont_use::is_class_helper < T > (0)) }; + }; + template < typename T > struct isPodLike + { + static const bool value = !is_class < T >::value; + }; +} +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Iterator > struct iterator_traits + { + }; + template < typename _Tp > struct iterator_traits <_Tp * > + { + typedef _Tp value_type; + }; +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Tp > class new_allocator + { + public:typedef size_t size_type; + typedef const _Tp & const_reference; + }; +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < + _Tp > + { + public:typedef size_t size_type; + template < typename _Tp1 > struct rebind + { + typedef allocator < _Tp1 > other; + }; + }; + template < typename _Tp, typename _Alloc > struct _Vector_base + { + typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type; + }; +template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp, + _Alloc + > + { + typedef _Vector_base < _Tp, _Alloc > _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + public:typedef _Tp value_type; + typedef typename _Tp_alloc_type::const_reference const_reference; + typedef size_t size_type; + size_type size () const + { + } const_reference operator[] (size_type __n) const + { + }}; +} + +namespace llvm +{ + struct LandingPadInfo; + class DwarfException + { + static bool PadLT (const LandingPadInfo * L, const LandingPadInfo * R); + struct CallSiteEntry + { + }; + void EmitExceptionTable (); + }; +} +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _RandomAccessIterator, + typename _Compare > + void __unguarded_linear_insert (_RandomAccessIterator __last, + _Compare __comp) + { + typename iterator_traits < _RandomAccessIterator >::value_type __val = + (*__last); + _RandomAccessIterator __next = __last; + while (__comp (__val, *__next)) + { + } + } + template < typename _RandomAccessIterator, + typename _Compare > void __insertion_sort (_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Compare __comp) + { + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + if (__comp (*__i, *__first)) + { + } + else + std::__unguarded_linear_insert (__i, __comp); + } + } + enum + { _S_threshold = 16 }; + template < typename _RandomAccessIterator, + typename _Compare > + void __final_insertion_sort (_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Compare __comp) + { + if (__last - __first > int (_S_threshold)) + { + std::__insertion_sort (__first, __first + int (_S_threshold), __comp); + } + } + template < typename _RandomAccessIterator, + typename _Compare > inline void sort (_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Compare __comp) + { + if (__first != __last) + { + std::__final_insertion_sort (__first, __last, __comp); + } + } +} + +namespace llvm +{ + class SmallVectorBase + { + protected:void *BeginX, *EndX, *CapacityX; + struct U + { + } FirstEl; + protected: SmallVectorBase (size_t Size):BeginX (&FirstEl), EndX (&FirstEl), + CapacityX ((char *) &FirstEl + Size) + { + }}; +template < typename T > class SmallVectorTemplateCommon:public + SmallVectorBase + { + public: SmallVectorTemplateCommon (size_t Size):SmallVectorBase (Size) + { + } typedef size_t size_type; + typedef T *iterator; + iterator begin () + { + } iterator end () + { + } size_type size () const + { + }}; +template < typename T, bool isPodLike > class SmallVectorTemplateBase:public SmallVectorTemplateCommon < + T > + { + public: SmallVectorTemplateBase (size_t Size):SmallVectorTemplateCommon < T > + (Size) + { + }}; +template < typename T > class SmallVectorImpl:public SmallVectorTemplateBase < T, + isPodLike < T >::value > + { + typedef SmallVectorTemplateBase < T, isPodLike < T >::value > SuperClass; + public:typedef typename SuperClass::iterator iterator; + explicit SmallVectorImpl (unsigned N):SmallVectorTemplateBase < T, + isPodLike < T >::value > (N * sizeof (T)) + { + } + }; + template < typename T, + unsigned N > class SmallVector:public SmallVectorImpl < T > + { + typedef typename SmallVectorImpl < T >::U U; + enum + { MinUs = + (static_cast < unsigned int >(sizeof (T)) * N + static_cast < + unsigned int >(sizeof (U)) - 1) /static_cast < + unsigned int >(sizeof (U)), NumInlineEltsElts = + MinUs > 1 ? (MinUs - 1) : 1, NumTsAvailable = + (NumInlineEltsElts + 1) * static_cast < + unsigned int >(sizeof (U)) / static_cast < + unsigned int >(sizeof (T)) }; + public: SmallVector ():SmallVectorImpl < T > (NumTsAvailable) + { + } + }; + struct LandingPadInfo + { + std::vector < int >TypeIds; + union + { + } Contents; + }; +} + +using namespace llvm; +bool +DwarfException::PadLT (const LandingPadInfo * L, const LandingPadInfo * R) +{ + const std::vector < int >&LIds = L->TypeIds, &RIds = R->TypeIds; + unsigned LSize = LIds.size (), RSize = RIds.size (); + unsigned MinSize = LSize < RSize ? LSize : RSize; + for (unsigned i = 0; i != MinSize; ++i) + if (LIds[i] != RIds[i]) + return LIds[i] < RIds[i]; +} + +void +DwarfException::EmitExceptionTable () +{ + SmallVector < const LandingPadInfo *, 64 > LandingPads; + std::sort (LandingPads.begin (), LandingPads.end (), PadLT); + SmallVector < CallSiteEntry, 64 > CallSites; + for (unsigned i = 0, e = CallSites.size (); i < e; ++i) + { + } +} -- cgit v1.2.3