test/OpenMP/parallel_for_codegen.cpp

   1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
   2 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
   3 // RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
   4 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -debug-info-kind=line-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
   5 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -O1 -fopenmp -emit-llvm %s -o - | FileCheck %s --check-prefix=CLEANUP
   6
   7 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s
   8 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
   9 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  10 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp-simd -fexceptions -fcxx-exceptions -debug-info-kind=line-tables-only -x c++ -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  11 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -O1 -fopenmp-simd -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  12 // SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
  13 // expected-no-diagnostics
  14 #ifndef HEADER
  15 #define HEADER
  16
  17 // CHECK-DAG: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
  18 // CHECK-DAG: [[LOOP_LOC:@.+]] = private unnamed_addr constant [[IDENT_T_TY]] { i32 0, i32 514, i32 0, i32 0, i8*
  19
  20 // CHECK-LABEL: with_var_schedule
  21 void with_var_schedule() {
  22   double a = 5;
  23 // CHECK: [[CHUNK_SIZE:%.+]] = fptosi double %{{.+}}to i8
  24 // CHECK: store i8 %{{.+}}, i8* [[CHUNK:%.+]],
  25 // CHECK: [[VAL:%.+]] = load i8, i8* [[CHUNK]],
  26 // CHECK: store i8 [[VAL]], i8*
  27 // CHECK: [[CHUNK:%.+]] = load i64, i64* %
  28 // CHECK: call void {{.+}} @__kmpc_fork_call({{.+}}, i64 [[CHUNK]])
  29
  30 // CHECK: [[CHUNK_VAL:%.+]] = load i8, i8* %
  31 // CHECK: [[CHUNK_SIZE:%.+]] = sext i8 [[CHUNK_VAL]] to i64
  32 // CHECK: call void @__kmpc_for_static_init_8u([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID:%[^,]+]], i32 33, i32* [[IS_LAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]], i64 1, i64 [[CHUNK_SIZE]])
  33 // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]])
  34 #pragma omp parallel for schedule(static, char(a))
  35   for (unsigned long long i = 1; i < 2; ++i) {
  36   }
  37 }
  38
  39 // CHECK-LABEL: define {{.*void}} @{{.*}}without_schedule_clause{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
  40 void without_schedule_clause(float *a, float *b, float *c, float *d) {
  41   #pragma omp parallel for
  42 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]], i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, float**, float**, float**, float**)* [[OMP_PARALLEL_FUNC:@.+]] to void (i32*, i32*, ...)*),
  43 // CHECK: define internal void [[OMP_PARALLEL_FUNC]](i32* noalias [[GTID_PARAM_ADDR:%.+]], i32* noalias %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}})
  44 // CHECK: store i32* [[GTID_PARAM_ADDR]], i32** [[GTID_REF_ADDR:%.+]],
  45 // CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID:%.+]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1)
  46 // UB = min(UB, GlobalUB)
  47 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
  48 // CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423
  49 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
  50 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
  51 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
  52 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
  53 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
  54 // Loop header
  55 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
  56 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
  57 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
  58 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
  59   for (int i = 33; i < 32000000; i += 7) {
  60 // CHECK: [[LOOP1_BODY]]
  61 // Start of body: calculate i from IV:
  62 // CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
  63 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7
  64 // CHECK-NEXT: [[CALC_I_2:%.+]] = add nsw i32 33, [[CALC_I_1]]
  65 // CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
  66 // ... loop body ...
  67 // End of body: store into a[i]:
  68 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
  69     a[i] = b[i] * c[i] * d[i];
  70 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
  71 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
  72 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
  73 // CHECK-NEXT: br label %{{.+}}
  74   }
  75 // CHECK: [[LOOP1_END]]
  76 // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]])
  77 // CHECK: ret void
  78 }
  79
  80 // CHECK-LABEL: define {{.*void}} @{{.*}}static_not_chunked{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
  81 void static_not_chunked(float *a, float *b, float *c, float *d) {
  82   #pragma omp parallel for schedule(static)
  83 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]], i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, float**, float**, float**, float**)* [[OMP_PARALLEL_FUNC:@.+]] to void (i32*, i32*, ...)*),
  84 // CHECK: define internal void [[OMP_PARALLEL_FUNC]](i32* noalias [[GTID_PARAM_ADDR:%.+]], i32* noalias %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}})
  85 // CHECK: store i32* [[GTID_PARAM_ADDR]], i32** [[GTID_REF_ADDR:%.+]],
  86 // CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID:%.+]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1)
  87 // UB = min(UB, GlobalUB)
  88 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
  89 // CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423
  90 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
  91 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
  92 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
  93 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
  94 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
  95 // Loop header
  96 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
  97 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
  98 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
  99 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
 100   for (int i = 32000000; i > 33; i += -7) {
 101 // CHECK: [[LOOP1_BODY]]
 102 // Start of body: calculate i from IV:
 103 // CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
 104 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7
 105 // CHECK-NEXT: [[CALC_I_2:%.+]] = sub nsw i32 32000000, [[CALC_I_1]]
 106 // CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
 107 // ... loop body ...
 108 // End of body: store into a[i]:
 109 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
 110     a[i] = b[i] * c[i] * d[i];
 111 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
 112 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
 113 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
 114 // CHECK-NEXT: br label %{{.+}}
 115   }
 116 // CHECK: [[LOOP1_END]]
 117 // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]])
 118 // CHECK: ret void
 119 }
 120
 121 // CHECK-LABEL: define {{.*void}} @{{.*}}static_chunked{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
 122 void static_chunked(float *a, float *b, float *c, float *d) {
 123   #pragma omp parallel for schedule(static, 5)
 124 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]], i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, float**, float**, float**, float**)* [[OMP_PARALLEL_FUNC:@.+]] to void (i32*, i32*, ...)*),
 125 // CHECK: define internal void [[OMP_PARALLEL_FUNC]](i32* noalias [[GTID_PARAM_ADDR:%.+]], i32* noalias %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}})
 126 // CHECK: store i32* [[GTID_PARAM_ADDR]], i32** [[GTID_REF_ADDR:%.+]],
 127 // CHECK: call void @__kmpc_for_static_init_4u([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID:%.+]], i32 33, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 5)
 128 // UB = min(UB, GlobalUB)
 129 // CHECK: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
 130 // CHECK-NEXT: [[UBCMP:%.+]] = icmp ugt i32 [[UB]], 16908288
 131 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
 132 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 16908288, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
 133 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
 134 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
 135 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
 136
 137 // Outer loop header
 138 // CHECK: [[O_IV:%.+]] = load i32, i32* [[OMP_IV]]
 139 // CHECK-NEXT: [[O_UB:%.+]] = load i32, i32* [[OMP_UB]]
 140 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ule i32 [[O_IV]], [[O_UB]]
 141 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
 142
 143 // Loop header
 144 // CHECK: [[O_LOOP1_BODY]]
 145 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
 146 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
 147 // CHECK-NEXT: [[CMP:%.+]] = icmp ule i32 [[IV]], [[UB]]
 148 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
 149   for (unsigned i = 131071; i <= 2147483647; i += 127) {
 150 // CHECK: [[LOOP1_BODY]]
 151 // Start of body: calculate i from IV:
 152 // CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
 153 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul i32 [[IV1_1]], 127
 154 // CHECK-NEXT: [[CALC_I_2:%.+]] = add i32 131071, [[CALC_I_1]]
 155 // CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
 156 // ... loop body ...
 157 // End of body: store into a[i]:
 158 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
 159     a[i] = b[i] * c[i] * d[i];
 160 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
 161 // CHECK-NEXT: [[ADD1_2:%.+]] = add i32 [[IV1_2]], 1
 162 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
 163 // CHECK-NEXT: br label %{{.+}}
 164   }
 165 // CHECK: [[LOOP1_END]]
 166 // Update the counters, adding stride
 167 // CHECK:  [[LB:%.+]] = load i32, i32* [[OMP_LB]]
 168 // CHECK-NEXT: [[ST:%.+]] = load i32, i32* [[OMP_ST]]
 169 // CHECK-NEXT: [[ADD_LB:%.+]] = add i32 [[LB]], [[ST]]
 170 // CHECK-NEXT: store i32 [[ADD_LB]], i32* [[OMP_LB]]
 171 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
 172 // CHECK-NEXT: [[ST:%.+]] = load i32, i32* [[OMP_ST]]
 173 // CHECK-NEXT: [[ADD_UB:%.+]] = add i32 [[UB]], [[ST]]
 174 // CHECK-NEXT: store i32 [[ADD_UB]], i32* [[OMP_UB]]
 175
 176 // CHECK: [[O_LOOP1_END]]
 177 // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]])
 178 // CHECK: ret void
 179 }
 180
 181 // CHECK-LABEL: define {{.*void}} @{{.*}}dynamic1{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
 182 void dynamic1(float *a, float *b, float *c, float *d) {
 183   #pragma omp parallel for schedule(dynamic)
 184 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]], i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, float**, float**, float**, float**)* [[OMP_PARALLEL_FUNC:@.+]] to void (i32*, i32*, ...)*),
 185 // CHECK: define internal void [[OMP_PARALLEL_FUNC]](i32* noalias [[GTID_PARAM_ADDR:%.+]], i32* noalias %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}})
 186 // CHECK: store i32* [[GTID_PARAM_ADDR]], i32** [[GTID_REF_ADDR:%.+]],
 187 // CHECK: call void @__kmpc_dispatch_init_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID:%.+]], i32 35, i64 0, i64 16908287, i64 1, i64 1)
 188 //
 189 // CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]])
 190 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
 191 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
 192
 193 // Loop header
 194 // CHECK: [[O_LOOP1_BODY]]
 195 // CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
 196 // CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
 197 // CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
 198
 199 // CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
 200 // CHECK-NEXT: [[CMP:%.+]] = icmp ule i64 [[IV]], [[UB]]
 201 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
 202   for (unsigned long long i = 131071; i < 2147483647; i += 127) {
 203 // CHECK: [[LOOP1_BODY]]
 204 // Start of body: calculate i from IV:
 205 // CHECK: [[IV1_1:%.+]] = load i64, i64* [[OMP_IV]]
 206 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul i64 [[IV1_1]], 127
 207 // CHECK-NEXT: [[CALC_I_2:%.+]] = add i64 131071, [[CALC_I_1]]
 208 // CHECK-NEXT: store i64 [[CALC_I_2]], i64* [[LC_I:.+]]
 209 // ... loop body ...
 210 // End of body: store into a[i]:
 211 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
 212     a[i] = b[i] * c[i] * d[i];
 213 // CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
 214 // CHECK-NEXT: [[ADD1_2:%.+]] = add i64 [[IV1_2]], 1
 215 // CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
 216 // CHECK-NEXT: br label %{{.+}}
 217   }
 218 // CHECK: [[LOOP1_END]]
 219 // CHECK: [[O_LOOP1_END]]
 220 // CHECK: ret void
 221 }
 222
 223 // CHECK-LABEL: define {{.*void}} @{{.*}}guided7{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
 224 void guided7(float *a, float *b, float *c, float *d) {
 225   #pragma omp parallel for schedule(guided, 7)
 226 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]], i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, float**, float**, float**, float**)* [[OMP_PARALLEL_FUNC:@.+]] to void (i32*, i32*, ...)*),
 227 // CHECK: define internal void [[OMP_PARALLEL_FUNC]](i32* noalias [[GTID_PARAM_ADDR:%.+]], i32* noalias %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}})
 228 // CHECK: store i32* [[GTID_PARAM_ADDR]], i32** [[GTID_REF_ADDR:%.+]],
 229 // CHECK: call void @__kmpc_dispatch_init_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID:%.+]], i32 36, i64 0, i64 16908287, i64 1, i64 7)
 230 //
 231 // CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]])
 232 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
 233 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
 234
 235 // Loop header
 236 // CHECK: [[O_LOOP1_BODY]]
 237 // CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
 238 // CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
 239 // CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
 240
 241 // CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
 242 // CHECK-NEXT: [[CMP:%.+]] = icmp ule i64 [[IV]], [[UB]]
 243 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
 244   for (unsigned long long i = 131071; i < 2147483647; i += 127) {
 245 // CHECK: [[LOOP1_BODY]]
 246 // Start of body: calculate i from IV:
 247 // CHECK: [[IV1_1:%.+]] = load i64, i64* [[OMP_IV]]
 248 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul i64 [[IV1_1]], 127
 249 // CHECK-NEXT: [[CALC_I_2:%.+]] = add i64 131071, [[CALC_I_1]]
 250 // CHECK-NEXT: store i64 [[CALC_I_2]], i64* [[LC_I:.+]]
 251 // ... loop body ...
 252 // End of body: store into a[i]:
 253 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
 254     a[i] = b[i] * c[i] * d[i];
 255 // CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
 256 // CHECK-NEXT: [[ADD1_2:%.+]] = add i64 [[IV1_2]], 1
 257 // CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
 258 // CHECK-NEXT: br label %{{.+}}
 259   }
 260 // CHECK: [[LOOP1_END]]
 261 // CHECK: [[O_LOOP1_END]]
 262 // CHECK: ret void
 263 }
 264
 265 // CHECK-LABEL: define {{.*void}} @{{.*}}test_auto{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
 266 void test_auto(float *a, float *b, float *c, float *d) {
 267   unsigned int x = 0;
 268   unsigned int y = 0;
 269   #pragma omp parallel for schedule(auto) collapse(2)
 270 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]], i32 6, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, i32*, i32*, float**, float**, float**, float**)* [[OMP_PARALLEL_FUNC:@.+]] to void (i32*, i32*, ...)*),
 271 // CHECK: define internal void [[OMP_PARALLEL_FUNC]](i32* noalias [[GTID_PARAM_ADDR:%.+]], i32* noalias %{{.+}}, i32* dereferenceable(4) %{{.+}}, i32* dereferenceable(4) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}})
 272 // CHECK: store i32* [[GTID_PARAM_ADDR]], i32** [[GTID_REF_ADDR:%.+]],
 273 // CHECK: call void @__kmpc_dispatch_init_8([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID:%.+]], i32 38, i64 0, i64 [[LAST_ITER:%[^,]+]], i64 1, i64 1)
 274 //
 275 // CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_8([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]])
 276 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
 277 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
 278
 279 // Loop header
 280 // CHECK: [[O_LOOP1_BODY]]
 281 // CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
 282 // CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
 283 // CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
 284
 285 // CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
 286 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i64 [[IV]], [[UB]]
 287 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
 288 // FIXME: When the iteration count of some nested loop is not a known constant,
 289 // we should pre-calculate it, like we do for the total number of iterations!
 290   for (char i = static_cast<char>(y); i <= '9'; ++i)
 291     for (x = 11; x > 0; --x) {
 292 // CHECK: [[LOOP1_BODY]]
 293 // Start of body: indices are calculated from IV:
 294 // CHECK: store i8 {{%[^,]+}}, i8* {{%[^,]+}}
 295 // CHECK: store i32 {{%[^,]+}}, i32* {{%[^,]+}}
 296 // ... loop body ...
 297 // End of body: store into a[i]:
 298 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
 299     a[i] = b[i] * c[i] * d[i];
 300 // CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
 301 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i64 [[IV1_2]], 1
 302 // CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
 303 // CHECK-NEXT: br label %{{.+}}
 304   }
 305 // CHECK: [[LOOP1_END]]
 306 // CHECK: [[O_LOOP1_END]]
 307 // CHECK: ret void
 308 }
 309
 310 // CHECK-LABEL: define {{.*void}} @{{.*}}runtime{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
 311 void runtime(float *a, float *b, float *c, float *d) {
 312   int x = 0;
 313   #pragma omp parallel for collapse(2) schedule(runtime)
 314 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]], i32 5, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, i32*, float**, float**, float**, float**)* [[OMP_PARALLEL_FUNC:@.+]] to void (i32*, i32*, ...)*),
 315 // CHECK: define internal void [[OMP_PARALLEL_FUNC]](i32* noalias [[GTID_PARAM_ADDR:%.+]], i32* noalias %{{.+}}, i32* dereferenceable(4) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}}, float** dereferenceable(8) %{{.+}})
 316 // CHECK: store i32* [[GTID_PARAM_ADDR]], i32** [[GTID_REF_ADDR:%.+]],
 317 // CHECK: call void @__kmpc_dispatch_init_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID:%.+]], i32 37, i32 0, i32 199, i32 1, i32 1)
 318 //
 319 // CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]])
 320 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
 321 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
 322
 323 // Loop header
 324 // CHECK: [[O_LOOP1_BODY]]
 325 // CHECK: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
 326 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
 327 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
 328
 329 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
 330 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
 331 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
 332   for (unsigned char i = '0' ; i <= '9'; ++i)
 333     for (x = -10; x < 10; ++x) {
 334 // CHECK: [[LOOP1_BODY]]
 335 // Start of body: indices are calculated from IV:
 336 // CHECK: store i8 {{%[^,]+}}, i8* {{%[^,]+}}
 337 // CHECK: store i32 {{%[^,]+}}, i32* {{%[^,]+}}
 338 // ... loop body ...
 339 // End of body: store into a[i]:
 340 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
 341     a[i] = b[i] * c[i] * d[i];
 342 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
 343 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
 344 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
 345 // CHECK-NEXT: br label %{{.+}}
 346   }
 347 // CHECK: [[LOOP1_END]]
 348 // CHECK: [[O_LOOP1_END]]
 349 // CHECK: ret void
 350 }
 351
 352 // TERM_DEBUG-LABEL: foo
 353 int foo() {return 0;};
 354
 355 // TERM_DEBUG-LABEL: parallel_for
 356 // CLEANUP: parallel_for
 357 void parallel_for(float *a, const int n) {
 358   float arr[n];
 359 #pragma omp parallel for schedule(static, 5) private(arr) default(none) firstprivate(n) shared(a)
 360   // TERM_DEBUG-NOT: __kmpc_global_thread_num
 361   // TERM_DEBUG:     call void @__kmpc_for_static_init_4u({{.+}}), !dbg [[DBG_LOC_START:![0-9]+]]
 362   // TERM_DEBUG:     invoke i32 {{.*}}foo{{.*}}()
 363   // TERM_DEBUG:     unwind label %[[TERM_LPAD:.+]],
 364   // TERM_DEBUG-NOT: __kmpc_global_thread_num
 365   // TERM_DEBUG:     call void @__kmpc_for_static_fini({{.+}}), !dbg [[DBG_LOC_END:![0-9]+]]
 366   // TERM_DEBUG:     [[TERM_LPAD]]
 367   // TERM_DEBUG:     call void @__clang_call_terminate
 368   // TERM_DEBUG:     unreachable
 369   // CLEANUP-NOT: __kmpc_global_thread_num
 370   // CLEANUP:     call void @__kmpc_for_static_init_4u({{.+}})
 371   // CLEANUP:     call void @__kmpc_for_static_fini({{.+}})
 372   for (unsigned i = 131071; i <= 2147483647; i += 127)
 373     a[i] += foo() + arr[i] + n;
 374 }
 375 // Check source line corresponds to "#pragma omp parallel for schedule(static, 5)" above:
 376 // TERM_DEBUG-DAG: [[DBG_LOC_START]] = !DILocation(line: [[@LINE-4]],
 377 // TERM_DEBUG-DAG: [[DBG_LOC_END]] = !DILocation(line: [[@LINE-18]],
 378
 379 #endif // HEADER
 380