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

   1 /* PR 16688.  Test provided by Wolfgang Bangerth.  The alias analyzer
   2    was aborting when trying to group aliases.  */
   3
   4 /* { dg-do compile } */
   5 /* { dg-options "-O2" } */
   6
   7 template<typename _Tp>
   8 struct iterator_traits;
   9
  10 template<typename _Tp>
  11 struct iterator_traits<_Tp*> {
  12     typedef _Tp& reference;
  13 };
  14
  15 template<typename _Iterator> struct NI {
  16     _Iterator current;
  17
  18     typedef typename iterator_traits<_Iterator>::reference reference;
  19
  20     NI() { }
  21
  22     NI(const _Iterator& __i) : current(__i) { }
  23
  24     reference operator*() const { return *current; }
  25
  26     NI& operator++() { return *this; }
  27
  28     const _Iterator& base() const { return current; }
  29 };
  30
  31 template<typename _IteratorL, typename _IteratorR>
  32 inline int
  33 operator-(const NI<_IteratorL>& __lhs,
  34           const NI<_IteratorR>& __rhs)
  35 { return __lhs.base() - __rhs.base(); }
  36
  37
  38 template<typename _II, typename _OI>
  39 inline _OI
  40 __copy_aux(_II __first, _II __last, _OI __result)
  41 {
  42   struct __copy {
  43       static _OI
  44       copy(_II __first, _II __last, _OI __result)
  45         {
  46           for (; __first != __last; ++__result, ++__first)
  47             *__result = *__first;
  48           return __result;
  49         }
  50   };
  51
  52   return __copy::copy(__first, __last, __result);
  53 }
  54
  55 struct __copy_normal
  56 {
  57     template<typename _II, typename _OI>
  58     static _OI
  59     copy_n(_II __first, _II __last, _OI __result)
  60       {
  61         return __copy_aux(__first, __last, __result);
  62       }
  63 };
  64 template<typename _InputIterator, typename _OutputIterator>
  65 inline _OutputIterator
  66 copy(_InputIterator __first, _InputIterator __last,
  67      _OutputIterator __result)
  68 {
  69   return __copy_normal::copy_n(__first, __last, __result);
  70 }
  71
  72 template <typename T, typename U, typename V>
  73 void uninitialized_fill_n(T,U,V);
  74
  75
  76 template<typename _Tp>
  77 struct _Vector_base {
  78     struct _Vector_impl {
  79         _Tp* start;
  80         _Tp* finish;
  81         _Tp* end_of_storage;
  82         _Vector_impl() : start(0), finish(0), end_of_storage(0)
  83           { }
  84     } impl;
  85
  86     _Vector_base(unsigned __n) {
  87       impl.start = allocate(__n);
  88       impl.finish = impl.start;
  89       impl.end_of_storage = impl.start + __n;
  90     }
  91
  92     ~_Vector_base() {
  93       deallocate(impl.start,
  94                     impl.end_of_storage - impl.start);
  95     }
  96
  97     _Tp* allocate(unsigned __n);
  98
  99     void deallocate(_Tp* __p, unsigned __n);
 100
 101     NI<_Tp*> begin() { return NI<_Tp*> (impl.start); }
 102 };
 103
 104
 105 template<typename _Tp>
 106 struct vector : _Vector_base<_Tp>
 107 {
 108     vector(int __n)
 109                     : _Vector_base<_Tp>(__n)
 110       {
 111         uninitialized_fill_n(this->impl.start, __n, _Tp());
 112       }
 113 };
 114
 115
 116
 117 struct Tensor
 118 {
 119     Tensor ();
 120     Tensor (const Tensor &);
 121
 122     double values[2];
 123 };
 124
 125
 126 inline
 127 Tensor::Tensor (const Tensor &p)
 128 {
 129   for (unsigned int i=0; i<2; ++i)
 130     values[i] = p.values[i];
 131 }
 132
 133
 134 struct TriaAccessor
 135 {
 136     typedef void * AccessorData;
 137
 138     void copy_from (const TriaAccessor &);
 139     void operator = (const TriaAccessor *);
 140
 141     TriaAccessor & operator = (const TriaAccessor &);
 142
 143     bool operator == (const TriaAccessor &) const;
 144
 145     bool operator != (const TriaAccessor &) const;
 146     void operator ++ ();
 147
 148     int state () const;
 149     bool used () const;
 150
 151     int present_level;
 152     int present_index;
 153     int** levels;
 154 };
 155
 156 inline int TriaAccessor::state () const {
 157   if ((present_level>=0) && (present_index>=0))
 158     return 0;
 159   else
 160     if ((present_level==-1) && (present_index==-1))
 161       return 1;
 162     else
 163       return 2;
 164 }
 165
 166
 167 inline
 168 void TriaAccessor::operator ++ () {
 169   ++this->present_index;
 170
 171   while (this->present_index >=
 172          static_cast<int>(*this->levels[this->present_level]))
 173     {
 174       ++this->present_level;
 175       this->present_index = 0;
 176
 177       if (this->present_level >= static_cast<int>(1))
 178         {
 179
 180           this->present_level = this->present_index = -1;
 181           return;
 182         }
 183     }
 184 }
 185
 186 struct MGDoFObjectAccessor : TriaAccessor {};
 187
 188
 189
 190 struct TriaRawIterator
 191 {
 192     TriaRawIterator ();
 193
 194     TriaRawIterator (const TriaRawIterator &);
 195     TriaRawIterator (const MGDoFObjectAccessor &a);
 196     const MGDoFObjectAccessor & operator * () const;
 197
 198     MGDoFObjectAccessor & operator * ();
 199     const MGDoFObjectAccessor * operator -> () const;
 200
 201     MGDoFObjectAccessor * operator -> ();
 202
 203     TriaRawIterator & operator = (const TriaRawIterator &);
 204
 205     bool operator == (const TriaRawIterator &) const;
 206     bool operator != (const TriaRawIterator &) const;
 207     bool operator < (const TriaRawIterator &) const;
 208     MGDoFObjectAccessor accessor;
 209
 210     TriaRawIterator & operator ++ ();
 211 };
 212
 213 struct TriaIterator : TriaRawIterator
 214 {
 215     TriaIterator ();
 216
 217     TriaIterator (const TriaIterator &i);
 218
 219     TriaIterator &
 220     operator = (const TriaIterator &);
 221
 222     TriaIterator &
 223     operator = (const TriaRawIterator &);
 224 };
 225
 226
 227 inline
 228 TriaRawIterator::TriaRawIterator (const TriaRawIterator &i) :
 229                 accessor (i.accessor) {}
 230
 231 inline
 232 TriaIterator::TriaIterator (const TriaIterator &i) :
 233                 TriaRawIterator (static_cast<TriaRawIterator >(i)) {}
 234
 235 inline
 236 TriaRawIterator & TriaRawIterator::operator ++ () {
 237   while (++accessor, (this->accessor.state() == 0))
 238     if (this->accessor.used() == true)
 239       return *this;
 240   return *this;
 241 }
 242
 243 struct Comp {
 244     Comp (const Tensor &dir) : dir(dir) {}
 245
 246     bool operator () (const TriaIterator &c1, const TriaIterator &c2) const;
 247     const Tensor dir;
 248 };
 249
 250
 251 template<typename Iter>
 252 void x1(Iter first, Iter last, int i, Comp comp)
 253 {
 254   x1(Iter(), last, i, comp);
 255 }
 256
 257 template<typename Iter>
 258 inline void x2(Iter first, Iter last, Comp comp)
 259 {
 260   if (first.base() != last.base())
 261     x1(first, last, (last - first), comp);
 262 }
 263
 264 void downstream_dg (const Tensor& direction)
 265 {
 266   vector<TriaIterator> ordered_cells(13);
 267   const Comp comparator(direction);
 268
 269   TriaIterator begin, end;
 270
 271   copy (begin, end, ordered_cells.begin());
 272   x2 (ordered_cells.begin(), ordered_cells.begin(), comparator);
 273 }