clang/test/Analysis/cfg-openmp.cpp

   1 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
   2
   3 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp | FileCheck %s --check-prefix=OMP51
   4
   5 #if _OPENMP == 202011
   6
   7 // OMP51-LABEL:  void target_has_device_addr(int argc)
   8 void target_has_device_addr(int argc) {
   9 // OMP51:   [B1]
  10 // OMP51-NEXT:   [[#TTD:]]: 5
  11 // OMP51-NEXT:   [[#TTD+1]]: int x = 5;
  12 // OMP51-NEXT:   [[#TTD+2]]: x
  13 // 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]]: argc
  17 // 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)
  24 void 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:]]: x
  28 // OMP51-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
  29 // OMP51-DAG: [[#TSB+2]]: argc
  30 // OMP51-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
  31 // OMP51-DAG:  [B1]
  32 // OMP51-DAG: [[#TS:]]: cond
  33 // 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]]: fp
  36 // OMP51-DAG: [[#TS+4]]: rd
  37 // OMP51-DAG: [[#TS+5]]: lin
  38 // OMP51-DAG: [[#TS+6]]: step_sz
  39 // 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)
  50 void target_t_l_has_device_addr(int argc) {
  51 int x, cond, fp, rd, map;
  52 // OMP51-DAG: [B3]
  53 // OMP51-DAG: [[#TTDB:]]: x
  54 // OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
  55 // OMP51-DAG: [[#TTDB+2]]: argc
  56 // OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
  57 // OMP51-DAG: [B1]
  58 // OMP51-DAG: [[#TTD:]]: cond
  59 // 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]]: fp
  62 // OMP51-DAG: [[#TTD+4]]: rd
  63 // 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)
  73 void target_p_l_has_device_addr(int argc) {
  74 int 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:]]: x
  78 // OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
  79 // OMP51-DAG: [[#TTDB+2]]: argc
  80 // OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
  81 // OMP51-DAG: [B1]
  82 // OMP51-DAG: [[#TTD:]]: cond
  83 // 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]]: fp
  86 // OMP51-DAG: [[#TTD+4]]: rd
  87 // 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 }
  95 struct 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:]]: 10
 105 // OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD:]]] (ImplicitCastExpr, IntegralToFloating, float)
 106 // OMP51-DAG: [[#TTD+2]]: this
 107 // OMP51-DAG: [[#TTD+3]]: [B1.[[#TTD+2]]]->devPtr
 108 // 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 };
 118 void use_template() {
 119   SomeKernel aKern;
 120   aKern.apply<32>();
 121 }
 122 #else // _OPENMP
 123
 124 // CHECK-LABEL:  void xxx(int argc)
 125 void 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:]]: x
 136 // CHECK-NEXT:   [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
 137 // CHECK-NEXT:   [[#ATOM+2]]: argc
 138 // CHECK-NEXT:   [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
 139 // CHECK-NEXT:   [[#ATOM+4]]: #pragma omp atomic read
 140 // CHECK-NEXT:   [B1.[[#ATOM+3]]];
 141 #pragma omp atomic read
 142   argc = x;
 143 // CHECK-NEXT:   [[#CRIT:]]: x
 144 // CHECK-NEXT:   [[#CRIT+1]]: [B1.[[#CRIT]]] (ImplicitCastExpr, LValueToRValue, int)
 145 // CHECK-NEXT:   [[#CRIT+2]]: argc
 146 // CHECK-NEXT:   [[#CRIT+3]]: [B1.[[#CRIT+2]]] = [B1.[[#CRIT+1]]]
 147 // CHECK-NEXT:   [[#CRIT+4]]: #pragma omp critical
 148 // CHECK-NEXT:   [B1.[[#CRIT+3]]];
 149 #pragma omp critical
 150   argc = x;
 151 // CHECK-NEXT:  [[#MASTER:]]: x
 152 // CHECK-NEXT:  [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
 153 // CHECK-NEXT:  [[#MASTER+2]]: argc
 154 // CHECK-NEXT:  [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
 155 // CHECK-NEXT:  [[#MASTER+4]]: #pragma omp master
 156 // CHECK-NEXT:    [B1.[[#MASTER+3]]];
 157 #pragma omp master
 158   argc = x;
 159 // CHECK-NEXT:  [[#PAR:]]: x
 160 // CHECK-NEXT:  [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
 161 // CHECK-NEXT:  [[#PAR+2]]: argc
 162 // CHECK-NEXT:  [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
 163 // CHECK-NEXT:  [[#PAR+4]]: cond
 164 // 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]]: fp
 167 // CHECK-NEXT:  [[#PAR+8]]: rd
 168 // 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:]]: x
 173 // CHECK-NEXT:  [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
 174 // CHECK-NEXT:  [[#PSECT+2]]: argc
 175 // CHECK-NEXT:  [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]
 176 // CHECK-NEXT:  [[#PSECT+4]]: cond
 177 // 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]]: fp
 180 // CHECK-NEXT:  [[#PSECT+8]]: rd
 181 // 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:]]: x
 190 // CHECK-NEXT:  [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
 191 // CHECK-NEXT:  [[#SINGLE+2]]: argc
 192 // CHECK-NEXT:  [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
 193 // CHECK-NEXT:  [[#SINGLE+4]]: #pragma omp single
 194 // CHECK-NEXT:    [B1.[[#SINGLE+3]]];
 195 #pragma omp single
 196   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]]: cond
 203 // 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]]: fp
 206 // CHECK-NEXT:  [[#TARGET+8]]: argc
 207 // CHECK-NEXT:  [[#TARGET+9]]: x
 208 // 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]]: cond
 219 // 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]]: fp
 222 // CHECK-NEXT:  [[#TP+8]]: rd
 223 // CHECK-NEXT:  [[#TP+9]]: map
 224 // CHECK-NEXT:  [[#TP+10]]: argc
 225 // CHECK-NEXT:  [[#TP+11]]: x
 226 // 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]]: cond
 236 // 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]]: fp
 239 // CHECK-NEXT:  [[#TT+8]]: rd
 240 // CHECK-NEXT:  [[#TT+9]]: map
 241 // CHECK-NEXT:  [[#TT+10]]: argc
 242 // CHECK-NEXT:  [[#TT+11]]: x
 243 // 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:]]: cond
 248 // 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]]: cond
 258 // 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]]: fp
 261 // CHECK-NEXT:  [[#TASK+8]]: argc
 262 // CHECK-NEXT:  [[#TASK+9]]: x
 263 // 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:]]: x
 268 // CHECK-NEXT:  [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
 269 // CHECK-NEXT:  [[#TG+2]]: argc
 270 // CHECK-NEXT:  [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]
 271 // CHECK-NEXT:  [[#TG+4]]: #pragma omp taskgroup
 272 // CHECK-NEXT:    [B1.[[#TG+3]]];
 273 #pragma omp taskgroup
 274   argc = x;
 275 // CHECK-NEXT:  [[#TEAMS:]]: x
 276 // CHECK-NEXT:  [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)
 277 // CHECK-NEXT:  [[#TEAMS+2]]: argc
 278 // 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]]: fp
 284 // CHECK-NEXT:  [[#TEAMS+8]]: rd
 285 // CHECK-NEXT:  [[#TEAMS+9]]: argc
 286 // CHECK-NEXT:  [[#TEAMS+10]]: x
 287 // CHECK-NEXT:  [[#TEAMS+11]]: #pragma omp target
 288 #pragma omp target
 289 #pragma omp teams firstprivate(fp) reduction(+:rd)
 290   argc = x;
 291 // CHECK-NEXT:  [B1.[[#TEAMS+6]]]   Preds
 292 }
 293
 294 // CHECK-LABEL:  void dpf(int argc)
 295 void dpf(int argc) {
 296   int x, cond, fp, rd, lin, step_sz, map;
 297 // CHECK-DAG:   [B3]
 298 // CHECK-DAG:  [[#DPFB:]]: x
 299 // CHECK-DAG:  [[#DPFB+1]]: [B3.[[#DPFB]]] (ImplicitCastExpr, LValueToRValue, int)
 300 // CHECK-DAG:  [[#DPFB+2]]: argc
 301 // CHECK-DAG:  [[#DPFB+3]]: [B3.[[#DPFB+2]]] = [B3.[[#DPFB+1]]]
 302 // CHECK-DAG:   [B1]
 303 // CHECK-DAG:  [[#DPF:]]: cond
 304 // 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]]: fp
 307 // CHECK-DAG:  [[#DPF+4]]: rd
 308 // 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)
 317 void dpfs(int argc) {
 318   int x, cond, fp, rd, lin, step_sz, map;
 319 // CHECK-DAG:   [B3]
 320 // CHECK-DAG:  [[#DPFSB:]]: x
 321 // CHECK-DAG:  [[#DPFSB+1]]: [B3.[[#DPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
 322 // CHECK-DAG:  [[#DPFSB+2]]: argc
 323 // CHECK-DAG:  [[#DPFSB+3]]: [B3.[[#DPFSB+2]]] = [B3.[[#DPFSB+1]]]
 324 // CHECK-DAG:   [B1]
 325 // CHECK-DAG:  [[#DPFS:]]: cond
 326 // 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]]: fp
 329 // CHECK-DAG:  [[#DPFS+4]]: rd
 330 // 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)
 339 void ds(int argc) {
 340   int x, cond, fp, rd, lin, step_sz, map;
 341 // CHECK-DAG:   [B3]
 342 // CHECK-DAG:  [[#DSB:]]: x
 343 // CHECK-DAG:  [[#DSB+1]]: [B3.[[#DSB]]] (ImplicitCastExpr, LValueToRValue, int)
 344 // CHECK-DAG:  [[#DSB+2]]: argc
 345 // CHECK-DAG:  [[#DSB+3]]: [B3.[[#DSB+2]]] = [B3.[[#DSB+1]]]
 346 // CHECK-DAG:   [B1]
 347 // CHECK-DAG:  [[#DS:]]: #pragma omp distribute simd
 348 // CHECK-DAG:    for (int i = 0;
 349 // CHECK-DAG:        [B3.[[#DSB+3]]];
 350 #pragma omp distribute simd
 351   for (int i = 0; i < 10; ++i)
 352     argc = x;
 353 }
 354
 355 // CHECK-LABEL:  void for_fn(int argc)
 356 void for_fn(int argc) {
 357   int x, cond, fp, rd, lin, step_sz, map;
 358 // CHECK-DAG:   [B3]
 359 // CHECK-DAG:  [[#FORB:]]: x
 360 // CHECK-DAG:  [[#FORB+1]]: [B3.[[#FORB]]] (ImplicitCastExpr, LValueToRValue, int)
 361 // CHECK-DAG:  [[#FORB+2]]: argc
 362 // CHECK-DAG:  [[#FORB+3]]: [B3.[[#FORB+2]]] = [B3.[[#FORB+1]]]
 363 // CHECK-DAG:   [B1]
 364 // CHECK-DAG:  [[#FOR:]]: lin
 365 // CHECK-DAG:  [[#FOR+1]]: step_sz
 366 // 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)
 376 void fs(int argc) {
 377   int x, cond, fp, rd, lin, step_sz, map;
 378 // CHECK-DAG:   [B3]
 379 // CHECK-DAG:  [[#FSB:]]: x
 380 // CHECK-DAG:  [[#FSB+1]]: [B3.[[#FSB]]] (ImplicitCastExpr, LValueToRValue, int)
 381 // CHECK-DAG:  [[#FSB+2]]: argc
 382 // CHECK-DAG:  [[#FSB+3]]: [B3.[[#FSB+2]]] = [B3.[[#FSB+1]]]
 383 // CHECK-DAG:   [B1]
 384 // CHECK-DAG:  [[#FS:]]: lin
 385 // CHECK-DAG:  [[#FS+1]]: step_sz
 386 // 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)
 396 void ord(int argc) {
 397   int x, cond, fp, rd, lin, step_sz, map;
 398 // CHECK-DAG:   [B3]
 399 // CHECK-DAG:  [[#ORDB:]]: x
 400 // CHECK-DAG:  [[#ORDB+1]]: [B3.[[#ORDB]]] (ImplicitCastExpr, LValueToRValue, int)
 401 // CHECK-DAG:  [[#ORDB+2]]: argc
 402 // CHECK-DAG:  [[#ORDB+3]]: [B3.[[#ORDB+2]]] = [B3.[[#ORDB+1]]]
 403 // CHECK-DAG:  [[#ORDB+4]]: #pragma omp ordered
 404 // CHECK-DAG:    [B3.[[#ORDB+3]]];
 405 // CHECK-DAG:   [B1]
 406 // CHECK-DAG:  [[#ORD:]]: #pragma omp for ordered
 407 // CHECK-DAG:    for (int i = 0
 408 // CHECK-DAG:[B3.[[#ORDB+4]]]    }
 409 #pragma omp for ordered
 410   for (int i = 0; i < 10; ++i) {
 411 #pragma omp ordered
 412     argc = x;
 413   }
 414 }
 415
 416 // CHECK-LABEL:  void pf(int argc)
 417 void pf(int argc) {
 418   int x, cond, fp, rd, lin, step_sz, map;
 419 // CHECK-DAG:   [B3]
 420 // CHECK-DAG:  [[#PFB:]]: x
 421 // CHECK-DAG:  [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
 422 // CHECK-DAG:  [[#PFB+2]]: argc
 423 // CHECK-DAG:  [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
 424 // CHECK-DAG:   [B1]
 425 // CHECK-DAG:  [[#PF:]]: cond
 426 // 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]]: fp
 429 // CHECK-DAG:  [[#PF+4]]: rd
 430 // CHECK-DAG:  [[#PF+5]]: lin
 431 // CHECK-DAG:  [[#PF+6]]: step_sz
 432 // 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)
 442 void pfs(int argc) {
 443   int x, cond, fp, rd, lin, step_sz, map;
 444 // CHECK-DAG:   [B3]
 445 // CHECK-DAG:  [[#PFSB:]]: x
 446 // CHECK-DAG:  [[#PFSB+1]]: [B3.[[#PFSB]]] (ImplicitCastExpr, LValueToRValue, int)
 447 // CHECK-DAG:  [[#PFSB+2]]: argc
 448 // CHECK-DAG:  [[#PFSB+3]]: [B3.[[#PFSB+2]]] = [B3.[[#PFSB+1]]]
 449 // CHECK-DAG:   [B1]
 450 // CHECK-DAG:  [[#PFS:]]: cond
 451 // 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]]: fp
 454 // CHECK-DAG:  [[#PFS+4]]: rd
 455 // CHECK-DAG:  [[#PFS+5]]: lin
 456 // CHECK-DAG:  [[#PFS+6]]: step_sz
 457 // 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)
 467 void simd(int argc) {
 468   int x, cond, fp, rd, lin, step_sz, map;
 469 // CHECK-DAG:   [B3]
 470 // CHECK-DAG:  [[#SIMDB:]]: x
 471 // CHECK-DAG:  [[#SIMDB+1]]: [B3.[[#SIMDB]]] (ImplicitCastExpr, LValueToRValue, int)
 472 // CHECK-DAG:  [[#SIMDB+2]]: argc
 473 // CHECK-DAG:  [[#SIMDB+3]]: [B3.[[#SIMDB+2]]] = [B3.[[#SIMDB+1]]]
 474 // CHECK-DAG:   [B1]
 475 // CHECK-DAG:  [[#SIMD:]]: lin
 476 // CHECK-DAG:  [[#SIMD+1]]: step_sz
 477 // 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)
 487 void tpf(int argc) {
 488   int x, cond, fp, rd, lin, step_sz, map;
 489 // CHECK-DAG:   [B3]
 490 // CHECK-DAG:  [[#TPFB:]]: x
 491 // CHECK-DAG:  [[#TPFB+1]]: [B3.[[#TPFB]]] (ImplicitCastExpr, LValueToRValue, int)
 492 // CHECK-DAG:  [[#TPFB+2]]: argc
 493 // CHECK-DAG:  [[#TPFB+3]]: [B3.[[#TPFB+2]]] = [B3.[[#TPFB+1]]]
 494 // CHECK-DAG:   [B1]
 495 // CHECK-DAG:  [[#TPF:]]: cond
 496 // 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]]: fp
 499 // CHECK-DAG:  [[#TPF+4]]: rd
 500 // CHECK-DAG:  [[#TPF+5]]: lin
 501 // CHECK-DAG:  [[#TPF+6]]: step_sz
 502 // CHECK-DAG:  [[#TPF+7]]: [B1.[[#TPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
 503 // CHECK-DAG:  [[#TPF+8]]: map
 504 // 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)
 515 void tpfs(int argc) {
 516   int x, cond, fp, rd, lin, step_sz, map;
 517 // CHECK-DAG:   [B3]
 518 // CHECK-DAG:  [[#TPFSB:]]: x
 519 // CHECK-DAG:  [[#TPFSB+1]]: [B3.[[#TPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
 520 // CHECK-DAG:  [[#TPFSB+2]]: argc
 521 // CHECK-DAG:  [[#TPFSB+3]]: [B3.[[#TPFSB+2]]] = [B3.[[#TPFSB+1]]]
 522 // CHECK-DAG:   [B1]
 523 // CHECK-DAG:  [[#TPFS:]]: cond
 524 // 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]]: fp
 527 // CHECK-DAG:  [[#TPFS+4]]: rd
 528 // CHECK-DAG:  [[#TPFS+5]]: lin
 529 // CHECK-DAG:  [[#TPFS+6]]: step_sz
 530 // CHECK-DAG:  [[#TPFS+7]]: [B1.[[#TPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
 531 // CHECK-DAG:  [[#TPFS+8]]: map
 532 // 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)
 543 void ts(int argc) {
 544   int x, cond, fp, rd, lin, step_sz, map;
 545 // CHECK-DAG:   [B3]
 546 // CHECK-DAG:  [[#TSB:]]: x
 547 // CHECK-DAG:  [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
 548 // CHECK-DAG:  [[#TSB+2]]: argc
 549 // CHECK-DAG:  [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
 550 // CHECK-DAG:   [B1]
 551 // CHECK-DAG:  [[#TS:]]: cond
 552 // 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]]: fp
 555 // CHECK-DAG:  [[#TS+4]]: rd
 556 // CHECK-DAG:  [[#TS+5]]: lin
 557 // CHECK-DAG:  [[#TS+6]]: step_sz
 558 // 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)
 570 void ttd(int argc) {
 571   int x, cond, fp, rd, lin, step_sz, map;
 572 // CHECK-DAG:   [B3]
 573 // CHECK-DAG:  [[#TTDB:]]: x
 574 // CHECK-DAG:  [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
 575 // CHECK-DAG:  [[#TTDB+2]]: argc
 576 // CHECK-DAG:  [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
 577 // CHECK-DAG:   [B1]
 578 // CHECK-DAG:  [[#TTD:]]: cond
 579 // 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]]: fp
 582 // CHECK-DAG:  [[#TTD+4]]: rd
 583 // 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)
 594 void ttdpf(int argc) {
 595   int x, cond, fp, rd, lin, step_sz, map;
 596 // CHECK-DAG:   [B3]
 597 // CHECK-DAG:  [[#TTDPFB:]]: x
 598 // CHECK-DAG:  [[#TTDPFB+1]]: [B3.[[#TTDPFB]]] (ImplicitCastExpr, LValueToRValue, int)
 599 // CHECK-DAG:  [[#TTDPFB+2]]: argc
 600 // CHECK-DAG:  [[#TTDPFB+3]]: [B3.[[#TTDPFB+2]]] = [B3.[[#TTDPFB+1]]]
 601 // CHECK-DAG:   [B1]
 602 // CHECK-DAG:  [[#TTDPF:]]: cond
 603 // 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]]: fp
 606 // CHECK-DAG:  [[#TTDPF+4]]: rd
 607 // 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)
 618 void ttdpfs(int argc) {
 619   int x, cond, fp, rd, lin, step_sz, map;
 620 // CHECK-DAG:   [B3]
 621 // CHECK-DAG:  [[#TTDPFSB:]]: x
 622 // CHECK-DAG:  [[#TTDPFSB+1]]: [B3.[[#TTDPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
 623 // CHECK-DAG:  [[#TTDPFSB+2]]: argc
 624 // CHECK-DAG:  [[#TTDPFSB+3]]: [B3.[[#TTDPFSB+2]]] = [B3.[[#TTDPFSB+1]]]
 625 // CHECK-DAG:   [B1]
 626 // CHECK-DAG:  [[#TTDPFS:]]: cond
 627 // 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]]: fp
 630 // CHECK-DAG:  [[#TTDPFS+4]]: rd
 631 // 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)
 642 void ttds(int argc) {
 643   int x, cond, fp, rd, lin, step_sz, map;
 644 // CHECK-DAG:   [B3]
 645 // CHECK-DAG:  [[#TTDSB:]]: x
 646 // CHECK-DAG:  [[#TTDSB+1]]: [B3.[[#TTDSB]]] (ImplicitCastExpr, LValueToRValue, int)
 647 // CHECK-DAG:  [[#TTDSB+2]]: argc
 648 // CHECK-DAG:  [[#TTDSB+3]]: [B3.[[#TTDSB+2]]] = [B3.[[#TTDSB+1]]]
 649 // CHECK-DAG:   [B1]
 650 // CHECK-DAG:  [[#TTDS:]]: cond
 651 // 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]]: fp
 654 // CHECK-DAG:  [[#TTDS+4]]: rd
 655 // CHECK-DAG:  [[#TTDS+5]]: map
 656 // 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)
 667 void tl(int argc) {
 668   int x, cond, fp, rd, lin, step_sz, map;
 669 // CHECK-DAG:   [B3]
 670 // CHECK-DAG:  [[#TLB:]]: x
 671 // CHECK-DAG:  [[#TLB+1]]: [B3.[[#TLB]]] (ImplicitCastExpr, LValueToRValue, int)
 672 // CHECK-DAG:  [[#TLB+2]]: argc
 673 // CHECK-DAG:  [[#TLB+3]]: [B3.[[#TLB+2]]] = [B3.[[#TLB+1]]]
 674 // CHECK-DAG:   [B1]
 675 // CHECK-DAG:  [[#TL:]]: cond
 676 // 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]]: fp
 679 // CHECK-DAG:  [[#TL+4]]: rd
 680 // 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)
 691 void maskedtaskloop(int argc) {
 692   int x, cond, fp, rd, lin, step_sz, map;
 693 // CHECK-DAG:   [B3]
 694 // CHECK-DAG:  [[#MTLB:]]: x
 695 // CHECK-DAG:  [[#MTLB+1]]: [B3.[[#MTLB]]] (ImplicitCastExpr, LValueToRValue, int)
 696 // CHECK-DAG:  [[#MTLB+2]]: argc
 697 // CHECK-DAG:  [[#MTLB+3]]: [B3.[[#MTLB+2]]] = [B3.[[#MTLB+1]]]
 698 // CHECK-DAG:   [B1]
 699 // CHECK-DAG:  [[#MTL:]]: cond
 700 // 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]]: fp
 703 // CHECK-DAG:  [[#MTL+4]]: rd
 704 // 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)
 715 void parallelmaskedtaskloop(int argc) {
 716   int x, cond, fp, rd, lin, step_sz, map;
 717 // CHECK-DAG:   [B3]
 718 // CHECK-DAG:  [[#PMTLB:]]: x
 719 // CHECK-DAG:  [[#PMTLB+1]]: [B3.[[#PMTLB]]] (ImplicitCastExpr, LValueToRValue, int)
 720 // CHECK-DAG:  [[#PMTLB+2]]: argc
 721 // CHECK-DAG:  [[#PMTLB+3]]: [B3.[[#PMTLB+2]]] = [B3.[[#PMTLB+1]]]
 722 // CHECK-DAG:   [B1]
 723 // CHECK-DAG:  [[#PMTL:]]: cond
 724 // 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]]: fp
 727 // CHECK-DAG:  [[#PMTL+4]]: rd
 728 // 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)
 739 void parallelmaskedtasksimdloop(int argc) {
 740   int x, cond, fp, rd, lin, step_sz, map;
 741 // CHECK-DAG:   [B3]
 742 // CHECK-DAG:  [[#PMTLSB:]]: x
 743 // CHECK-DAG:  [[#PMTLSB+1]]: [B3.[[#PMTLSB]]] (ImplicitCastExpr, LValueToRValue, int)
 744 // CHECK-DAG:  [[#PMTLSB+2]]: argc
 745 // CHECK-DAG:  [[#PMTLSB+3]]: [B3.[[#PMTLSB+2]]] = [B3.[[#PMTLSB+1]]]
 746 // CHECK-DAG:   [B1]
 747 // CHECK-DAG:  [[#PMTLS:]]: cond
 748 // 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]]: fp
 751 // CHECK-DAG:  [[#PMTLS+4]]: rd
 752 // 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)
 763 void tls(int argc) {
 764   int x, cond, fp, rd, lin, step_sz, map;
 765 // CHECK-DAG:   [B3]
 766 // CHECK-DAG:  [[#TLSB:]]: x
 767 // CHECK-DAG:  [[#TLSB+1]]: [B3.[[#TLSB]]] (ImplicitCastExpr, LValueToRValue, int)
 768 // CHECK-DAG:  [[#TLSB+2]]: argc
 769 // CHECK-DAG:  [[#TLSB+3]]: [B3.[[#TLSB+2]]] = [B3.[[#TLSB+1]]]
 770 // CHECK-DAG:   [B1]
 771 // CHECK-DAG:  [[#TLS:]]: cond
 772 // 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]]: fp
 775 // CHECK-DAG:  [[#TLS+4]]: rd
 776 // CHECK-DAG:  [[#TLS+5]]: lin
 777 // CHECK-DAG:  [[#TLS+6]]: step_sz
 778 // 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)
 790 void maskedtaskloopsimd(int argc) {
 791   int x, cond, fp, rd, lin, step_sz, map;
 792 // CHECK-DAG:   [B3]
 793 // CHECK-DAG:  [[#MTLSB:]]: x
 794 // CHECK-DAG:  [[#MTLSB+1]]: [B3.[[#MTLSB]]] (ImplicitCastExpr, LValueToRValue, int)
 795 // CHECK-DAG:  [[#MTLSB+2]]: argc
 796 // CHECK-DAG:  [[#MTLSB+3]]: [B3.[[#MTLSB+2]]] = [B3.[[#MTLSB+1]]]
 797 // CHECK-DAG:   [B1]
 798 // CHECK-DAG:  [[#MTLS:]]: cond
 799 // 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]]: fp
 802 // CHECK-DAG:  [[#MTLS+4]]: rd
 803 // CHECK-DAG:  [[#MTLS+5]]: lin
 804 // CHECK-DAG:  [[#MTLS+6]]: step_sz
 805 // 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)
 817 void 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]]: cond
 829 // CHECK-DAG:  [[#TDPF+7]]: fp
 830 // CHECK-DAG:  [[#TDPF+8]]: rd
 831 // CHECK-DAG:  [[#TDPF+9]]: argc
 832 // CHECK-DAG:  [[#TDPF+10]]: x
 833 // CHECK-DAG:  [[#TDPF+11]]: #pragma omp target
 834 // CHECK-DAG:   [B3]
 835 // CHECK-DAG:  [[#TDPFB-3]]: x
 836 // CHECK-DAG:  [[#TDPFB-2]]: [B3.[[#TDPFB-3]]] (ImplicitCastExpr, LValueToRValue, int)
 837 // CHECK-DAG:  [[#TDPFB-1]]: argc
 838 // CHECK-DAG:  [[#TDPFB]]: [B3.[[#TDPFB-1]]] = [B3.[[#TDPFB-2]]]
 839 #pragma omp target
 840 #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)
 846 void 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]]: cond
 858 // CHECK-DAG:  [[#TDPFS+7]]: fp
 859 // CHECK-DAG:  [[#TDPFS+8]]: rd
 860 // CHECK-DAG:  [[#TDPFS+9]]: argc
 861 // CHECK-DAG:  [[#TDPFS+10]]: x
 862 // CHECK-DAG:  [[#TDPFS+11]]: #pragma omp target
 863 // CHECK-DAG:   [B3]
 864 // CHECK-DAG:  [[#TDPFSB-3]]: x
 865 // CHECK-DAG:  [[#TDPFSB-2]]: [B3.[[#TDPFSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
 866 // CHECK-DAG:  [[#TDPFSB-1]]: argc
 867 // CHECK-DAG:  [[#TDPFSB]]: [B3.[[#TDPFSB-1]]] = [B3.[[#TDPFSB-2]]]
 868 #pragma omp target
 869 #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)
 875 void 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]]: fp
 884 // CHECK-DAG:  [[#TDS+2]]: rd
 885 // CHECK-DAG:  [[#TDS+3]]: argc
 886 // CHECK-DAG:  [[#TDS+4]]: x
 887 // CHECK-DAG:  [[#TDS+5]]: #pragma omp target
 888 // CHECK-DAG:   [B3]
 889 // CHECK-DAG:  [[#TDSB-3]]: x
 890 // CHECK-DAG:  [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
 891 // CHECK-DAG:  [[#TDSB-1]]: argc
 892 // CHECK-DAG:  [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
 893 #pragma omp target
 894 #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)
 900 void 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]]: fp
 909 // CHECK-DAG:  [[#TDS+2]]: rd
 910 // CHECK-DAG:  [[#TDS+3]]: argc
 911 // CHECK-DAG:  [[#TDS+4]]: x
 912 // CHECK-DAG:  [[#TDS+5]]: #pragma omp target
 913 // CHECK-DAG:   [B3]
 914 // CHECK-DAG:  [[#TDSB-3]]: x
 915 // CHECK-DAG:  [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
 916 // CHECK-DAG:  [[#TDSB-1]]: argc
 917 // CHECK-DAG:  [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
 918 #pragma omp target
 919 #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)
 925 void targetteamsloop(int argc) {
 926   int x, cond, fp, rd, map;
 927 // CHECK-DAG:   [B3]
 928 // CHECK-DAG:  [[#TTDB:]]: x
 929 // CHECK-DAG:  [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
 930 // CHECK-DAG:  [[#TTDB+2]]: argc
 931 // CHECK-DAG:  [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
 932 // CHECK-DAG:   [B1]
 933 // CHECK-DAG:  [[#TTD:]]: cond
 934 // 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]]: fp
 937 // CHECK-DAG:  [[#TTD+4]]: rd
 938 // 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)
 949 void parallelloop(int argc) {
 950   int x, cond, fp, rd;
 951 // CHECK-DAG:   [B3]
 952 // CHECK-DAG:  [[#PFB:]]: x
 953 // CHECK-DAG:  [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
 954 // CHECK-DAG:  [[#PFB+2]]: argc
 955 // CHECK-DAG:  [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
 956 // CHECK-DAG:   [B1]
 957 // CHECK-DAG:  [[#PF:]]: cond
 958 // 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]]: fp
 961 // CHECK-DAG:  [[#PF+4]]: rd
 962 // 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)
 971 void targetparallelloop(int argc) {
 972   int x, cond, fp, rd, map;
 973 // CHECK-DAG:   [B3]
 974 // CHECK-DAG:  [[#TTDB:]]: x
 975 // CHECK-DAG:  [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
 976 // CHECK-DAG:  [[#TTDB+2]]: argc
 977 // CHECK-DAG:  [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
 978 // CHECK-DAG:   [B1]
 979 // CHECK-DAG:  [[#TTD:]]: cond
 980 // 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]]: fp
 983 // CHECK-DAG:  [[#TTD+4]]: rd
 984 // 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)
 995 void parallelmasked(int argc) {
 996   int x = 0;
 997 // CHECK:        [B1]
 998 // CHECK-NEXT:   1: 0
 999 // CHECK-NEXT:   2: int x = 0;
1000 // CHECK-NEXT:   [[#MASKED:]]: x
1001 // CHECK-NEXT:   [[#MASKED+1]]: [B1.[[#MASKED]]] (ImplicitCastExpr, LValueToRValue, int)
1002 // CHECK-NEXT:   [[#MASKED+2]]: argc
1003 // CHECK-NEXT:   [[#MASKED+3]]: [B1.[[#MASKED+2]]] = [B1.[[#MASKED+1]]]
1004 // CHECK-NEXT:   [[#MASKED+4]]: #pragma omp parallel masked
1005 #pragma omp parallel masked
1006   argc = x;
1007 }
1008 #endif  // _OPENMP