This is an archive of the discontinued LLVM Phabricator instance.

Differential D66668

[OPENMP][Analysis] Add analysis of the map clauses.
ClosedPublic

Authored by ABataev on Aug 23 2019, 10:55 AM.

Details

Reviewers
NoQ
Commits
rG94a170f811de: [OPENMP][Analysis] Add analysis of the map clauses.
rC370214: [OPENMP][Analysis] Add analysis of the map clauses.
rL370214: [OPENMP][Analysis] Add analysis of the map clauses.
Summary

Added basic analysis of map clauses. Only map clauses with to and tofrom
map type must be analyzed since all other map types (alloc, delete, etc.) do not require to use the value of the initial variable, instead they create the new copy of the variable.

Diff Detail

Repository
rL LLVM

Event Timeline

ABataev created this revision.Aug 23 2019, 10:55 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 23 2019, 10:56 AM
Herald added a subscriber: guansong. · View Herald Transcript
Harbormaster completed remote builds in B37205: Diff 216902.Aug 23 2019, 10:56 AM
NoQ accepted this revision.Aug 27 2019, 7:02 PM

Yes please! :)

This revision is now accepted and ready to land.Aug 27 2019, 7:02 PM
Closed by commit rL370214: [OPENMP][Analysis] Add analysis of the map clauses. (authored by ABataev). · Explain WhyAug 28 2019, 7:53 AM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptAug 28 2019, 7:53 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript

Revision Contents

Diff 217654

cfe/trunk/include/clang/AST/OpenMPClause.h

Show First 20 Lines • Show All 5,019 Lines • ▼ Show 20 Linespublic:
} }
const_child_range children() const { const_child_range children() const {
auto Children = const_cast<OMPMapClause *>(this)->children(); auto Children = const_cast<OMPMapClause *>(this)->children();
return const_child_range(Children.begin(), Children.end()); return const_child_range(Children.begin(), Children.end());
} }
child_range used_children() { child_range used_children() {
if (MapType == OMPC_MAP_to || MapType == OMPC_MAP_tofrom)
return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
reinterpret_cast<Stmt **>(varlist_end()));
return child_range(child_iterator(), child_iterator()); return child_range(child_iterator(), child_iterator());
} }
const_child_range used_children() const { const_child_range used_children() const {
return const_child_range(const_child_iterator(), const_child_iterator()); auto Children = const_cast<OMPMapClause *>(this)->used_children();
return const_child_range(Children.begin(), Children.end());
} }
static bool classof(const OMPClause *T) { static bool classof(const OMPClause *T) {
return T->getClauseKind() == OMPC_map; return T->getClauseKind() == OMPC_map;
} }
}; };
/// This represents 'num_teams' clause in the '#pragma omp ...' /// This represents 'num_teams' clause in the '#pragma omp ...'
/// directive. /// directive.
/// ///
▲ Show 20 Lines • Show All 1,228 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/cfg-openmp.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
// CHECK-LABEL: void xxx(int argc) // CHECK-LABEL: void xxx(int argc)
void xxx(int argc) { void xxx(int argc) {
// CHECK: [B1] // CHECK: [B1]
// CHECK-NEXT: 1: int x; // CHECK-NEXT: 1: int x;
// CHECK-NEXT: 2: int cond; // CHECK-NEXT: 2: int cond;
// CHECK-NEXT: 3: int fp; // CHECK-NEXT: 3: int fp;
// CHECK-NEXT: 4: int rd; // CHECK-NEXT: 4: int rd;
// CHECK-NEXT: 5: int lin; // CHECK-NEXT: 5: int lin;
// CHECK-NEXT: 6: int step; // CHECK-NEXT: 6: int step;
int x, cond, fp, rd, lin, step; // CHECK-NEXT: 7: int map;
int x, cond, fp, rd, lin, step, map;
// CHECK-NEXT: [[#ATOM:]]: x // CHECK-NEXT: [[#ATOM:]]: x
// CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#ATOM+2]]: argc // CHECK-NEXT: [[#ATOM+2]]: argc
// CHECK-NEXT: [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]] // CHECK-NEXT: [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
// CHECK-NEXT: [[#ATOM+4]]: #pragma omp atomic read // CHECK-NEXT: [[#ATOM+4]]: #pragma omp atomic read
// CHECK-NEXT: [B1.[[#ATOM+3]]]; // CHECK-NEXT: [B1.[[#ATOM+3]]];
#pragma omp atomic read #pragma omp atomic read
argc = x; argc = x;
▲ Show 20 Lines • Show All 193 Lines • ▼ Show 20 Lines
// CHECK-NEXT: [[#TARGET+9]]: argc // CHECK-NEXT: [[#TARGET+9]]: argc
// CHECK-NEXT: [[#TARGET+10]]: x // CHECK-NEXT: [[#TARGET+10]]: x
// CHECK-NEXT: [[#TARGET+11]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp) reduction(-: rd) // CHECK-NEXT: [[#TARGET+11]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp) reduction(-: rd)
// CHECK-NEXT: [B1.[[#TARGET+3]]]; // CHECK-NEXT: [B1.[[#TARGET+3]]];
#pragma omp target depend(in \ #pragma omp target depend(in \
: argc) if(cond) firstprivate(fp) reduction(-:rd) : argc) if(cond) firstprivate(fp) reduction(-:rd)
argc = x; argc = x;
// CHECK-NEXT: [[#TPF:]]: // CHECK-NEXT: [[#TPF:]]:
// CHECK-SAME: [B1.[[#TPF+13]]] // CHECK-SAME: [B1.[[#TPF+14]]]
// CHECK-NEXT: [[#TPF+1]]: [B1.[[#TPF+13]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TPF+1]]: [B1.[[#TPF+14]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPF+2]]: [B1.[[#TPF+12]]] // CHECK-NEXT: [[#TPF+2]]: [B1.[[#TPF+13]]]
// CHECK-NEXT: [[#TPF+3]]: [B1.[[#TPF+12]]] = [B1.[[#TPF+1]]] // CHECK-NEXT: [[#TPF+3]]: [B1.[[#TPF+13]]] = [B1.[[#TPF+1]]]
// CHECK-NEXT: [[#TPF+4]]: cond // CHECK-NEXT: [[#TPF+4]]: cond
// CHECK-NEXT: [[#TPF+5]]: [B1.[[#TPF+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TPF+5]]: [B1.[[#TPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPF+6]]: [B1.[[#TPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TPF+6]]: [B1.[[#TPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TPF+7]]: fp // CHECK-NEXT: [[#TPF+7]]: fp
// CHECK-NEXT: [[#TPF+8]]: rd // CHECK-NEXT: [[#TPF+8]]: rd
// CHECK-NEXT: [[#TPF+9]]: lin // CHECK-NEXT: [[#TPF+9]]: lin
// CHECK-NEXT: [[#TPF+10]]: step // CHECK-NEXT: [[#TPF+10]]: step
// CHECK-NEXT: [[#TPF+11]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TPF+11]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPF+12]]: argc // CHECK-NEXT: [[#TPF+12]]: map
// CHECK-NEXT: [[#TPF+13]]: x // CHECK-NEXT: [[#TPF+13]]: argc
// CHECK-NEXT: [[#TPF+14]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step) // CHECK-NEXT: [[#TPF+14]]: x
// CHECK-NEXT: [[#TPF+15]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step) map(tofrom: map)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TPF+3]]]; // CHECK-NEXT: [B1.[[#TPF+3]]];
#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step) #pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step) map(map)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
argc = x; argc = x;
// CHECK-NEXT: [[#TPFS:]]: // CHECK-NEXT: [[#TPFS:]]:
// CHECK-SAME: [B1.[[#TPFS+13]]] // CHECK-SAME: [B1.[[#TPFS+14]]]
// CHECK-NEXT: [[#TPFS+1]]: [B1.[[#TPFS+13]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TPFS+1]]: [B1.[[#TPFS+14]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPFS+2]]: [B1.[[#TPFS+12]]] // CHECK-NEXT: [[#TPFS+2]]: [B1.[[#TPFS+13]]]
// CHECK-NEXT: [[#TPFS+3]]: [B1.[[#TPFS+12]]] = [B1.[[#TPFS+1]]] // CHECK-NEXT: [[#TPFS+3]]: [B1.[[#TPFS+13]]] = [B1.[[#TPFS+1]]]
// CHECK-NEXT: [[#TPFS+4]]: cond // CHECK-NEXT: [[#TPFS+4]]: cond
// CHECK-NEXT: [[#TPFS+5]]: [B1.[[#TPFS+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TPFS+5]]: [B1.[[#TPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPFS+6]]: [B1.[[#TPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TPFS+6]]: [B1.[[#TPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TPFS+7]]: fp // CHECK-NEXT: [[#TPFS+7]]: fp
// CHECK-NEXT: [[#TPFS+8]]: rd // CHECK-NEXT: [[#TPFS+8]]: rd
// CHECK-NEXT: [[#TPFS+9]]: lin // CHECK-NEXT: [[#TPFS+9]]: lin
// CHECK-NEXT: [[#TPFS+10]]: step // CHECK-NEXT: [[#TPFS+10]]: step
// CHECK-NEXT: [[#TPFS+11]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TPFS+11]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPFS+12]]: argc // CHECK-NEXT: [[#TPFS+12]]: map
// CHECK-NEXT: [[#TPFS+13]]: x // CHECK-NEXT: [[#TPFS+13]]: argc
// CHECK-NEXT: [[#TPFS+14]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step) // CHECK-NEXT: [[#TPFS+14]]: x
// CHECK-NEXT: [[#TPFS+15]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step) map(tofrom: map)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TPFS+3]]]; // CHECK-NEXT: [B1.[[#TPFS+3]]];
#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step) #pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step) map(tofrom:map)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
argc = x; argc = x;
// CHECK-NEXT: [[#TP:]]: // CHECK-NEXT: [[#TP:]]:
// CHECK-SAME: [B1.[[#TP+10]]] // CHECK-SAME: [B1.[[#TP+11]]]
// CHECK-NEXT: [[#TP+1]]: [B1.[[#TP+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TP+1]]: [B1.[[#TP+11]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TP+2]]: [B1.[[#TP+9]]] // CHECK-NEXT: [[#TP+2]]: [B1.[[#TP+10]]]
// CHECK-NEXT: [[#TP+3]]: [B1.[[#TP+9]]] = [B1.[[#TP+1]]] // CHECK-NEXT: [[#TP+3]]: [B1.[[#TP+10]]] = [B1.[[#TP+1]]]
// CHECK-NEXT: [[#TP+4]]: cond // CHECK-NEXT: [[#TP+4]]: cond
// CHECK-NEXT: [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TP+7]]: fp // CHECK-NEXT: [[#TP+7]]: fp
// CHECK-NEXT: [[#TP+8]]: rd // CHECK-NEXT: [[#TP+8]]: rd
// CHECK-NEXT: [[#TP+9]]: argc // CHECK-NEXT: [[#TP+9]]: map
// CHECK-NEXT: [[#TP+10]]: x // CHECK-NEXT: [[#TP+10]]: argc
// CHECK-NEXT: [[#TP+11]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd) // CHECK-NEXT: [[#TP+11]]: x
// CHECK-NEXT: [[#TP+12]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd) map(to: map)
// CHECK-NEXT: [B1.[[#TP+3]]]; // CHECK-NEXT: [B1.[[#TP+3]]];
#pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) #pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) map(to:map)
argc = x; argc = x;
// CHECK-NEXT: [[#TSIMD:]]: // CHECK-NEXT: [[#TSIMD:]]:
// CHECK-SAME: [B1.[[#TSIMD+13]]] // CHECK-SAME: [B1.[[#TSIMD+13]]]
// CHECK-NEXT: [[#TSIMD+1]]: [B1.[[#TSIMD+13]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TSIMD+1]]: [B1.[[#TSIMD+13]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TSIMD+2]]: [B1.[[#TSIMD+12]]] // CHECK-NEXT: [[#TSIMD+2]]: [B1.[[#TSIMD+12]]]
// CHECK-NEXT: [[#TSIMD+3]]: [B1.[[#TSIMD+12]]] = [B1.[[#TSIMD+1]]] // CHECK-NEXT: [[#TSIMD+3]]: [B1.[[#TSIMD+12]]] = [B1.[[#TSIMD+1]]]
// CHECK-NEXT: [[#TSIMD+4]]: cond // CHECK-NEXT: [[#TSIMD+4]]: cond
// CHECK-NEXT: [[#TSIMD+5]]: [B1.[[#TSIMD+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TSIMD+5]]: [B1.[[#TSIMD+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TSIMD+6]]: [B1.[[#TSIMD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TSIMD+6]]: [B1.[[#TSIMD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TSIMD+7]]: fp // CHECK-NEXT: [[#TSIMD+7]]: fp
// CHECK-NEXT: [[#TSIMD+8]]: rd // CHECK-NEXT: [[#TSIMD+8]]: rd
// CHECK-NEXT: [[#TSIMD+9]]: lin // CHECK-NEXT: [[#TSIMD+9]]: lin
// CHECK-NEXT: [[#TSIMD+10]]: step // CHECK-NEXT: [[#TSIMD+10]]: step
// CHECK-NEXT: [[#TSIMD+11]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TSIMD+11]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TSIMD+12]]: argc // CHECK-NEXT: [[#TSIMD+12]]: argc
// CHECK-NEXT: [[#TSIMD+13]]: x // CHECK-NEXT: [[#TSIMD+13]]: x
// CHECK-NEXT: [[#TSIMD+14]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step) // CHECK-NEXT: [[#TSIMD+14]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step) map(alloc: map)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TSIMD+3]]]; // CHECK-NEXT: [B1.[[#TSIMD+3]]];
#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step) #pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step) map(alloc:map)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
argc = x; argc = x;
// CHECK-NEXT: [[#TTD:]]: // CHECK-NEXT: [[#TTD:]]:
// CHECK-SAME: [B1.[[#TTD+10]]] // CHECK-SAME: [B1.[[#TTD+10]]]
// CHECK-NEXT: [[#TTD+1]]: [B1.[[#TTD+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTD+1]]: [B1.[[#TTD+10]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTD+2]]: [B1.[[#TTD+9]]] // CHECK-NEXT: [[#TTD+2]]: [B1.[[#TTD+9]]]
// CHECK-NEXT: [[#TTD+3]]: [B1.[[#TTD+9]]] = [B1.[[#TTD+1]]] // CHECK-NEXT: [[#TTD+3]]: [B1.[[#TTD+9]]] = [B1.[[#TTD+1]]]
// CHECK-NEXT: [[#TTD+4]]: cond // CHECK-NEXT: [[#TTD+4]]: cond
// CHECK-NEXT: [[#TTD+5]]: [B1.[[#TTD+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTD+5]]: [B1.[[#TTD+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTD+6]]: [B1.[[#TTD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TTD+6]]: [B1.[[#TTD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TTD+7]]: fp // CHECK-NEXT: [[#TTD+7]]: fp
// CHECK-NEXT: [[#TTD+8]]: rd // CHECK-NEXT: [[#TTD+8]]: rd
// CHECK-NEXT: [[#TTD+9]]: argc // CHECK-NEXT: [[#TTD+9]]: argc
// CHECK-NEXT: [[#TTD+10]]: x // CHECK-NEXT: [[#TTD+10]]: x
// CHECK-NEXT: [[#TTD+11]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) // CHECK-NEXT: [[#TTD+11]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) map(release: map)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TTD+3]]]; // CHECK-NEXT: [B1.[[#TTD+3]]];
#pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) map(release:map)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
argc = x; argc = x;
// CHECK-NEXT: [[#TTDPF:]]: // CHECK-NEXT: [[#TTDPF:]]:
// CHECK-SAME: [B1.[[#TTDPF+10]]] // CHECK-SAME: [B1.[[#TTDPF+10]]]
// CHECK-NEXT: [[#TTDPF+1]]: [B1.[[#TTDPF+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTDPF+1]]: [B1.[[#TTDPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTDPF+2]]: [B1.[[#TTDPF+9]]] // CHECK-NEXT: [[#TTDPF+2]]: [B1.[[#TTDPF+9]]]
// CHECK-NEXT: [[#TTDPF+3]]: [B1.[[#TTDPF+9]]] = [B1.[[#TTDPF+1]]] // CHECK-NEXT: [[#TTDPF+3]]: [B1.[[#TTDPF+9]]] = [B1.[[#TTDPF+1]]]
// CHECK-NEXT: [[#TTDPF+4]]: cond // CHECK-NEXT: [[#TTDPF+4]]: cond
// CHECK-NEXT: [[#TTDPF+5]]: [B1.[[#TTDPF+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTDPF+5]]: [B1.[[#TTDPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTDPF+6]]: [B1.[[#TTDPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TTDPF+6]]: [B1.[[#TTDPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TTDPF+7]]: fp // CHECK-NEXT: [[#TTDPF+7]]: fp
// CHECK-NEXT: [[#TTDPF+8]]: rd // CHECK-NEXT: [[#TTDPF+8]]: rd
// CHECK-NEXT: [[#TTDPF+9]]: argc // CHECK-NEXT: [[#TTDPF+9]]: argc
// CHECK-NEXT: [[#TTDPF+10]]: x // CHECK-NEXT: [[#TTDPF+10]]: x
// CHECK-NEXT: [[#TTDPF+11]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) // CHECK-NEXT: [[#TTDPF+11]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) map(delete: map)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TTDPF+3]]]; // CHECK-NEXT: [B1.[[#TTDPF+3]]];
#pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) map(delete:map)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
argc = x; argc = x;
// CHECK-NEXT: [[#TTDPFS:]]: // CHECK-NEXT: [[#TTDPFS:]]:
// CHECK-SAME: [B1.[[#TTDPFS+10]]] // CHECK-SAME: [B1.[[#TTDPFS+10]]]
// CHECK-NEXT: [[#TTDPFS+1]]: [B1.[[#TTDPFS+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTDPFS+1]]: [B1.[[#TTDPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTDPFS+2]]: [B1.[[#TTDPFS+9]]] // CHECK-NEXT: [[#TTDPFS+2]]: [B1.[[#TTDPFS+9]]]
// CHECK-NEXT: [[#TTDPFS+3]]: [B1.[[#TTDPFS+9]]] = [B1.[[#TTDPFS+1]]] // CHECK-NEXT: [[#TTDPFS+3]]: [B1.[[#TTDPFS+9]]] = [B1.[[#TTDPFS+1]]]
// CHECK-NEXT: [[#TTDPFS+4]]: cond // CHECK-NEXT: [[#TTDPFS+4]]: cond
// CHECK-NEXT: [[#TTDPFS+5]]: [B1.[[#TTDPFS+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTDPFS+5]]: [B1.[[#TTDPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTDPFS+6]]: [B1.[[#TTDPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TTDPFS+6]]: [B1.[[#TTDPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TTDPFS+7]]: fp // CHECK-NEXT: [[#TTDPFS+7]]: fp
// CHECK-NEXT: [[#TTDPFS+8]]: rd // CHECK-NEXT: [[#TTDPFS+8]]: rd
// CHECK-NEXT: [[#TTDPFS+9]]: argc // CHECK-NEXT: [[#TTDPFS+9]]: argc
// CHECK-NEXT: [[#TTDPFS+10]]: x // CHECK-NEXT: [[#TTDPFS+10]]: x
// CHECK-NEXT: [[#TTDPFS+11]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) // CHECK-NEXT: [[#TTDPFS+11]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) map(from: map)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TTDPFS+3]]]; // CHECK-NEXT: [B1.[[#TTDPFS+3]]];
#pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp) reduction(+:rd) #pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp) reduction(+:rd) map(from:map)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
argc = x; argc = x;
// CHECK-NEXT: [[#TTDS:]]: // CHECK-NEXT: [[#TTDS:]]:
// CHECK-SAME: [B1.[[#TTDS+10]]] // CHECK-SAME: [B1.[[#TTDS+11]]]
// CHECK-NEXT: [[#TTDS+1]]: [B1.[[#TTDS+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTDS+1]]: [B1.[[#TTDS+11]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTDS+2]]: [B1.[[#TTDS+9]]] // CHECK-NEXT: [[#TTDS+2]]: [B1.[[#TTDS+10]]]
// CHECK-NEXT: [[#TTDS+3]]: [B1.[[#TTDS+9]]] = [B1.[[#TTDS+1]]] // CHECK-NEXT: [[#TTDS+3]]: [B1.[[#TTDS+10]]] = [B1.[[#TTDS+1]]]
// CHECK-NEXT: [[#TTDS+4]]: cond // CHECK-NEXT: [[#TTDS+4]]: cond
// CHECK-NEXT: [[#TTDS+5]]: [B1.[[#TTDS+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TTDS+5]]: [B1.[[#TTDS+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TTDS+6]]: [B1.[[#TTDS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TTDS+6]]: [B1.[[#TTDS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TTDS+7]]: fp // CHECK-NEXT: [[#TTDS+7]]: fp
// CHECK-NEXT: [[#TTDS+8]]: rd // CHECK-NEXT: [[#TTDS+8]]: rd
// CHECK-NEXT: [[#TTDS+9]]: argc // CHECK-NEXT: [[#TTDS+9]]: map
// CHECK-NEXT: [[#TTDS+10]]: x // CHECK-NEXT: [[#TTDS+10]]: argc
// CHECK-NEXT: [[#TTDS+11]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) // CHECK-NEXT: [[#TTDS+11]]: x
// CHECK-NEXT: [[#TTDS+12]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TTDS+3]]]; // CHECK-NEXT: [B1.[[#TTDS+3]]];
#pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) map(map)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
argc = x; argc = x;
// CHECK-NEXT: [[#TT:]]: // CHECK-NEXT: [[#TT:]]:
// CHECK-SAME: [B1.[[#TT+10]]] // CHECK-SAME: [B1.[[#TT+11]]]
// CHECK-NEXT: [[#TT+1]]: [B1.[[#TT+10]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TT+1]]: [B1.[[#TT+11]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TT+2]]: [B1.[[#TT+9]]] // CHECK-NEXT: [[#TT+2]]: [B1.[[#TT+10]]]
// CHECK-NEXT: [[#TT+3]]: [B1.[[#TT+9]]] = [B1.[[#TT+1]]] // CHECK-NEXT: [[#TT+3]]: [B1.[[#TT+10]]] = [B1.[[#TT+1]]]
// CHECK-NEXT: [[#TT+4]]: cond // CHECK-NEXT: [[#TT+4]]: cond
// CHECK-NEXT: [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TT+7]]: fp // CHECK-NEXT: [[#TT+7]]: fp
// CHECK-NEXT: [[#TT+8]]: rd // CHECK-NEXT: [[#TT+8]]: rd
// CHECK-NEXT: [[#TT+9]]: argc // CHECK-NEXT: [[#TT+9]]: map
// CHECK-NEXT: [[#TT+10]]: x // CHECK-NEXT: [[#TT+10]]: argc
// CHECK-NEXT: [[#TT+11]]: #pragma omp target teams if(cond) firstprivate(fp) reduction(+: rd) // CHECK-NEXT: [[#TT+11]]: x
// CHECK-NEXT: [[#TT+12]]: #pragma omp target teams if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
// CHECK-NEXT: [B1.[[#TT+3]]]; // CHECK-NEXT: [B1.[[#TT+3]]];
#pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) #pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) map(tofrom:map)
argc = x; argc = x;
// CHECK-NEXT: [[#TU:]]: cond // CHECK-NEXT: [[#TU:]]: cond
// CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int) // CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool) // CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond) // CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)
#pragma omp target update to(x) if(target update:cond) #pragma omp target update to(x) if(target update:cond)
// CHECK-NEXT: [[#TASK:]]: // CHECK-NEXT: [[#TASK:]]:
// CHECK-SAME: [B1.[[#TASK+9]]] // CHECK-SAME: [B1.[[#TASK+9]]]
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_data_messages.c

// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -ferror-limit 100 -o - %s -Wuninitialized // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -ferror-limit 100 -o - %s -Wuninitialized
// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp-simd -ferror-limit 100 -o - %s -Wuninitialized // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp-simd -ferror-limit 100 -o - %s -Wuninitialized
void foo() { } void foo() { }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target data map(map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
int main(int argc, char **argv) { int main(int argc, char **argv) {
int a; int a;
#pragma omp target data // expected-error {{expected at least one 'map' or 'use_device_ptr' clause for '#pragma omp target data'}} #pragma omp target data // expected-error {{expected at least one 'map' or 'use_device_ptr' clause for '#pragma omp target data'}}
{} {}
L1: L1:
foo(); foo();
#pragma omp target data map(a) allocate(a) // expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp target data'}} #pragma omp target data map(a) allocate(a) // expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp target data'}}
{ {
Show All 18 Lines

cfe/trunk/test/OpenMP/target_enter_data_map_messages.c

// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -ferror-limit 100 -o - %s -Wuninitialized // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -ferror-limit 100 -o - %s -Wuninitialized
// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -ferror-limit 100 -o - -x c++ %s -Wuninitialized // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -ferror-limit 100 -o - -x c++ %s -Wuninitialized
// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp-simd -ferror-limit 100 -o - %s -Wuninitialized // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp-simd -ferror-limit 100 -o - %s -Wuninitialized
// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp-simd -ferror-limit 100 -o - -x c++ %s -Wuninitialized // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp-simd -ferror-limit 100 -o - -x c++ %s -Wuninitialized
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target enter data map(to: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
int main(int argc, char **argv) { int main(int argc, char **argv) {
int r; int r;
#pragma omp target enter data // expected-error {{expected at least one 'map' clause for '#pragma omp target enter data'}} #pragma omp target enter data // expected-error {{expected at least one 'map' clause for '#pragma omp target enter data'}}
#pragma omp target enter data map(r) // expected-error {{map type must be specified for '#pragma omp target enter data'}} #pragma omp target enter data map(r) // expected-error {{map type must be specified for '#pragma omp target enter data'}}
#pragma omp target enter data map(tofrom: r) // expected-error {{map type 'tofrom' is not allowed for '#pragma omp target enter data'}} #pragma omp target enter data map(tofrom: r) // expected-error {{map type 'tofrom' is not allowed for '#pragma omp target enter data'}}
#pragma omp target enter data map(always, to: r) allocate(r) // expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp target enter data'}} #pragma omp target enter data map(always, to: r) allocate(r) // expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp target enter data'}}
#pragma omp target enter data map(always, alloc: r) #pragma omp target enter data map(always, alloc: r)
#pragma omp target enter data map(always, from: r) // expected-error {{map type 'from' is not allowed for '#pragma omp target enter data'}} #pragma omp target enter data map(always, from: r) // expected-error {{map type 'from' is not allowed for '#pragma omp target enter data'}}
#pragma omp target enter data map(release: r) // expected-error {{map type 'release' is not allowed for '#pragma omp target enter data'}} #pragma omp target enter data map(release: r) // expected-error {{map type 'release' is not allowed for '#pragma omp target enter data'}}
#pragma omp target enter data map(delete: r) // expected-error {{map type 'delete' is not allowed for '#pragma omp target enter data'}} #pragma omp target enter data map(delete: r) // expected-error {{map type 'delete' is not allowed for '#pragma omp target enter data'}}
return 0; return 0;
} }

cfe/trunk/test/OpenMP/target_map_messages.cpp

Show All 14 Linesvoid foo(int arg) {
{} {}
#pragma omp target map(marr[:][1:][:]) // expected-error {{array section does not specify contiguous storage}} #pragma omp target map(marr[:][1:][:]) // expected-error {{array section does not specify contiguous storage}}
{} {}
#pragma omp target map(marr[:][n:][:]) #pragma omp target map(marr[:][n:][:])
{} {}
} }
#else #else
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct SREF { struct SREF {
int &a; int &a;
int b; int b;
SREF(int &a) : a(a) {} SREF(int &a) : a(a) {}
}; };
template <typename T, int I> template <typename T, int I>
struct SA { struct SA {
▲ Show 20 Lines • Show All 649 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_parallel_for_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target parallel for map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_parallel_for_simd_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target parallel for simd map(map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_parallel_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target parallel map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_simd_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target simd map(to: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 256 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_distribute_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target teams distribute map(map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target teams distribute parallel for map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_simd_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target teams distribute parallel for simd map(to: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_distribute_simd_map_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-target -Wuninitialized
void foo() { void foo() {
} }
bool foobool(int argc) { bool foobool(int argc) {
return argc; return argc;
} }
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target teams distribute simd map(map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
struct S1; // expected-note 2 {{declared here}} struct S1; // expected-note 2 {{declared here}}
extern S1 a; extern S1 a;
class S2 { class S2 {
mutable int a; mutable int a;
public: public:
S2():a(0) { } S2():a(0) { }
S2(S2 &s2):a(s2.a) { } S2(S2 &s2):a(s2.a) { }
static float S2s; static float S2s;
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_map_messages.cpp

Show All 15 Linesvoid foo(int arg) {
#pragma omp target teams map(marr[:][0:][:]) #pragma omp target teams map(marr[:][0:][:])
{} {}
#pragma omp target teams map(marr[:][1:][:]) // expected-error {{array section does not specify contiguous storage}} #pragma omp target teams map(marr[:][1:][:]) // expected-error {{array section does not specify contiguous storage}}
{} {}
#pragma omp target teams map(marr[:][n:][:]) #pragma omp target teams map(marr[:][n:][:])
{} {}
} }
#else #else
void xxx(int argc) {
int map; // expected-note {{initialize the variable 'map' to silence this warning}}
#pragma omp target teams map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
for (int i = 0; i < 10; ++i)
;
}
template <typename T, int I> template <typename T, int I>
struct SA { struct SA {
static int ss; static int ss;
#pragma omp threadprivate(ss) // expected-note {{defined as threadprivate or thread local}} #pragma omp threadprivate(ss) // expected-note {{defined as threadprivate or thread local}}
float a; float a;
int b[12]; int b[12];
float *c; float *c;
T d; T d;
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines