1009 lines · cpp
1// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s2 3// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp | FileCheck %s --check-prefix=OMP514 5#if _OPENMP == 2020116 7// OMP51-LABEL: void target_has_device_addr(int argc)8void target_has_device_addr(int argc) {9// OMP51: [B1]10// OMP51-NEXT: [[#TTD:]]: 511// OMP51-NEXT: [[#TTD+1]]: int x = 5;12// OMP51-NEXT: [[#TTD+2]]: x13// OMP51-NEXT: [[#TTD+3]]: [B1.[[#TTD+2]]] (ImplicitCastExpr, LValueToRValue, int)14// OMP51-NEXT: [[#TTD+4]]: [B1.[[#TTD+6]]]15// OMP51-NEXT: [[#TTD+5]]: [B1.[[#TTD+6]]] = [B1.[[#TTD+3]]]16// OMP51-NEXT: [[#TTD+6]]: argc17// OMP51-NEXT: [[#TTD+7]]: #pragma omp target has_device_addr(x)18// OMP51-NEXT: [B1.[[#TTD+5]]]19 int x = 5;20#pragma omp target has_device_addr(x)21 argc = x;22}23// OMP51-LABEL: void target_s_has_device_addr(int argc)24void target_s_has_device_addr(int argc) {25 int x, cond, fp, rd, lin, step_sz, map;26// OMP51-DAG: [B3]27// OMP51-DAG: [[#TSB:]]: x28// OMP51-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)29// OMP51-DAG: [[#TSB+2]]: argc30// OMP51-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]31// OMP51-DAG: [B1]32// OMP51-DAG: [[#TS:]]: cond33// OMP51-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)34// OMP51-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)35// OMP51-DAG: [[#TS+3]]: fp36// OMP51-DAG: [[#TS+4]]: rd37// OMP51-DAG: [[#TS+5]]: lin38// OMP51-DAG: [[#TS+6]]: step_sz39// OMP51-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)40// OMP51-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]41// OMP51-DAG: [[#TS+9]]: [B3.[[#TSB]]]42// OMP51-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz)) has_device_addr(map)43// OMP51-DAG: for (int i = 0;44// OMP51-DAG: [B3.[[#TSB+3]]];45#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz) has_device_addr(map)46 for (int i = 0; i < 10; ++i)47 argc = x;48}49// OMP51-LABEL: void target_t_l_has_device_addr(int argc)50void target_t_l_has_device_addr(int argc) {51int x, cond, fp, rd, map;52// OMP51-DAG: [B3]53// OMP51-DAG: [[#TTDB:]]: x54// OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)55// OMP51-DAG: [[#TTDB+2]]: argc56// OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]57// OMP51-DAG: [B1]58// OMP51-DAG: [[#TTD:]]: cond59// OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)60// OMP51-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)61// OMP51-DAG: [[#TTD+3]]: fp62// OMP51-DAG: [[#TTD+4]]: rd63// OMP51-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]64// OMP51-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]65// OMP51-DAG: [[#TTD+7]]: #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+: rd) has_device_addr(map)66// OMP51-DAG: for (int i = 0;67// OMP51-DAG: [B3.[[#TTDB+3]]];68#pragma omp target teams loop if(cond) firstprivate(fp) reduction(+:rd) has_device_addr(map)69 for (int i = 0; i <10; ++i)70 argc = x;71}72// OMP51-LABEL: void target_p_l_has_device_addr(int argc)73void target_p_l_has_device_addr(int argc) {74int x, cond, fp, rd, map;75#pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+:rd) has_device_addr(map)76// OMP51-DAG: [B3]77// OMP51-DAG: [[#TTDB:]]: x78// OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)79// OMP51-DAG: [[#TTDB+2]]: argc80// OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]81// OMP51-DAG: [B1]82// OMP51-DAG: [[#TTD:]]: cond83// OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)84// OMP51-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)85// OMP51-DAG: [[#TTD+3]]: fp86// OMP51-DAG: [[#TTD+4]]: rd87// OMP51-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]88// OMP51-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]89// OMP51-DAG: [[#TTD+7]]: #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+: rd) has_device_addr(map)90// OMP51-DAG: for (int i = 0;91// OMP51-DAG: [B3.[[#TTDB+3]]];92 for (int i = 0; i < 10; ++i)93 argc = x;94}95struct SomeKernel {96 int targetDev;97 float devPtr;98 SomeKernel();99 ~SomeKernel();100// OMP51-LABEL: template<> void apply<32U>()101 template<unsigned int nRHS>102 void apply() {103// OMP51-DAG: [B1]104// OMP51-DAG: [[#TTD:]]: 10105// OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD:]]] (ImplicitCastExpr, IntegralToFloating, float)106// OMP51-DAG: [[#TTD+2]]: this107// OMP51-DAG: [[#TTD+3]]: [B1.[[#TTD+2]]]->devPtr108// OMP51-DAG: [[#TTD+4]]: [B1.[[#TTD+3]]] = [B1.[[#TTD+1]]]109// OMP51-DAG: [[#TTD+5]]: #pragma omp target has_device_addr(this->devPtr) device(this->targetDev)110// OMP51-DAG: {111// OMP51-DAG: [B1.[[#TTD+4]]];112 #pragma omp target has_device_addr(devPtr) device(targetDev)113 {114 devPtr = 10;115 }116 }117};118void use_template() {119 SomeKernel aKern;120 aKern.apply<32>();121}122#else // _OPENMP123 124// CHECK-LABEL: void xxx(int argc)125void xxx(int argc) {126// CHECK: [B1]127// CHECK-NEXT: 1: int x;128// CHECK-NEXT: 2: int cond;129// CHECK-NEXT: 3: int fp;130// CHECK-NEXT: 4: int rd;131// CHECK-NEXT: 5: int lin;132// CHECK-NEXT: 6: int step_sz;133// CHECK-NEXT: 7: int map;134 int x, cond, fp, rd, lin, step_sz, map;135// CHECK-NEXT: [[#ATOM:]]: x136// CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)137// CHECK-NEXT: [[#ATOM+2]]: argc138// CHECK-NEXT: [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]139// CHECK-NEXT: [[#ATOM+4]]: #pragma omp atomic read140// CHECK-NEXT: [B1.[[#ATOM+3]]];141#pragma omp atomic read142 argc = x;143// CHECK-NEXT: [[#CRIT:]]: x144// CHECK-NEXT: [[#CRIT+1]]: [B1.[[#CRIT]]] (ImplicitCastExpr, LValueToRValue, int)145// CHECK-NEXT: [[#CRIT+2]]: argc146// CHECK-NEXT: [[#CRIT+3]]: [B1.[[#CRIT+2]]] = [B1.[[#CRIT+1]]]147// CHECK-NEXT: [[#CRIT+4]]: #pragma omp critical148// CHECK-NEXT: [B1.[[#CRIT+3]]];149#pragma omp critical150 argc = x;151// CHECK-NEXT: [[#MASTER:]]: x152// CHECK-NEXT: [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)153// CHECK-NEXT: [[#MASTER+2]]: argc154// CHECK-NEXT: [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]155// CHECK-NEXT: [[#MASTER+4]]: #pragma omp master156// CHECK-NEXT: [B1.[[#MASTER+3]]];157#pragma omp master158 argc = x;159// CHECK-NEXT: [[#PAR:]]: x160// CHECK-NEXT: [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)161// CHECK-NEXT: [[#PAR+2]]: argc162// CHECK-NEXT: [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]163// CHECK-NEXT: [[#PAR+4]]: cond164// CHECK-NEXT: [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)165// CHECK-NEXT: [[#PAR+6]]: [B1.[[#PAR+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)166// CHECK-NEXT: [[#PAR+7]]: fp167// CHECK-NEXT: [[#PAR+8]]: rd168// CHECK-NEXT: [[#PAR+9]]: #pragma omp parallel if(cond) firstprivate(fp) reduction(min: rd)169// CHECK-NEXT: [B1.[[#PAR+3]]];170#pragma omp parallel if(cond) firstprivate(fp) reduction(min:rd)171 argc = x;172// CHECK-NEXT: [[#PSECT:]]: x173// CHECK-NEXT: [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)174// CHECK-NEXT: [[#PSECT+2]]: argc175// CHECK-NEXT: [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]176// CHECK-NEXT: [[#PSECT+4]]: cond177// CHECK-NEXT: [[#PSECT+5]]: [B1.[[#PSECT+4]]] (ImplicitCastExpr, LValueToRValue, int)178// CHECK-NEXT: [[#PSECT+6]]: [B1.[[#PSECT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)179// CHECK-NEXT: [[#PSECT+7]]: fp180// CHECK-NEXT: [[#PSECT+8]]: rd181// CHECK-NEXT: [[#PSECT+9]]: #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&: rd)182// CHECK-NEXT: {183// CHECK-NEXT: [B1.[[#PSECT+3]]];184// CHECK-NEXT: }185#pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&:rd)186 {187 argc = x;188 }189// CHECK-NEXT: [[#SINGLE:]]: x190// CHECK-NEXT: [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)191// CHECK-NEXT: [[#SINGLE+2]]: argc192// CHECK-NEXT: [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]193// CHECK-NEXT: [[#SINGLE+4]]: #pragma omp single194// CHECK-NEXT: [B1.[[#SINGLE+3]]];195#pragma omp single196 argc = x;197// CHECK-NEXT: [[#TARGET:]]:198// CHECK-SAME: [B1.[[#TARGET+9]]]199// CHECK-NEXT: [[#TARGET+1]]: [B1.[[#TARGET+9]]] (ImplicitCastExpr, LValueToRValue, int)200// CHECK-NEXT: [[#TARGET+2]]: [B1.[[#TARGET+8]]]201// CHECK-NEXT: [[#TARGET+3]]: [B1.[[#TARGET+8]]] = [B1.[[#TARGET+1]]]202// CHECK-NEXT: [[#TARGET+4]]: cond203// CHECK-NEXT: [[#TARGET+5]]: [B1.[[#TARGET+4]]] (ImplicitCastExpr, LValueToRValue, int)204// CHECK-NEXT: [[#TARGET+6]]: [B1.[[#TARGET+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)205// CHECK-NEXT: [[#TARGET+7]]: fp206// CHECK-NEXT: [[#TARGET+8]]: argc207// CHECK-NEXT: [[#TARGET+9]]: x208// CHECK-NEXT: [[#TARGET+10]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp)209// CHECK-NEXT: [B1.[[#TARGET+3]]];210#pragma omp target depend(in \211 : argc) if(cond) firstprivate(fp)212 argc = x;213// CHECK-NEXT: [[#TP:]]:214// CHECK-SAME: [B1.[[#TP+11]]]215// CHECK-NEXT: [[#TP+1]]: [B1.[[#TP+11]]] (ImplicitCastExpr, LValueToRValue, int)216// CHECK-NEXT: [[#TP+2]]: [B1.[[#TP+10]]]217// CHECK-NEXT: [[#TP+3]]: [B1.[[#TP+10]]] = [B1.[[#TP+1]]]218// CHECK-NEXT: [[#TP+4]]: cond219// CHECK-NEXT: [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)220// CHECK-NEXT: [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)221// CHECK-NEXT: [[#TP+7]]: fp222// CHECK-NEXT: [[#TP+8]]: rd223// CHECK-NEXT: [[#TP+9]]: map224// CHECK-NEXT: [[#TP+10]]: argc225// CHECK-NEXT: [[#TP+11]]: x226// CHECK-NEXT: [[#TP+12]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd) map(to: map)227// CHECK-NEXT: [B1.[[#TP+3]]];228#pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) map(to:map)229 argc = x;230// CHECK-NEXT: [[#TT:]]:231// CHECK-SAME: [B1.[[#TT+11]]]232// CHECK-NEXT: [[#TT+1]]: [B1.[[#TT+11]]] (ImplicitCastExpr, LValueToRValue, int)233// CHECK-NEXT: [[#TT+2]]: [B1.[[#TT+10]]]234// CHECK-NEXT: [[#TT+3]]: [B1.[[#TT+10]]] = [B1.[[#TT+1]]]235// CHECK-NEXT: [[#TT+4]]: cond236// CHECK-NEXT: [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)237// CHECK-NEXT: [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)238// CHECK-NEXT: [[#TT+7]]: fp239// CHECK-NEXT: [[#TT+8]]: rd240// CHECK-NEXT: [[#TT+9]]: map241// CHECK-NEXT: [[#TT+10]]: argc242// CHECK-NEXT: [[#TT+11]]: x243// CHECK-NEXT: [[#TT+12]]: #pragma omp target teams if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)244// CHECK-NEXT: [B1.[[#TT+3]]];245#pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) map(tofrom:map)246 argc = x;247// CHECK-NEXT: [[#TU:]]: cond248// CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)249// CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)250// CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)251#pragma omp target update to(x) if(target update:cond)252// CHECK-NEXT: [[#TASK:]]:253// CHECK-SAME: [B1.[[#TASK+9]]]254// CHECK-NEXT: [[#TASK+1]]: [B1.[[#TASK+9]]] (ImplicitCastExpr, LValueToRValue, int)255// CHECK-NEXT: [[#TASK+2]]: [B1.[[#TASK+8]]]256// CHECK-NEXT: [[#TASK+3]]: [B1.[[#TASK+8]]] = [B1.[[#TASK+1]]]257// CHECK-NEXT: [[#TASK+4]]: cond258// CHECK-NEXT: [[#TASK+5]]: [B1.[[#TASK+4]]] (ImplicitCastExpr, LValueToRValue, int)259// CHECK-NEXT: [[#TASK+6]]: [B1.[[#TASK+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)260// CHECK-NEXT: [[#TASK+7]]: fp261// CHECK-NEXT: [[#TASK+8]]: argc262// CHECK-NEXT: [[#TASK+9]]: x263// CHECK-NEXT: [[#TASK+10]]: #pragma omp task if(cond) firstprivate(fp)264// CHECK-NEXT: [B1.[[#TASK+3]]];265#pragma omp task if(cond) firstprivate(fp)266 argc = x;267// CHECK-NEXT: [[#TG:]]: x268// CHECK-NEXT: [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)269// CHECK-NEXT: [[#TG+2]]: argc270// CHECK-NEXT: [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]271// CHECK-NEXT: [[#TG+4]]: #pragma omp taskgroup272// CHECK-NEXT: [B1.[[#TG+3]]];273#pragma omp taskgroup274 argc = x;275// CHECK-NEXT: [[#TEAMS:]]: x276// CHECK-NEXT: [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)277// CHECK-NEXT: [[#TEAMS+2]]: argc278// CHECK-NEXT: [[#TEAMS+3]]: [B1.[[#TEAMS+2]]] = [B1.[[#TEAMS+1]]]279// CHECK-NEXT: [[#TEAMS+4]]: [B1.[[#TEAMS+7]]]280// CHECK-NEXT: [[#TEAMS+5]]: [B1.[[#TEAMS+8]]]281// CHECK-NEXT: [[#TEAMS+6]]: #pragma omp teams firstprivate(fp) reduction(+: rd)282// CHECK-NEXT: [B1.[[#TEAMS+3]]];283// CHECK-NEXT: [[#TEAMS+7]]: fp284// CHECK-NEXT: [[#TEAMS+8]]: rd285// CHECK-NEXT: [[#TEAMS+9]]: argc286// CHECK-NEXT: [[#TEAMS+10]]: x287// CHECK-NEXT: [[#TEAMS+11]]: #pragma omp target288#pragma omp target289#pragma omp teams firstprivate(fp) reduction(+:rd)290 argc = x;291// CHECK-NEXT: [B1.[[#TEAMS+6]]] Preds292}293 294// CHECK-LABEL: void dpf(int argc)295void dpf(int argc) {296 int x, cond, fp, rd, lin, step_sz, map;297// CHECK-DAG: [B3]298// CHECK-DAG: [[#DPFB:]]: x299// CHECK-DAG: [[#DPFB+1]]: [B3.[[#DPFB]]] (ImplicitCastExpr, LValueToRValue, int)300// CHECK-DAG: [[#DPFB+2]]: argc301// CHECK-DAG: [[#DPFB+3]]: [B3.[[#DPFB+2]]] = [B3.[[#DPFB+1]]]302// CHECK-DAG: [B1]303// CHECK-DAG: [[#DPF:]]: cond304// CHECK-DAG: [[#DPF+1]]: [B1.[[#DPF]]] (ImplicitCastExpr, LValueToRValue, int)305// CHECK-DAG: [[#DPF+2]]: [B1.[[#DPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)306// CHECK-DAG: [[#DPF+3]]: fp307// CHECK-DAG: [[#DPF+4]]: rd308// CHECK-DAG: [[#DPF+5]]: #pragma omp distribute parallel for if(parallel: cond) firstprivate(fp) reduction(+: rd)309// CHECK-DAG: for (int i = 0;310// CHECK-DAG: [B3.[[#DPFB+3]]];311#pragma omp distribute parallel for if(parallel:cond) firstprivate(fp) reduction(+:rd)312 for (int i = 0; i < 10; ++i)313 argc = x;314}315 316// CHECK-LABEL: void dpfs(int argc)317void dpfs(int argc) {318 int x, cond, fp, rd, lin, step_sz, map;319// CHECK-DAG: [B3]320// CHECK-DAG: [[#DPFSB:]]: x321// CHECK-DAG: [[#DPFSB+1]]: [B3.[[#DPFSB]]] (ImplicitCastExpr, LValueToRValue, int)322// CHECK-DAG: [[#DPFSB+2]]: argc323// CHECK-DAG: [[#DPFSB+3]]: [B3.[[#DPFSB+2]]] = [B3.[[#DPFSB+1]]]324// CHECK-DAG: [B1]325// CHECK-DAG: [[#DPFS:]]: cond326// CHECK-DAG: [[#DPFS+1]]: [B1.[[#DPFS]]] (ImplicitCastExpr, LValueToRValue, int)327// CHECK-DAG: [[#DPFS+2]]: [B1.[[#DPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)328// CHECK-DAG: [[#DPFS+3]]: fp329// CHECK-DAG: [[#DPFS+4]]: rd330// CHECK-DAG: [[#DPFS+5]]: #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-: rd)331// CHECK-DAG: for (int i = 0;332// CHECK-DAG: [B3.[[#DPFSB+3]]];333#pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-:rd)334 for (int i = 0; i < 10; ++i)335 argc = x;336}337 338// CHECK-LABEL: void ds(int argc)339void ds(int argc) {340 int x, cond, fp, rd, lin, step_sz, map;341// CHECK-DAG: [B3]342// CHECK-DAG: [[#DSB:]]: x343// CHECK-DAG: [[#DSB+1]]: [B3.[[#DSB]]] (ImplicitCastExpr, LValueToRValue, int)344// CHECK-DAG: [[#DSB+2]]: argc345// CHECK-DAG: [[#DSB+3]]: [B3.[[#DSB+2]]] = [B3.[[#DSB+1]]]346// CHECK-DAG: [B1]347// CHECK-DAG: [[#DS:]]: #pragma omp distribute simd348// CHECK-DAG: for (int i = 0;349// CHECK-DAG: [B3.[[#DSB+3]]];350#pragma omp distribute simd351 for (int i = 0; i < 10; ++i)352 argc = x;353}354 355// CHECK-LABEL: void for_fn(int argc)356void for_fn(int argc) {357 int x, cond, fp, rd, lin, step_sz, map;358// CHECK-DAG: [B3]359// CHECK-DAG: [[#FORB:]]: x360// CHECK-DAG: [[#FORB+1]]: [B3.[[#FORB]]] (ImplicitCastExpr, LValueToRValue, int)361// CHECK-DAG: [[#FORB+2]]: argc362// CHECK-DAG: [[#FORB+3]]: [B3.[[#FORB+2]]] = [B3.[[#FORB+1]]]363// CHECK-DAG: [B1]364// CHECK-DAG: [[#FOR:]]: lin365// CHECK-DAG: [[#FOR+1]]: step_sz366// CHECK-DAG: [[#FOR+2]]: [B1.[[#FOR+1]]] (ImplicitCastExpr, LValueToRValue, int)367// CHECK-DAG: [[#FOR+3]]: #pragma omp for linear(lin: step(step_sz))368// CHECK-DAG: for (int i = 0;369// CHECK-DAG: [B3.[[#FORB+3]]];370#pragma omp for linear(lin : step_sz)371 for (int i = 0; i < 10; ++i)372 argc = x;373}374 375// CHECK-LABEL: void fs(int argc)376void fs(int argc) {377 int x, cond, fp, rd, lin, step_sz, map;378// CHECK-DAG: [B3]379// CHECK-DAG: [[#FSB:]]: x380// CHECK-DAG: [[#FSB+1]]: [B3.[[#FSB]]] (ImplicitCastExpr, LValueToRValue, int)381// CHECK-DAG: [[#FSB+2]]: argc382// CHECK-DAG: [[#FSB+3]]: [B3.[[#FSB+2]]] = [B3.[[#FSB+1]]]383// CHECK-DAG: [B1]384// CHECK-DAG: [[#FS:]]: lin385// CHECK-DAG: [[#FS+1]]: step_sz386// CHECK-DAG: [[#FS+2]]: [B1.[[#FS+1]]] (ImplicitCastExpr, LValueToRValue, int)387// CHECK-DAG: [[#FS+3]]: #pragma omp for simd linear(lin: step(step_sz))388// CHECK-DAG: for (int i = 0;389// CHECK-DAG: [B3.[[#FSB+3]]];390#pragma omp for simd linear(lin: step_sz)391 for (int i = 0; i < 10; ++i)392 argc = x;393}394 395// CHECK-LABEL: void ord(int argc)396void ord(int argc) {397 int x, cond, fp, rd, lin, step_sz, map;398// CHECK-DAG: [B3]399// CHECK-DAG: [[#ORDB:]]: x400// CHECK-DAG: [[#ORDB+1]]: [B3.[[#ORDB]]] (ImplicitCastExpr, LValueToRValue, int)401// CHECK-DAG: [[#ORDB+2]]: argc402// CHECK-DAG: [[#ORDB+3]]: [B3.[[#ORDB+2]]] = [B3.[[#ORDB+1]]]403// CHECK-DAG: [[#ORDB+4]]: #pragma omp ordered404// CHECK-DAG: [B3.[[#ORDB+3]]];405// CHECK-DAG: [B1]406// CHECK-DAG: [[#ORD:]]: #pragma omp for ordered407// CHECK-DAG: for (int i = 0408// CHECK-DAG:[B3.[[#ORDB+4]]] }409#pragma omp for ordered410 for (int i = 0; i < 10; ++i) {411#pragma omp ordered412 argc = x;413 }414}415 416// CHECK-LABEL: void pf(int argc)417void pf(int argc) {418 int x, cond, fp, rd, lin, step_sz, map;419// CHECK-DAG: [B3]420// CHECK-DAG: [[#PFB:]]: x421// CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)422// CHECK-DAG: [[#PFB+2]]: argc423// CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]424// CHECK-DAG: [B1]425// CHECK-DAG: [[#PF:]]: cond426// CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)427// CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)428// CHECK-DAG: [[#PF+3]]: fp429// CHECK-DAG: [[#PF+4]]: rd430// CHECK-DAG: [[#PF+5]]: lin431// CHECK-DAG: [[#PF+6]]: step_sz432// CHECK-DAG: [[#PF+7]]: [B1.[[#PF+6]]] (ImplicitCastExpr, LValueToRValue, int)433// CHECK-DAG: [[#PF+8]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step(step_sz))434// CHECK-DAG: for (int i = 0;435// CHECK-DAG: [B3.[[#PFB+3]]];436#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step_sz)437 for (int i = 0; i < 10; ++i)438 argc = x;439}440 441// CHECK-LABEL: void pfs(int argc)442void pfs(int argc) {443 int x, cond, fp, rd, lin, step_sz, map;444// CHECK-DAG: [B3]445// CHECK-DAG: [[#PFSB:]]: x446// CHECK-DAG: [[#PFSB+1]]: [B3.[[#PFSB]]] (ImplicitCastExpr, LValueToRValue, int)447// CHECK-DAG: [[#PFSB+2]]: argc448// CHECK-DAG: [[#PFSB+3]]: [B3.[[#PFSB+2]]] = [B3.[[#PFSB+1]]]449// CHECK-DAG: [B1]450// CHECK-DAG: [[#PFS:]]: cond451// CHECK-DAG: [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)452// CHECK-DAG: [[#PFS+2]]: [B1.[[#PFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)453// CHECK-DAG: [[#PFS+3]]: fp454// CHECK-DAG: [[#PFS+4]]: rd455// CHECK-DAG: [[#PFS+5]]: lin456// CHECK-DAG: [[#PFS+6]]: step_sz457// CHECK-DAG: [[#PFS+7]]: [B1.[[#PFS+6]]] (ImplicitCastExpr, LValueToRValue, int)458// CHECK-DAG: [[#PFS+8]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step(step_sz))459// CHECK-DAG: for (int i = 0;460// CHECK-DAG: [B3.[[#PFSB+3]]];461#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step_sz)462 for (int i = 0; i < 10; ++i)463 argc = x;464}465 466// CHECK-LABEL: void simd(int argc)467void simd(int argc) {468 int x, cond, fp, rd, lin, step_sz, map;469// CHECK-DAG: [B3]470// CHECK-DAG: [[#SIMDB:]]: x471// CHECK-DAG: [[#SIMDB+1]]: [B3.[[#SIMDB]]] (ImplicitCastExpr, LValueToRValue, int)472// CHECK-DAG: [[#SIMDB+2]]: argc473// CHECK-DAG: [[#SIMDB+3]]: [B3.[[#SIMDB+2]]] = [B3.[[#SIMDB+1]]]474// CHECK-DAG: [B1]475// CHECK-DAG: [[#SIMD:]]: lin476// CHECK-DAG: [[#SIMD+1]]: step_sz477// CHECK-DAG: [[#SIMD+2]]: [B1.[[#SIMD+1]]] (ImplicitCastExpr, LValueToRValue, int)478// CHECK-DAG: [[#SIMD+3]]: #pragma omp simd linear(lin: step(step_sz))479// CHECK-DAG: for (int i = 0;480// CHECK-DAG: [B3.[[#SIMDB+3]]];481#pragma omp simd linear(lin: step_sz)482 for (int i = 0; i < 10; ++i)483 argc = x;484}485 486// CHECK-LABEL: void tpf(int argc)487void tpf(int argc) {488 int x, cond, fp, rd, lin, step_sz, map;489// CHECK-DAG: [B3]490// CHECK-DAG: [[#TPFB:]]: x491// CHECK-DAG: [[#TPFB+1]]: [B3.[[#TPFB]]] (ImplicitCastExpr, LValueToRValue, int)492// CHECK-DAG: [[#TPFB+2]]: argc493// CHECK-DAG: [[#TPFB+3]]: [B3.[[#TPFB+2]]] = [B3.[[#TPFB+1]]]494// CHECK-DAG: [B1]495// CHECK-DAG: [[#TPF:]]: cond496// CHECK-DAG: [[#TPF+1]]: [B1.[[#TPF]]] (ImplicitCastExpr, LValueToRValue, int)497// CHECK-DAG: [[#TPF+2]]: [B1.[[#TPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)498// CHECK-DAG: [[#TPF+3]]: fp499// CHECK-DAG: [[#TPF+4]]: rd500// CHECK-DAG: [[#TPF+5]]: lin501// CHECK-DAG: [[#TPF+6]]: step_sz502// CHECK-DAG: [[#TPF+7]]: [B1.[[#TPF+6]]] (ImplicitCastExpr, LValueToRValue, int)503// CHECK-DAG: [[#TPF+8]]: map504// CHECK-DAG: [[#TPF+9]]: [B3.[[#TPFB+2]]]505// CHECK-DAG: [[#TPF+10]]: [B3.[[#TPFB]]]506// CHECK-DAG: [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step(step_sz)) map(tofrom: map)507// CHECK-DAG: for (int i = 0;508// CHECK-DAG: [B3.[[#TPFB+3]]];509#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step_sz) map(map)510 for (int i = 0; i < 10; ++i)511 argc = x;512}513 514// CHECK-LABEL: void tpfs(int argc)515void tpfs(int argc) {516 int x, cond, fp, rd, lin, step_sz, map;517// CHECK-DAG: [B3]518// CHECK-DAG: [[#TPFSB:]]: x519// CHECK-DAG: [[#TPFSB+1]]: [B3.[[#TPFSB]]] (ImplicitCastExpr, LValueToRValue, int)520// CHECK-DAG: [[#TPFSB+2]]: argc521// CHECK-DAG: [[#TPFSB+3]]: [B3.[[#TPFSB+2]]] = [B3.[[#TPFSB+1]]]522// CHECK-DAG: [B1]523// CHECK-DAG: [[#TPFS:]]: cond524// CHECK-DAG: [[#TPFS+1]]: [B1.[[#TPFS]]] (ImplicitCastExpr, LValueToRValue, int)525// CHECK-DAG: [[#TPFS+2]]: [B1.[[#TPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)526// CHECK-DAG: [[#TPFS+3]]: fp527// CHECK-DAG: [[#TPFS+4]]: rd528// CHECK-DAG: [[#TPFS+5]]: lin529// CHECK-DAG: [[#TPFS+6]]: step_sz530// CHECK-DAG: [[#TPFS+7]]: [B1.[[#TPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)531// CHECK-DAG: [[#TPFS+8]]: map532// CHECK-DAG: [[#TPFS+9]]: [B3.[[#TPFSB+2]]]533// CHECK-DAG: [[#TPFS+10]]: [B3.[[#TPFSB]]]534// CHECK-DAG: [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step(step_sz)) map(tofrom: map)535// CHECK-DAG: for (int i = 0;536// CHECK-DAG: [B3.[[#TPFSB+3]]];537#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step_sz) map(tofrom:map)538 for (int i = 0; i < 10; ++i)539 argc = x;540}541 542// CHECK-LABEL: void ts(int argc)543void ts(int argc) {544 int x, cond, fp, rd, lin, step_sz, map;545// CHECK-DAG: [B3]546// CHECK-DAG: [[#TSB:]]: x547// CHECK-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)548// CHECK-DAG: [[#TSB+2]]: argc549// CHECK-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]550// CHECK-DAG: [B1]551// CHECK-DAG: [[#TS:]]: cond552// CHECK-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)553// CHECK-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)554// CHECK-DAG: [[#TS+3]]: fp555// CHECK-DAG: [[#TS+4]]: rd556// CHECK-DAG: [[#TS+5]]: lin557// CHECK-DAG: [[#TS+6]]: step_sz558// CHECK-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)559// CHECK-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]560// CHECK-DAG: [[#TS+9]]: [B3.[[#TSB]]]561// CHECK-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz)) map(alloc: map)562// CHECK-DAG: for (int i = 0;563// CHECK-DAG: [B3.[[#TSB+3]]];564#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz) map(alloc:map)565 for (int i = 0; i < 10; ++i)566 argc = x;567}568 569// CHECK-LABEL: void ttd(int argc)570void ttd(int argc) {571 int x, cond, fp, rd, lin, step_sz, map;572// CHECK-DAG: [B3]573// CHECK-DAG: [[#TTDB:]]: x574// CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)575// CHECK-DAG: [[#TTDB+2]]: argc576// CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]577// CHECK-DAG: [B1]578// CHECK-DAG: [[#TTD:]]: cond579// CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)580// CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)581// CHECK-DAG: [[#TTD+3]]: fp582// CHECK-DAG: [[#TTD+4]]: rd583// CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]584// CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]585// CHECK-DAG: [[#TTD+7]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)586// CHECK-DAG: for (int i = 0;587// CHECK-DAG: [B3.[[#TTDB+3]]];588#pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)589 for (int i = 0; i < 10; ++i)590 argc = x;591}592 593// CHECK-LABEL: void ttdpf(int argc)594void ttdpf(int argc) {595 int x, cond, fp, rd, lin, step_sz, map;596// CHECK-DAG: [B3]597// CHECK-DAG: [[#TTDPFB:]]: x598// CHECK-DAG: [[#TTDPFB+1]]: [B3.[[#TTDPFB]]] (ImplicitCastExpr, LValueToRValue, int)599// CHECK-DAG: [[#TTDPFB+2]]: argc600// CHECK-DAG: [[#TTDPFB+3]]: [B3.[[#TTDPFB+2]]] = [B3.[[#TTDPFB+1]]]601// CHECK-DAG: [B1]602// CHECK-DAG: [[#TTDPF:]]: cond603// CHECK-DAG: [[#TTDPF+1]]: [B1.[[#TTDPF]]] (ImplicitCastExpr, LValueToRValue, int)604// CHECK-DAG: [[#TTDPF+2]]: [B1.[[#TTDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)605// CHECK-DAG: [[#TTDPF+3]]: fp606// CHECK-DAG: [[#TTDPF+4]]: rd607// CHECK-DAG: [[#TTDPF+5]]: [B3.[[#TTDPFB+2]]]608// CHECK-DAG: [[#TTDPF+6]]: [B3.[[#TTDPFB]]]609// CHECK-DAG: [[#TTDPF+7]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)610// CHECK-DAG: for (int i = 0;611// CHECK-DAG: [B3.[[#TTDPFB+3]]];612#pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)613 for (int i = 0; i < 10; ++i)614 argc = x;615}616 617// CHECK-LABEL: void ttdpfs(int argc)618void ttdpfs(int argc) {619 int x, cond, fp, rd, lin, step_sz, map;620// CHECK-DAG: [B3]621// CHECK-DAG: [[#TTDPFSB:]]: x622// CHECK-DAG: [[#TTDPFSB+1]]: [B3.[[#TTDPFSB]]] (ImplicitCastExpr, LValueToRValue, int)623// CHECK-DAG: [[#TTDPFSB+2]]: argc624// CHECK-DAG: [[#TTDPFSB+3]]: [B3.[[#TTDPFSB+2]]] = [B3.[[#TTDPFSB+1]]]625// CHECK-DAG: [B1]626// CHECK-DAG: [[#TTDPFS:]]: cond627// CHECK-DAG: [[#TTDPFS+1]]: [B1.[[#TTDPFS]]] (ImplicitCastExpr, LValueToRValue, int)628// CHECK-DAG: [[#TTDPFS+2]]: [B1.[[#TTDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)629// CHECK-DAG: [[#TTDPFS+3]]: fp630// CHECK-DAG: [[#TTDPFS+4]]: rd631// CHECK-DAG: [[#TTDPFS+5]]: [B3.[[#TTDPFSB+2]]]632// CHECK-DAG: [[#TTDPFS+6]]: [B3.[[#TTDPFSB]]]633// CHECK-DAG: [[#TTDPFS+7]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) map(from: map)634// CHECK-DAG: for (int i = 0;635// CHECK-DAG: [B3.[[#TTDPFSB+3]]];636#pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp) reduction(+:rd) map(from:map)637 for (int i = 0; i < 10; ++i)638 argc = x;639}640 641// CHECK-LABEL: void ttds(int argc)642void ttds(int argc) {643 int x, cond, fp, rd, lin, step_sz, map;644// CHECK-DAG: [B3]645// CHECK-DAG: [[#TTDSB:]]: x646// CHECK-DAG: [[#TTDSB+1]]: [B3.[[#TTDSB]]] (ImplicitCastExpr, LValueToRValue, int)647// CHECK-DAG: [[#TTDSB+2]]: argc648// CHECK-DAG: [[#TTDSB+3]]: [B3.[[#TTDSB+2]]] = [B3.[[#TTDSB+1]]]649// CHECK-DAG: [B1]650// CHECK-DAG: [[#TTDS:]]: cond651// CHECK-DAG: [[#TTDS+1]]: [B1.[[#TTDS]]] (ImplicitCastExpr, LValueToRValue, int)652// CHECK-DAG: [[#TTDS+2]]: [B1.[[#TTDS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)653// CHECK-DAG: [[#TTDS+3]]: fp654// CHECK-DAG: [[#TTDS+4]]: rd655// CHECK-DAG: [[#TTDS+5]]: map656// CHECK-DAG: [[#TTDS+6]]: [B3.[[#TTDSB+2]]]657// CHECK-DAG: [[#TTDS+7]]: [B3.[[#TTDSB]]]658// CHECK-DAG: [[#TTDS+8]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)659// CHECK-DAG: for (int i = 0;660// CHECK-DAG: [B3.[[#TTDPFSB+3]]];661#pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) map(map)662 for (int i = 0; i < 10; ++i)663 argc = x;664}665 666// CHECK-LABEL: void tl(int argc)667void tl(int argc) {668 int x, cond, fp, rd, lin, step_sz, map;669// CHECK-DAG: [B3]670// CHECK-DAG: [[#TLB:]]: x671// CHECK-DAG: [[#TLB+1]]: [B3.[[#TLB]]] (ImplicitCastExpr, LValueToRValue, int)672// CHECK-DAG: [[#TLB+2]]: argc673// CHECK-DAG: [[#TLB+3]]: [B3.[[#TLB+2]]] = [B3.[[#TLB+1]]]674// CHECK-DAG: [B1]675// CHECK-DAG: [[#TL:]]: cond676// CHECK-DAG: [[#TL+1]]: [B1.[[#TL]]] (ImplicitCastExpr, LValueToRValue, int)677// CHECK-DAG: [[#TL+2]]: [B1.[[#TL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)678// CHECK-DAG: [[#TL+3]]: fp679// CHECK-DAG: [[#TL+4]]: rd680// CHECK-DAG: [[#TL+5]]: [B3.[[#TLB+2]]]681// CHECK-DAG: [[#TL+6]]: [B3.[[#TLB]]]682// CHECK-DAG: [[#TL+7]]: #pragma omp taskloop if(cond) firstprivate(fp) reduction(+: rd)683// CHECK-DAG: for (int i = 0;684// CHECK-DAG: [B3.[[#TLB+3]]];685#pragma omp taskloop if(cond) firstprivate(fp) reduction(+:rd)686 for (int i = 0; i < 10; ++i)687 argc = x;688}689 690// CHECK-LABEL: void maskedtaskloop(int argc)691void maskedtaskloop(int argc) {692 int x, cond, fp, rd, lin, step_sz, map;693// CHECK-DAG: [B3]694// CHECK-DAG: [[#MTLB:]]: x695// CHECK-DAG: [[#MTLB+1]]: [B3.[[#MTLB]]] (ImplicitCastExpr, LValueToRValue, int)696// CHECK-DAG: [[#MTLB+2]]: argc697// CHECK-DAG: [[#MTLB+3]]: [B3.[[#MTLB+2]]] = [B3.[[#MTLB+1]]]698// CHECK-DAG: [B1]699// CHECK-DAG: [[#MTL:]]: cond700// CHECK-DAG: [[#MTL+1]]: [B1.[[#MTL]]] (ImplicitCastExpr, LValueToRValue, int)701// CHECK-DAG: [[#MTL+2]]: [B1.[[#MTL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)702// CHECK-DAG: [[#MTL+3]]: fp703// CHECK-DAG: [[#MTL+4]]: rd704// CHECK-DAG: [[#MTL+5]]: [B3.[[#MTLB+2]]]705// CHECK-DAG: [[#MTL+6]]: [B3.[[#MTLB]]]706// CHECK-DAG: [[#MTL+7]]: #pragma omp masked taskloop if(cond) firstprivate(fp) reduction(+: rd)707// CHECK-DAG: for (int i = 0;708// CHECK-DAG: [B3.[[#MTLB+3]]];709#pragma omp masked taskloop if(cond) firstprivate(fp) reduction(+:rd)710 for (int i = 0; i < 10; ++i)711 argc = x;712}713 714// CHECK-LABEL: void parallelmaskedtaskloop(int argc)715void parallelmaskedtaskloop(int argc) {716 int x, cond, fp, rd, lin, step_sz, map;717// CHECK-DAG: [B3]718// CHECK-DAG: [[#PMTLB:]]: x719// CHECK-DAG: [[#PMTLB+1]]: [B3.[[#PMTLB]]] (ImplicitCastExpr, LValueToRValue, int)720// CHECK-DAG: [[#PMTLB+2]]: argc721// CHECK-DAG: [[#PMTLB+3]]: [B3.[[#PMTLB+2]]] = [B3.[[#PMTLB+1]]]722// CHECK-DAG: [B1]723// CHECK-DAG: [[#PMTL:]]: cond724// CHECK-DAG: [[#PMTL+1]]: [B1.[[#PMTL]]] (ImplicitCastExpr, LValueToRValue, int)725// CHECK-DAG: [[#PMTL+2]]: [B1.[[#PMTL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)726// CHECK-DAG: [[#PMTL+3]]: fp727// CHECK-DAG: [[#PMTL+4]]: rd728// CHECK-DAG: [[#PMTL+5]]: [B3.[[#PMTLB+2]]]729// CHECK-DAG: [[#PMTL+6]]: [B3.[[#PMTLB]]]730// CHECK-DAG: [[#PMTL+7]]: #pragma omp parallel masked taskloop if(cond) firstprivate(fp) reduction(+: rd)731// CHECK-DAG: for (int i = 0;732// CHECK-DAG: [B3.[[#PMTLB+3]]];733#pragma omp parallel masked taskloop if(cond) firstprivate(fp) reduction(+:rd)734 for (int i = 0; i < 10; ++i)735 argc = x;736}737 738// CHECK-LABEL: void parallelmaskedtasksimdloop(int argc)739void parallelmaskedtasksimdloop(int argc) {740 int x, cond, fp, rd, lin, step_sz, map;741// CHECK-DAG: [B3]742// CHECK-DAG: [[#PMTLSB:]]: x743// CHECK-DAG: [[#PMTLSB+1]]: [B3.[[#PMTLSB]]] (ImplicitCastExpr, LValueToRValue, int)744// CHECK-DAG: [[#PMTLSB+2]]: argc745// CHECK-DAG: [[#PMTLSB+3]]: [B3.[[#PMTLSB+2]]] = [B3.[[#PMTLSB+1]]]746// CHECK-DAG: [B1]747// CHECK-DAG: [[#PMTLS:]]: cond748// CHECK-DAG: [[#PMTLS+1]]: [B1.[[#PMTLS]]] (ImplicitCastExpr, LValueToRValue, int)749// CHECK-DAG: [[#PMTLS+2]]: [B1.[[#PMTLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)750// CHECK-DAG: [[#PMTLS+3]]: fp751// CHECK-DAG: [[#PMTLS+4]]: rd752// CHECK-DAG: [[#PMTLS+5]]: [B3.[[#PMTLSB+2]]]753// CHECK-DAG: [[#PMTLS+6]]: [B3.[[#PMTLSB]]]754// CHECK-DAG: [[#PMTLS+7]]: #pragma omp parallel masked taskloop simd if(cond) firstprivate(fp) reduction(+: rd)755// CHECK-DAG: for (int i = 0;756// CHECK-DAG: [B3.[[#PMTLSB+3]]];757#pragma omp parallel masked taskloop simd if(cond) firstprivate(fp) reduction(+:rd)758 for (int i = 0; i < 10; ++i)759 argc = x;760}761 762// CHECK-LABEL: void tls(int argc)763void tls(int argc) {764 int x, cond, fp, rd, lin, step_sz, map;765// CHECK-DAG: [B3]766// CHECK-DAG: [[#TLSB:]]: x767// CHECK-DAG: [[#TLSB+1]]: [B3.[[#TLSB]]] (ImplicitCastExpr, LValueToRValue, int)768// CHECK-DAG: [[#TLSB+2]]: argc769// CHECK-DAG: [[#TLSB+3]]: [B3.[[#TLSB+2]]] = [B3.[[#TLSB+1]]]770// CHECK-DAG: [B1]771// CHECK-DAG: [[#TLS:]]: cond772// CHECK-DAG: [[#TLS+1]]: [B1.[[#TLS]]] (ImplicitCastExpr, LValueToRValue, int)773// CHECK-DAG: [[#TLS+2]]: [B1.[[#TLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)774// CHECK-DAG: [[#TLS+3]]: fp775// CHECK-DAG: [[#TLS+4]]: rd776// CHECK-DAG: [[#TLS+5]]: lin777// CHECK-DAG: [[#TLS+6]]: step_sz778// CHECK-DAG: [[#TLS+7]]: [B1.[[#TLS+6]]] (ImplicitCastExpr, LValueToRValue, int)779// CHECK-DAG: [[#TLS+8]]: [B3.[[#TLSB+2]]]780// CHECK-DAG: [[#TLS+9]]: [B3.[[#TLSB]]]781// CHECK-DAG: [[#TLS+10]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz))782// CHECK-DAG: for (int i = 0;783// CHECK-DAG: [B3.[[#TLSB+3]]];784#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz)785 for (int i = 0; i < 10; ++i)786 argc = x;787}788 789// CHECK-LABEL: void maskedtaskloopsimd(int argc)790void maskedtaskloopsimd(int argc) {791 int x, cond, fp, rd, lin, step_sz, map;792// CHECK-DAG: [B3]793// CHECK-DAG: [[#MTLSB:]]: x794// CHECK-DAG: [[#MTLSB+1]]: [B3.[[#MTLSB]]] (ImplicitCastExpr, LValueToRValue, int)795// CHECK-DAG: [[#MTLSB+2]]: argc796// CHECK-DAG: [[#MTLSB+3]]: [B3.[[#MTLSB+2]]] = [B3.[[#MTLSB+1]]]797// CHECK-DAG: [B1]798// CHECK-DAG: [[#MTLS:]]: cond799// CHECK-DAG: [[#MTLS+1]]: [B1.[[#MTLS]]] (ImplicitCastExpr, LValueToRValue, int)800// CHECK-DAG: [[#MTLS+2]]: [B1.[[#MTLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)801// CHECK-DAG: [[#MTLS+3]]: fp802// CHECK-DAG: [[#MTLS+4]]: rd803// CHECK-DAG: [[#MTLS+5]]: lin804// CHECK-DAG: [[#MTLS+6]]: step_sz805// CHECK-DAG: [[#MTLS+7]]: [B1.[[#MTLS+6]]] (ImplicitCastExpr, LValueToRValue, int)806// CHECK-DAG: [[#MTLS+8]]: [B3.[[#MTLSB+2]]]807// CHECK-DAG: [[#MTLS+9]]: [B3.[[#MTLSB]]]808// CHECK-DAG: [[#MTLS+10]]: #pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz))809// CHECK-DAG: for (int i = 0;810// CHECK-DAG: [B3.[[#MTLSB+3]]];811#pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz)812 for (int i = 0; i < 10; ++i)813 argc = x;814}815 816// CHECK-LABEL: void tdpf(int argc)817void tdpf(int argc) {818 int x, cond, fp, rd, lin, step_sz, map;819// CHECK-DAG: [B1]820// CHECK-DAG: [[#TDPF:]]: [B1.{{.+}}]821// CHECK-DAG: [[#TDPF+1]]: [B1.[[#TDPF+6]]] (ImplicitCastExpr, LValueToRValue, int)822// CHECK-DAG: [[#TDPF+2]]: [B1.[[#TDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)823// CHECK-DAG: [[#TDPF+3]]: [B1.[[#TDPF+7]]]824// CHECK-DAG: [[#TDPF+4]]: [B1.[[#TDPF+8]]]825// CHECK-DAG: [[#TDPF+5]]: #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd)826// CHECK-DAG: for (int i = 0;827// CHECK-DAG: [B3.[[#TDPFB:]]];828// CHECK-DAG: [[#TDPF+6]]: cond829// CHECK-DAG: [[#TDPF+7]]: fp830// CHECK-DAG: [[#TDPF+8]]: rd831// CHECK-DAG: [[#TDPF+9]]: argc832// CHECK-DAG: [[#TDPF+10]]: x833// CHECK-DAG: [[#TDPF+11]]: #pragma omp target834// CHECK-DAG: [B3]835// CHECK-DAG: [[#TDPFB-3]]: x836// CHECK-DAG: [[#TDPFB-2]]: [B3.[[#TDPFB-3]]] (ImplicitCastExpr, LValueToRValue, int)837// CHECK-DAG: [[#TDPFB-1]]: argc838// CHECK-DAG: [[#TDPFB]]: [B3.[[#TDPFB-1]]] = [B3.[[#TDPFB-2]]]839#pragma omp target840#pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd)841 for (int i = 0; i < 10; ++i)842 argc = x;843}844 845// CHECK-LABEL: void tdpfs(int argc)846void tdpfs(int argc) {847 int x, cond, fp, rd, lin, step_sz, map;848// CHECK-DAG: [B1]849// CHECK-DAG: [[#TDPFS:]]: [B1.{{.+}}]850// CHECK-DAG: [[#TDPFS+1]]: [B1.[[#TDPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)851// CHECK-DAG: [[#TDPFS+2]]: [B1.[[#TDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)852// CHECK-DAG: [[#TDPFS+3]]: [B1.[[#TDPFS+7]]]853// CHECK-DAG: [[#TDPFS+4]]: [B1.[[#TDPFS+8]]]854// CHECK-DAG: [[#TDPFS+5]]: #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+: rd)855// CHECK-DAG: for (int i = 0;856// CHECK-DAG: [B3.[[#TDPFSB:]]];857// CHECK-DAG: [[#TDPFS+6]]: cond858// CHECK-DAG: [[#TDPFS+7]]: fp859// CHECK-DAG: [[#TDPFS+8]]: rd860// CHECK-DAG: [[#TDPFS+9]]: argc861// CHECK-DAG: [[#TDPFS+10]]: x862// CHECK-DAG: [[#TDPFS+11]]: #pragma omp target863// CHECK-DAG: [B3]864// CHECK-DAG: [[#TDPFSB-3]]: x865// CHECK-DAG: [[#TDPFSB-2]]: [B3.[[#TDPFSB-3]]] (ImplicitCastExpr, LValueToRValue, int)866// CHECK-DAG: [[#TDPFSB-1]]: argc867// CHECK-DAG: [[#TDPFSB]]: [B3.[[#TDPFSB-1]]] = [B3.[[#TDPFSB-2]]]868#pragma omp target869#pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+:rd)870 for (int i = 0; i < 10; ++i)871 argc = x;872}873 874// CHECK-LABEL: void tds(int argc)875void tds(int argc) {876 int x, cond, fp, rd, lin, step_sz, map;877// CHECK-DAG: [B1]878// CHECK-DAG: [[#TDS:]]: #pragma omp teams distribute simd firstprivate(fp) reduction(+: rd)879// CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]880// CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]881// CHECK-DAG: for (int i = 0;882// CHECK-DAG: [B3.[[#TDSB:]]];883// CHECK-DAG: [[#TDS+1]]: fp884// CHECK-DAG: [[#TDS+2]]: rd885// CHECK-DAG: [[#TDS+3]]: argc886// CHECK-DAG: [[#TDS+4]]: x887// CHECK-DAG: [[#TDS+5]]: #pragma omp target888// CHECK-DAG: [B3]889// CHECK-DAG: [[#TDSB-3]]: x890// CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)891// CHECK-DAG: [[#TDSB-1]]: argc892// CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]893#pragma omp target894#pragma omp teams distribute simd firstprivate(fp) reduction(+:rd)895 for (int i = 0; i < 10; ++i)896 argc = x;897}898 899// CHECK-LABEL: void teamsloop(int argc)900void teamsloop(int argc) {901 int x, cond, fp, rd, lin, step_sz, map;902// CHECK-DAG: [B1]903// CHECK-DAG: [[#TDS:]]: #pragma omp teams loop firstprivate(fp) reduction(+: rd)904// CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]905// CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]906// CHECK-DAG: for (int i = 0;907// CHECK-DAG: [B3.[[#TDSB:]]];908// CHECK-DAG: [[#TDS+1]]: fp909// CHECK-DAG: [[#TDS+2]]: rd910// CHECK-DAG: [[#TDS+3]]: argc911// CHECK-DAG: [[#TDS+4]]: x912// CHECK-DAG: [[#TDS+5]]: #pragma omp target913// CHECK-DAG: [B3]914// CHECK-DAG: [[#TDSB-3]]: x915// CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)916// CHECK-DAG: [[#TDSB-1]]: argc917// CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]918#pragma omp target919#pragma omp teams loop firstprivate(fp) reduction(+:rd)920 for (int i = 0; i < 10; ++i)921 argc = x;922}923 924// CHECK-LABEL: void targetteamsloop(int argc)925void targetteamsloop(int argc) {926 int x, cond, fp, rd, map;927// CHECK-DAG: [B3]928// CHECK-DAG: [[#TTDB:]]: x929// CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)930// CHECK-DAG: [[#TTDB+2]]: argc931// CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]932// CHECK-DAG: [B1]933// CHECK-DAG: [[#TTD:]]: cond934// CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)935// CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)936// CHECK-DAG: [[#TTD+3]]: fp937// CHECK-DAG: [[#TTD+4]]: rd938// CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]939// CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]940// CHECK-DAG: [[#TTD+7]]: #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)941// CHECK-DAG: for (int i = 0;942// CHECK-DAG: [B3.[[#TTDB+3]]];943#pragma omp target teams loop if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)944 for (int i = 0; i < 10; ++i)945 argc = x;946}947 948// CHECK-LABEL: void parallelloop(int argc)949void parallelloop(int argc) {950 int x, cond, fp, rd;951// CHECK-DAG: [B3]952// CHECK-DAG: [[#PFB:]]: x953// CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)954// CHECK-DAG: [[#PFB+2]]: argc955// CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]956// CHECK-DAG: [B1]957// CHECK-DAG: [[#PF:]]: cond958// CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)959// CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)960// CHECK-DAG: [[#PF+3]]: fp961// CHECK-DAG: [[#PF+4]]: rd962// CHECK-DAG: [[#PF+5]]: #pragma omp parallel loop if(cond) firstprivate(fp) reduction(&: rd)963// CHECK-DAG: for (int i = 0;964// CHECK-DAG: [B3.[[#PFB+3]]];965#pragma omp parallel loop if(cond) firstprivate(fp) reduction(&:rd)966 for (int i = 0; i < 10; ++i)967 argc = x;968}969 970// CHECK-LABEL: void targetparallelloop(int argc)971void targetparallelloop(int argc) {972 int x, cond, fp, rd, map;973// CHECK-DAG: [B3]974// CHECK-DAG: [[#TTDB:]]: x975// CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)976// CHECK-DAG: [[#TTDB+2]]: argc977// CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]978// CHECK-DAG: [B1]979// CHECK-DAG: [[#TTD:]]: cond980// CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)981// CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)982// CHECK-DAG: [[#TTD+3]]: fp983// CHECK-DAG: [[#TTD+4]]: rd984// CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]985// CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]986// CHECK-DAG: [[#TTD+7]]: #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)987// CHECK-DAG: for (int i = 0;988// CHECK-DAG: [B3.[[#TTDB+3]]];989#pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)990 for (int i = 0; i < 10; ++i)991 argc = x;992}993 994// CHECK-LABEL: void parallelmasked(int argc)995void parallelmasked(int argc) {996 int x = 0;997// CHECK: [B1]998// CHECK-NEXT: 1: 0999// CHECK-NEXT: 2: int x = 0;1000// CHECK-NEXT: [[#MASKED:]]: x1001// CHECK-NEXT: [[#MASKED+1]]: [B1.[[#MASKED]]] (ImplicitCastExpr, LValueToRValue, int)1002// CHECK-NEXT: [[#MASKED+2]]: argc1003// CHECK-NEXT: [[#MASKED+3]]: [B1.[[#MASKED+2]]] = [B1.[[#MASKED+1]]]1004// CHECK-NEXT: [[#MASKED+4]]: #pragma omp parallel masked1005#pragma omp parallel masked1006 argc = x;1007}1008#endif // _OPENMP1009