gcc/testsuite/g++.dg/tree-ssa/pr42337.C

   1 // PR tree-optimize/42337
   2 // { dg-do compile }
   3 // { dg-options "-O2" }
   4 // { dg-additional-options "-Wno-return-type" }
   5
   6 template<class _T1, class _T2> struct pair {
   7   _T2 second;
   8 };
   9 template<typename _Tp>
  10 inline const _Tp& max(const _Tp& __a, const _Tp& __b) { }
  11
  12 template<typename _ForwardIterator, typename _Tp, typename _Compare> _ForwardIterator
  13 lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { }
  14 template<class _CharT> struct char_traits {};
  15
  16 template<typename _Iterator, typename _Container> class __normal_iterator {
  17  public: typedef _Iterator iterator_type;
  18   __normal_iterator& operator++() {
  19   }
  20 };
  21 template<typename _IteratorL, typename _IteratorR, typename _Container>
  22 inline bool operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { }
  23 template<typename _Tp> class new_allocator {
  24  public:
  25   typedef _Tp* pointer;
  26   typedef const _Tp* const_pointer;
  27 };
  28
  29 template<typename _Tp>
  30 class allocator: public new_allocator<_Tp> {
  31  public:
  32   template<typename _Tp1> struct rebind {
  33     typedef allocator<_Tp1> other;
  34   };
  35 };
  36
  37 template<typename _Arg, typename _Result> struct unary_function { };
  38 template<typename _Arg1, typename _Arg2, typename _Result> struct binary_function { };
  39 template<typename _Tp> struct less : public binary_function<_Tp, _Tp, bool> { };
  40 template<typename _Pair> struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> { };
  41 template<typename _Tp> struct _Rb_tree_iterator {
  42   typedef _Tp* pointer;
  43   pointer operator->() const {
  44   }
  45 };
  46 template<typename _Key, typename _Val, typename _KeyOfValue, typename _Compare, typename _Alloc = allocator<_Val> >
  47 class _Rb_tree {
  48   typedef _Val value_type;
  49  public: typedef _Rb_tree_iterator<value_type> iterator;
  50 };
  51 template <typename _Key, typename _Tp, typename _Compare = less<_Key>, typename _Alloc = allocator<pair<const _Key, _Tp> > >
  52 class map {
  53  public: typedef _Key key_type;
  54   typedef pair<const _Key, _Tp> value_type;
  55   typedef _Compare key_compare;
  56  private: typedef typename _Alloc::template rebind<value_type>::other _Pair_alloc_type;
  57   typedef _Rb_tree<key_type, value_type, _Select1st<value_type>, key_compare, _Pair_alloc_type> _Rep_type;
  58  public: typedef typename _Pair_alloc_type::pointer pointer;
  59   typedef typename _Rep_type::iterator iterator;
  60   iterator find(const key_type& __x) { }
  61 };
  62
  63 template<typename _Tp, typename _Alloc> struct _Vector_base {
  64   typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
  65 };
  66 template<typename _Tp, typename _Alloc = allocator<_Tp> >
  67 class vector : protected _Vector_base<_Tp, _Alloc> {
  68   typedef _Vector_base<_Tp, _Alloc> _Base;
  69   typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
  70  public:
  71   typedef typename _Tp_alloc_type::pointer pointer;
  72   typedef typename _Tp_alloc_type::const_pointer const_pointer;
  73   typedef __normal_iterator<pointer, vector> iterator;
  74   typedef __normal_iterator<const_pointer, vector> const_iterator;
  75   iterator begin() { }
  76   const_iterator begin() const { }
  77   const_iterator end() const { }
  78   unsigned long size() const { }
  79 };
  80
  81 class SSC {
  82  public:
  83   SSC () {}
  84   SSC (const int& cs);
  85 };
  86 extern int flag;
  87
  88 struct TP {
  89    const int cl_;
  90    const vector<int> &its_;
  91    int max_s_;
  92  };
  93
  94 double foo(TP *p);
  95 map<int, int> cs_;
  96
  97 template <typename T> class vector32 {
  98  public:
  99   typedef T& reference;
 100   typedef T* iterator;
 101   typedef const T* const_iterator;
 102   iterator begin() { return data_; }
 103   iterator end() { return data_ + size_; }
 104   long unsigned int size() const { return size_; }
 105   T* data_;
 106   unsigned size_;
 107 };
 108
 109 struct SF : public pair<unsigned long long, double> { };
 110
 111 template<typename KEY, typename VALUE> class SFVT {
 112  private: typedef vector32<SF> Container;
 113   typedef typename Container::const_iterator CI;
 114   mutable Container v_;
 115   mutable bool sorted_;
 116   struct Cmp : public binary_function<SF, SF, bool> {
 117   };
 118   __attribute__((always_inline)) VALUE IS(const SFVT &sfv) const {
 119     if (sfv.v_.size() < v_.size()) {
 120       return sfv.IS(*this);
 121     }
 122     else {
 123       VALUE sum = 0.0;
 124       CI beg = sfv.v_.begin();
 125       CI end = sfv.v_.end();
 126       for (CI i = v_.begin();
 127            i != v_.end();
 128            ++i) { beg = lower_bound(beg, end, *i, Cmp()); if (beg == end) { return sum; } }
 129     }
 130   }
 131  public: explicit SFVT(const int capacity = 0) : sorted_(true) { }
 132   long unsigned int size() const { }
 133   __attribute__((always_inline)) VALUE DP(const SFVT &sfv) const {
 134     return IS(sfv);
 135   }
 136 };
 137 class SFV : public SFVT<unsigned long long, double> { };
 138
 139 class Edge;
 140 extern int flag2;
 141
 142 double foo(TP *p) {
 143   int nbests_requested = max(p->max_s_, flag);
 144   map<int, int>::iterator it = cs_.find(p->cl_);
 145   int* c = &it->second;
 146   for (vector<int>::const_iterator iter = p->its_.begin();
 147        iter != p->its_.end();
 148        ++iter) {
 149   }
 150   vector<int*> fb;
 151   vector<double> w;
 152   int *hg = 0;
 153   if (flag2 == 10) {
 154     hg = &flag2;
 155   }
 156   int nr = 0;
 157   for (vector<int*>::iterator iter = fb.begin();
 158        (iter != fb.end() && nr < nbests_requested);
 159        ++iter) {
 160   }
 161   if (hg) {
 162     SFV s_weights;
 163     for (int i = 0;
 164          i < w.size();
 165          ++i) {
 166     }
 167     SFV uw;
 168     for (int i = 0, j = 0;
 169          i < uw.size() && j < s_weights.size();
 170          ) {
 171     }
 172     const double tc = uw.DP(s_weights);
 173   }
 174 }