head	1.1;
branch	1.1.1;
access;
symbols
	netbsd-10-2-RELEASE:1.1.1.5
	netbsd-9-5-RELEASE:1.1.1.4
	netbsd-11-0-RELEASE:1.1.1.5
	netbsd-11-0-RC7:1.1.1.5
	netbsd-11-0-RC6:1.1.1.5
	netbsd-11-0-RC5:1.1.1.5
	netbsd-11-0-RC4:1.1.1.5
	netbsd-11-0-RC3:1.1.1.5
	netbsd-11-0-RC2:1.1.1.5
	netbsd-11-0-RC1:1.1.1.5
	perseant-exfatfs-base-20250801:1.1.1.5
	netbsd-11:1.1.1.5.0.10
	netbsd-11-base:1.1.1.5
	netbsd-10-1-RELEASE:1.1.1.5
	perseant-exfatfs-base-20240630:1.1.1.5
	perseant-exfatfs:1.1.1.5.0.8
	perseant-exfatfs-base:1.1.1.5
	netbsd-8-3-RELEASE:1.1.1.3
	netbsd-9-4-RELEASE:1.1.1.4
	netbsd-10-0-RELEASE:1.1.1.5
	netbsd-10-0-RC6:1.1.1.5
	netbsd-10-0-RC5:1.1.1.5
	netbsd-10-0-RC4:1.1.1.5
	netbsd-10-0-RC3:1.1.1.5
	netbsd-10-0-RC2:1.1.1.5
	netbsd-10-0-RC1:1.1.1.5
	netbsd-10:1.1.1.5.0.6
	netbsd-10-base:1.1.1.5
	netbsd-9-3-RELEASE:1.1.1.4
	cjep_sun2x:1.1.1.5.0.4
	cjep_sun2x-base:1.1.1.5
	cjep_staticlib_x-base1:1.1.1.5
	netbsd-9-2-RELEASE:1.1.1.4
	cjep_staticlib_x:1.1.1.5.0.2
	cjep_staticlib_x-base:1.1.1.5
	netbsd-9-1-RELEASE:1.1.1.4
	phil-wifi-20200421:1.1.1.5
	phil-wifi-20200411:1.1.1.5
	phil-wifi-20200406:1.1.1.5
	netbsd-8-2-RELEASE:1.1.1.3
	netbsd-9-0-RELEASE:1.1.1.4
	netbsd-9-0-RC2:1.1.1.4
	netbsd-9-0-RC1:1.1.1.4
	netbsd-9:1.1.1.4.0.2
	netbsd-9-base:1.1.1.4
	phil-wifi-20190609:1.1.1.4
	netbsd-8-1-RELEASE:1.1.1.3
	netbsd-8-1-RC1:1.1.1.3
	pgoyette-compat-merge-20190127:1.1.1.3.12.1
	pgoyette-compat-20190127:1.1.1.4
	pgoyette-compat-20190118:1.1.1.4
	pgoyette-compat-1226:1.1.1.4
	pgoyette-compat-1126:1.1.1.4
	pgoyette-compat-1020:1.1.1.4
	pgoyette-compat-0930:1.1.1.4
	pgoyette-compat-0906:1.1.1.4
	netbsd-7-2-RELEASE:1.1.1.1
	pgoyette-compat-0728:1.1.1.4
	clang-337282:1.1.1.4
	netbsd-8-0-RELEASE:1.1.1.3
	phil-wifi:1.1.1.3.0.14
	phil-wifi-base:1.1.1.3
	pgoyette-compat-0625:1.1.1.3
	netbsd-8-0-RC2:1.1.1.3
	pgoyette-compat-0521:1.1.1.3
	pgoyette-compat-0502:1.1.1.3
	pgoyette-compat-0422:1.1.1.3
	netbsd-8-0-RC1:1.1.1.3
	pgoyette-compat-0415:1.1.1.3
	pgoyette-compat-0407:1.1.1.3
	pgoyette-compat-0330:1.1.1.3
	pgoyette-compat-0322:1.1.1.3
	pgoyette-compat-0315:1.1.1.3
	netbsd-7-1-2-RELEASE:1.1.1.1
	pgoyette-compat:1.1.1.3.0.12
	pgoyette-compat-base:1.1.1.3
	netbsd-7-1-1-RELEASE:1.1.1.1
	clang-319952:1.1.1.3
	matt-nb8-mediatek:1.1.1.3.0.10
	matt-nb8-mediatek-base:1.1.1.3
	clang-309604:1.1.1.3
	perseant-stdc-iso10646:1.1.1.3.0.8
	perseant-stdc-iso10646-base:1.1.1.3
	netbsd-8:1.1.1.3.0.6
	netbsd-8-base:1.1.1.3
	prg-localcount2-base3:1.1.1.3
	prg-localcount2-base2:1.1.1.3
	prg-localcount2-base1:1.1.1.3
	prg-localcount2:1.1.1.3.0.4
	prg-localcount2-base:1.1.1.3
	pgoyette-localcount-20170426:1.1.1.3
	bouyer-socketcan-base1:1.1.1.3
	pgoyette-localcount-20170320:1.1.1.3
	netbsd-7-1:1.1.1.1.0.10
	netbsd-7-1-RELEASE:1.1.1.1
	netbsd-7-1-RC2:1.1.1.1
	clang-294123:1.1.1.3
	netbsd-7-nhusb-base-20170116:1.1.1.1
	bouyer-socketcan:1.1.1.3.0.2
	bouyer-socketcan-base:1.1.1.3
	clang-291444:1.1.1.3
	pgoyette-localcount-20170107:1.1.1.2
	netbsd-7-1-RC1:1.1.1.1
	pgoyette-localcount-20161104:1.1.1.2
	netbsd-7-0-2-RELEASE:1.1.1.1
	localcount-20160914:1.1.1.2
	netbsd-7-nhusb:1.1.1.1.0.8
	netbsd-7-nhusb-base:1.1.1.1
	clang-280599:1.1.1.2
	pgoyette-localcount-20160806:1.1.1.2
	pgoyette-localcount-20160726:1.1.1.2
	pgoyette-localcount:1.1.1.2.0.2
	pgoyette-localcount-base:1.1.1.2
	netbsd-7-0-1-RELEASE:1.1.1.1
	clang-261930:1.1.1.2
	netbsd-7-0:1.1.1.1.0.6
	netbsd-7-0-RELEASE:1.1.1.1
	netbsd-7-0-RC3:1.1.1.1
	netbsd-7-0-RC2:1.1.1.1
	netbsd-7-0-RC1:1.1.1.1
	clang-237755:1.1.1.1
	clang-232565:1.1.1.1
	clang-227398:1.1.1.1
	tls-maxphys-base:1.1.1.1
	tls-maxphys:1.1.1.1.0.4
	netbsd-7:1.1.1.1.0.2
	netbsd-7-base:1.1.1.1
	clang-215315:1.1.1.1
	LLVM:1.1.1;
locks; strict;
comment	@// @;


1.1
date	2014.08.10.17.08.41;	author joerg;	state Exp;
branches
	1.1.1.1;
next	;
commitid	N85tXAN6Ex9VZPLx;

1.1.1.1
date	2014.08.10.17.08.41;	author joerg;	state Exp;
branches
	1.1.1.1.4.1;
next	1.1.1.2;
commitid	N85tXAN6Ex9VZPLx;

1.1.1.2
date	2016.02.27.22.08.34;	author joerg;	state Exp;
branches
	1.1.1.2.2.1;
next	1.1.1.3;
commitid	tIimz3oDlh1NpBWy;

1.1.1.3
date	2017.01.11.10.38.38;	author joerg;	state Exp;
branches
	1.1.1.3.12.1
	1.1.1.3.14.1;
next	1.1.1.4;
commitid	CNnUNfII1jgNmxBz;

1.1.1.4
date	2018.07.17.18.31.38;	author joerg;	state Exp;
branches;
next	1.1.1.5;
commitid	wDzL46ALjrCZgwKA;

1.1.1.5
date	2019.11.13.22.22.44;	author joerg;	state dead;
branches;
next	;
commitid	QD8YATxuNG34YJKB;

1.1.1.1.4.1
date	2014.08.10.17.08.41;	author tls;	state dead;
branches;
next	1.1.1.1.4.2;
commitid	jTnpym9Qu0o4R1Nx;

1.1.1.1.4.2
date	2014.08.19.23.48.39;	author tls;	state Exp;
branches;
next	;
commitid	jTnpym9Qu0o4R1Nx;

1.1.1.2.2.1
date	2017.03.20.06.53.28;	author pgoyette;	state Exp;
branches;
next	;
commitid	jjw7cAwgyKq7RfKz;

1.1.1.3.12.1
date	2018.07.28.04.34.06;	author pgoyette;	state Exp;
branches;
next	;
commitid	1UP1xAIUxv1ZgRLA;

1.1.1.3.14.1
date	2019.06.10.21.46.27;	author christos;	state Exp;
branches;
next	1.1.1.3.14.2;
commitid	jtc8rnCzWiEEHGqB;

1.1.1.3.14.2
date	2020.04.13.07.50.12;	author martin;	state dead;
branches;
next	;
commitid	X01YhRUPVUDaec4C;


desc
@@


1.1
log
@Initial revision
@
text
@// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s

void foo() {
}

bool foobool(int argc) {
  return argc;
}

struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
extern S1 a;
class S2 {
  mutable int a;
  S2 &operator+=(const S2 &arg) { return (*this); }

public:
  S2() : a(0) {}
  S2(S2 &s2) : a(s2.a) {}
  static float S2s; // expected-note 2 {{static data member is predetermined as shared}}
  static const float S2sc;
};
const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}}
S2 b;                     // expected-note 2 {{'b' defined here}}
const S2 ba[5];           // expected-note 2 {{'ba' defined here}}
class S3 {
  int a;

public:
  S3() : a(0) {}
  S3(const S3 &s3) : a(s3.a) {}
  S3 operator+=(const S3 &arg1) { return arg1; }
};
int operator+=(const S3 &arg1, const S3 &arg2) { return 5; }
S3 c;               // expected-note 2 {{'c' defined here}}
const S3 ca[5];     // expected-note 2 {{'ca' defined here}}
extern const int f; // expected-note 4 {{'f' declared here}}
class S4 {          // expected-note {{'S4' declared here}}
  int a;
  S4();
  S4(const S4 &s4);
  S4 &operator+=(const S4 &arg) { return (*this); }

public:
  S4(int v) : a(v) {}
};
S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; }
class S5 {
  int a;
  S5() : a(0) {}
  S5(const S5 &s5) : a(s5.a) {}
  S5 &operator+=(const S5 &arg);

public:
  S5(int v) : a(v) {}
};
class S6 {
  int a;

public:
  S6() : a(6) {}
  operator int() { return 6; }
} o; // expected-note 2 {{'o' defined here}}

S3 h, k;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class T>       // expected-note {{declared here}}
T tmain(T argc) {        // expected-note 2 {{'argc' defined here}}
  const T d = T();       // expected-note 4 {{'d' defined here}}
  const T da[5] = {T()}; // expected-note 2 {{'da' defined here}}
  T qa[5] = {T()};
  T i;
  T &j = i;                // expected-note 4 {{'j' defined here}}
  S3 &p = k;               // expected-note 2 {{'p' defined here}}
  const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}}
  T &q = qa[(int)i];       // expected-note 2 {{'q' defined here}}
  T fl;                    // expected-note {{'fl' defined here}}
#pragma omp parallel
#pragma omp sections reduction // expected-error {{expected '(' after 'reduction'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp sections' are ignored}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : argc)
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : T) // expected-error {{'T' does not refer to a value}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(max : qa[1]) // expected-error 2 {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(k)
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel shared(i)
#pragma omp parallel reduction(min : i)
#pragma omp sections reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(fl)       // expected-note 2 {{defined as private}}
#pragma omp sections reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}}
  {
    foo();
  }
#pragma omp parallel reduction(* : fl) // expected-note 2 {{defined as reduction}}
#pragma omp sections reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}}
  {
    foo();
  }

  return T();
}

int main(int argc, char **argv) {
  const int d = 5;       // expected-note 2 {{'d' defined here}}
  const int da[5] = {0}; // expected-note {{'da' defined here}}
  int qa[5] = {0};
  S4 e(4); // expected-note {{'e' defined here}}
  S5 g(5); // expected-note {{'g' defined here}}
  int i;
  int &j = i;           // expected-note 2 {{'j' defined here}}
  S3 &p = k;            // expected-note 2 {{'p' defined here}}
  const int &r = da[i]; // expected-note {{'r' defined here}}
  int &q = qa[i];       // expected-note {{'q' defined here}}
  float fl;             // expected-note {{'fl' defined here}}
#pragma omp parallel
#pragma omp sections reduction // expected-error {{expected '(' after 'reduction'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp sections' are ignored}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(~ : argc) // expected-error {{expected unqualified-id}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : argc)
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : S1) // expected-error {{'S1' does not refer to a value}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(max : argv[1]) // expected-error {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(k)
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel shared(i)
#pragma omp parallel reduction(min : i)
#pragma omp sections reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(fl)       // expected-note {{defined as private}}
#pragma omp sections reduction(+ : fl) // expected-error {{reduction variable must be shared}}
  {
    foo();
  }
#pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}}
#pragma omp sections reduction(+ : fl) // expected-error {{reduction variable must be shared}}
  {
    foo();
  }

  return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}}
}
@


1.1.1.1
log
@Import clang 3.6svn r215315.
@
text
@@


1.1.1.2
log
@Import Clang 3.8.0rc3 r261930.
@
text
@d1 1
a1 3
// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s
d14 1
a14 1
  S2 &operator+(const S2 &arg) { return (*this); } // expected-note 4 {{implicitly declared private here}}
a28 1
  int b;
d31 1
a31 1
  S3 operator+(const S3 &arg1) { return arg1; }
d33 1
a33 1
int operator+(const S3 &arg1, const S3 &arg2) { return 5; }
d37 1
a37 1
class S4 {
d39 1
a39 1
  S4(); // expected-note {{implicitly declared private here}}
d41 1
a41 1
  S4 &operator+(const S4 &arg) { return (*this); }
d49 1
a49 1
  S5() : a(0) {} // expected-note {{implicitly declared private here}}
d51 1
a51 1
  S5 &operator+(const S5 &arg);
d56 1
a56 4
class S6 { // expected-note 2 {{candidate function (the implicit copy assignment operator) not viable: no known conversion from 'int' to 'const S6' for 1st argument}}
#if __cplusplus >= 201103L // C++11 or later
// expected-note@@-2 2 {{candidate function (the implicit move assignment operator) not viable}}
#endif
d62 1
a62 1
} o;
d68 1
a68 1
T tmain(T argc) {
d77 1
a77 1
  T fl;
d114 1
a114 1
#pragma omp sections reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
d119 1
a119 1
#pragma omp sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
d124 1
a124 1
#pragma omp sections reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name, array element or array section}}
d144 1
a144 1
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 3 {{const-qualified list item cannot be reduction}} expected-error 3 {{'operator+' is a private member of 'S2'}}
d149 1
a149 1
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified list item cannot be reduction}}
d154 1
a154 1
#pragma omp sections reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
d159 1
a159 1
#pragma omp sections reduction(+ : ba) // expected-error {{a reduction list item with array type 'const S2 [5]'}}
d164 1
a164 1
#pragma omp sections reduction(* : ca) // expected-error {{a reduction list item with array type 'const S3 [5]'}}
d169 1
a169 1
#pragma omp sections reduction(- : da) // expected-error {{a reduction list item with array type 'const int [5]'}} expected-error {{a reduction list item with array type 'const float [5]'}}
d174 1
a174 1
#pragma omp sections reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
d184 1
a184 1
#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified list item cannot be reduction}}
d194 1
a194 1
#pragma omp sections reduction(+ : o) // expected-error {{no viable overloaded '='}}
d214 1
a214 1
#pragma omp sections reduction(+ : r) // expected-error 2 {{const-qualified list item cannot be reduction}}
a237 8
namespace A {
double x;
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
}
namespace B {
using A::x;
}

d242 2
a243 2
  S4 e(4);
  S5 g(5);
d249 1
a249 1
  float fl;
d296 1
a296 1
#pragma omp sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name, array element or array section}}
d316 1
a316 1
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{const-qualified list item cannot be reduction}} expected-error {{'operator+' is a private member of 'S2'}}
d321 1
a321 1
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified list item cannot be reduction}}
d326 1
a326 1
#pragma omp sections reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
d331 1
a331 1
#pragma omp sections reduction(+ : ba) // expected-error {{a reduction list item with array type 'const S2 [5]'}}
d336 1
a336 1
#pragma omp sections reduction(* : ca) // expected-error {{a reduction list item with array type 'const S3 [5]'}}
d341 1
a341 1
#pragma omp sections reduction(- : da) // expected-error {{a reduction list item with array type 'const int [5]'}}
d346 1
a346 1
#pragma omp sections reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
d356 1
a356 1
#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified list item cannot be reduction}}
d361 1
a361 1
#pragma omp sections reduction(& : e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{invalid operands to binary expression ('S4' and 'S4')}} expected-error {{calling a private constructor of class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 'S5')}}
d366 1
a366 1
#pragma omp sections reduction(+ : h, k, B::x) // expected-error 2 {{threadprivate or thread local variable cannot be reduction}}
d371 1
a371 1
#pragma omp sections reduction(+ : o) // expected-error {{no viable overloaded '='}}
d391 1
a391 1
#pragma omp sections reduction(+ : r) // expected-error {{const-qualified list item cannot be reduction}}
a410 5
  static int m;
#pragma omp sections reduction(+ : m) // OK
  {
    foo();
  }
@


1.1.1.2.2.1
log
@Sync with HEAD
@
text
@a11 8
void foobar(int &ref) {
#pragma omp parallel   
#pragma omp sections reduction(+:ref)
  {
    foo();
  }
}

d16 1
a16 1
  S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
d25 1
a25 1
S2 b;                     // expected-note 3 {{'b' defined here}}
d37 1
a37 1
S3 c;               // expected-note 3 {{'c' defined here}}
d59 1
a59 1
class S6 { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable: no known conversion from 'int' to 'const S6' for 1st argument}}
d61 1
a61 1
// expected-note@@-2 3 {{candidate function (the implicit move assignment operator) not viable}}
d135 1
a135 1
#pragma omp sections reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'float'}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'int'}}
d150 1
a150 1
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 3 {{const-qualified list item cannot be reduction}} expected-error 2 {{'operator+' is a private member of 'S2'}}
d155 1
a155 1
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 4 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified list item cannot be reduction}}
d165 1
a165 1
#pragma omp sections reduction(+ : ba) // expected-error {{const-qualified list item cannot be reduction}}
d170 1
a170 1
#pragma omp sections reduction(* : ca) // expected-error {{const-qualified list item cannot be reduction}}
d175 1
a175 1
#pragma omp sections reduction(- : da) // expected-error {{const-qualified list item cannot be reduction}} expected-error {{const-qualified list item cannot be reduction}}
d200 1
a200 1
#pragma omp sections reduction(+ : o) // expected-error 2 {{no viable overloaded '='}}
d215 1
a215 1
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 2 {{previously referenced here}}
d345 1
a345 1
#pragma omp sections reduction(+ : ba) // expected-error {{const-qualified list item cannot be reduction}}
d350 1
a350 1
#pragma omp sections reduction(* : ca) // expected-error {{const-qualified list item cannot be reduction}}
d355 1
a355 1
#pragma omp sections reduction(- : da) // expected-error {{const-qualified list item cannot be reduction}}
@


1.1.1.3
log
@Import Clang pre-4.0.0 r291444.
@
text
@a11 8
void foobar(int &ref) {
#pragma omp parallel   
#pragma omp sections reduction(+:ref)
  {
    foo();
  }
}

d16 1
a16 1
  S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
d25 1
a25 1
S2 b;                     // expected-note 3 {{'b' defined here}}
d37 1
a37 1
S3 c;               // expected-note 3 {{'c' defined here}}
d59 1
a59 1
class S6 { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable: no known conversion from 'int' to 'const S6' for 1st argument}}
d61 1
a61 1
// expected-note@@-2 3 {{candidate function (the implicit move assignment operator) not viable}}
d135 1
a135 1
#pragma omp sections reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'float'}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'int'}}
d150 1
a150 1
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 3 {{const-qualified list item cannot be reduction}} expected-error 2 {{'operator+' is a private member of 'S2'}}
d155 1
a155 1
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 4 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified list item cannot be reduction}}
d165 1
a165 1
#pragma omp sections reduction(+ : ba) // expected-error {{const-qualified list item cannot be reduction}}
d170 1
a170 1
#pragma omp sections reduction(* : ca) // expected-error {{const-qualified list item cannot be reduction}}
d175 1
a175 1
#pragma omp sections reduction(- : da) // expected-error {{const-qualified list item cannot be reduction}} expected-error {{const-qualified list item cannot be reduction}}
d200 1
a200 1
#pragma omp sections reduction(+ : o) // expected-error 2 {{no viable overloaded '='}}
d215 1
a215 1
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 2 {{previously referenced here}}
d345 1
a345 1
#pragma omp sections reduction(+ : ba) // expected-error {{const-qualified list item cannot be reduction}}
d350 1
a350 1
#pragma omp sections reduction(* : ca) // expected-error {{const-qualified list item cannot be reduction}}
d355 1
a355 1
#pragma omp sections reduction(- : da) // expected-error {{const-qualified list item cannot be reduction}}
@


1.1.1.3.14.1
log
@Sync with HEAD
@
text
@a4 4
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s

d30 1
a30 1
  static const float S2sc; // expected-note 2 {{'S2sc' declared here}}
d32 1
a32 1
const float S2::S2sc = 0;
@


1.1.1.3.14.2
log
@Mostly merge changes from HEAD upto 20200411
@
text
@@


1.1.1.3.12.1
log
@Sync with HEAD
@
text
@a4 4
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s

d30 1
a30 1
  static const float S2sc; // expected-note 2 {{'S2sc' declared here}}
d32 1
a32 1
const float S2::S2sc = 0;
@


1.1.1.4
log
@Import clang r337282 from trunk
@
text
@a4 4
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s

d30 1
a30 1
  static const float S2sc; // expected-note 2 {{'S2sc' declared here}}
d32 1
a32 1
const float S2::S2sc = 0;
@


1.1.1.5
log
@Mark old LLVM instance as dead.
@
text
@@


1.1.1.1.4.1
log
@file sections_reduction_messages.cpp was added on branch tls-maxphys on 2014-08-19 23:48:39 +0000
@
text
@d1 413
@


1.1.1.1.4.2
log
@Rebase to HEAD as of a few days ago.
@
text
@a0 413
// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s

void foo() {
}

bool foobool(int argc) {
  return argc;
}

struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
extern S1 a;
class S2 {
  mutable int a;
  S2 &operator+=(const S2 &arg) { return (*this); }

public:
  S2() : a(0) {}
  S2(S2 &s2) : a(s2.a) {}
  static float S2s; // expected-note 2 {{static data member is predetermined as shared}}
  static const float S2sc;
};
const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}}
S2 b;                     // expected-note 2 {{'b' defined here}}
const S2 ba[5];           // expected-note 2 {{'ba' defined here}}
class S3 {
  int a;

public:
  S3() : a(0) {}
  S3(const S3 &s3) : a(s3.a) {}
  S3 operator+=(const S3 &arg1) { return arg1; }
};
int operator+=(const S3 &arg1, const S3 &arg2) { return 5; }
S3 c;               // expected-note 2 {{'c' defined here}}
const S3 ca[5];     // expected-note 2 {{'ca' defined here}}
extern const int f; // expected-note 4 {{'f' declared here}}
class S4 {          // expected-note {{'S4' declared here}}
  int a;
  S4();
  S4(const S4 &s4);
  S4 &operator+=(const S4 &arg) { return (*this); }

public:
  S4(int v) : a(v) {}
};
S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; }
class S5 {
  int a;
  S5() : a(0) {}
  S5(const S5 &s5) : a(s5.a) {}
  S5 &operator+=(const S5 &arg);

public:
  S5(int v) : a(v) {}
};
class S6 {
  int a;

public:
  S6() : a(6) {}
  operator int() { return 6; }
} o; // expected-note 2 {{'o' defined here}}

S3 h, k;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class T>       // expected-note {{declared here}}
T tmain(T argc) {        // expected-note 2 {{'argc' defined here}}
  const T d = T();       // expected-note 4 {{'d' defined here}}
  const T da[5] = {T()}; // expected-note 2 {{'da' defined here}}
  T qa[5] = {T()};
  T i;
  T &j = i;                // expected-note 4 {{'j' defined here}}
  S3 &p = k;               // expected-note 2 {{'p' defined here}}
  const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}}
  T &q = qa[(int)i];       // expected-note 2 {{'q' defined here}}
  T fl;                    // expected-note {{'fl' defined here}}
#pragma omp parallel
#pragma omp sections reduction // expected-error {{expected '(' after 'reduction'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp sections' are ignored}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : argc)
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : T) // expected-error {{'T' does not refer to a value}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(max : qa[1]) // expected-error 2 {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(k)
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel shared(i)
#pragma omp parallel reduction(min : i)
#pragma omp sections reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(fl)       // expected-note 2 {{defined as private}}
#pragma omp sections reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}}
  {
    foo();
  }
#pragma omp parallel reduction(* : fl) // expected-note 2 {{defined as reduction}}
#pragma omp sections reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}}
  {
    foo();
  }

  return T();
}

int main(int argc, char **argv) {
  const int d = 5;       // expected-note 2 {{'d' defined here}}
  const int da[5] = {0}; // expected-note {{'da' defined here}}
  int qa[5] = {0};
  S4 e(4); // expected-note {{'e' defined here}}
  S5 g(5); // expected-note {{'g' defined here}}
  int i;
  int &j = i;           // expected-note 2 {{'j' defined here}}
  S3 &p = k;            // expected-note 2 {{'p' defined here}}
  const int &r = da[i]; // expected-note {{'r' defined here}}
  int &q = qa[i];       // expected-note {{'q' defined here}}
  float fl;             // expected-note {{'fl' defined here}}
#pragma omp parallel
#pragma omp sections reduction // expected-error {{expected '(' after 'reduction'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp sections' are ignored}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(~ : argc) // expected-error {{expected unqualified-id}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : argc)
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : S1) // expected-error {{'S1' does not refer to a value}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(max : argv[1]) // expected-error {{expected variable name}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(k)
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}}
  {
    foo();
  }
#pragma omp parallel
#pragma omp sections reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}}
  {
    foo();
  }
#pragma omp parallel shared(i)
#pragma omp parallel reduction(min : i)
#pragma omp sections reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  {
    foo();
  }
#pragma omp parallel private(fl)       // expected-note {{defined as private}}
#pragma omp sections reduction(+ : fl) // expected-error {{reduction variable must be shared}}
  {
    foo();
  }
#pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}}
#pragma omp sections reduction(+ : fl) // expected-error {{reduction variable must be shared}}
  {
    foo();
  }

  return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}}
}
@