Subversion Repositories openrisc

// { dg-do run }

typedef __PTRDIFF_TYPE__ ptrdiff_t;

extern "C" void abort ();

template 

class I

{

public:

  typedef ptrdiff_t difference_type;

  I ();

  ~I ();

  I (T *);

  I (const I &);

  T &operator * ();

  T *operator -> ();

  T &operator [] (const difference_type &) const;

  I &operator = (const I &);

  I &operator ++ ();

  I operator ++ (int);

  I &operator -- ();

  I operator -- (int);

  I &operator += (const difference_type &);

  I &operator -= (const difference_type &);

  I operator + (const difference_type &) const;

  I operator - (const difference_type &) const;

  template  friend bool operator == (I &, I &);

  template  friend bool operator == (const I &, const I &);

  template  friend bool operator < (I &, I &);

  template  friend bool operator < (const I &, const I &);

  template  friend bool operator <= (I &, I &);

  template  friend bool operator <= (const I &, const I &);

  template  friend bool operator > (I &, I &);

  template  friend bool operator > (const I &, const I &);

  template  friend bool operator >= (I &, I &);

  template  friend bool operator >= (const I &, const I &);

  template  friend typename I::difference_type operator - (I &, I &);

  template  friend typename I::difference_type operator - (const I &, const I &);

  template  friend I operator + (typename I::difference_type , const I &);

private:

  T *p;

};

template  I::I () : p (0) {}

template  I::~I () { p = (T *) 0; }

template  I::I (T *x) : p (x) {}

template  I::I (const I &x) : p (x.p) {}

template  T &I::operator * () { return *p; }

template  T *I::operator -> () { return p; }

template  T &I::operator [] (const difference_type &x) const { return p[x]; }

template  I &I::operator = (const I &x) { p = x.p; return *this; }

template  I &I::operator ++ () { ++p; return *this; }

template  I I::operator ++ (int) { return I (p++); }

template  I &I::operator -- () { --p; return *this; }

template  I I::operator -- (int) { return I (p--); }

template  I &I::operator += (const difference_type &x) { p += x; return *this; }

template  I &I::operator -= (const difference_type &x) { p -= x; return *this; }

template  I I::operator + (const difference_type &x) const { return I (p + x); }

template  I I::operator - (const difference_type &x) const { return I (p - x); }

template  bool operator == (I &x, I &y) { return x.p == y.p; }

template  bool operator == (const I &x, const I &y) { return x.p == y.p; }

template  bool operator != (I &x, I &y) { return !(x == y); }

template  bool operator != (const I &x, const I &y) { return !(x == y); }

template  bool operator < (I &x, I &y) { return x.p < y.p; }

template  bool operator < (const I &x, const I &y) { return x.p < y.p; }

template  bool operator <= (I &x, I &y) { return x.p <= y.p; }

template  bool operator <= (const I &x, const I &y) { return x.p <= y.p; }

template  bool operator > (I &x, I &y) { return x.p > y.p; }

template  bool operator > (const I &x, const I &y) { return x.p > y.p; }

template  bool operator >= (I &x, I &y) { return x.p >= y.p; }

template  bool operator >= (const I &x, const I &y) { return x.p >= y.p; }

template  typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }

template  typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }

template  I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }

template 

class J

{

public:

  J(const I &x, const I &y) : b (x), e (y) {}

  const I &begin ();

  const I &end ();

private:

  I b, e;

};

template  const I &J::begin () { return b; }

template  const I &J::end () { return e; }

int results[2000];

template 

void

baz (I &i)

{

  if (*i < 0 || *i >= 2000)

    abort ();

  results[*i]++;

}

I

f1 (const I &x, const I &y)

{

  I i;

#pragma omp parallel shared (i)

  {

  #pragma omp for lastprivate (i) schedule(runtime)

    for (i = x; i < y - 1; ++i)

      baz (i);

  #pragma omp single

    i += 3;

  }

  return I (i);

}

I

f2 (const I &x, const I &y)

{

  I i;

#pragma omp parallel for lastprivate (i)

  for (i = x; i < y - 1; i = 1 - 6 + 7 + i)

    baz (i);

  return I (i);

}

template 

I

f3 (const I &x, const I &y)

{

  I i;

#pragma omp parallel

  #pragma omp for lastprivate (i)

    for (i = x + 1000 - 64; i <= y - 10; i++)

      baz (i);

  return i;

}

template 

I

f4 (const I &x, const I &y)

{

  I i;

#pragma omp parallel for lastprivate (i)

  for (i = x + 2000 - 64; i > y + 10; --i)

    baz (i);

  return I (i);

}

template 

I

f5 (const I &x, const I &y)

{

  I i;

#pragma omp parallel for lastprivate (i)

  for (i = x; i > y + T (6); i--)

    baz (i);

  return i;

}

template 

I

f6 (const I &x, const I &y)

{

  I i;

#pragma omp parallel for lastprivate (i)

  for (i = x - T (7); i > y; i -= T (2))

    baz (i);

  return I (i);

}

template 

I

f7 (I i, const I &x, const I &y)

{

#pragma omp parallel for lastprivate (i)

  for (i = x - 10; i <= y + 10; i += N)

    baz (i);

  return I (i);

}

template 

I

f8 (J j)

{

  I i;

#pragma omp parallel shared (i)

  #pragma omp for lastprivate (i)

    for (i = j.begin (); i <= j.end () + N; i += 2)

      baz (i);

  return i;

}

I i9;

template 

I &

f9 (J j)

{

#pragma omp parallel for lastprivate (i9)

  for (i9 = j.begin () + N; i9 <= j.end () - N; i9 = i9 - N)

    baz (i9);

  return i9;

}

template 

I

f10 (const I &x, const I &y)

{

  I i;

#pragma omp parallel for lastprivate (i)

  for (i = x; i > y; i = i + N)

    baz (i);

  return i;

}

template 

T

f11 (T i, const T &x, const T &y)

{

#pragma omp parallel

  #pragma omp for lastprivate (i)

  for (i = x + U (2); i <= y + U (1); i = U (2) + U (3) + i)

    baz (i);

  return T (i);

}

template 

T

f12 (const T &x, const T &y)

{

  T i;

#pragma omp parallel for lastprivate (i)

  for (i = x; i > y; --i)

    baz (i);

  return i;

}

#define check(expr) \

  for (int i = 0; i < 2000; i++)                        \

    if (expr)                                           \

      {                                                 \

        if (results[i] != 1)                            \

          abort ();                                     \

        results[i] = 0;                                 \

      }                                                 \

    else if (results[i])                                \

      abort ()

int

main ()

{

  int a[2000];

  long b[2000];

  for (int i = 0; i < 2000; i++)

    {

      a[i] = i;

      b[i] = i;

    }

  if (*f1 (&a[10], &a[1873]) != 1875)

    abort ();

  check (i >= 10 && i < 1872);

  if (*f2 (&a[0], &a[1998]) != 1998)

    abort ();

  check (i < 1997 && (i & 1) == 0);

  if (*f3 (&a[10], &a[1971]) != 1962)

    abort ();

  check (i >= 946 && i <= 1961);

  if (*f4 (&a[0], &a[30]) != 40)

    abort ();

  check (i > 40 && i <= 2000 - 64);

  if (*f5 (&a[1931], &a[17]) != 23)

    abort ();

  check (i > 23 && i <= 1931);

  if (*f6 (&a[1931], &a[17]) != 16)

    abort ();

  check (i > 17 && i <= 1924 && (i & 1) == 0);

  if (*f7<6> (I (), &a[12], &a[1800]) != 1814)

    abort ();

  check (i >= 2 && i <= 1808 && (i - 2) % 6 == 0);

  if (*f8<121> (J (&a[14], &a[1803])) != 1926)

    abort ();

  check (i >= 14 && i <= 1924 && (i & 1) == 0);

  if (*f9<-3L> (J (&a[27], &a[1761])) != 1767)

    abort ();

  check (i >= 24 && i <= 1764 && (i % 3) == 0);

  if (*f10 (&a[1939], &a[17]) != 14)

    abort ();

  check (i >= 21 && i <= 1939 && i % 7 == 0);

  if (*f11, short> (I (), &a[71], &a[1941]) != 1943)

    abort ();

  check (i >= 73 && i <= 1938 && (i - 73) % 5 == 0);

  if (*f12 > (&a[1761], &a[37]) != 37)

    abort ();

  check (i > 37 && i <= 1761);

  if (*f10 (&b[1939], &b[17]) != 14)

    abort ();

  check (i >= 21 && i <= 1939 && i % 7 == 0);

  if (*f11, short> (I (), &b[71], &b[1941]) != 1943)

    abort ();

  check (i >= 73 && i <= 1938 && (i - 73) % 5 == 0);

  if (*f12 > (&b[1761], &b[37]) != 37)

    abort ();

  check (i > 37 && i <= 1761);

}