test/OpenMP/for_reduction_codegen.cpp

   1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck %s
   2 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-apple-darwin10 -emit-pch -o %t %s
   3 // RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-apple-darwin10 -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
   4 // RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11 -DLAMBDA -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=LAMBDA %s
   5 // RUN: %clang_cc1 -verify -fopenmp -x c++ -fblocks -DBLOCKS -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=BLOCKS %s
   6 // expected-no-diagnostics
   7 #ifndef HEADER
   8 #define HEADER
   9
  10 volatile double g, g_orig;
  11 volatile double &g1 = g_orig;
  12
  13 template <class T>
  14 struct S {
  15   T f;
  16   S(T a) : f(a + g) {}
  17   S() : f(g) {}
  18   operator T() { return T(); }
  19   S &operator&(const S &) { return *this; }
  20   ~S() {}
  21 };
  22
  23 // CHECK-DAG: [[S_FLOAT_TY:%.+]] = type { float }
  24 // CHECK-DAG: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} }
  25 // CHECK-DAG: [[ATOMIC_REDUCE_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 18, i32 0, i32 0, i8*
  26 // CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*
  27 // CHECK-DAG: [[REDUCTION_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 18, i32 0, i32 0, i8*
  28 // CHECK-DAG: [[REDUCTION_LOCK:@.+]] = common global [8 x i32] zeroinitializer
  29
  30 template <typename T>
  31 T tmain() {
  32   T t;
  33   S<T> test;
  34   T t_var = T(), t_var1;
  35   T vec[] = {1, 2};
  36   S<T> s_arr[] = {1, 2};
  37   S<T> &var = test;
  38   S<T> var1;
  39 #pragma omp parallel
  40 #pragma omp for reduction(+:t_var) reduction(&:var) reduction(&& : var1) reduction(min: t_var1) nowait
  41   for (int i = 0; i < 2; ++i) {
  42     vec[i] = t_var;
  43     s_arr[i] = var;
  44   }
  45 #pragma omp parallel
  46 #pragma omp for reduction(&& : t_var)
  47   for (int i = 0; i < 2; ++i) {
  48     vec[i] = t_var;
  49     s_arr[i] = var;
  50   }
  51   return T();
  52 }
  53
  54 extern S<float> **foo();
  55
  56 int main() {
  57 #ifdef LAMBDA
  58   // LAMBDA: [[G:@.+]] = global double
  59   // LAMBDA-LABEL: @main
  60   // LAMBDA: call void [[OUTER_LAMBDA:@.+]](
  61   [&]() {
  62   // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
  63   // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
  64 #pragma omp parallel
  65 #pragma omp for reduction(+:g, g1)
  66     for (int i = 0; i < 2; ++i) {
  67     // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* noalias %{{.+}}, i32* noalias %{{.+}})
  68     // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca double,
  69
  70     // Reduction list for runtime.
  71     // LAMBDA: [[RED_LIST:%.+]] = alloca [2 x i8*],
  72
  73     // LAMBDA: store double 0.0{{.+}}, double* [[G_PRIVATE_ADDR]]
  74     // LAMBDA: call void @__kmpc_for_static_init_4(
  75     g = 1;
  76     g1 = 1;
  77     // LAMBDA: store double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]],
  78     // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
  79     // LAMBDA: store double* [[G_PRIVATE_ADDR]], double** [[G_PRIVATE_ADDR_REF]]
  80     // LAMBDA: call void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]])
  81     // LAMBDA: call void @__kmpc_for_static_fini(
  82
  83     // LAMBDA: [[G_PRIV_REF:%.+]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[RED_LIST]], i64 0, i64 0
  84     // LAMBDA: [[BITCAST:%.+]] = bitcast double* [[G_PRIVATE_ADDR]] to i8*
  85     // LAMBDA: store i8* [[BITCAST]], i8** [[G_PRIV_REF]],
  86     // LAMBDA: call i32 @__kmpc_reduce(
  87     // LAMBDA: switch i32 %{{.+}}, label %[[REDUCTION_DONE:.+]] [
  88     // LAMBDA: i32 1, label %[[CASE1:.+]]
  89     // LAMBDA: i32 2, label %[[CASE2:.+]]
  90     // LAMBDA: [[CASE1]]
  91     // LAMBDA: [[G_VAL:%.+]] = load double, double* [[G]]
  92     // LAMBDA: [[G_PRIV_VAL:%.+]] = load double, double* [[G_PRIVATE_ADDR]]
  93     // LAMBDA: [[ADD:%.+]] = fadd double [[G_VAL]], [[G_PRIV_VAL]]
  94     // LAMBDA: store double [[ADD]], double* [[G]]
  95     // LAMBDA: call void @__kmpc_end_reduce(
  96     // LAMBDA: br label %[[REDUCTION_DONE]]
  97     // LAMBDA: [[CASE2]]
  98     // LAMBDA: [[G_PRIV_VAL:%.+]] = load double, double* [[G_PRIVATE_ADDR]]
  99     // LAMBDA: fadd double
 100     // LAMBDA: cmpxchg i64*
 101     // LAMBDA: call void @__kmpc_end_reduce(
 102     // LAMBDA: br label %[[REDUCTION_DONE]]
 103     // LAMBDA: [[REDUCTION_DONE]]
 104     // LAMBDA: ret void
 105     [&]() {
 106       // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]])
 107       // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]],
 108       g = 2;
 109       g1 = 2;
 110       // LAMBDA: [[ARG_PTR:%.+]] = load %{{.+}}*, %{{.+}}** [[ARG_PTR_REF]]
 111       // LAMBDA: [[G_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
 112       // LAMBDA: [[G_REF:%.+]] = load double*, double** [[G_PTR_REF]]
 113       // LAMBDA: store double 2.0{{.+}}, double* [[G_REF]]
 114     }();
 115   }
 116   }();
 117   return 0;
 118 #elif defined(BLOCKS)
 119   // BLOCKS: [[G:@.+]] = global double
 120   // BLOCKS-LABEL: @main
 121   // BLOCKS: call void {{%.+}}(i8
 122   ^{
 123   // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
 124   // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
 125 #pragma omp parallel
 126 #pragma omp for reduction(-:g, g1)
 127     for (int i = 0; i < 2; ++i)  {
 128     // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* noalias %{{.+}}, i32* noalias %{{.+}})
 129     // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca double,
 130
 131     // Reduction list for runtime.
 132     // BLOCKS: [[RED_LIST:%.+]] = alloca [2 x i8*],
 133
 134     // BLOCKS: store double 0.0{{.+}}, double* [[G_PRIVATE_ADDR]]
 135     g = 1;
 136     g1 = 1;
 137     // BLOCKS: call void @__kmpc_for_static_init_4(
 138     // BLOCKS: store double 1.0{{.+}}, double* [[G_PRIVATE_ADDR]],
 139     // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
 140     // BLOCKS: double* [[G_PRIVATE_ADDR]]
 141     // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
 142     // BLOCKS: call void {{%.+}}(i8
 143     // BLOCKS: call void @__kmpc_for_static_fini(
 144
 145     // BLOCKS: [[G_PRIV_REF:%.+]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[RED_LIST]], i64 0, i64 0
 146     // BLOCKS: [[BITCAST:%.+]] = bitcast double* [[G_PRIVATE_ADDR]] to i8*
 147     // BLOCKS: store i8* [[BITCAST]], i8** [[G_PRIV_REF]],
 148     // BLOCKS: call i32 @__kmpc_reduce(
 149     // BLOCKS: switch i32 %{{.+}}, label %[[REDUCTION_DONE:.+]] [
 150     // BLOCKS: i32 1, label %[[CASE1:.+]]
 151     // BLOCKS: i32 2, label %[[CASE2:.+]]
 152     // BLOCKS: [[CASE1]]
 153     // BLOCKS: [[G_VAL:%.+]] = load double, double* [[G]]
 154     // BLOCKS: [[G_PRIV_VAL:%.+]] = load double, double* [[G_PRIVATE_ADDR]]
 155     // BLOCKS: [[ADD:%.+]] = fadd double [[G_VAL]], [[G_PRIV_VAL]]
 156     // BLOCKS: store double [[ADD]], double* [[G]]
 157     // BLOCKS: call void @__kmpc_end_reduce(
 158     // BLOCKS: br label %[[REDUCTION_DONE]]
 159     // BLOCKS: [[CASE2]]
 160     // BLOCKS: [[G_PRIV_VAL:%.+]] = load double, double* [[G_PRIVATE_ADDR]]
 161     // BLOCKS: fadd double
 162     // BLOCKS: cmpxchg i64*
 163     // BLOCKS: call void @__kmpc_end_reduce(
 164     // BLOCKS: br label %[[REDUCTION_DONE]]
 165     // BLOCKS: [[REDUCTION_DONE]]
 166     // BLOCKS: ret void
 167     ^{
 168       // BLOCKS: define {{.+}} void {{@.+}}(i8*
 169       g = 2;
 170       g1 = 2;
 171       // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
 172       // BLOCKS: store double 2.0{{.+}}, double*
 173       // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
 174       // BLOCKS: ret
 175     }();
 176   }
 177   }();
 178   return 0;
 179 #else
 180   S<float> test;
 181   float t_var = 0, t_var1;
 182   int vec[] = {1, 2};
 183   S<float> s_arr[] = {1, 2};
 184   S<float> &var = test;
 185   S<float> var1, arrs[10][4];
 186   S<float> **var2 = foo();
 187   S<float> vvar2[2];
 188   S<float> (&var3)[2] = s_arr;
 189 #pragma omp parallel
 190 #pragma omp for reduction(+:t_var) reduction(&:var) reduction(&& : var1) reduction(min: t_var1)
 191   for (int i = 0; i < 2; ++i) {
 192     vec[i] = t_var;
 193     s_arr[i] = var;
 194   }
 195   int arr[10][vec[1]];
 196 #pragma omp parallel for reduction(+:arr[1][:vec[1]]) reduction(&:arrs[1:vec[1]][1:2])
 197   for (int i = 0; i < 10; ++i)
 198     ++arr[1][i];
 199 #pragma omp parallel
 200 #pragma omp for reduction(+:arr) reduction(&:arrs)
 201   for (int i = 0; i < 10; ++i)
 202     ++arr[1][i];
 203 #pragma omp parallel
 204 #pragma omp for reduction(& : var2[0 : 5][1 : 6])
 205   for (int i = 0; i < 10; ++i)
 206     ;
 207 #pragma omp parallel
 208 #pragma omp for reduction(& : vvar2[0 : 5])
 209   for (int i = 0; i < 10; ++i)
 210     ;
 211 #pragma omp parallel
 212 #pragma omp for reduction(& : var3[1 : 2])
 213   for (int i = 0; i < 10; ++i)
 214     ;
 215 #pragma omp parallel
 216 #pragma omp for reduction(& : var3)
 217   for (int i = 0; i < 10; ++i)
 218     ;
 219   return tmain<int>();
 220 #endif
 221 }
 222
 223 // CHECK: define {{.*}}i{{[0-9]+}} @main()
 224 // CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]],
 225 // CHECK: call {{.*}} [[S_FLOAT_TY_CONSTR:@.+]]([[S_FLOAT_TY]]* [[TEST]])
 226 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 6, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, float*, [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]*, float*, [2 x i32]*, [2 x [[S_FLOAT_TY]]]*)* [[MAIN_MICROTASK:@.+]] to void
 227 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 5, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, i64, i64, i32*, [2 x i32]*, [10 x [4 x [[S_FLOAT_TY]]]]*)* [[MAIN_MICROTASK1:@.+]] to void
 228 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 4, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, i64, i64, i32*, [10 x [4 x [[S_FLOAT_TY]]]]*)* [[MAIN_MICROTASK2:@.+]] to void
 229 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[S_FLOAT_TY]]***)* [[MAIN_MICROTASK3:@.+]] to void
 230 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [2 x [[S_FLOAT_TY]]]*)* [[MAIN_MICROTASK4:@.+]] to void
 231 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [2 x [[S_FLOAT_TY]]]*)* [[MAIN_MICROTASK5:@.+]] to void
 232 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [2 x [[S_FLOAT_TY]]]*)* [[MAIN_MICROTASK6:@.+]] to void
 233 // CHECK: = call {{.*}}i{{.+}} [[TMAIN_INT:@.+]]()
 234 // CHECK: call {{.*}} [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]*
 235 // CHECK: ret
 236 //
 237 // CHECK: define internal void [[MAIN_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, float* dereferenceable(4) %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}}, float* dereferenceable(4) %{{.+}}, [2 x i32]* dereferenceable(8) %vec, [2 x [[S_FLOAT_TY]]]* dereferenceable(8) %{{.+}})
 238 // CHECK: [[T_VAR_PRIV:%.+]] = alloca float,
 239 // CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]],
 240 // CHECK: [[VAR1_PRIV:%.+]] = alloca [[S_FLOAT_TY]],
 241 // CHECK: [[T_VAR1_PRIV:%.+]] = alloca float,
 242
 243 // Reduction list for runtime.
 244 // CHECK: [[RED_LIST:%.+]] = alloca [4 x i8*],
 245
 246 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
 247
 248 // CHECK: [[T_VAR_REF:%.+]] = load float*, float** %
 249 // CHECK: [[VAR1_REF:%.+]] = load [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** %
 250 // CHECK: [[T_VAR1_REF:%.+]] = load float*, float** %
 251
 252 // For + reduction operation initial value of private variable is 0.
 253 // CHECK: store float 0.0{{.+}}, float* [[T_VAR_PRIV]],
 254
 255 // For & reduction operation initial value of private variable is ones in all bits.
 256 // CHECK: [[VAR_REF:%.+]] = load [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** %
 257 // CHECK: call {{.*}} [[S_FLOAT_TY_CONSTR:@.+]]([[S_FLOAT_TY]]* [[VAR_PRIV]])
 258
 259 // For && reduction operation initial value of private variable is 1.0.
 260 // CHECK: call {{.*}} [[S_FLOAT_TY_CONSTR:@.+]]([[S_FLOAT_TY]]* [[VAR1_PRIV]])
 261
 262 // For min reduction operation initial value of private variable is largest repesentable value.
 263 // CHECK: store float 0x47EFFFFFE0000000, float* [[T_VAR1_PRIV]],
 264
 265
 266 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]]
 267 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
 268 // CHECK: call void @__kmpc_for_static_init_4(
 269 // Skip checks for internal operations.
 270 // CHECK: call void @__kmpc_for_static_fini(
 271
 272 // void *RedList[<n>] = {<ReductionVars>[0], ..., <ReductionVars>[<n>-1]};
 273
 274 // CHECK: [[T_VAR_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 0
 275 // CHECK: [[BITCAST:%.+]] = bitcast float* [[T_VAR_PRIV]] to i8*
 276 // CHECK: store i8* [[BITCAST]], i8** [[T_VAR_PRIV_REF]],
 277 // CHECK: [[VAR_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 1
 278 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR_PRIV]] to i8*
 279 // CHECK: store i8* [[BITCAST]], i8** [[VAR_PRIV_REF]],
 280 // CHECK: [[VAR1_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 2
 281 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR1_PRIV]] to i8*
 282 // CHECK: store i8* [[BITCAST]], i8** [[VAR1_PRIV_REF]],
 283 // CHECK: [[T_VAR1_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 3
 284 // CHECK: [[BITCAST:%.+]] = bitcast float* [[T_VAR1_PRIV]] to i8*
 285 // CHECK: store i8* [[BITCAST]], i8** [[T_VAR1_PRIV_REF]],
 286
 287 // res = __kmpc_reduce(<loc>, <gtid>, <n>, sizeof(RedList), RedList, reduce_func, &<lock>);
 288
 289 // CHECK: [[BITCAST:%.+]] = bitcast [4 x i8*]* [[RED_LIST]] to i8*
 290 // CHECK: [[RES:%.+]] = call i32 @__kmpc_reduce(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], i32 4, i64 32, i8* [[BITCAST]], void (i8*, i8*)* [[REDUCTION_FUNC:@.+]], [8 x i32]* [[REDUCTION_LOCK]])
 291
 292 // switch(res)
 293 // CHECK: switch i32 [[RES]], label %[[RED_DONE:.+]] [
 294 // CHECK: i32 1, label %[[CASE1:.+]]
 295 // CHECK: i32 2, label %[[CASE2:.+]]
 296 // CHECK: ]
 297
 298 // case 1:
 299 // t_var += t_var_reduction;
 300 // CHECK: [[T_VAR_VAL:%.+]] = load float, float* [[T_VAR_REF]],
 301 // CHECK: [[T_VAR_PRIV_VAL:%.+]] = load float, float* [[T_VAR_PRIV]],
 302 // CHECK: [[UP:%.+]] = fadd float [[T_VAR_VAL]], [[T_VAR_PRIV_VAL]]
 303 // CHECK: store float [[UP]], float* [[T_VAR_REF]],
 304
 305 // var = var.operator &(var_reduction);
 306 // CHECK: [[UP:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @{{.+}}([[S_FLOAT_TY]]* [[VAR_REF]], [[S_FLOAT_TY]]* dereferenceable(4) [[VAR_PRIV]])
 307 // CHECK: [[BC1:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR_REF]] to i8*
 308 // CHECK: [[BC2:%.+]] = bitcast [[S_FLOAT_TY]]* [[UP]] to i8*
 309 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
 310
 311 // var1 = var1.operator &&(var1_reduction);
 312 // CHECK: [[TO_FLOAT:%.+]] = call float @{{.+}}([[S_FLOAT_TY]]* [[VAR1_REF]])
 313 // CHECK: [[VAR1_BOOL:%.+]] = fcmp une float [[TO_FLOAT]], 0.0
 314 // CHECK: br i1 [[VAR1_BOOL]], label %[[TRUE:.+]], label %[[END2:.+]]
 315 // CHECK: [[TRUE]]
 316 // CHECK: [[TO_FLOAT:%.+]] = call float @{{.+}}([[S_FLOAT_TY]]* [[VAR1_PRIV]])
 317 // CHECK: [[VAR1_REDUCTION_BOOL:%.+]] = fcmp une float [[TO_FLOAT]], 0.0
 318 // CHECK: br label %[[END2]]
 319 // CHECK: [[END2]]
 320 // CHECK: [[COND_LVALUE:%.+]] = phi i1 [ false, %{{.+}} ], [ [[VAR1_REDUCTION_BOOL]], %[[TRUE]] ]
 321 // CHECK: [[CONV:%.+]] = uitofp i1 [[COND_LVALUE]] to float
 322 // CHECK:  call void @{{.+}}([[S_FLOAT_TY]]* [[COND_LVALUE:%.+]], float [[CONV]])
 323 // CHECK: [[BC1:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR1_REF]] to i8*
 324 // CHECK: [[BC2:%.+]] = bitcast [[S_FLOAT_TY]]* [[COND_LVALUE]] to i8*
 325 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
 326
 327 // t_var1 = min(t_var1, t_var1_reduction);
 328 // CHECK: [[T_VAR1_VAL:%.+]] = load float, float* [[T_VAR1_REF]],
 329 // CHECK: [[T_VAR1_PRIV_VAL:%.+]] = load float, float* [[T_VAR1_PRIV]],
 330 // CHECK: [[CMP:%.+]] = fcmp olt float [[T_VAR1_VAL]], [[T_VAR1_PRIV_VAL]]
 331 // CHECK: br i1 [[CMP]]
 332 // CHECK: [[UP:%.+]] = phi float
 333 // CHECK: store float [[UP]], float* [[T_VAR1_REF]],
 334
 335 // __kmpc_end_reduce(<loc>, <gtid>, &<lock>);
 336 // CHECK: call void @__kmpc_end_reduce(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], [8 x i32]* [[REDUCTION_LOCK]])
 337
 338 // break;
 339 // CHECK: br label %[[RED_DONE]]
 340
 341 // case 2:
 342 // t_var += t_var_reduction;
 343 // CHECK: load float, float* [[T_VAR_PRIV]]
 344 // CHECK: [[T_VAR_REF_INT:%.+]] = bitcast float* [[T_VAR_REF]] to i32*
 345 // CHECK: [[OLD1:%.+]] = load atomic i32, i32* [[T_VAR_REF_INT]] monotonic,
 346 // CHECK: br label %[[CONT:.+]]
 347 // CHECK: [[CONT]]
 348 // CHECK: [[ORIG_OLD_INT:%.+]] = phi i32 [ [[OLD1]], %{{.+}} ], [ [[OLD2:%.+]], %[[CONT]] ]
 349 // CHECK: fadd float
 350 // CHECK: [[UP_INT:%.+]] = load i32, i32*
 351 // CHECK: [[T_VAR_REF_INT:%.+]] = bitcast float* [[T_VAR_REF]] to i32*
 352 // CHECK: [[RES:%.+]] = cmpxchg i32* [[T_VAR_REF_INT]], i32 [[ORIG_OLD_INT]], i32 [[UP_INT]] monotonic monotonic
 353 // CHECK: [[OLD2:%.+]] = extractvalue { i32, i1 } [[RES]], 0
 354 // CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i32, i1 } [[RES]], 1
 355 // CHECK: br i1 [[SUCCESS_FAIL]], label %[[ATOMIC_DONE:.+]], label %[[CONT]]
 356 // CHECK: [[ATOMIC_DONE]]
 357
 358 // var = var.operator &(var_reduction);
 359 // CHECK: call void @__kmpc_critical(
 360 // CHECK: [[UP:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @{{.+}}([[S_FLOAT_TY]]* [[VAR_REF]], [[S_FLOAT_TY]]* dereferenceable(4) [[VAR_PRIV]])
 361 // CHECK: [[BC1:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR_REF]] to i8*
 362 // CHECK: [[BC2:%.+]] = bitcast [[S_FLOAT_TY]]* [[UP]] to i8*
 363 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
 364 // CHECK: call void @__kmpc_end_critical(
 365
 366 // var1 = var1.operator &&(var1_reduction);
 367 // CHECK: call void @__kmpc_critical(
 368 // CHECK: [[TO_FLOAT:%.+]] = call float @{{.+}}([[S_FLOAT_TY]]* [[VAR1_REF]])
 369 // CHECK: [[VAR1_BOOL:%.+]] = fcmp une float [[TO_FLOAT]], 0.0
 370 // CHECK: br i1 [[VAR1_BOOL]], label %[[TRUE:.+]], label %[[END2:.+]]
 371 // CHECK: [[TRUE]]
 372 // CHECK: [[TO_FLOAT:%.+]] = call float @{{.+}}([[S_FLOAT_TY]]* [[VAR1_PRIV]])
 373 // CHECK: [[VAR1_REDUCTION_BOOL:%.+]] = fcmp une float [[TO_FLOAT]], 0.0
 374 // CHECK: br label %[[END2]]
 375 // CHECK: [[END2]]
 376 // CHECK: [[COND_LVALUE:%.+]] = phi i1 [ false, %{{.+}} ], [ [[VAR1_REDUCTION_BOOL]], %[[TRUE]] ]
 377 // CHECK: [[CONV:%.+]] = uitofp i1 [[COND_LVALUE]] to float
 378 // CHECK:  call void @{{.+}}([[S_FLOAT_TY]]* [[COND_LVALUE:%.+]], float [[CONV]])
 379 // CHECK: [[BC1:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR1_REF]] to i8*
 380 // CHECK: [[BC2:%.+]] = bitcast [[S_FLOAT_TY]]* [[COND_LVALUE]] to i8*
 381 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
 382 // CHECK: call void @__kmpc_end_critical(
 383
 384 // t_var1 = min(t_var1, t_var1_reduction);
 385 // CHECK: load float, float* [[T_VAR1_PRIV]]
 386 // CHECK: [[T_VAR1_REF_INT:%.+]] = bitcast float* [[T_VAR1_REF]] to i32*
 387 // CHECK: [[OLD1:%.+]] = load atomic i32, i32* [[T_VAR1_REF_INT]] monotonic,
 388 // CHECK: br label %[[CONT:.+]]
 389 // CHECK: [[CONT]]
 390 // CHECK: [[ORIG_OLD_INT:%.+]] = phi i32 [ [[OLD1]], %{{.+}} ], [ [[OLD2:%.+]], %{{.+}} ]
 391 // CHECK: [[CMP:%.+]] = fcmp olt float
 392 // CHECK: br i1 [[CMP]]
 393 // CHECK: phi float
 394 // CHECK: [[UP_INT:%.+]] = load i32
 395 // CHECK: [[T_VAR1_REF_INT:%.+]] = bitcast float* [[T_VAR1_REF]] to i32*
 396 // CHECK: [[RES:%.+]] = cmpxchg i32* [[T_VAR1_REF_INT]], i32 [[ORIG_OLD_INT]], i32 [[UP_INT]] monotonic monotonic
 397 // CHECK: [[OLD2:%.+]] = extractvalue { i32, i1 } [[RES]], 0
 398 // CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i32, i1 } [[RES]], 1
 399 // CHECK: br i1 [[SUCCESS_FAIL]], label %[[ATOMIC_DONE:.+]], label %[[CONT]]
 400 // CHECK: [[ATOMIC_DONE]]
 401
 402 // __kmpc_end_reduce(<loc>, <gtid>, &<lock>);
 403 // CHECK: call void @__kmpc_end_reduce(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], [8 x i32]* [[REDUCTION_LOCK]])
 404
 405 // break;
 406 // CHECK: br label %[[RED_DONE]]
 407 // CHECK: [[RED_DONE]]
 408 // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]])
 409 // CHECK-DAG: call {{.*}} [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]*
 410 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
 411
 412 // CHECK: ret void
 413
 414 // void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
 415 //  *(Type0*)lhs[0] = ReductionOperation0(*(Type0*)lhs[0], *(Type0*)rhs[0]);
 416 //  ...
 417 //  *(Type<n>-1*)lhs[<n>-1] = ReductionOperation<n>-1(*(Type<n>-1*)lhs[<n>-1],
 418 //  *(Type<n>-1*)rhs[<n>-1]);
 419 // }
 420 // CHECK: define internal void [[REDUCTION_FUNC]](i8*, i8*)
 421 // t_var_lhs = (float*)lhs[0];
 422 // CHECK: [[T_VAR_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS:%.+]], i64 0, i64 0
 423 // CHECK: [[T_VAR_RHS_VOID:%.+]] = load i8*, i8** [[T_VAR_RHS_REF]],
 424 // CHECK: [[T_VAR_RHS:%.+]] = bitcast i8* [[T_VAR_RHS_VOID]] to float*
 425 // t_var_rhs = (float*)rhs[0];
 426 // CHECK: [[T_VAR_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS:%.+]], i64 0, i64 0
 427 // CHECK: [[T_VAR_LHS_VOID:%.+]] = load i8*, i8** [[T_VAR_LHS_REF]],
 428 // CHECK: [[T_VAR_LHS:%.+]] = bitcast i8* [[T_VAR_LHS_VOID]] to float*
 429
 430 // var_lhs = (S<float>*)lhs[1];
 431 // CHECK: [[VAR_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS]], i64 0, i64 1
 432 // CHECK: [[VAR_RHS_VOID:%.+]] = load i8*, i8** [[VAR_RHS_REF]],
 433 // CHECK: [[VAR_RHS:%.+]] = bitcast i8* [[VAR_RHS_VOID]] to [[S_FLOAT_TY]]*
 434 // var_rhs = (S<float>*)rhs[1];
 435 // CHECK: [[VAR_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 1
 436 // CHECK: [[VAR_LHS_VOID:%.+]] = load i8*, i8** [[VAR_LHS_REF]],
 437 // CHECK: [[VAR_LHS:%.+]] = bitcast i8* [[VAR_LHS_VOID]] to [[S_FLOAT_TY]]*
 438
 439 // var1_lhs = (S<float>*)lhs[2];
 440 // CHECK: [[VAR1_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS]], i64 0, i64 2
 441 // CHECK: [[VAR1_RHS_VOID:%.+]] = load i8*, i8** [[VAR1_RHS_REF]],
 442 // CHECK: [[VAR1_RHS:%.+]] = bitcast i8* [[VAR1_RHS_VOID]] to [[S_FLOAT_TY]]*
 443 // var1_rhs = (S<float>*)rhs[2];
 444 // CHECK: [[VAR1_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 2
 445 // CHECK: [[VAR1_LHS_VOID:%.+]] = load i8*, i8** [[VAR1_LHS_REF]],
 446 // CHECK: [[VAR1_LHS:%.+]] = bitcast i8* [[VAR1_LHS_VOID]] to [[S_FLOAT_TY]]*
 447
 448 // t_var1_lhs = (float*)lhs[3];
 449 // CHECK: [[T_VAR1_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS]], i64 0, i64 3
 450 // CHECK: [[T_VAR1_RHS_VOID:%.+]] = load i8*, i8** [[T_VAR1_RHS_REF]],
 451 // CHECK: [[T_VAR1_RHS:%.+]] = bitcast i8* [[T_VAR1_RHS_VOID]] to float*
 452 // t_var1_rhs = (float*)rhs[3];
 453 // CHECK: [[T_VAR1_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 3
 454 // CHECK: [[T_VAR1_LHS_VOID:%.+]] = load i8*, i8** [[T_VAR1_LHS_REF]],
 455 // CHECK: [[T_VAR1_LHS:%.+]] = bitcast i8* [[T_VAR1_LHS_VOID]] to float*
 456
 457 // t_var_lhs += t_var_rhs;
 458 // CHECK: [[T_VAR_LHS_VAL:%.+]] = load float, float* [[T_VAR_LHS]],
 459 // CHECK: [[T_VAR_RHS_VAL:%.+]] = load float, float* [[T_VAR_RHS]],
 460 // CHECK: [[UP:%.+]] = fadd float [[T_VAR_LHS_VAL]], [[T_VAR_RHS_VAL]]
 461 // CHECK: store float [[UP]], float* [[T_VAR_LHS]],
 462
 463 // var_lhs = var_lhs.operator &(var_rhs);
 464 // CHECK: [[UP:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @{{.+}}([[S_FLOAT_TY]]* [[VAR_LHS]], [[S_FLOAT_TY]]* dereferenceable(4) [[VAR_RHS]])
 465 // CHECK: [[BC1:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR_LHS]] to i8*
 466 // CHECK: [[BC2:%.+]] = bitcast [[S_FLOAT_TY]]* [[UP]] to i8*
 467 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
 468
 469 // var1_lhs = var1_lhs.operator &&(var1_rhs);
 470 // CHECK: [[TO_FLOAT:%.+]] = call float @{{.+}}([[S_FLOAT_TY]]* [[VAR1_LHS]])
 471 // CHECK: [[VAR1_BOOL:%.+]] = fcmp une float [[TO_FLOAT]], 0.0
 472 // CHECK: br i1 [[VAR1_BOOL]], label %[[TRUE:.+]], label %[[END2:.+]]
 473 // CHECK: [[TRUE]]
 474 // CHECK: [[TO_FLOAT:%.+]] = call float @{{.+}}([[S_FLOAT_TY]]* [[VAR1_RHS]])
 475 // CHECK: [[VAR1_REDUCTION_BOOL:%.+]] = fcmp une float [[TO_FLOAT]], 0.0
 476 // CHECK: br label %[[END2]]
 477 // CHECK: [[END2]]
 478 // CHECK: [[COND_LVALUE:%.+]] = phi i1 [ false, %{{.+}} ], [ [[VAR1_REDUCTION_BOOL]], %[[TRUE]] ]
 479 // CHECK: [[CONV:%.+]] = uitofp i1 [[COND_LVALUE]] to float
 480 // CHECK:  call void @{{.+}}([[S_FLOAT_TY]]* [[COND_LVALUE:%.+]], float [[CONV]])
 481 // CHECK: [[BC1:%.+]] = bitcast [[S_FLOAT_TY]]* [[VAR1_LHS]] to i8*
 482 // CHECK: [[BC2:%.+]] = bitcast [[S_FLOAT_TY]]* [[COND_LVALUE]] to i8*
 483 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
 484
 485 // t_var1_lhs = min(t_var1_lhs, t_var1_rhs);
 486 // CHECK: [[T_VAR1_LHS_VAL:%.+]] = load float, float* [[T_VAR1_LHS]],
 487 // CHECK: [[T_VAR1_RHS_VAL:%.+]] = load float, float* [[T_VAR1_RHS]],
 488 // CHECK: [[CMP:%.+]] = fcmp olt float [[T_VAR1_LHS_VAL]], [[T_VAR1_RHS_VAL]]
 489 // CHECK: br i1 [[CMP]]
 490 // CHECK: [[UP:%.+]] = phi float
 491 // CHECK: store float [[UP]], float* [[T_VAR1_LHS]],
 492 // CHECK: ret void
 493
 494 // CHECK: define internal void [[MAIN_MICROTASK1]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, i64 %{{.+}}, i64 %{{.+}}, i32* %{{.+}}, [2 x i32]* dereferenceable(8) %{{.+}}, [10 x [4 x [[S_FLOAT_TY]]]]* dereferenceable(160) %{{.+}})
 495
 496 // Reduction list for runtime.
 497 // CHECK: [[RED_LIST:%.+]] = alloca [4 x i8*],
 498
 499 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
 500
 501 // CHECK: [[IDX1:%.+]] = mul nsw i64 1, %{{.+}}
 502 // CHECK: [[LB1:%.+]] = getelementptr inbounds i32, i32* %{{.+}}, i64 [[IDX1]]
 503 // CHECK: [[LB1_0:%.+]] = getelementptr inbounds i32, i32* [[LB1]], i64 0
 504 // CHECK: [[IDX1:%.+]] = mul nsw i64 1, %{{.+}}
 505 // CHECK: [[UB1:%.+]] = getelementptr inbounds i32, i32* %{{.+}}, i64 [[IDX1]]
 506 // CHECK: [[UB1_UP:%.+]] = getelementptr inbounds i32, i32* [[UB1]], i64 %
 507 // CHECK: [[UB_CAST:%.+]] = ptrtoint i32* [[UB1_UP]] to i64
 508 // CHECK: [[LB_CAST:%.+]] = ptrtoint i32* [[LB1_0]] to i64
 509 // CHECK: [[DIFF:%.+]] = sub i64 [[UB_CAST]], [[LB_CAST]]
 510 // CHECK: [[SIZE_1:%.+]] = sdiv exact i64 [[DIFF]], ptrtoint (i32* getelementptr (i32, i32* null, i32 1) to i64)
 511 // CHECK: [[ARR_SIZE:%.+]] = add nuw i64 [[SIZE_1]], 1
 512 // CHECK: call i8* @llvm.stacksave()
 513 // CHECK: [[ARR_PRIV:%.+]] = alloca i32, i64 [[ARR_SIZE]],
 514
 515 // Check initialization of private copy.
 516 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[ARR_PRIV]], i64 [[ARR_SIZE]]
 517 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[ARR_PRIV]], [[END]]
 518 // CHECK: br i1 [[ISEMPTY]],
 519 // CHECK: phi i32*
 520 // CHECK: store i32 0, i32* %
 521 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 522 // CHECK: br i1 [[DONE]],
 523
 524 // CHECK: [[ARRS_PRIV:%.+]] = alloca [[S_FLOAT_TY]], i64 [[ARRS_SIZE:%.+]],
 525
 526 // Check initialization of private copy.
 527 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[ARRS_PRIV]], i64 [[ARRS_SIZE]]
 528 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[ARRS_PRIV]], [[END]]
 529 // CHECK: br i1 [[ISEMPTY]],
 530 // CHECK: phi [[S_FLOAT_TY]]*
 531 // CHECK: call void @_ZN1SIfEC1Ev([[S_FLOAT_TY]]* %
 532 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 533 // CHECK: br i1 [[DONE]],
 534
 535 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]]
 536 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
 537 // CHECK: call void @__kmpc_for_static_init_4(
 538 // Skip checks for internal operations.
 539 // CHECK: call void @__kmpc_for_static_fini(
 540
 541 // void *RedList[<n>] = {<ReductionVars>[0], ..., <ReductionVars>[<n>-1]};
 542
 543 // CHECK: [[ARR_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 0
 544 // CHECK: [[BITCAST:%.+]] = bitcast i32* [[ARR_PRIV]] to i8*
 545 // CHECK: store i8* [[BITCAST]], i8** [[ARR_PRIV_REF]],
 546 // CHECK: [[ARR_SIZE_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 1
 547 // CHECK: [[BITCAST:%.+]] = inttoptr i64 [[ARR_SIZE]] to i8*
 548 // CHECK: store i8* [[BITCAST]], i8** [[ARR_SIZE_REF]],
 549 // CHECK: [[ARRS_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 2
 550 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[ARRS_PRIV]] to i8*
 551 // CHECK: store i8* [[BITCAST]], i8** [[ARRS_PRIV_REF]],
 552 // CHECK: [[ARRS_SIZE_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 3
 553 // CHECK: [[BITCAST:%.+]] = inttoptr i64 [[ARRS_SIZE]] to i8*
 554 // CHECK: store i8* [[BITCAST]], i8** [[ARRS_SIZE_REF]],
 555
 556 // res = __kmpc_reduce(<loc>, <gtid>, <n>, sizeof(RedList), RedList, reduce_func, &<lock>);
 557
 558 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]]
 559 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
 560 // CHECK: [[BITCAST:%.+]] = bitcast [4 x i8*]* [[RED_LIST]] to i8*
 561 // CHECK: [[RES:%.+]] = call i32 @__kmpc_reduce_nowait(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], i32 2, i64 32, i8* [[BITCAST]], void (i8*, i8*)* [[REDUCTION_FUNC:@.+]], [8 x i32]* [[REDUCTION_LOCK]])
 562
 563 // switch(res)
 564 // CHECK: switch i32 [[RES]], label %[[RED_DONE:.+]] [
 565 // CHECK: i32 1, label %[[CASE1:.+]]
 566 // CHECK: i32 2, label %[[CASE2:.+]]
 567 // CHECK: ]
 568
 569 // case 1:
 570 // CHECK: [[CASE1]]
 571
 572 // arr[:] += arr_reduction[:];
 573 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[LB1_0]], i64 [[ARR_SIZE]]
 574 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[LB1_0]], [[END]]
 575 // CHECK: br i1 [[ISEMPTY]],
 576 // CHECK: phi i32*
 577 // CHECK: [[ADD:%.+]] = add nsw i32 %
 578 // CHECK: store i32 [[ADD]], i32* %
 579 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 580 // CHECK: br i1 [[DONE]],
 581
 582 // arrs[:] = var.operator &(arrs_reduction[:]);
 583 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[ARRS_LB:%.+]], i64 [[ARRS_SIZE]]
 584 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[ARRS_LB]], [[END]]
 585 // CHECK: br i1 [[ISEMPTY]],
 586 // CHECK: phi [[S_FLOAT_TY]]*
 587 // CHECK: [[AND:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @_ZN1SIfEanERKS0_([[S_FLOAT_TY]]* %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}})
 588 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[AND]] to i8*
 589 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.+}}, i8* [[BITCAST]], i64 4, i32 4, i1 false)
 590 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 591 // CHECK: br i1 [[DONE]],
 592
 593 // __kmpc_end_reduce(<loc>, <gtid>, &<lock>);
 594 // CHECK: call void @__kmpc_end_reduce_nowait(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], [8 x i32]* [[REDUCTION_LOCK]])
 595
 596 // break;
 597 // CHECK: br label %[[RED_DONE]]
 598
 599 // case 2:
 600 // CHECK: [[CASE2]]
 601
 602 // arr[:] += arr_reduction[:];
 603 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[LB1_0]], i64 [[ARR_SIZE]]
 604 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[LB1_0]], [[END]]
 605 // CHECK: br i1 [[ISEMPTY]],
 606 // CHECK: phi i32*
 607 // CHECK: atomicrmw add i32* %{{.+}}, i32 %{{.+}} monotonic
 608 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 609 // CHECK: br i1 [[DONE]],
 610
 611 // arrs[:] = var.operator &(arrs_reduction[:]);
 612 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[ARRS_LB:%.+]], i64 [[ARRS_SIZE]]
 613 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[ARRS_LB]], [[END]]
 614 // CHECK: br i1 [[ISEMPTY]],
 615 // CHECK: phi [[S_FLOAT_TY]]*
 616 // CHECK: call void @__kmpc_critical(
 617 // CHECK: [[AND:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @_ZN1SIfEanERKS0_([[S_FLOAT_TY]]* %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}})
 618 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[AND]] to i8*
 619 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.+}}, i8* [[BITCAST]], i64 4, i32 4, i1 false)
 620 // CHECK: call void @__kmpc_end_critical(
 621 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 622 // CHECK: br i1 [[DONE]],
 623
 624 // break;
 625 // CHECK: br label %[[RED_DONE]]
 626 // CHECK: [[RED_DONE]]
 627
 628 // Check destruction of private copy.
 629 // CHECK: [[END:%.+]] = getelementptr inbounds [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[ARRS_PRIV]], i64 [[ARRS_SIZE]]
 630 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[ARRS_PRIV]], [[END]]
 631 // CHECK: br i1 [[ISEMPTY]],
 632 // CHECK: phi [[S_FLOAT_TY]]*
 633 // CHECK: call void @_ZN1SIfED1Ev([[S_FLOAT_TY]]* %
 634 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[ARRS_PRIV]]
 635 // CHECK: br i1 [[DONE]],
 636 // CHECK: call void @llvm.stackrestore(i8*
 637
 638 // CHECK: ret void
 639
 640 // void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
 641 //  *(Type0*)lhs[0] = ReductionOperation0(*(Type0*)lhs[0], *(Type0*)rhs[0]);
 642 //  ...
 643 //  *(Type<n>-1*)lhs[<n>-1] = ReductionOperation<n>-1(*(Type<n>-1*)lhs[<n>-1],
 644 //  *(Type<n>-1*)rhs[<n>-1]);
 645 // }
 646 // CHECK: define internal void [[REDUCTION_FUNC]](i8*, i8*)
 647 // arr_rhs = (int*)rhs[0];
 648 // CHECK: [[ARR_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS:%.+]], i64 0, i64 0
 649 // CHECK: [[ARR_RHS_VOID:%.+]] = load i8*, i8** [[ARR_RHS_REF]],
 650 // CHECK: [[ARR_RHS:%.+]] = bitcast i8* [[ARR_RHS_VOID]] to i32*
 651 // arr_lhs = (int*)lhs[0];
 652 // CHECK: [[ARR_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS:%.+]], i64 0, i64 0
 653 // CHECK: [[ARR_LHS_VOID:%.+]] = load i8*, i8** [[ARR_LHS_REF]],
 654 // CHECK: [[ARR_LHS:%.+]] = bitcast i8* [[ARR_LHS_VOID]] to i32*
 655
 656 // arr_size = (size_t)lhs[1];
 657 // CHECK: [[ARR_SIZE_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 1
 658 // CHECK: [[ARR_SIZE_VOID:%.+]] = load i8*, i8** [[ARR_SIZE_REF]],
 659 // CHECK: [[ARR_SIZE:%.+]] = ptrtoint i8* [[ARR_SIZE_VOID]] to i64
 660
 661 // arrs_rhs = (S<float>*)rhs[2];
 662 // CHECK: [[ARRS_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS]], i64 0, i64 2
 663 // CHECK: [[ARRS_RHS_VOID:%.+]] = load i8*, i8** [[ARRS_RHS_REF]],
 664 // CHECK: [[ARRS_RHS:%.+]] = bitcast i8* [[ARRS_RHS_VOID]] to [[S_FLOAT_TY]]*
 665 // arrs_lhs = (S<float>*)lhs[2];
 666 // CHECK: [[ARRS_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 2
 667 // CHECK: [[ARRS_LHS_VOID:%.+]] = load i8*, i8** [[ARRS_LHS_REF]],
 668 // CHECK: [[ARRS_LHS:%.+]] = bitcast i8* [[ARRS_LHS_VOID]] to [[S_FLOAT_TY]]*
 669
 670 // arrs_size = (size_t)lhs[3];
 671 // CHECK: [[ARRS_SIZE_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 3
 672 // CHECK: [[ARRS_SIZE_VOID:%.+]] = load i8*, i8** [[ARRS_SIZE_REF]],
 673 // CHECK: [[ARRS_SIZE:%.+]] = ptrtoint i8* [[ARRS_SIZE_VOID]] to i64
 674
 675 // arr_lhs[:] += arr_rhs[:];
 676 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[ARR_LHS]], i64 [[ARR_SIZE]]
 677 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[ARR_LHS]], [[END]]
 678 // CHECK: br i1 [[ISEMPTY]],
 679 // CHECK: phi i32*
 680 // CHECK: [[ADD:%.+]] = add nsw i32 %
 681 // CHECK: store i32 [[ADD]], i32* %
 682 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 683 // CHECK: br i1 [[DONE]],
 684
 685 // arrs_lhs = arrs_lhs.operator &(arrs_rhs);
 686 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[ARRS_LB:%.+]], i64 [[ARRS_SIZE]]
 687 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[ARRS_LB]], [[END]]
 688 // CHECK: br i1 [[ISEMPTY]],
 689 // CHECK: phi [[S_FLOAT_TY]]*
 690 // CHECK: [[AND:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @_ZN1SIfEanERKS0_([[S_FLOAT_TY]]* %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}})
 691 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[AND]] to i8*
 692 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.+}}, i8* [[BITCAST]], i64 4, i32 4, i1 false)
 693 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 694 // CHECK: br i1 [[DONE]],
 695
 696 // CHECK: ret void
 697
 698 // CHECK: define internal void [[MAIN_MICROTASK2]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, i64 %{{.+}}, i64 %{{.+}}, i32* %{{.+}}, [10 x [4 x [[S_FLOAT_TY]]]]* dereferenceable(160) %{{.+}})
 699
 700 // CHECK: [[ARRS_PRIV:%.+]] = alloca [10 x [4 x [[S_FLOAT_TY]]]],
 701
 702 // Reduction list for runtime.
 703 // CHECK: [[RED_LIST:%.+]] = alloca [3 x i8*],
 704
 705 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
 706
 707 // CHECK: [[ARR_SIZE:%.+]] = mul nuw i64 %{{.+}}, 4
 708 // CHECK: call i8* @llvm.stacksave()
 709 // CHECK: [[ARR_PRIV:%.+]] = alloca i32, i64 [[ARR_SIZE]],
 710
 711 // Check initialization of private copy.
 712 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[ARR_PRIV]], i64 [[ARR_SIZE]]
 713 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[ARR_PRIV]], [[END]]
 714 // CHECK: br i1 [[ISEMPTY]],
 715 // CHECK: phi i32*
 716 // CHECK: store i32 0, i32* %
 717 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 718 // CHECK: br i1 [[DONE]],
 719
 720 // Check initialization of private copy.
 721 // CHECK: [[LHS_BEGIN:%.+]] = bitcast [10 x [4 x [[S_FLOAT_TY]]]]* %{{.+}} to [[S_FLOAT_TY]]*
 722 // CHECK: [[BEGIN:%.+]] = getelementptr inbounds [10 x [4 x [[S_FLOAT_TY]]]], [10 x [4 x [[S_FLOAT_TY]]]]* [[ARRS_PRIV]], i32 0, i32 0, i32 0
 723 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[BEGIN]], i64 40
 724 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[BEGIN]], [[END]]
 725 // CHECK: br i1 [[ISEMPTY]],
 726 // CHECK: phi [[S_FLOAT_TY]]*
 727 // CHECK: call void @_ZN1SIfEC1Ev([[S_FLOAT_TY]]* %
 728 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 729 // CHECK: br i1 [[DONE]],
 730 // CHECK: [[ARRS_PRIV_BEGIN:%.+]] = bitcast [10 x [4 x [[S_FLOAT_TY]]]]* [[ARRS_PRIV]] to [[S_FLOAT_TY]]*
 731
 732 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]]
 733 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
 734 // CHECK: call void @__kmpc_for_static_init_4(
 735 // Skip checks for internal operations.
 736 // CHECK: call void @__kmpc_for_static_fini(
 737
 738 // void *RedList[<n>] = {<ReductionVars>[0], ..., <ReductionVars>[<n>-1]};
 739
 740 // CHECK: [[ARR_PRIV_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST]], i64 0, i64 0
 741 // CHECK: [[BITCAST:%.+]] = bitcast i32* [[ARR_PRIV]] to i8*
 742 // CHECK: store i8* [[BITCAST]], i8** [[ARR_PRIV_REF]],
 743 // CHECK: [[ARR_SIZE_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST]], i64 0, i64 1
 744 // CHECK: [[BITCAST:%.+]] = inttoptr i64 [[ARR_SIZE]] to i8*
 745 // CHECK: store i8* [[BITCAST]], i8** [[ARR_SIZE_REF]],
 746 // CHECK: [[ARRS_PRIV_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST]], i64 0, i64 2
 747 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[ARRS_PRIV_BEGIN]] to i8*
 748 // CHECK: store i8* [[BITCAST]], i8** [[ARRS_PRIV_REF]],
 749
 750 // res = __kmpc_reduce(<loc>, <gtid>, <n>, sizeof(RedList), RedList, reduce_func, &<lock>);
 751
 752 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]]
 753 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
 754 // CHECK: [[BITCAST:%.+]] = bitcast [3 x i8*]* [[RED_LIST]] to i8*
 755 // CHECK: [[RES:%.+]] = call i32 @__kmpc_reduce(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], i32 2, i64 24, i8* [[BITCAST]], void (i8*, i8*)* [[REDUCTION_FUNC:@.+]], [8 x i32]* [[REDUCTION_LOCK]])
 756
 757 // switch(res)
 758 // CHECK: switch i32 [[RES]], label %[[RED_DONE:.+]] [
 759 // CHECK: i32 1, label %[[CASE1:.+]]
 760 // CHECK: i32 2, label %[[CASE2:.+]]
 761 // CHECK: ]
 762
 763 // case 1:
 764 // CHECK: [[CASE1]]
 765
 766 // arr[:] += arr_reduction[:];
 767 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[LB1_0:%.+]], i64 [[ARR_SIZE]]
 768 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[LB1_0]], [[END]]
 769 // CHECK: br i1 [[ISEMPTY]],
 770 // CHECK: phi i32*
 771 // CHECK: [[ADD:%.+]] = add nsw i32 %
 772 // CHECK: store i32 [[ADD]], i32* %
 773 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 774 // CHECK: br i1 [[DONE]],
 775
 776 // arrs[:] = var.operator &(arrs_reduction[:]);
 777 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[LHS_BEGIN]], i64 40
 778 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[LHS_BEGIN]], [[END]]
 779 // CHECK: br i1 [[ISEMPTY]],
 780 // CHECK: phi [[S_FLOAT_TY]]*
 781 // CHECK: [[AND:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @_ZN1SIfEanERKS0_([[S_FLOAT_TY]]* %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}})
 782 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[AND]] to i8*
 783 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.+}}, i8* [[BITCAST]], i64 4, i32 4, i1 false)
 784 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 785 // CHECK: br i1 [[DONE]],
 786
 787 // __kmpc_end_reduce(<loc>, <gtid>, &<lock>);
 788 // CHECK: call void @__kmpc_end_reduce(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], [8 x i32]* [[REDUCTION_LOCK]])
 789
 790 // break;
 791 // CHECK: br label %[[RED_DONE]]
 792
 793 // case 2:
 794 // CHECK: [[CASE2]]
 795
 796 // arr[:] += arr_reduction[:];
 797 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[LB1_0]], i64 [[ARR_SIZE]]
 798 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[LB1_0]], [[END]]
 799 // CHECK: br i1 [[ISEMPTY]],
 800 // CHECK: phi i32*
 801 // CHECK: atomicrmw add i32* %{{.+}}, i32 %{{.+}} monotonic
 802 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 803 // CHECK: br i1 [[DONE]],
 804
 805 // arrs[:] = var.operator &(arrs_reduction[:]);
 806 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[LHS_BEGIN]], i64 40
 807 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[LHS_BEGIN]], [[END]]
 808 // CHECK: br i1 [[ISEMPTY]],
 809 // CHECK: phi [[S_FLOAT_TY]]*
 810 // CHECK: call void @__kmpc_critical(
 811 // CHECK: [[AND:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @_ZN1SIfEanERKS0_([[S_FLOAT_TY]]* %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}})
 812 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[AND]] to i8*
 813 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.+}}, i8* [[BITCAST]], i64 4, i32 4, i1 false)
 814 // CHECK: call void @__kmpc_end_critical(
 815 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 816 // CHECK: br i1 [[DONE]],
 817
 818 // break;
 819 // CHECK: br label %[[RED_DONE]]
 820 // CHECK: [[RED_DONE]]
 821
 822 // Check destruction of private copy.
 823 // CHECK: [[BEGIN:%.+]] = getelementptr inbounds [10 x [4 x [[S_FLOAT_TY]]]], [10 x [4 x [[S_FLOAT_TY]]]]* [[ARRS_PRIV]], i32 0, i32 0, i32 0
 824 // CHECK: [[END:%.+]] = getelementptr inbounds [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[BEGIN]], i64 40
 825 // CHECK: br
 826 // CHECK: phi [[S_FLOAT_TY]]*
 827 // CHECK: call void @_ZN1SIfED1Ev([[S_FLOAT_TY]]* %
 828 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[BEGIN]]
 829 // CHECK: br i1 [[DONE]],
 830 // CHECK: call void @llvm.stackrestore(i8*
 831 // CHECK: call void @__kmpc_barrier(
 832
 833 // CHECK: ret void
 834
 835 // void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
 836 //  *(Type0*)lhs[0] = ReductionOperation0(*(Type0*)lhs[0], *(Type0*)rhs[0]);
 837 //  ...
 838 //  *(Type<n>-1*)lhs[<n>-1] = ReductionOperation<n>-1(*(Type<n>-1*)lhs[<n>-1],
 839 //  *(Type<n>-1*)rhs[<n>-1]);
 840 // }
 841 // CHECK: define internal void [[REDUCTION_FUNC]](i8*, i8*)
 842 // arr_rhs = (int*)rhs[0];
 843 // CHECK: [[ARR_RHS_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST_RHS:%.+]], i64 0, i64 0
 844 // CHECK: [[ARR_RHS_VOID:%.+]] = load i8*, i8** [[ARR_RHS_REF]],
 845 // CHECK: [[ARR_RHS:%.+]] = bitcast i8* [[ARR_RHS_VOID]] to i32*
 846 // arr_lhs = (int*)lhs[0];
 847 // CHECK: [[ARR_LHS_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST_LHS:%.+]], i64 0, i64 0
 848 // CHECK: [[ARR_LHS_VOID:%.+]] = load i8*, i8** [[ARR_LHS_REF]],
 849 // CHECK: [[ARR_LHS:%.+]] = bitcast i8* [[ARR_LHS_VOID]] to i32*
 850
 851 // arr_size = (size_t)lhs[1];
 852 // CHECK: [[ARR_SIZE_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST_LHS]], i64 0, i64 1
 853 // CHECK: [[ARR_SIZE_VOID:%.+]] = load i8*, i8** [[ARR_SIZE_REF]],
 854 // CHECK: [[ARR_SIZE:%.+]] = ptrtoint i8* [[ARR_SIZE_VOID]] to i64
 855
 856 // arrs_rhs = (S<float>*)rhs[2];
 857 // CHECK: [[ARRS_RHS_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST_RHS]], i64 0, i64 2
 858 // CHECK: [[ARRS_RHS_VOID:%.+]] = load i8*, i8** [[ARRS_RHS_REF]],
 859 // CHECK: [[ARRS_RHS:%.+]] = bitcast i8* [[ARRS_RHS_VOID]] to [[S_FLOAT_TY]]*
 860 // arrs_lhs = (S<float>*)lhs[2];
 861 // CHECK: [[ARRS_LHS_REF:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[RED_LIST_LHS]], i64 0, i64 2
 862 // CHECK: [[ARRS_LHS_VOID:%.+]] = load i8*, i8** [[ARRS_LHS_REF]],
 863 // CHECK: [[ARRS_LHS:%.+]] = bitcast i8* [[ARRS_LHS_VOID]] to [[S_FLOAT_TY]]*
 864
 865 // arr_lhs[:] += arr_rhs[:];
 866 // CHECK: [[END:%.+]] = getelementptr i32, i32* [[ARR_LHS]], i64 [[ARR_SIZE]]
 867 // CHECK: [[ISEMPTY:%.+]] = icmp eq i32* [[ARR_LHS]], [[END]]
 868 // CHECK: br i1 [[ISEMPTY]],
 869 // CHECK: phi i32*
 870 // CHECK: [[ADD:%.+]] = add nsw i32 %
 871 // CHECK: store i32 [[ADD]], i32* %
 872 // CHECK: [[DONE:%.+]] = icmp eq i32* %{{.+}}, [[END]]
 873 // CHECK: br i1 [[DONE]],
 874
 875 // arrs_lhs = arrs_lhs.operator &(arrs_rhs);
 876 // CHECK: [[END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[ARRS_LB:%.+]], i64 40
 877 // CHECK: [[ISEMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[ARRS_LB]], [[END]]
 878 // CHECK: br i1 [[ISEMPTY]],
 879 // CHECK: phi [[S_FLOAT_TY]]*
 880 // CHECK: [[AND:%.+]] = call dereferenceable(4) [[S_FLOAT_TY]]* @_ZN1SIfEanERKS0_([[S_FLOAT_TY]]* %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}})
 881 // CHECK: [[BITCAST:%.+]] = bitcast [[S_FLOAT_TY]]* [[AND]] to i8*
 882 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.+}}, i8* [[BITCAST]], i64 4, i32 4, i1 false)
 883 // CHECK: [[DONE:%.+]] = icmp eq [[S_FLOAT_TY]]* %{{.+}}, [[END]]
 884 // CHECK: br i1 [[DONE]],
 885
 886 // CHECK: ret void
 887
 888 // CHECK: define internal void [[MAIN_MICROTASK3]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[S_FLOAT_TY]]*** dereferenceable(8) %{{.+}})
 889
 890 // CHECK: [[VAR2_ORIG_ADDR:%.+]] = alloca [[S_FLOAT_TY]]***,
 891
 892 // Reduction list for runtime.
 893 // CHECK: [[RED_LIST:%.+]] = alloca [2 x i8*],
 894
 895 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
 896 // CHECK: [[VAR2_ORIG:%.+]] = load [[S_FLOAT_TY]]***, [[S_FLOAT_TY]]**** [[VAR2_ORIG_ADDR]],
 897
 898 // CHECK: load [[S_FLOAT_TY]]**, [[S_FLOAT_TY]]*** [[VAR2_ORIG]],
 899 // CHECK: getelementptr inbounds [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** %{{.+}}, i64 0
 900 // CHECK: load [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** %
 901 // CHECK: [[LOW:%.+]] = getelementptr inbounds [[S_FLOAT_TY]], [[S_FLOAT_TY]]* %{{.+}}, i64 1
 902 // CHECK: load [[S_FLOAT_TY]]**, [[S_FLOAT_TY]]*** [[VAR2_ORIG]],
 903 // CHECK: getelementptr inbounds [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** %{{.+}}, i64 4
 904 // CHECK: load [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** %
 905 // CHECK: getelementptr inbounds [[S_FLOAT_TY]], [[S_FLOAT_TY]]* %{{.+}}, i64 6
 906 // CHECK: [[LD:%.+]] = load [[S_FLOAT_TY]]**, [[S_FLOAT_TY]]*** [[VAR2_ORIG]],
 907 // CHECK: [[ORIG_START:%.+]] = load [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** [[LD]],
 908 // CHECK: [[LAST:%.+]] = ptrtoint [[S_FLOAT_TY]]* %{{.+}} to i64
 909 // CHECK: [[FIRST:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[LOW]] to i64
 910 // CHECK: [[BYTE_DIF:%.+]] = sub i64 [[LAST]], [[FIRST]]
 911 // CHECK: [[DIF:%.+]] = sdiv exact i64 [[BYTE_DIF]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
 912 // CHECK: [[SIZE:%.+]] = add nuw i64 [[DIF]], 1
 913 // CHECK: call i8* @llvm.stacksave()
 914 // CHECK: [[VAR2_PRIV:%.+]] = alloca [[S_FLOAT_TY]], i64 [[SIZE]],
 915 // CHECK: [[START:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[ORIG_START]] to i64
 916 // CHECK: [[LOW_BOUND:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[LOW]] to i64
 917 // CHECK: [[OFFSET_BYTES:%.+]] = sub i64 [[START]], [[LOW_BOUND]]
 918 // CHECK: [[OFFSET:%.+]] = sdiv exact i64 [[OFFSET_BYTES]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
 919 // CHECK: [[PSEUDO_VAR2_PRIV:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[VAR2_PRIV]], i64 [[OFFSET]]
 920 // CHECK: store [[S_FLOAT_TY]]** [[REF:.+]], [[S_FLOAT_TY]]*** %
 921 // CHECK: store [[S_FLOAT_TY]]* [[PSEUDO_VAR2_PRIV]], [[S_FLOAT_TY]]** [[REF]]
 922 // CHECK: ret void
 923
 924 // CHECK: define internal void [[MAIN_MICROTASK4]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [2 x [[S_FLOAT_TY]]]* dereferenceable(8) %{{.+}})
 925
 926 // CHECK: [[VVAR2_ORIG_ADDR:%.+]] = alloca [2 x [[S_FLOAT_TY]]]*,
 927
 928 // Reduction list for runtime.
 929 // CHECK: [[RED_LIST:%.+]] = alloca [2 x i8*],
 930
 931 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
 932 // CHECK: [[VVAR2_ORIG:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** [[VVAR2_ORIG_ADDR]],
 933
 934 // CHECK: [[LOW:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[VVAR2_ORIG]], i64 0, i64 0
 935 // CHECK: getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[VVAR2_ORIG]], i64 0, i64 4
 936 // CHECK: [[ORIG_START:%.+]] = bitcast [2 x [[S_FLOAT_TY]]]* [[VVAR2_ORIG]] to [[S_FLOAT_TY]]*
 937 // CHECK: [[LAST:%.+]] = ptrtoint [[S_FLOAT_TY]]* %{{.+}} to i64
 938 // CHECK: [[FIRST:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[LOW]] to i64
 939 // CHECK: [[BYTE_DIF:%.+]] = sub i64 [[LAST]], [[FIRST]]
 940 // CHECK: [[DIF:%.+]] = sdiv exact i64 [[BYTE_DIF]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
 941 // CHECK: [[SIZE:%.+]] = add nuw i64 [[DIF]], 1
 942 // CHECK: call i8* @llvm.stacksave()
 943 // CHECK: [[VVAR2_PRIV:%.+]] = alloca [[S_FLOAT_TY]], i64 [[SIZE]],
 944 // CHECK: [[START:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[ORIG_START]] to i64
 945 // CHECK: [[LOW_BOUND:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[LOW]] to i64
 946 // CHECK: [[OFFSET_BYTES:%.+]] = sub i64 [[START]], [[LOW_BOUND]]
 947 // CHECK: [[OFFSET:%.+]] = sdiv exact i64 [[OFFSET_BYTES]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
 948 // CHECK: [[PSEUDO_VVAR2_PRIV:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[VVAR2_PRIV]], i64 [[OFFSET]]
 949 // CHECK: [[VVAR2_PRIV:%.+]] = bitcast [[S_FLOAT_TY]]* [[PSEUDO_VVAR2_PRIV]] to [2 x [[S_FLOAT_TY]]]*
 950 // CHECK: ret void
 951
 952 // CHECK: define internal void [[MAIN_MICROTASK5]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [2 x [[S_FLOAT_TY]]]* dereferenceable(8) %{{.+}})
 953
 954 // CHECK: [[VAR3_ORIG_ADDR:%.+]] = alloca [2 x [[S_FLOAT_TY]]]*,
 955
 956 // Reduction list for runtime.
 957 // CHECK: [[RED_LIST:%.+]] = alloca [2 x i8*],
 958
 959 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
 960
 961 // CHECK: [[VAR3_ORIG:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR]],
 962 // CHECK: store [2 x [[S_FLOAT_TY]]]* [[VAR3_ORIG]], [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR:%.+]],
 963 // CHECK: [[VAR3_ORIG:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR]],
 964 // CHECK: [[LOW:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[VAR3_ORIG]], i64 0, i64 1
 965 // CHECK: [[VAR3_ORIG:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR]],
 966 // CHECK: getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[VAR3_ORIG]], i64 0, i64 2
 967 // CHECK: [[VAR3_ORIG:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR]],
 968 // CHECK: [[ORIG_START:%.+]] = bitcast [2 x [[S_FLOAT_TY]]]* [[VAR3_ORIG]] to [[S_FLOAT_TY]]*
 969 // CHECK: [[LAST:%.+]] = ptrtoint [[S_FLOAT_TY]]* %{{.+}} to i64
 970 // CHECK: [[FIRST:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[LOW]] to i64
 971 // CHECK: [[BYTE_DIF:%.+]] = sub i64 [[LAST]], [[FIRST]]
 972 // CHECK: [[DIF:%.+]] = sdiv exact i64 [[BYTE_DIF]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
 973 // CHECK: [[SIZE:%.+]] = add nuw i64 [[DIF]], 1
 974 // CHECK: call i8* @llvm.stacksave()
 975 // CHECK: [[VAR3_PRIV:%.+]] = alloca [[S_FLOAT_TY]], i64 [[SIZE]],
 976 // CHECK: [[START:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[ORIG_START]] to i64
 977 // CHECK: [[LOW_BOUND:%.+]] = ptrtoint [[S_FLOAT_TY]]* [[LOW]] to i64
 978 // CHECK: [[OFFSET_BYTES:%.+]] = sub i64 [[START]], [[LOW_BOUND]]
 979 // CHECK: [[OFFSET:%.+]] = sdiv exact i64 [[OFFSET_BYTES]], ptrtoint (float* getelementptr (float, float* null, i32 1) to i64)
 980 // CHECK: [[PSEUDO_VAR3_PRIV:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[VAR3_PRIV]], i64 [[OFFSET]]
 981 // CHECK: [[VAR3_PRIV:%.+]] = bitcast [[S_FLOAT_TY]]* [[PSEUDO_VAR3_PRIV]] to [2 x [[S_FLOAT_TY]]]*
 982
 983 // CHECK: store [2 x [[S_FLOAT_TY]]]* [[VAR3_PRIV]], [2 x [[S_FLOAT_TY]]]** %
 984
 985 // CHECK: ret void
 986
 987 // CHECK: define internal void [[MAIN_MICROTASK6]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [2 x [[S_FLOAT_TY]]]* dereferenceable(8) %{{.+}})
 988
 989 // CHECK: [[VAR3_ORIG_ADDR:%.+]] = alloca [2 x [[S_FLOAT_TY]]]*,
 990 // CHECK: [[VAR3_PRIV:%.+]] = alloca [2 x [[S_FLOAT_TY]]],
 991
 992 // Reduction list for runtime.
 993 // CHECK: [[RED_LIST:%.+]] = alloca [1 x i8*],
 994
 995 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
 996
 997 // CHECK: [[VAR3_ORIG:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR]],
 998 // CHECK: store [2 x [[S_FLOAT_TY]]]* [[VAR3_ORIG]], [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR:%.+]],
 999 // CHECK: [[VAR3_ORIG:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** [[VAR3_ORIG_ADDR]],
1000 // CHECK: bitcast [2 x [[S_FLOAT_TY]]]* [[VAR3_ORIG]] to [[S_FLOAT_TY]]*
1001 // CHECK: getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[VAR3_PRIV]], i32 0, i32 0
1002 // CHECK: getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* %{{.+}}, i64 2
1003
1004 // CHECK: store [2 x [[S_FLOAT_TY]]]* [[VAR3_PRIV]], [2 x [[S_FLOAT_TY]]]** %
1005
1006 // CHECK: ret void
1007
1008 // CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]()
1009 // CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]],
1010 // CHECK: call {{.*}} [[S_INT_TY_CONSTR:@.+]]([[S_INT_TY]]* [[TEST]])
1011 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 6, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, i32*, [[S_INT_TY]]*, [[S_INT_TY]]*, i32*, [2 x i32]*, [2 x [[S_INT_TY]]]*)* [[TMAIN_MICROTASK:@.+]] to void
1012 // CHECK: call {{.*}} [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]*
1013 // CHECK: ret
1014 //
1015 // CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, i32* dereferenceable(4) %{{.+}}, [[S_INT_TY]]* dereferenceable(4) %{{.+}}, [[S_INT_TY]]* dereferenceable(4) %{{.+}}, i32* dereferenceable(4) %{{.+}}, [2 x i32]* dereferenceable(8) %{{.+}}, [2 x [[S_INT_TY]]]* dereferenceable(8) %{{.+}})
1016 // CHECK: alloca i{{[0-9]+}},
1017 // CHECK: alloca i{{[0-9]+}},
1018 // CHECK: alloca i{{[0-9]+}},
1019 // CHECK: alloca i{{[0-9]+}},
1020 // CHECK: alloca i{{[0-9]+}},
1021 // CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}},
1022 // CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]],
1023 // CHECK: [[VAR1_PRIV:%.+]] = alloca [[S_INT_TY]],
1024 // CHECK: [[T_VAR1_PRIV:%.+]] = alloca i{{[0-9]+}},
1025
1026 // Reduction list for runtime.
1027 // CHECK: [[RED_LIST:%.+]] = alloca [4 x i8*],
1028
1029 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
1030
1031 // CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %
1032 // CHECK: [[VAR1_REF:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** %
1033 // CHECK: [[T_VAR1_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %
1034
1035 // For + reduction operation initial value of private variable is 0.
1036 // CHECK: store i{{[0-9]+}} 0, i{{[0-9]+}}* [[T_VAR_PRIV]],
1037
1038 // For & reduction operation initial value of private variable is ones in all bits.
1039 // CHECK: [[VAR_REF:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** %
1040 // CHECK: call {{.*}} [[S_INT_TY_CONSTR:@.+]]([[S_INT_TY]]* [[VAR_PRIV]])
1041
1042 // For && reduction operation initial value of private variable is 1.0.
1043 // CHECK: call {{.*}} [[S_INT_TY_CONSTR:@.+]]([[S_INT_TY]]* [[VAR1_PRIV]])
1044
1045 // For min reduction operation initial value of private variable is largest repesentable value.
1046 // CHECK: store i{{[0-9]+}} 2147483647, i{{[0-9]+}}* [[T_VAR1_PRIV]],
1047
1048 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_ADDR]]
1049 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
1050 // CHECK: call void @__kmpc_for_static_init_4(
1051 // Skip checks for internal operations.
1052 // CHECK: call void @__kmpc_for_static_fini(
1053
1054 // void *RedList[<n>] = {<ReductionVars>[0], ..., <ReductionVars>[<n>-1]};
1055
1056 // CHECK: [[T_VAR_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 0
1057 // CHECK: [[BITCAST:%.+]] = bitcast i{{[0-9]+}}* [[T_VAR_PRIV]] to i8*
1058 // CHECK: store i8* [[BITCAST]], i8** [[T_VAR_PRIV_REF]],
1059 // CHECK: [[VAR_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 1
1060 // CHECK: [[BITCAST:%.+]] = bitcast [[S_INT_TY]]* [[VAR_PRIV]] to i8*
1061 // CHECK: store i8* [[BITCAST]], i8** [[VAR_PRIV_REF]],
1062 // CHECK: [[VAR1_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 2
1063 // CHECK: [[BITCAST:%.+]] = bitcast [[S_INT_TY]]* [[VAR1_PRIV]] to i8*
1064 // CHECK: store i8* [[BITCAST]], i8** [[VAR1_PRIV_REF]],
1065 // CHECK: [[T_VAR1_PRIV_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST]], i64 0, i64 3
1066 // CHECK: [[BITCAST:%.+]] = bitcast i{{[0-9]+}}* [[T_VAR1_PRIV]] to i8*
1067 // CHECK: store i8* [[BITCAST]], i8** [[T_VAR1_PRIV_REF]],
1068
1069 // res = __kmpc_reduce_nowait(<loc>, <gtid>, <n>, sizeof(RedList), RedList, reduce_func, &<lock>);
1070
1071 // CHECK: [[BITCAST:%.+]] = bitcast [4 x i8*]* [[RED_LIST]] to i8*
1072 // CHECK: [[RES:%.+]] = call i32 @__kmpc_reduce_nowait(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], i32 4, i64 32, i8* [[BITCAST]], void (i8*, i8*)* [[REDUCTION_FUNC:@.+]], [8 x i32]* [[REDUCTION_LOCK]])
1073
1074 // switch(res)
1075 // CHECK: switch i32 [[RES]], label %[[RED_DONE:.+]] [
1076 // CHECK: i32 1, label %[[CASE1:.+]]
1077 // CHECK: i32 2, label %[[CASE2:.+]]
1078 // CHECK: ]
1079
1080 // case 1:
1081 // t_var += t_var_reduction;
1082 // CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_REF]],
1083 // CHECK: [[T_VAR_PRIV_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]],
1084 // CHECK: [[UP:%.+]] = add nsw i{{[0-9]+}} [[T_VAR_VAL]], [[T_VAR_PRIV_VAL]]
1085 // CHECK: store i{{[0-9]+}} [[UP]], i{{[0-9]+}}* [[T_VAR_REF]],
1086
1087 // var = var.operator &(var_reduction);
1088 // CHECK: [[UP:%.+]] = call dereferenceable(4) [[S_INT_TY]]* @{{.+}}([[S_INT_TY]]* [[VAR_REF]], [[S_INT_TY]]* dereferenceable(4) [[VAR_PRIV]])
1089 // CHECK: [[BC1:%.+]] = bitcast [[S_INT_TY]]* [[VAR_REF]] to i8*
1090 // CHECK: [[BC2:%.+]] = bitcast [[S_INT_TY]]* [[UP]] to i8*
1091 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
1092
1093 // var1 = var1.operator &&(var1_reduction);
1094 // CHECK: [[TO_INT:%.+]] = call i{{[0-9]+}} @{{.+}}([[S_INT_TY]]* [[VAR1_REF]])
1095 // CHECK: [[VAR1_BOOL:%.+]] = icmp ne i{{[0-9]+}} [[TO_INT]], 0
1096 // CHECK: br i1 [[VAR1_BOOL]], label %[[TRUE:.+]], label %[[END2:.+]]
1097 // CHECK: [[TRUE]]
1098 // CHECK: [[TO_INT:%.+]] = call i{{[0-9]+}} @{{.+}}([[S_INT_TY]]* [[VAR1_PRIV]])
1099 // CHECK: [[VAR1_REDUCTION_BOOL:%.+]] = icmp ne i{{[0-9]+}} [[TO_INT]], 0
1100 // CHECK: br label %[[END2]]
1101 // CHECK: [[END2]]
1102 // CHECK: [[COND_LVALUE:%.+]] = phi i1 [ false, %{{.+}} ], [ [[VAR1_REDUCTION_BOOL]], %[[TRUE]] ]
1103 // CHECK: [[CONV:%.+]] = zext i1 [[COND_LVALUE]] to i32
1104 // CHECK:  call void @{{.+}}([[S_INT_TY]]* [[COND_LVALUE:%.+]], i32 [[CONV]])
1105 // CHECK: [[BC1:%.+]] = bitcast [[S_INT_TY]]* [[VAR1_REF]] to i8*
1106 // CHECK: [[BC2:%.+]] = bitcast [[S_INT_TY]]* [[COND_LVALUE]] to i8*
1107 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
1108
1109 // t_var1 = min(t_var1, t_var1_reduction);
1110 // CHECK: [[T_VAR1_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR1_REF]],
1111 // CHECK: [[T_VAR1_PRIV_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR1_PRIV]],
1112 // CHECK: [[CMP:%.+]] = icmp slt i{{[0-9]+}} [[T_VAR1_VAL]], [[T_VAR1_PRIV_VAL]]
1113 // CHECK: br i1 [[CMP]]
1114 // CHECK: [[UP:%.+]] = phi i32
1115 // CHECK: store i{{[0-9]+}} [[UP]], i{{[0-9]+}}* [[T_VAR1_REF]],
1116
1117 // __kmpc_end_reduce_nowait(<loc>, <gtid>, &<lock>);
1118 // CHECK: call void @__kmpc_end_reduce_nowait(%{{.+}}* [[REDUCTION_LOC]], i32 [[GTID]], [8 x i32]* [[REDUCTION_LOCK]])
1119
1120 // break;
1121 // CHECK: br label %[[RED_DONE]]
1122
1123 // case 2:
1124 // t_var += t_var_reduction;
1125 // CHECK: [[T_VAR_PRIV_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]]
1126 // CHECK: atomicrmw add i32* [[T_VAR_REF]], i32 [[T_VAR_PRIV_VAL]] monotonic
1127
1128 // var = var.operator &(var_reduction);
1129 // CHECK: call void @__kmpc_critical(
1130 // CHECK: [[UP:%.+]] = call dereferenceable(4) [[S_INT_TY]]* @{{.+}}([[S_INT_TY]]* [[VAR_REF]], [[S_INT_TY]]* dereferenceable(4) [[VAR_PRIV]])
1131 // CHECK: [[BC1:%.+]] = bitcast [[S_INT_TY]]* [[VAR_REF]] to i8*
1132 // CHECK: [[BC2:%.+]] = bitcast [[S_INT_TY]]* [[UP]] to i8*
1133 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
1134 // CHECK: call void @__kmpc_end_critical(
1135
1136 // var1 = var1.operator &&(var1_reduction);
1137 // CHECK: call void @__kmpc_critical(
1138 // CHECK: [[TO_INT:%.+]] = call i{{[0-9]+}} @{{.+}}([[S_INT_TY]]* [[VAR1_REF]])
1139 // CHECK: [[VAR1_BOOL:%.+]] = icmp ne i{{[0-9]+}} [[TO_INT]], 0
1140 // CHECK: br i1 [[VAR1_BOOL]], label %[[TRUE:.+]], label %[[END2:.+]]
1141 // CHECK: [[TRUE]]
1142 // CHECK: [[TO_INT:%.+]] = call i{{[0-9]+}} @{{.+}}([[S_INT_TY]]* [[VAR1_PRIV]])
1143 // CHECK: [[VAR1_REDUCTION_BOOL:%.+]] = icmp ne i{{[0-9]+}} [[TO_INT]], 0
1144 // CHECK: br label %[[END2]]
1145 // CHECK: [[END2]]
1146 // CHECK: [[COND_LVALUE:%.+]] = phi i1 [ false, %{{.+}} ], [ [[VAR1_REDUCTION_BOOL]], %[[TRUE]] ]
1147 // CHECK: [[CONV:%.+]] = zext i1 [[COND_LVALUE]] to i32
1148 // CHECK:  call void @{{.+}}([[S_INT_TY]]* [[COND_LVALUE:%.+]], i32 [[CONV]])
1149 // CHECK: [[BC1:%.+]] = bitcast [[S_INT_TY]]* [[VAR1_REF]] to i8*
1150 // CHECK: [[BC2:%.+]] = bitcast [[S_INT_TY]]* [[COND_LVALUE]] to i8*
1151 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
1152 // CHECK: call void @__kmpc_end_critical(
1153
1154 // t_var1 = min(t_var1, t_var1_reduction);
1155 // CHECK: [[T_VAR1_PRIV_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR1_PRIV]]
1156 // CHECK: atomicrmw min i32* [[T_VAR1_REF]], i32 [[T_VAR1_PRIV_VAL]] monotonic
1157
1158 // break;
1159 // CHECK: br label %[[RED_DONE]]
1160 // CHECK: [[RED_DONE]]
1161 // CHECK-DAG: call {{.*}} [[S_INT_TY_DESTR]]([[S_INT_TY]]* [[VAR_PRIV]])
1162 // CHECK-DAG: call {{.*}} [[S_INT_TY_DESTR]]([[S_INT_TY]]*
1163 // CHECK: ret void
1164
1165 // void reduce_func(void *lhs[<n>], void *rhs[<n>]) {
1166 //  *(Type0*)lhs[0] = ReductionOperation0(*(Type0*)lhs[0], *(Type0*)rhs[0]);
1167 //  ...
1168 //  *(Type<n>-1*)lhs[<n>-1] = ReductionOperation<n>-1(*(Type<n>-1*)lhs[<n>-1],
1169 //  *(Type<n>-1*)rhs[<n>-1]);
1170 // }
1171 // CHECK: define internal void [[REDUCTION_FUNC]](i8*, i8*)
1172 // t_var_lhs = (i{{[0-9]+}}*)lhs[0];
1173 // CHECK: [[T_VAR_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS:%.+]], i64 0, i64 0
1174 // CHECK: [[T_VAR_RHS_VOID:%.+]] = load i8*, i8** [[T_VAR_RHS_REF]],
1175 // CHECK: [[T_VAR_RHS:%.+]] = bitcast i8* [[T_VAR_RHS_VOID]] to i{{[0-9]+}}*
1176 // t_var_rhs = (i{{[0-9]+}}*)rhs[0];
1177 // CHECK: [[T_VAR_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS:%.+]], i64 0, i64 0
1178 // CHECK: [[T_VAR_LHS_VOID:%.+]] = load i8*, i8** [[T_VAR_LHS_REF]],
1179 // CHECK: [[T_VAR_LHS:%.+]] = bitcast i8* [[T_VAR_LHS_VOID]] to i{{[0-9]+}}*
1180
1181 // var_lhs = (S<i{{[0-9]+}}>*)lhs[1];
1182 // CHECK: [[VAR_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS]], i64 0, i64 1
1183 // CHECK: [[VAR_RHS_VOID:%.+]] = load i8*, i8** [[VAR_RHS_REF]],
1184 // CHECK: [[VAR_RHS:%.+]] = bitcast i8* [[VAR_RHS_VOID]] to [[S_INT_TY]]*
1185 // var_rhs = (S<i{{[0-9]+}}>*)rhs[1];
1186 // CHECK: [[VAR_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 1
1187 // CHECK: [[VAR_LHS_VOID:%.+]] = load i8*, i8** [[VAR_LHS_REF]],
1188 // CHECK: [[VAR_LHS:%.+]] = bitcast i8* [[VAR_LHS_VOID]] to [[S_INT_TY]]*
1189
1190 // var1_lhs = (S<i{{[0-9]+}}>*)lhs[2];
1191 // CHECK: [[VAR1_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS]], i64 0, i64 2
1192 // CHECK: [[VAR1_RHS_VOID:%.+]] = load i8*, i8** [[VAR1_RHS_REF]],
1193 // CHECK: [[VAR1_RHS:%.+]] = bitcast i8* [[VAR1_RHS_VOID]] to [[S_INT_TY]]*
1194 // var1_rhs = (S<i{{[0-9]+}}>*)rhs[2];
1195 // CHECK: [[VAR1_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 2
1196 // CHECK: [[VAR1_LHS_VOID:%.+]] = load i8*, i8** [[VAR1_LHS_REF]],
1197 // CHECK: [[VAR1_LHS:%.+]] = bitcast i8* [[VAR1_LHS_VOID]] to [[S_INT_TY]]*
1198
1199 // t_var1_lhs = (i{{[0-9]+}}*)lhs[3];
1200 // CHECK: [[T_VAR1_RHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_RHS]], i64 0, i64 3
1201 // CHECK: [[T_VAR1_RHS_VOID:%.+]] = load i8*, i8** [[T_VAR1_RHS_REF]],
1202 // CHECK: [[T_VAR1_RHS:%.+]] = bitcast i8* [[T_VAR1_RHS_VOID]] to i{{[0-9]+}}*
1203 // t_var1_rhs = (i{{[0-9]+}}*)rhs[3];
1204 // CHECK: [[T_VAR1_LHS_REF:%.+]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[RED_LIST_LHS]], i64 0, i64 3
1205 // CHECK: [[T_VAR1_LHS_VOID:%.+]] = load i8*, i8** [[T_VAR1_LHS_REF]],
1206 // CHECK: [[T_VAR1_LHS:%.+]] = bitcast i8* [[T_VAR1_LHS_VOID]] to i{{[0-9]+}}*
1207
1208 // t_var_lhs += t_var_rhs;
1209 // CHECK: [[T_VAR_LHS_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_LHS]],
1210 // CHECK: [[T_VAR_RHS_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_RHS]],
1211 // CHECK: [[UP:%.+]] = add nsw i{{[0-9]+}} [[T_VAR_LHS_VAL]], [[T_VAR_RHS_VAL]]
1212 // CHECK: store i{{[0-9]+}} [[UP]], i{{[0-9]+}}* [[T_VAR_LHS]],
1213
1214 // var_lhs = var_lhs.operator &(var_rhs);
1215 // CHECK: [[UP:%.+]] = call dereferenceable(4) [[S_INT_TY]]* @{{.+}}([[S_INT_TY]]* [[VAR_LHS]], [[S_INT_TY]]* dereferenceable(4) [[VAR_RHS]])
1216 // CHECK: [[BC1:%.+]] = bitcast [[S_INT_TY]]* [[VAR_LHS]] to i8*
1217 // CHECK: [[BC2:%.+]] = bitcast [[S_INT_TY]]* [[UP]] to i8*
1218 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
1219
1220 // var1_lhs = var1_lhs.operator &&(var1_rhs);
1221 // CHECK: [[TO_INT:%.+]] = call i{{[0-9]+}} @{{.+}}([[S_INT_TY]]* [[VAR1_LHS]])
1222 // CHECK: [[VAR1_BOOL:%.+]] = icmp ne i{{[0-9]+}} [[TO_INT]], 0
1223 // CHECK: br i1 [[VAR1_BOOL]], label %[[TRUE:.+]], label %[[END2:.+]]
1224 // CHECK: [[TRUE]]
1225 // CHECK: [[TO_INT:%.+]] = call i{{[0-9]+}} @{{.+}}([[S_INT_TY]]* [[VAR1_RHS]])
1226 // CHECK: [[VAR1_REDUCTION_BOOL:%.+]] = icmp ne i{{[0-9]+}} [[TO_INT]], 0
1227 // CHECK: br label %[[END2]]
1228 // CHECK: [[END2]]
1229 // CHECK: [[COND_LVALUE:%.+]] = phi i1 [ false, %{{.+}} ], [ [[VAR1_REDUCTION_BOOL]], %[[TRUE]] ]
1230 // CHECK: [[CONV:%.+]] = zext i1 [[COND_LVALUE]] to i32
1231 // CHECK:  call void @{{.+}}([[S_INT_TY]]* [[COND_LVALUE:%.+]], i32 [[CONV]])
1232 // CHECK: [[BC1:%.+]] = bitcast [[S_INT_TY]]* [[VAR1_LHS]] to i8*
1233 // CHECK: [[BC2:%.+]] = bitcast [[S_INT_TY]]* [[COND_LVALUE]] to i8*
1234 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[BC1]], i8* [[BC2]], i64 4, i32 4, i1 false)
1235
1236 // t_var1_lhs = min(t_var1_lhs, t_var1_rhs);
1237 // CHECK: [[T_VAR1_LHS_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR1_LHS]],
1238 // CHECK: [[T_VAR1_RHS_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR1_RHS]],
1239 // CHECK: [[CMP:%.+]] = icmp slt i{{[0-9]+}} [[T_VAR1_LHS_VAL]], [[T_VAR1_RHS_VAL]]
1240 // CHECK: br i1 [[CMP]]
1241 // CHECK: [[UP:%.+]] = phi i32
1242 // CHECK: store i{{[0-9]+}} [[UP]], i{{[0-9]+}}* [[T_VAR1_LHS]],
1243 // CHECK: ret void
1244
1245 #endif
1246