OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [torture/] [pr44357.C] - Blame information for rev 801

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 693 jeremybenn 
/* { 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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.