caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d661b4b57504b965a37dc30b79bdd5ac36fca9ec
clang-p2996/clang/test/Analysis/cfg-openmp.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

1010 lines
41 KiB
C++
Raw Blame History

// 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 | FileCheck %s --check-prefix=OMP51
#if _OPENMP == 202011
// OMP51-LABEL: void target_has_device_addr(int argc)
void target_has_device_addr(int argc) {
// OMP51: [B1]
// OMP51-NEXT: [[#TTD:]]: 5
// OMP51-NEXT: [[#TTD+1]]: int x = 5;
// OMP51-NEXT: [[#TTD+2]]: x
// OMP51-NEXT: [[#TTD+3]]: [B1.[[#TTD+2]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-NEXT: [[#TTD+4]]: [B1.[[#TTD+6]]]
// OMP51-NEXT: [[#TTD+5]]: [B1.[[#TTD+6]]] = [B1.[[#TTD+3]]]
// OMP51-NEXT: [[#TTD+6]]: argc
// OMP51-NEXT: [[#TTD+7]]: #pragma omp target has_device_addr(x)
// OMP51-NEXT: [B1.[[#TTD+5]]]
int x = 5;
#pragma omp target has_device_addr(x)
argc = x;
}
// OMP51-LABEL: void target_s_has_device_addr(int argc)
void target_s_has_device_addr(int argc) {
int x, cond, fp, rd, lin, step, map;
// OMP51-DAG: [B3]
// OMP51-DAG: [[#TSB:]]: x
// OMP51-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-DAG: [[#TSB+2]]: argc
// OMP51-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
// OMP51-DAG: [B1]
// OMP51-DAG: [[#TS:]]: cond
// OMP51-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// OMP51-DAG: [[#TS+3]]: fp
// OMP51-DAG: [[#TS+4]]: rd
// OMP51-DAG: [[#TS+5]]: lin
// OMP51-DAG: [[#TS+6]]: step
// OMP51-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]
// OMP51-DAG: [[#TS+9]]: [B3.[[#TSB]]]
// OMP51-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step) has_device_addr(map)
// OMP51-DAG: for (int i = 0;
// OMP51-DAG: [B3.[[#TSB+3]]];
#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step) has_device_addr(map)
for (int i = 0; i < 10; ++i)
argc = x;
}
// OMP51-LABEL: void target_t_l_has_device_addr(int argc)
void target_t_l_has_device_addr(int argc) {
int x, cond, fp, rd, map;
// OMP51-DAG: [B3]
// OMP51-DAG: [[#TTDB:]]: x
// OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-DAG: [[#TTDB+2]]: argc
// OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
// OMP51-DAG: [B1]
// OMP51-DAG: [[#TTD:]]: cond
// OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// OMP51-DAG: [[#TTD+3]]: fp
// OMP51-DAG: [[#TTD+4]]: rd
// OMP51-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
// OMP51-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
// OMP51-DAG: [[#TTD+7]]: #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+: rd) has_device_addr(map)
// OMP51-DAG: for (int i = 0;
// OMP51-DAG: [B3.[[#TTDB+3]]];
#pragma omp target teams loop if(cond) firstprivate(fp) reduction(+:rd) has_device_addr(map)
for (int i = 0; i <10; ++i)
argc = x;
}
// OMP51-LABEL: void target_p_l_has_device_addr(int argc)
void target_p_l_has_device_addr(int argc) {
int x, cond, fp, rd, map;
#pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+:rd) has_device_addr(map)
// OMP51-DAG: [B3]
// OMP51-DAG: [[#TTDB:]]: x
// OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-DAG: [[#TTDB+2]]: argc
// OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
// OMP51-DAG: [B1]
// OMP51-DAG: [[#TTD:]]: cond
// OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
// OMP51-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// OMP51-DAG: [[#TTD+3]]: fp
// OMP51-DAG: [[#TTD+4]]: rd
// OMP51-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
// OMP51-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
// OMP51-DAG: [[#TTD+7]]: #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+: rd) has_device_addr(map)
// OMP51-DAG: for (int i = 0;
// OMP51-DAG: [B3.[[#TTDB+3]]];
for (int i = 0; i < 10; ++i)
argc = x;
}
struct SomeKernel {
int targetDev;
float devPtr;
SomeKernel();
~SomeKernel();
// OMP51-LABEL: template<> void apply<32U>()
template<unsigned int nRHS>
void apply() {
// OMP51-DAG: [B1]
// OMP51-DAG: [[#TTD:]]: 10
// OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD:]]] (ImplicitCastExpr, IntegralToFloating, float)
// OMP51-DAG: [[#TTD+2]]: this
// OMP51-DAG: [[#TTD+3]]: [B1.[[#TTD+2]]]->devPtr
// OMP51-DAG: [[#TTD+4]]: [B1.[[#TTD+3]]] = [B1.[[#TTD+1]]]
// OMP51-DAG: [[#TTD+5]]: #pragma omp target has_device_addr(this->devPtr) device(this->targetDev)
// OMP51-DAG: {
// OMP51-DAG: [B1.[[#TTD+4]]];
#pragma omp target has_device_addr(devPtr) device(targetDev)
{
devPtr = 10;
}
}
};
void use_template() {
SomeKernel aKern;
aKern.apply<32>();
}
#else // _OPENMP
// CHECK-LABEL: void xxx(int argc)
void xxx(int argc) {
// CHECK: [B1]
// CHECK-NEXT: 1: int x;
// CHECK-NEXT: 2: int cond;
// CHECK-NEXT: 3: int fp;
// CHECK-NEXT: 4: int rd;
// CHECK-NEXT: 5: int lin;
// CHECK-NEXT: 6: int step;
// CHECK-NEXT: 7: int map;
int x, cond, fp, rd, lin, step, map;
// CHECK-NEXT: [[#ATOM:]]: x
// CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#ATOM+2]]: argc
// CHECK-NEXT: [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
// CHECK-NEXT: [[#ATOM+4]]: #pragma omp atomic read
// CHECK-NEXT: [B1.[[#ATOM+3]]];
#pragma omp atomic read
argc = x;
// CHECK-NEXT: [[#CRIT:]]: x
// CHECK-NEXT: [[#CRIT+1]]: [B1.[[#CRIT]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#CRIT+2]]: argc
// CHECK-NEXT: [[#CRIT+3]]: [B1.[[#CRIT+2]]] = [B1.[[#CRIT+1]]]
// CHECK-NEXT: [[#CRIT+4]]: #pragma omp critical
// CHECK-NEXT: [B1.[[#CRIT+3]]];
#pragma omp critical
argc = x;
// CHECK-NEXT: [[#MASTER:]]: x
// CHECK-NEXT: [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#MASTER+2]]: argc
// CHECK-NEXT: [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
// CHECK-NEXT: [[#MASTER+4]]: #pragma omp master
// CHECK-NEXT: [B1.[[#MASTER+3]]];
#pragma omp master
argc = x;
// CHECK-NEXT: [[#PAR:]]: x
// CHECK-NEXT: [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#PAR+2]]: argc
// CHECK-NEXT: [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
// CHECK-NEXT: [[#PAR+4]]: cond
// CHECK-NEXT: [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#PAR+6]]: [B1.[[#PAR+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#PAR+7]]: fp
// CHECK-NEXT: [[#PAR+8]]: rd
// CHECK-NEXT: [[#PAR+9]]: #pragma omp parallel if(cond) firstprivate(fp) reduction(min: rd)
// CHECK-NEXT: [B1.[[#PAR+3]]];
#pragma omp parallel if(cond) firstprivate(fp) reduction(min:rd)
argc = x;
// CHECK-NEXT: [[#PSECT:]]: x
// CHECK-NEXT: [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#PSECT+2]]: argc
// CHECK-NEXT: [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]
// CHECK-NEXT: [[#PSECT+4]]: cond
// CHECK-NEXT: [[#PSECT+5]]: [B1.[[#PSECT+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#PSECT+6]]: [B1.[[#PSECT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#PSECT+7]]: fp
// CHECK-NEXT: [[#PSECT+8]]: rd
// CHECK-NEXT: [[#PSECT+9]]: #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&: rd)
// CHECK-NEXT: {
// CHECK-NEXT: [B1.[[#PSECT+3]]];
// CHECK-NEXT: }
#pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&:rd)
{
argc = x;
}
// CHECK-NEXT: [[#SINGLE:]]: x
// CHECK-NEXT: [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#SINGLE+2]]: argc
// CHECK-NEXT: [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
// CHECK-NEXT: [[#SINGLE+4]]: #pragma omp single
// CHECK-NEXT: [B1.[[#SINGLE+3]]];
#pragma omp single
argc = x;
// CHECK-NEXT: [[#TARGET:]]:
// CHECK-SAME: [B1.[[#TARGET+10]]]
// CHECK-NEXT: [[#TARGET+1]]: [B1.[[#TARGET+10]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TARGET+2]]: [B1.[[#TARGET+9]]]
// CHECK-NEXT: [[#TARGET+3]]: [B1.[[#TARGET+9]]] = [B1.[[#TARGET+1]]]
// CHECK-NEXT: [[#TARGET+4]]: cond
// CHECK-NEXT: [[#TARGET+5]]: [B1.[[#TARGET+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TARGET+6]]: [B1.[[#TARGET+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TARGET+7]]: fp
// CHECK-NEXT: [[#TARGET+8]]: rd
// CHECK-NEXT: [[#TARGET+9]]: argc
// CHECK-NEXT: [[#TARGET+10]]: x
// CHECK-NEXT: [[#TARGET+11]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp) reduction(-: rd)
// CHECK-NEXT: [B1.[[#TARGET+3]]];
#pragma omp target depend(in \
: argc) if(cond) firstprivate(fp) reduction(-:rd)
argc = x;
// CHECK-NEXT: [[#TP:]]:
// CHECK-SAME: [B1.[[#TP+11]]]
// CHECK-NEXT: [[#TP+1]]: [B1.[[#TP+11]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TP+2]]: [B1.[[#TP+10]]]
// CHECK-NEXT: [[#TP+3]]: [B1.[[#TP+10]]] = [B1.[[#TP+1]]]
// CHECK-NEXT: [[#TP+4]]: cond
// CHECK-NEXT: [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TP+7]]: fp
// CHECK-NEXT: [[#TP+8]]: rd
// CHECK-NEXT: [[#TP+9]]: map
// CHECK-NEXT: [[#TP+10]]: argc
// 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]]];
#pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) map(to:map)
argc = x;
// CHECK-NEXT: [[#TT:]]:
// CHECK-SAME: [B1.[[#TT+11]]]
// CHECK-NEXT: [[#TT+1]]: [B1.[[#TT+11]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TT+2]]: [B1.[[#TT+10]]]
// CHECK-NEXT: [[#TT+3]]: [B1.[[#TT+10]]] = [B1.[[#TT+1]]]
// CHECK-NEXT: [[#TT+4]]: cond
// CHECK-NEXT: [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TT+7]]: fp
// CHECK-NEXT: [[#TT+8]]: rd
// CHECK-NEXT: [[#TT+9]]: map
// CHECK-NEXT: [[#TT+10]]: argc
// 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]]];
#pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) map(tofrom:map)
argc = x;
// CHECK-NEXT: [[#TU:]]: cond
// CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)
#pragma omp target update to(x) if(target update:cond)
// CHECK-NEXT: [[#TASK:]]:
// CHECK-SAME: [B1.[[#TASK+9]]]
// CHECK-NEXT: [[#TASK+1]]: [B1.[[#TASK+9]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TASK+2]]: [B1.[[#TASK+8]]]
// CHECK-NEXT: [[#TASK+3]]: [B1.[[#TASK+8]]] = [B1.[[#TASK+1]]]
// CHECK-NEXT: [[#TASK+4]]: cond
// CHECK-NEXT: [[#TASK+5]]: [B1.[[#TASK+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TASK+6]]: [B1.[[#TASK+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TASK+7]]: fp
// CHECK-NEXT: [[#TASK+8]]: argc
// CHECK-NEXT: [[#TASK+9]]: x
// CHECK-NEXT: [[#TASK+10]]: #pragma omp task if(cond) firstprivate(fp)
// CHECK-NEXT: [B1.[[#TASK+3]]];
#pragma omp task if(cond) firstprivate(fp)
argc = x;
// CHECK-NEXT: [[#TG:]]: x
// CHECK-NEXT: [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TG+2]]: argc
// CHECK-NEXT: [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]
// CHECK-NEXT: [[#TG+4]]: #pragma omp taskgroup
// CHECK-NEXT: [B1.[[#TG+3]]];
#pragma omp taskgroup
argc = x;
// CHECK-NEXT: [[#TEAMS:]]: x
// CHECK-NEXT: [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TEAMS+2]]: argc
// CHECK-NEXT: [[#TEAMS+3]]: [B1.[[#TEAMS+2]]] = [B1.[[#TEAMS+1]]]
// CHECK-NEXT: [[#TEAMS+4]]: [B1.[[#TEAMS+7]]]
// CHECK-NEXT: [[#TEAMS+5]]: [B1.[[#TEAMS+8]]]
// CHECK-NEXT: [[#TEAMS+6]]: #pragma omp teams firstprivate(fp) reduction(+: rd)
// CHECK-NEXT: [B1.[[#TEAMS+3]]];
// CHECK-NEXT: [[#TEAMS+7]]: fp
// CHECK-NEXT: [[#TEAMS+8]]: rd
// CHECK-NEXT: [[#TEAMS+9]]: argc
// CHECK-NEXT: [[#TEAMS+10]]: x
// CHECK-NEXT: [[#TEAMS+11]]: #pragma omp target
#pragma omp target
#pragma omp teams firstprivate(fp) reduction(+:rd)
argc = x;
// CHECK-NEXT: [B1.[[#TEAMS+6]]] Preds
}
// CHECK-LABEL: void dpf(int argc)
void dpf(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#DPFB:]]: x
// CHECK-DAG: [[#DPFB+1]]: [B3.[[#DPFB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#DPFB+2]]: argc
// CHECK-DAG: [[#DPFB+3]]: [B3.[[#DPFB+2]]] = [B3.[[#DPFB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#DPF:]]: cond
// CHECK-DAG: [[#DPF+1]]: [B1.[[#DPF]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#DPF+2]]: [B1.[[#DPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#DPF+3]]: fp
// CHECK-DAG: [[#DPF+4]]: rd
// CHECK-DAG: [[#DPF+5]]: #pragma omp distribute parallel for if(parallel: cond) firstprivate(fp) reduction(+: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#DPFB+3]]];
#pragma omp distribute parallel for if(parallel:cond) firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void dpfs(int argc)
void dpfs(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#DPFSB:]]: x
// CHECK-DAG: [[#DPFSB+1]]: [B3.[[#DPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#DPFSB+2]]: argc
// CHECK-DAG: [[#DPFSB+3]]: [B3.[[#DPFSB+2]]] = [B3.[[#DPFSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#DPFS:]]: cond
// CHECK-DAG: [[#DPFS+1]]: [B1.[[#DPFS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#DPFS+2]]: [B1.[[#DPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#DPFS+3]]: fp
// CHECK-DAG: [[#DPFS+4]]: rd
// CHECK-DAG: [[#DPFS+5]]: #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#DPFSB+3]]];
#pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void ds(int argc)
void ds(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#DSB:]]: x
// CHECK-DAG: [[#DSB+1]]: [B3.[[#DSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#DSB+2]]: argc
// CHECK-DAG: [[#DSB+3]]: [B3.[[#DSB+2]]] = [B3.[[#DSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#DS:]]: #pragma omp distribute simd
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#DSB+3]]];
#pragma omp distribute simd
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void for_fn(int argc)
void for_fn(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#FORB:]]: x
// CHECK-DAG: [[#FORB+1]]: [B3.[[#FORB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#FORB+2]]: argc
// CHECK-DAG: [[#FORB+3]]: [B3.[[#FORB+2]]] = [B3.[[#FORB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#FOR:]]: lin
// CHECK-DAG: [[#FOR+1]]: step
// CHECK-DAG: [[#FOR+2]]: [B1.[[#FOR+1]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#FOR+3]]: #pragma omp for linear(lin: step)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#FORB+3]]];
#pragma omp for linear(lin : step)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void fs(int argc)
void fs(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#FSB:]]: x
// CHECK-DAG: [[#FSB+1]]: [B3.[[#FSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#FSB+2]]: argc
// CHECK-DAG: [[#FSB+3]]: [B3.[[#FSB+2]]] = [B3.[[#FSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#FS:]]: lin
// CHECK-DAG: [[#FS+1]]: step
// CHECK-DAG: [[#FS+2]]: [B1.[[#FS+1]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#FS+3]]: #pragma omp for simd linear(lin: step)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#FSB+3]]];
#pragma omp for simd linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void ord(int argc)
void ord(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#ORDB:]]: x
// CHECK-DAG: [[#ORDB+1]]: [B3.[[#ORDB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#ORDB+2]]: argc
// CHECK-DAG: [[#ORDB+3]]: [B3.[[#ORDB+2]]] = [B3.[[#ORDB+1]]]
// CHECK-DAG: [[#ORDB+4]]: #pragma omp ordered
// CHECK-DAG: [B3.[[#ORDB+3]]];
// CHECK-DAG: [B1]
// CHECK-DAG: [[#ORD:]]: #pragma omp for ordered
// CHECK-DAG: for (int i = 0
// CHECK-DAG:[B3.[[#ORDB+4]]] }
#pragma omp for ordered
for (int i = 0; i < 10; ++i) {
#pragma omp ordered
argc = x;
}
}
// CHECK-LABEL: void pf(int argc)
void pf(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#PFB:]]: x
// CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PFB+2]]: argc
// CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#PF:]]: cond
// CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#PF+3]]: fp
// CHECK-DAG: [[#PF+4]]: rd
// CHECK-DAG: [[#PF+5]]: lin
// CHECK-DAG: [[#PF+6]]: step
// CHECK-DAG: [[#PF+7]]: [B1.[[#PF+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PF+8]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#PFB+3]]];
#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void pfs(int argc)
void pfs(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#PFSB:]]: x
// CHECK-DAG: [[#PFSB+1]]: [B3.[[#PFSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PFSB+2]]: argc
// CHECK-DAG: [[#PFSB+3]]: [B3.[[#PFSB+2]]] = [B3.[[#PFSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#PFS:]]: cond
// CHECK-DAG: [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PFS+2]]: [B1.[[#PFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#PFS+3]]: fp
// CHECK-DAG: [[#PFS+4]]: rd
// CHECK-DAG: [[#PFS+5]]: lin
// CHECK-DAG: [[#PFS+6]]: step
// CHECK-DAG: [[#PFS+7]]: [B1.[[#PFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PFS+8]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#PFSB+3]]];
#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void simd(int argc)
void simd(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#SIMDB:]]: x
// CHECK-DAG: [[#SIMDB+1]]: [B3.[[#SIMDB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#SIMDB+2]]: argc
// CHECK-DAG: [[#SIMDB+3]]: [B3.[[#SIMDB+2]]] = [B3.[[#SIMDB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#SIMD:]]: lin
// CHECK-DAG: [[#SIMD+1]]: step
// CHECK-DAG: [[#SIMD+2]]: [B1.[[#SIMD+1]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#SIMD+3]]: #pragma omp simd linear(lin: step)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#SIMDB+3]]];
#pragma omp simd linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void tpf(int argc)
void tpf(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TPFB:]]: x
// CHECK-DAG: [[#TPFB+1]]: [B3.[[#TPFB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TPFB+2]]: argc
// CHECK-DAG: [[#TPFB+3]]: [B3.[[#TPFB+2]]] = [B3.[[#TPFB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TPF:]]: cond
// CHECK-DAG: [[#TPF+1]]: [B1.[[#TPF]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TPF+2]]: [B1.[[#TPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TPF+3]]: fp
// CHECK-DAG: [[#TPF+4]]: rd
// CHECK-DAG: [[#TPF+5]]: lin
// CHECK-DAG: [[#TPF+6]]: step
// CHECK-DAG: [[#TPF+7]]: [B1.[[#TPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TPF+8]]: map
// CHECK-DAG: [[#TPF+9]]: [B3.[[#TPFB+2]]]
// CHECK-DAG: [[#TPF+10]]: [B3.[[#TPFB]]]
// CHECK-DAG: [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step) map(tofrom: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TPFB+3]]];
#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)
argc = x;
}
// CHECK-LABEL: void tpfs(int argc)
void tpfs(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TPFSB:]]: x
// CHECK-DAG: [[#TPFSB+1]]: [B3.[[#TPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TPFSB+2]]: argc
// CHECK-DAG: [[#TPFSB+3]]: [B3.[[#TPFSB+2]]] = [B3.[[#TPFSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TPFS:]]: cond
// CHECK-DAG: [[#TPFS+1]]: [B1.[[#TPFS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TPFS+2]]: [B1.[[#TPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TPFS+3]]: fp
// CHECK-DAG: [[#TPFS+4]]: rd
// CHECK-DAG: [[#TPFS+5]]: lin
// CHECK-DAG: [[#TPFS+6]]: step
// CHECK-DAG: [[#TPFS+7]]: [B1.[[#TPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TPFS+8]]: map
// CHECK-DAG: [[#TPFS+9]]: [B3.[[#TPFSB+2]]]
// CHECK-DAG: [[#TPFS+10]]: [B3.[[#TPFSB]]]
// CHECK-DAG: [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step) map(tofrom: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TPFSB+3]]];
#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)
argc = x;
}
// CHECK-LABEL: void ts(int argc)
void ts(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TSB:]]: x
// CHECK-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TSB+2]]: argc
// CHECK-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TS:]]: cond
// CHECK-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TS+3]]: fp
// CHECK-DAG: [[#TS+4]]: rd
// CHECK-DAG: [[#TS+5]]: lin
// CHECK-DAG: [[#TS+6]]: step
// CHECK-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]
// CHECK-DAG: [[#TS+9]]: [B3.[[#TSB]]]
// CHECK-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step) map(alloc: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TSB+3]]];
#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step) map(alloc:map)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void ttd(int argc)
void ttd(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TTDB:]]: x
// CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDB+2]]: argc
// CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TTD:]]: cond
// CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TTD+3]]: fp
// CHECK-DAG: [[#TTD+4]]: rd
// CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
// CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
// CHECK-DAG: [[#TTD+7]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TTDB+3]]];
#pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void ttdpf(int argc)
void ttdpf(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TTDPFB:]]: x
// CHECK-DAG: [[#TTDPFB+1]]: [B3.[[#TTDPFB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDPFB+2]]: argc
// CHECK-DAG: [[#TTDPFB+3]]: [B3.[[#TTDPFB+2]]] = [B3.[[#TTDPFB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TTDPF:]]: cond
// CHECK-DAG: [[#TTDPF+1]]: [B1.[[#TTDPF]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDPF+2]]: [B1.[[#TTDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TTDPF+3]]: fp
// CHECK-DAG: [[#TTDPF+4]]: rd
// CHECK-DAG: [[#TTDPF+5]]: [B3.[[#TTDPFB+2]]]
// CHECK-DAG: [[#TTDPF+6]]: [B3.[[#TTDPFB]]]
// CHECK-DAG: [[#TTDPF+7]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TTDPFB+3]]];
#pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void ttdpfs(int argc)
void ttdpfs(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TTDPFSB:]]: x
// CHECK-DAG: [[#TTDPFSB+1]]: [B3.[[#TTDPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDPFSB+2]]: argc
// CHECK-DAG: [[#TTDPFSB+3]]: [B3.[[#TTDPFSB+2]]] = [B3.[[#TTDPFSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TTDPFS:]]: cond
// CHECK-DAG: [[#TTDPFS+1]]: [B1.[[#TTDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDPFS+2]]: [B1.[[#TTDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TTDPFS+3]]: fp
// CHECK-DAG: [[#TTDPFS+4]]: rd
// CHECK-DAG: [[#TTDPFS+5]]: [B3.[[#TTDPFSB+2]]]
// CHECK-DAG: [[#TTDPFS+6]]: [B3.[[#TTDPFSB]]]
// CHECK-DAG: [[#TTDPFS+7]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) map(from: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TTDPFSB+3]]];
#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)
argc = x;
}
// CHECK-LABEL: void ttds(int argc)
void ttds(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TTDSB:]]: x
// CHECK-DAG: [[#TTDSB+1]]: [B3.[[#TTDSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDSB+2]]: argc
// CHECK-DAG: [[#TTDSB+3]]: [B3.[[#TTDSB+2]]] = [B3.[[#TTDSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TTDS:]]: cond
// CHECK-DAG: [[#TTDS+1]]: [B1.[[#TTDS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDS+2]]: [B1.[[#TTDS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TTDS+3]]: fp
// CHECK-DAG: [[#TTDS+4]]: rd
// CHECK-DAG: [[#TTDS+5]]: map
// CHECK-DAG: [[#TTDS+6]]: [B3.[[#TTDSB+2]]]
// CHECK-DAG: [[#TTDS+7]]: [B3.[[#TTDSB]]]
// CHECK-DAG: [[#TTDS+8]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TTDPFSB+3]]];
#pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) map(map)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void tl(int argc)
void tl(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TLB:]]: x
// CHECK-DAG: [[#TLB+1]]: [B3.[[#TLB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TLB+2]]: argc
// CHECK-DAG: [[#TLB+3]]: [B3.[[#TLB+2]]] = [B3.[[#TLB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TL:]]: cond
// CHECK-DAG: [[#TL+1]]: [B1.[[#TL]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TL+2]]: [B1.[[#TL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TL+3]]: fp
// CHECK-DAG: [[#TL+4]]: rd
// CHECK-DAG: [[#TL+5]]: [B3.[[#TLB+2]]]
// CHECK-DAG: [[#TL+6]]: [B3.[[#TLB]]]
// CHECK-DAG: [[#TL+7]]: #pragma omp taskloop if(cond) firstprivate(fp) reduction(+: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TLB+3]]];
#pragma omp taskloop if(cond) firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void maskedtaskloop(int argc)
void maskedtaskloop(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#MTLB:]]: x
// CHECK-DAG: [[#MTLB+1]]: [B3.[[#MTLB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#MTLB+2]]: argc
// CHECK-DAG: [[#MTLB+3]]: [B3.[[#MTLB+2]]] = [B3.[[#MTLB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#MTL:]]: cond
// CHECK-DAG: [[#MTL+1]]: [B1.[[#MTL]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#MTL+2]]: [B1.[[#MTL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#MTL+3]]: fp
// CHECK-DAG: [[#MTL+4]]: rd
// CHECK-DAG: [[#MTL+5]]: [B3.[[#MTLB+2]]]
// CHECK-DAG: [[#MTL+6]]: [B3.[[#MTLB]]]
// CHECK-DAG: [[#MTL+7]]: #pragma omp masked taskloop if(cond) firstprivate(fp) reduction(+: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#MTLB+3]]];
#pragma omp masked taskloop if(cond) firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void parallelmaskedtaskloop(int argc)
void parallelmaskedtaskloop(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#PMTLB:]]: x
// CHECK-DAG: [[#PMTLB+1]]: [B3.[[#PMTLB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PMTLB+2]]: argc
// CHECK-DAG: [[#PMTLB+3]]: [B3.[[#PMTLB+2]]] = [B3.[[#PMTLB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#PMTL:]]: cond
// CHECK-DAG: [[#PMTL+1]]: [B1.[[#PMTL]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PMTL+2]]: [B1.[[#PMTL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#PMTL+3]]: fp
// CHECK-DAG: [[#PMTL+4]]: rd
// CHECK-DAG: [[#PMTL+5]]: [B3.[[#PMTLB+2]]]
// CHECK-DAG: [[#PMTL+6]]: [B3.[[#PMTLB]]]
// CHECK-DAG: [[#PMTL+7]]: #pragma omp parallel masked taskloop if(cond) firstprivate(fp) reduction(+: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#PMTLB+3]]];
#pragma omp parallel masked taskloop if(cond) firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void parallelmaskedtasksimdloop(int argc)
void parallelmaskedtasksimdloop(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#PMTLSB:]]: x
// CHECK-DAG: [[#PMTLSB+1]]: [B3.[[#PMTLSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PMTLSB+2]]: argc
// CHECK-DAG: [[#PMTLSB+3]]: [B3.[[#PMTLSB+2]]] = [B3.[[#PMTLSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#PMTLS:]]: cond
// CHECK-DAG: [[#PMTLS+1]]: [B1.[[#PMTLS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PMTLS+2]]: [B1.[[#PMTLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#PMTLS+3]]: fp
// CHECK-DAG: [[#PMTLS+4]]: rd
// CHECK-DAG: [[#PMTLS+5]]: [B3.[[#PMTLSB+2]]]
// CHECK-DAG: [[#PMTLS+6]]: [B3.[[#PMTLSB]]]
// CHECK-DAG: [[#PMTLS+7]]: #pragma omp parallel masked taskloop simd if(cond) firstprivate(fp) reduction(+: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#PMTLSB+3]]];
#pragma omp parallel masked taskloop simd if(cond) firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void tls(int argc)
void tls(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TLSB:]]: x
// CHECK-DAG: [[#TLSB+1]]: [B3.[[#TLSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TLSB+2]]: argc
// CHECK-DAG: [[#TLSB+3]]: [B3.[[#TLSB+2]]] = [B3.[[#TLSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TLS:]]: cond
// CHECK-DAG: [[#TLS+1]]: [B1.[[#TLS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TLS+2]]: [B1.[[#TLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TLS+3]]: fp
// CHECK-DAG: [[#TLS+4]]: rd
// CHECK-DAG: [[#TLS+5]]: lin
// CHECK-DAG: [[#TLS+6]]: step
// CHECK-DAG: [[#TLS+7]]: [B1.[[#TLS+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TLS+8]]: [B3.[[#TLSB+2]]]
// CHECK-DAG: [[#TLS+9]]: [B3.[[#TLSB]]]
// CHECK-DAG: [[#TLS+10]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TLSB+3]]];
#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void maskedtaskloopsimd(int argc)
void maskedtaskloopsimd(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#MTLSB:]]: x
// CHECK-DAG: [[#MTLSB+1]]: [B3.[[#MTLSB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#MTLSB+2]]: argc
// CHECK-DAG: [[#MTLSB+3]]: [B3.[[#MTLSB+2]]] = [B3.[[#MTLSB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#MTLS:]]: cond
// CHECK-DAG: [[#MTLS+1]]: [B1.[[#MTLS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#MTLS+2]]: [B1.[[#MTLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#MTLS+3]]: fp
// CHECK-DAG: [[#MTLS+4]]: rd
// CHECK-DAG: [[#MTLS+5]]: lin
// CHECK-DAG: [[#MTLS+6]]: step
// CHECK-DAG: [[#MTLS+7]]: [B1.[[#MTLS+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#MTLS+8]]: [B3.[[#MTLSB+2]]]
// CHECK-DAG: [[#MTLS+9]]: [B3.[[#MTLSB]]]
// CHECK-DAG: [[#MTLS+10]]: #pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#MTLSB+3]]];
#pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void tdpf(int argc)
void tdpf(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TDPF:]]: [B1.{{.+}}]
// CHECK-DAG: [[#TDPF+1]]: [B1.[[#TDPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TDPF+2]]: [B1.[[#TDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TDPF+3]]: [B1.[[#TDPF+7]]]
// CHECK-DAG: [[#TDPF+4]]: [B1.[[#TDPF+8]]]
// CHECK-DAG: [[#TDPF+5]]: #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TDPFB:]]];
// CHECK-DAG: [[#TDPF+6]]: cond
// CHECK-DAG: [[#TDPF+7]]: fp
// CHECK-DAG: [[#TDPF+8]]: rd
// CHECK-DAG: [[#TDPF+9]]: argc
// CHECK-DAG: [[#TDPF+10]]: x
// CHECK-DAG: [[#TDPF+11]]: #pragma omp target
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TDPFB-3]]: x
// CHECK-DAG: [[#TDPFB-2]]: [B3.[[#TDPFB-3]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TDPFB-1]]: argc
// CHECK-DAG: [[#TDPFB]]: [B3.[[#TDPFB-1]]] = [B3.[[#TDPFB-2]]]
#pragma omp target
#pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void tdpfs(int argc)
void tdpfs(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TDPFS:]]: [B1.{{.+}}]
// CHECK-DAG: [[#TDPFS+1]]: [B1.[[#TDPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TDPFS+2]]: [B1.[[#TDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TDPFS+3]]: [B1.[[#TDPFS+7]]]
// CHECK-DAG: [[#TDPFS+4]]: [B1.[[#TDPFS+8]]]
// CHECK-DAG: [[#TDPFS+5]]: #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TDPFSB:]]];
// CHECK-DAG: [[#TDPFS+6]]: cond
// CHECK-DAG: [[#TDPFS+7]]: fp
// CHECK-DAG: [[#TDPFS+8]]: rd
// CHECK-DAG: [[#TDPFS+9]]: argc
// CHECK-DAG: [[#TDPFS+10]]: x
// CHECK-DAG: [[#TDPFS+11]]: #pragma omp target
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TDPFSB-3]]: x
// CHECK-DAG: [[#TDPFSB-2]]: [B3.[[#TDPFSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TDPFSB-1]]: argc
// CHECK-DAG: [[#TDPFSB]]: [B3.[[#TDPFSB-1]]] = [B3.[[#TDPFSB-2]]]
#pragma omp target
#pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void tds(int argc)
void tds(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TDS:]]: #pragma omp teams distribute simd firstprivate(fp) reduction(+: rd)
// CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]
// CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TDSB:]]];
// CHECK-DAG: [[#TDS+1]]: fp
// CHECK-DAG: [[#TDS+2]]: rd
// CHECK-DAG: [[#TDS+3]]: argc
// CHECK-DAG: [[#TDS+4]]: x
// CHECK-DAG: [[#TDS+5]]: #pragma omp target
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TDSB-3]]: x
// CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TDSB-1]]: argc
// CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
#pragma omp target
#pragma omp teams distribute simd firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void teamsloop(int argc)
void teamsloop(int argc) {
int x, cond, fp, rd, lin, step, map;
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TDS:]]: #pragma omp teams loop firstprivate(fp) reduction(+: rd)
// CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]
// CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TDSB:]]];
// CHECK-DAG: [[#TDS+1]]: fp
// CHECK-DAG: [[#TDS+2]]: rd
// CHECK-DAG: [[#TDS+3]]: argc
// CHECK-DAG: [[#TDS+4]]: x
// CHECK-DAG: [[#TDS+5]]: #pragma omp target
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TDSB-3]]: x
// CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TDSB-1]]: argc
// CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
#pragma omp target
#pragma omp teams loop firstprivate(fp) reduction(+:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void targetteamsloop(int argc)
void targetteamsloop(int argc) {
int x, cond, fp, rd, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TTDB:]]: x
// CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDB+2]]: argc
// CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TTD:]]: cond
// CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TTD+3]]: fp
// CHECK-DAG: [[#TTD+4]]: rd
// CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
// CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
// CHECK-DAG: [[#TTD+7]]: #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TTDB+3]]];
#pragma omp target teams loop if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void parallelloop(int argc)
void parallelloop(int argc) {
int x, cond, fp, rd;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#PFB:]]: x
// CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PFB+2]]: argc
// CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#PF:]]: cond
// CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#PF+3]]: fp
// CHECK-DAG: [[#PF+4]]: rd
// CHECK-DAG: [[#PF+5]]: #pragma omp parallel loop if(cond) firstprivate(fp) reduction(&: rd)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#PFB+3]]];
#pragma omp parallel loop if(cond) firstprivate(fp) reduction(&:rd)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void targetparallelloop(int argc)
void targetparallelloop(int argc) {
int x, cond, fp, rd, map;
// CHECK-DAG: [B3]
// CHECK-DAG: [[#TTDB:]]: x
// CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTDB+2]]: argc
// CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
// CHECK-DAG: [B1]
// CHECK-DAG: [[#TTD:]]: cond
// CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-DAG: [[#TTD+3]]: fp
// CHECK-DAG: [[#TTD+4]]: rd
// CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
// CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
// CHECK-DAG: [[#TTD+7]]: #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
// CHECK-DAG: for (int i = 0;
// CHECK-DAG: [B3.[[#TTDB+3]]];
#pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
for (int i = 0; i < 10; ++i)
argc = x;
}
// CHECK-LABEL: void parallelmasked(int argc)
void parallelmasked(int argc) {
int x = 0;
// CHECK: [B1]
// CHECK-NEXT: 1: 0
// CHECK-NEXT: 2: int x = 0;
// CHECK-NEXT: [[#MASKED:]]: x
// CHECK-NEXT: [[#MASKED+1]]: [B1.[[#MASKED]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#MASKED+2]]: argc
// CHECK-NEXT: [[#MASKED+3]]: [B1.[[#MASKED+2]]] = [B1.[[#MASKED+1]]]
// CHECK-NEXT: [[#MASKED+4]]: #pragma omp parallel masked
#pragma omp parallel masked
argc = x;
}
#endif // _OPENMP
Reference in New Issue View Git Blame Copy Permalink