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