1/* { dg-do compile } */ 2extern "C" 3{ 4 typedef long unsigned int size_t; 5} 6namespace llvm 7{ 8 namespace dont_use 9 { 10 template < typename T > double is_class_helper (...); 11 } 12 template < typename T > struct is_class 13 { 14 public:enum 15 { value = sizeof (char) == sizeof (dont_use::is_class_helper < T > (0)) }; 16 }; 17 template < typename T > struct isPodLike 18 { 19 static const bool value = !is_class < T >::value; 20 }; 21} 22namespace std __attribute__ ((__visibility__ ("default"))) 23{ 24 template < typename _Iterator > struct iterator_traits 25 { 26 }; 27 template < typename _Tp > struct iterator_traits <_Tp * > 28 { 29 typedef _Tp value_type; 30 }; 31} 32 33namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) 34{ 35 template < typename _Tp > class new_allocator 36 { 37 public:typedef size_t size_type; 38 typedef const _Tp & const_reference; 39 }; 40} 41 42namespace std __attribute__ ((__visibility__ ("default"))) 43{ 44template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < 45 _Tp > 46 { 47 public:typedef size_t size_type; 48 template < typename _Tp1 > struct rebind 49 { 50 typedef allocator < _Tp1 > other; 51 }; 52 }; 53 template < typename _Tp, typename _Alloc > struct _Vector_base 54 { 55 typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type; 56 }; 57template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp, 58 _Alloc 59 > 60 { 61 typedef _Vector_base < _Tp, _Alloc > _Base; 62 typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; 63 public:typedef _Tp value_type; 64 typedef typename _Tp_alloc_type::const_reference const_reference; 65 typedef size_t size_type; 66 size_type size () const 67 { 68 } const_reference operator[] (size_type __n) const 69 { 70 }}; 71} 72 73namespace llvm 74{ 75 struct LandingPadInfo; 76 class DwarfException 77 { 78 static bool PadLT (const LandingPadInfo * L, const LandingPadInfo * R); 79 struct CallSiteEntry 80 { 81 }; 82 void EmitExceptionTable (); 83 }; 84} 85namespace std __attribute__ ((__visibility__ ("default"))) 86{ 87 template < typename _RandomAccessIterator, 88 typename _Compare > 89 void __unguarded_linear_insert (_RandomAccessIterator __last, 90 _Compare __comp) 91 { 92 typename iterator_traits < _RandomAccessIterator >::value_type __val = 93 (*__last); 94 _RandomAccessIterator __next = __last; 95 while (__comp (__val, *__next)) 96 { 97 } 98 } 99 template < typename _RandomAccessIterator, 100 typename _Compare > void __insertion_sort (_RandomAccessIterator __first, 101 _RandomAccessIterator __last, 102 _Compare __comp) 103 { 104 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) 105 { 106 if (__comp (*__i, *__first)) 107 { 108 } 109 else 110 std::__unguarded_linear_insert (__i, __comp); 111 } 112 } 113 enum 114 { _S_threshold = 16 }; 115 template < typename _RandomAccessIterator, 116 typename _Compare > 117 void __final_insertion_sort (_RandomAccessIterator __first, 118 _RandomAccessIterator __last, 119 _Compare __comp) 120 { 121 if (__last - __first > int (_S_threshold)) 122 { 123 std::__insertion_sort (__first, __first + int (_S_threshold), __comp); 124 } 125 } 126 template < typename _RandomAccessIterator, 127 typename _Compare > inline void sort (_RandomAccessIterator __first, 128 _RandomAccessIterator __last, 129 _Compare __comp) 130 { 131 if (__first != __last) 132 { 133 std::__final_insertion_sort (__first, __last, __comp); 134 } 135 } 136} 137 138namespace llvm 139{ 140 class SmallVectorBase 141 { 142 protected:void *BeginX, *EndX, *CapacityX; 143 struct U 144 { 145 } FirstEl; 146 protected: SmallVectorBase (size_t Size):BeginX (&FirstEl), EndX (&FirstEl), 147 CapacityX ((char *) &FirstEl + Size) 148 { 149 }}; 150template < typename T > class SmallVectorTemplateCommon:public 151 SmallVectorBase 152 { 153 public: SmallVectorTemplateCommon (size_t Size):SmallVectorBase (Size) 154 { 155 } typedef size_t size_type; 156 typedef T *iterator; 157 iterator begin () 158 { 159 } iterator end () 160 { 161 } size_type size () const 162 { 163 }}; 164template < typename T, bool isPodLike > class SmallVectorTemplateBase:public SmallVectorTemplateCommon < 165 T > 166 { 167 public: SmallVectorTemplateBase (size_t Size):SmallVectorTemplateCommon < T > 168 (Size) 169 { 170 }}; 171template < typename T > class SmallVectorImpl:public SmallVectorTemplateBase < T, 172 isPodLike < T >::value > 173 { 174 typedef SmallVectorTemplateBase < T, isPodLike < T >::value > SuperClass; 175 public:typedef typename SuperClass::iterator iterator; 176 explicit SmallVectorImpl (unsigned N):SmallVectorTemplateBase < T, 177 isPodLike < T >::value > (N * sizeof (T)) 178 { 179 } 180 }; 181 template < typename T, 182 unsigned N > class SmallVector:public SmallVectorImpl < T > 183 { 184 typedef typename SmallVectorImpl < T >::U U; 185 enum 186 { MinUs = 187 (static_cast < unsigned int >(sizeof (T)) * N + static_cast < 188 unsigned int >(sizeof (U)) - 1) /static_cast < 189 unsigned int >(sizeof (U)), NumInlineEltsElts = 190 MinUs > 1 ? (MinUs - 1) : 1, NumTsAvailable = 191 (NumInlineEltsElts + 1) * static_cast < 192 unsigned int >(sizeof (U)) / static_cast < 193 unsigned int >(sizeof (T)) }; 194 public: SmallVector ():SmallVectorImpl < T > (NumTsAvailable) 195 { 196 } 197 }; 198 struct LandingPadInfo 199 { 200 std::vector < int >TypeIds; 201 union 202 { 203 } Contents; 204 }; 205} 206 207using namespace llvm; 208bool 209DwarfException::PadLT (const LandingPadInfo * L, const LandingPadInfo * R) 210{ 211 const std::vector < int >&LIds = L->TypeIds, &RIds = R->TypeIds; 212 unsigned LSize = LIds.size (), RSize = RIds.size (); 213 unsigned MinSize = LSize < RSize ? LSize : RSize; 214 for (unsigned i = 0; i != MinSize; ++i) 215 if (LIds[i] != RIds[i]) 216 return LIds[i] < RIds[i]; 217} 218 219void 220DwarfException::EmitExceptionTable () 221{ 222 SmallVector < const LandingPadInfo *, 64 > LandingPads; 223 std::sort (LandingPads.begin (), LandingPads.end (), PadLT); 224 SmallVector < CallSiteEntry, 64 > CallSites; 225 for (unsigned i = 0, e = CallSites.size (); i < e; ++i) 226 { 227 } 228} 229