URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [tags/] [gnu-dev/] [fsf-gcc-snapshot-1-mar-12/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [torture/] [pr44357.C] - Rev 783
Compare with Previous | Blame | View Log
/* { 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)
{
}
}