caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d661b4b57504b965a37dc30b79bdd5ac36fca9ec
clang-p2996/clang/test/OpenMP/target_parallel_for_linear_messages.cpp
Animesh Kumar 0c6f2f629c [OpenMP] Update the default version of OpenMP to 5.1 
The default version of OpenMP is updated from 5.0 to 5.1 which means if -fopenmp is specified but -fopenmp-version is not specified with clang, the default version of OpenMP is taken to be 5.1.  After modifying the Frontend for that, various LIT tests were updated. This patch contains all such changes. At a high level, these are the patterns of changes observed in LIT tests -

  # RUN lines which mentioned `-fopenmp-version=50` need to kept only if the IR for version 5.0 and 5.1 are different. Otherwise only one RUN line with no version info(i.e. default version) needs to be there.

  # Test cases of this sort already had the RUN lines with respect to the older default version 5.0 and the version 5.1. Only swapping the version specification flag `-fopenmp-version` from newer version RUN line to older version RUN line is required.

  # Diagnostics: Remove the 5.0 version specific RUN lines if there was no difference in the Diagnostics messages with respect to the default 5.1.

  # Diagnostics: In case there was any difference in diagnostics messages between 5.0 and 5.1, mention version specific messages in tests.

  # If the test contained version specific ifdef's e.g. "#ifdef OMP5" but there were no RUN lines for any other version than 5.X, then bring the code guarded by ifdef's outside and remove the ifdef's.

  # Some tests had RUN lines for both 5.0 and 5.1 versions, but it is found that the IR for 5.0 is not different from the 5.1, therefore such RUN lines are redundant. So, such duplicated lines are removed.

  # To generate CHECK lines automatically, use the script llvm/utils/update_cc_test_checks.py

Reviewed By: saiislam, ABataev

Differential Revision: https://reviews.llvm.org/D129635

(cherry picked from commit 9dd2999907dc791136a75238a6000f69bf67cf4e)
2023-06-15 12:41:09 +05:30

290 lines
9.9 KiB
C++
Raw Blame History

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_null_allocator;
extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
extern const omp_allocator_handle_t omp_pteam_mem_alloc;
extern const omp_allocator_handle_t omp_thread_mem_alloc;
void xxx(int argc) {
int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
#pragma omp target parallel for linear(lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
for (i = 0; i < 10; ++i)
;
}
namespace X {
int x;
};
struct B {
static int ib; // expected-note {{'B::ib' declared here}}
static int bfoo() { return 8; }
};
int bfoo() { return 4; }
int z;
const int C1 = 1;
const int C2 = 2;
void test_linear_colons() {
int B = 0;
#pragma omp target parallel for linear(B : bfoo())
for (int i = 0; i < 10; ++i)
;
// expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}}
#pragma omp target parallel for linear(B::ib : B : bfoo())
for (int i = 0; i < 10; ++i)
;
// expected-error@+1 {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
#pragma omp target parallel for linear(B : ib)
for (int i = 0; i < 10; ++i)
;
// expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}}
#pragma omp target parallel for linear(z : B : ib)
for (int i = 0; i < 10; ++i)
;
#pragma omp target parallel for linear(B : B::bfoo())
for (int i = 0; i < 10; ++i)
;
#pragma omp target parallel for linear(X::x : ::z)
for (int i = 0; i < 10; ++i)
;
#pragma omp target parallel for linear(B, ::z, X::x)
for (int i = 0; i < 10; ++i)
;
#pragma omp target parallel for linear(::z)
for (int i = 0; i < 10; ++i)
;
// expected-error@+1 {{expected variable name}}
#pragma omp target parallel for linear(B::bfoo())
for (int i = 0; i < 10; ++i)
;
#pragma omp target parallel for linear(B::ib, B : C1 + C2)
for (int i = 0; i < 10; ++i)
;
}
template <int L, class T, class N>
T test_template(T *arr, N num) {
N i;
T sum = (T)0;
T ind2 = -num * L; // expected-note {{'ind2' defined here}}
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type}}
#pragma omp target parallel for linear(ind2 : L)
for (i = 0; i < num; ++i) {
T cur = arr[(int)ind2];
ind2 += L;
sum += cur;
}
return T();
}
template <int LEN>
int test_warn() {
int ind2 = 0;
// expected-warning@+1 {{zero linear step (ind2 should probably be const)}}
#pragma omp target parallel for linear(ind2 : LEN)
for (int i = 0; i < 100; i++) {
ind2 += LEN;
}
return ind2;
}
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;
class S2 {
mutable int a;
public:
S2() : a(0) {}
};
const S2 b; // expected-note 2 {{'b' defined here}}
const S2 ba[5];
class S3 {
int a;
public:
S3() : a(0) {}
};
const S3 ca[5];
class S4 {
int a;
S4();
public:
S4(int v) : a(v) {}
};
class S5 {
int a;
S5() : a(0) {}
public:
S5(int v) : a(v) {}
};
S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
template <class I, class C>
int foomain(I argc, C **argv) {
I e(4);
I g(5);
int i, z;
int &j = i;
#pragma omp target parallel for linear // expected-error {{expected '(' after 'linear'}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear() // expected-error {{expected expression}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc : 5) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(S1) // expected-error {{'S1' does not refer to a value}}
for (int k = 0; k < argc; ++k)
++k;
// expected-error@+2 {{linear variable with incomplete type 'S1'}}
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S2'}}
#pragma omp target parallel for linear(a, b : B::ib)
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argv[1]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for allocate(omp_thread_mem_alloc: e) linear(e, g) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'target parallel for' directive}} expected-error {{allocator must be specified in the 'uses_allocators' clause}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(z, h) // expected-error {{threadprivate or thread local variable cannot be linear}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(i)
for (int k = 0; k < argc; ++k)
++k;
#pragma omp parallel
{
int v = 0;
int i;
#pragma omp target parallel for linear(v : i)
for (int k = 0; k < argc; ++k) {
i = k;
v += i;
}
}
#pragma omp target parallel for linear(j)
for (int k = 0; k < argc; ++k)
++k;
int v = 0;
#pragma omp target parallel for linear(v : j)
for (int k = 0; k < argc; ++k) {
++k;
v += j;
}
#pragma omp target parallel for linear(i)
for (int k = 0; k < argc; ++k)
++k;
return 0;
}
namespace A {
double x;
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
}
namespace C {
using A::x;
}
int main(int argc, char **argv) {
double darr[100];
// expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}}
test_template<-4>(darr, 4);
// expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}}
test_warn<0>();
S4 e(4); // expected-note {{'e' defined here}}
S5 g(5); // expected-note {{'g' defined here}}
int i, z;
int &j = i;
#pragma omp target parallel for linear // expected-error {{expected '(' after 'linear'}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear() // expected-error {{expected expression}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argc, z)
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(S1) // expected-error {{'S1' does not refer to a value}}
for (int k = 0; k < argc; ++k)
++k;
// expected-error@+2 {{linear variable with incomplete type 'S1'}}
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S2'}}
#pragma omp target parallel for linear(a, b)
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(argv[1]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)
++k;
// expected-error@+2 {{argument of a linear clause should be of integral or pointer type, not 'S4'}}
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S5'}}
#pragma omp target parallel for linear(e, g)
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(h, C::x) // expected-error 2 {{threadprivate or thread local variable cannot be linear}}
for (int k = 0; k < argc; ++k)
++k;
#pragma omp parallel
{
int i;
#pragma omp target parallel for linear(i)
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(i : 4)
for (int k = 0; k < argc; ++k) {
++k;
i += 4;
}
}
#pragma omp target parallel for linear(j)
for (int k = 0; k < argc; ++k)
++k;
#pragma omp target parallel for linear(i)
for (int k = 0; k < argc; ++k)
++k;
foomain<int, char>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink