1 /* { dg-do compile } */
2 extern "C"
3 {
4   typedef long unsigned int size_t;
5 }
6 namespace 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 }
22 namespace 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 
33 namespace __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 
42 namespace std __attribute__ ((__visibility__ ("default")))
43 {
44 template < 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   };
57 template < 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 
73 namespace 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 }
85 namespace 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 
138 namespace 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   }};
150 template < 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   }};
164 template < typename T, bool isPodLike > class SmallVectorTemplateBase:public SmallVectorTemplateCommon <
165     T >
166   {
167   public: SmallVectorTemplateBase (size_t Size):SmallVectorTemplateCommon < T >
168       (Size)
169     {
170   }};
171 template < 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 
207 using namespace llvm;
208 bool
209 DwarfException::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 
219 void
220 DwarfException::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