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 7 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s 8 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple x86_64-apple-darwin10 -emit-pch -o %t %s 9 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple x86_64-apple-darwin10 -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s 10 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -std=c++11 -DLAMBDA -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s 11 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -fblocks -DBLOCKS -triple x86_64-apple-darwin10 -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 enum omp_allocator_handle_t { 18 omp_null_allocator = 0, 19 omp_default_mem_alloc = 1, 20 omp_large_cap_mem_alloc = 2, 21 omp_const_mem_alloc = 3, 22 omp_high_bw_mem_alloc = 4, 23 omp_low_lat_mem_alloc = 5, 24 omp_cgroup_mem_alloc = 6, 25 omp_pteam_mem_alloc = 7, 26 omp_thread_mem_alloc = 8, 27 KMP_ALLOCATOR_MAX_HANDLE = __UINTPTR_MAX__ 28 }; 29 30 struct SS { 31 int a; 32 int b : 4; 33 int &c; 34 SS(int &d) : a(0), b(0), c(d) { 35 #pragma omp parallel 36 #pragma omp for lastprivate(a, b, c) 37 for (int i = 0; i < 2; ++i) 38 #ifdef LAMBDA 39 [&]() { 40 ++this->a, --b, (this)->c /= 1; 41 #pragma omp parallel 42 #pragma omp for lastprivate(a, b, c) 43 for (int i = 0; i < 2; ++i) 44 ++(this)->a, --b, this->c /= 1; 45 }(); 46 #elif defined(BLOCKS) 47 ^{ 48 ++a; 49 --this->b; 50 (this)->c /= 1; 51 #pragma omp parallel 52 #pragma omp for lastprivate(a, b, c) 53 for (int i = 0; i < 2; ++i) 54 ++(this)->a, --b, this->c /= 1; 55 }(); 56 #else 57 ++this->a, --b, c /= 1; 58 #endif 59 #pragma omp for 60 for (a = 0; a < 2; ++a) 61 #ifdef LAMBDA 62 [&]() { 63 --this->a, ++b, (this)->c *= 2; 64 #pragma omp parallel 65 #pragma omp for lastprivate(b) 66 for (b = 0; b < 2; ++b) 67 ++(this)->a, --b, this->c /= 1; 68 }(); 69 #elif defined(BLOCKS) 70 ^{ 71 ++a; 72 --this->b; 73 (this)->c /= 1; 74 #pragma omp parallel 75 #pragma omp for 76 for (c = 0; c < 2; ++c) 77 ++(this)->a, --b, this->c /= 1; 78 }(); 79 #else 80 ++this->a, --b, c /= 1; 81 #endif 82 } 83 }; 84 85 template <typename T> 86 struct SST { 87 T a; 88 SST() : a(T()) { 89 #pragma omp parallel 90 #pragma omp for lastprivate(a) 91 for (int i = 0; i < 2; ++i) 92 #ifdef LAMBDA 93 [&]() { 94 [&]() { 95 ++this->a; 96 #pragma omp parallel 97 #pragma omp for lastprivate(a) 98 for (int i = 0; i < 2; ++i) 99 ++(this)->a; 100 }(); 101 }(); 102 #elif defined(BLOCKS) 103 ^{ 104 ^{ 105 ++a; 106 #pragma omp parallel 107 #pragma omp for lastprivate(a) 108 for (int i = 0; i < 2; ++i) 109 ++(this)->a; 110 }(); 111 }(); 112 #else 113 ++(this)->a; 114 #endif 115 #pragma omp for 116 for (a = 0; a < 2; ++a) 117 #ifdef LAMBDA 118 [&]() { 119 ++this->a; 120 #pragma omp parallel 121 #pragma omp for 122 for (a = 0; a < 2; ++(this)->a) 123 ++(this)->a; 124 }(); 125 #elif defined(BLOCKS) 126 ^{ 127 ++a; 128 #pragma omp parallel 129 #pragma omp for 130 for (this->a = 0; a < 2; ++a) 131 ++(this)->a; 132 }(); 133 #else 134 ++(this)->a; 135 #endif 136 } 137 }; 138 139 template <class T> 140 struct S { 141 T f; 142 S(T a) : f(a) {} 143 S() : f() {} 144 S<T> &operator=(const S<T> &); 145 operator T() { return T(); } 146 ~S() {} 147 }; 148 149 volatile int g __attribute__((aligned(128)))= 1212; 150 volatile int &g1 = g; 151 float f; 152 char cnt; 153 154 // CHECK: [[SS_TY:%.+]] = type { i{{[0-9]+}}, i8 155 // LAMBDA: [[SS_TY:%.+]] = type { i{{[0-9]+}}, i8 156 // BLOCKS: [[SS_TY:%.+]] = type { i{{[0-9]+}}, i8 157 // CHECK: [[S_FLOAT_TY:%.+]] = type { float } 158 // CHECK: [[S_INT_TY:%.+]] = type { i32 } 159 // CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr global %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8* 160 // CHECK-DAG: [[X:@.+]] = global double 0.0 161 // CHECK-DAG: [[F:@.+]] = global float 0.0 162 // CHECK-DAG: [[CNT:@.+]] = global i8 0 163 template <typename T> 164 T tmain() { 165 S<T> test; 166 SST<T> sst; 167 T t_var __attribute__((aligned(128))) = T(); 168 T vec[] __attribute__((aligned(128))) = {1, 2}; 169 S<T> s_arr[] __attribute__((aligned(128))) = {1, 2}; 170 S<T> &var __attribute__((aligned(128))) = test; 171 #pragma omp parallel 172 #pragma omp for lastprivate(t_var, vec, s_arr, var) 173 for (int i = 0; i < 2; ++i) { 174 vec[i] = t_var; 175 s_arr[i] = var; 176 } 177 return T(); 178 } 179 180 namespace A { 181 double x; 182 } 183 namespace B { 184 using A::x; 185 } 186 187 int main() { 188 static int sivar; 189 SS ss(sivar); 190 #ifdef LAMBDA 191 // LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212, 192 // LAMBDA: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0, 193 // LAMBDA-LABEL: @main 194 // LAMBDA: alloca [[SS_TY]], 195 // LAMBDA: alloca [[CAP_TY:%.+]], 196 // FIXME: The outer lambda should not capture 'sivar'; that capture is not 197 // used for anything. 198 // LAMBDA: store {{.*}}@_ZZ4mainE5sivar, 199 // LAMBDA: call void [[OUTER_LAMBDA:@.+]]([[CAP_TY]]* 200 [&]() { 201 // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]]( 202 // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i32* @_ZZ4mainE5sivar) 203 #pragma omp parallel 204 #pragma omp for lastprivate(g, g1, sivar) 205 for (int i = 0; i < 2; ++i) { 206 // LAMBDA: define {{.+}} @{{.+}}([[SS_TY]]* 207 // LAMBDA: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0 208 // LAMBDA: store i{{[0-9]+}} 0, i{{[0-9]+}}* % 209 // LAMBDA: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1 210 // LAMBDA: store i8 211 // LAMBDA: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2 212 // LAMBDA: 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]+}}*, [[SS_TY]]*)* [[SS_MICROTASK:@.+]] to void 213 // LAMBDA: call void @__kmpc_for_static_init_4( 214 // LAMBDA-NOT: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0 215 // LAMBDA: call{{.*}} void [[SS_LAMBDA1:@[^ ]+]] 216 // LAMBDA: call void @__kmpc_for_static_fini(% 217 // LAMBDA: ret 218 219 // LAMBDA: define internal void [[SS_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}) 220 // LAMBDA: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 0 221 // LAMBDA-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1 222 // LAMBDA: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 2 223 // LAMBDA: call void @__kmpc_for_static_init_4( 224 // LAMBDA-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* 225 // LAMBDA: call{{.*}} void [[SS_LAMBDA:@[^ ]+]] 226 // LAMBDA: call void @__kmpc_for_static_fini( 227 // LAMBDA: br i1 228 // LAMBDA: [[B_REF:%.+]] = getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1 229 // LAMBDA: store i8 %{{.+}}, i8* [[B_REF]], 230 // LAMBDA: br label 231 // LAMBDA: ret void 232 233 // LAMBDA: define internal void @{{.+}}(i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}, i32* {{.+}}, i32* {{.+}}, i32* {{.+}}) 234 // LAMBDA: alloca i{{[0-9]+}}, 235 // LAMBDA: alloca i{{[0-9]+}}, 236 // LAMBDA: alloca i{{[0-9]+}}, 237 // LAMBDA: alloca i{{[0-9]+}}, 238 // LAMBDA: alloca i{{[0-9]+}}, 239 // LAMBDA: alloca i{{[0-9]+}}, 240 // LAMBDA: [[A_PRIV:%.+]] = alloca i{{[0-9]+}}, 241 // LAMBDA: [[B_PRIV:%.+]] = alloca i{{[0-9]+}}, 242 // LAMBDA: [[C_PRIV:%.+]] = alloca i{{[0-9]+}}, 243 // LAMBDA: store i{{[0-9]+}}* [[A_PRIV]], i{{[0-9]+}}** [[REFA:%.+]], 244 // LAMBDA: store i{{[0-9]+}}* [[C_PRIV]], i{{[0-9]+}}** [[REFC:%.+]], 245 // LAMBDA: call void @__kmpc_for_static_init_4( 246 // LAMBDA: [[A_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFA]], 247 // LAMBDA-NEXT: [[A_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[A_PRIV]], 248 // LAMBDA-NEXT: [[INC:%.+]] = add nsw i{{[0-9]+}} [[A_VAL]], 1 249 // LAMBDA-NEXT: store i{{[0-9]+}} [[INC]], i{{[0-9]+}}* [[A_PRIV]], 250 // LAMBDA-NEXT: [[B_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[B_PRIV]], 251 // LAMBDA-NEXT: [[DEC:%.+]] = add nsw i{{[0-9]+}} [[B_VAL]], -1 252 // LAMBDA-NEXT: store i{{[0-9]+}} [[DEC]], i{{[0-9]+}}* [[B_PRIV]], 253 // LAMBDA-NEXT: [[C_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFC]], 254 // LAMBDA-NEXT: [[C_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[C_PRIV]], 255 // LAMBDA-NEXT: [[DIV:%.+]] = sdiv i{{[0-9]+}} [[C_VAL]], 1 256 // LAMBDA-NEXT: store i{{[0-9]+}} [[DIV]], i{{[0-9]+}}* [[C_PRIV]], 257 // LAMBDA: call void @__kmpc_for_static_fini( 258 // LAMBDA: br i1 259 // LAMBDA: br label 260 // LAMBDA: ret void 261 262 // LAMBDA: define internal void @{{.+}}(i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}) 263 // LAMBDA: ret void 264 265 // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* noalias %{{.+}}, i32* noalias %{{.+}}, i32* dereferenceable(4) [[SIVAR:%.+]]) 266 // LAMBDA: alloca i{{[0-9]+}}, 267 // LAMBDA: alloca i{{[0-9]+}}, 268 // LAMBDA: alloca i{{[0-9]+}}, 269 // LAMBDA: alloca i{{[0-9]+}}, 270 // LAMBDA: alloca i{{[0-9]+}}, 271 // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, align 128 272 // LAMBDA: [[G1_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, 273 // LAMBDA: [[G1_PRIVATE_REF:%.+]] = alloca i{{[0-9]+}}*, 274 // LAMBDA: [[SIVAR_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, 275 // LAMBDA: [[SIVAR_PRIVATE_ADDR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %{{.+}}, 276 277 // LAMBDA: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %{{.+}} 278 // LAMBDA: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] 279 280 // LAMBDA: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) 281 // LAMBDA: store i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], 282 // LAMBDA: [[G1_PRIVATE_ADDR:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[G1_PRIVATE_REF]], 283 // LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G1_PRIVATE_ADDR]], 284 // LAMBDA: store i{{[0-9]+}} 2, i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]], 285 // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 286 // LAMBDA: store i{{[0-9]+}}* [[G_PRIVATE_ADDR]], i{{[0-9]+}}** [[G_PRIVATE_ADDR_REF]] 287 // LAMBDA: [[G1_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 288 // LAMBDA: [[G1_PRIVATE_ADDR:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[G1_PRIVATE_REF]], 289 // LAMBDA: store i{{[0-9]+}}* [[G1_PRIVATE_ADDR]], i{{[0-9]+}}** [[G1_PRIVATE_ADDR_REF]] 290 // LAMBDA: [[SIVAR_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 2 291 // LAMBDA: store i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]], i{{[0-9]+}}** [[SIVAR_PRIVATE_ADDR_REF]] 292 // LAMBDA: call void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]]) 293 // LAMBDA: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]]) 294 g = 1; 295 g1 = 1; 296 sivar = 2; 297 // Check for final copying of private values back to original vars. 298 // LAMBDA: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]], 299 // LAMBDA: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0 300 // LAMBDA: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]] 301 // LAMBDA: [[LAST_THEN]] 302 // Actual copying. 303 304 // original g=private_g; 305 // LAMBDA: [[G_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], 306 // LAMBDA: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G]], 307 308 // original sivar=private_sivar; 309 // LAMBDA: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]], 310 // LAMBDA: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* %{{.+}}, 311 // LAMBDA: br label %[[LAST_DONE]] 312 // LAMBDA: [[LAST_DONE]] 313 // LAMBDA: call void @__kmpc_barrier(%{{.+}}* @{{.+}}, i{{[0-9]+}} [[GTID]]) 314 [&]() { 315 // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]]) 316 // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]], 317 g = 2; 318 g1 = 2; 319 sivar = 4; 320 // LAMBDA: [[ARG_PTR:%.+]] = load %{{.+}}*, %{{.+}}** [[ARG_PTR_REF]] 321 // LAMBDA: [[G_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 322 // LAMBDA: [[G_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[G_PTR_REF]] 323 // LAMBDA: store i{{[0-9]+}} 2, i{{[0-9]+}}* [[G_REF]] 324 // LAMBDA: [[G1_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 1 325 // LAMBDA: [[G1_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[G1_PTR_REF]] 326 // LAMBDA: store i{{[0-9]+}} 2, i{{[0-9]+}}* [[G1_REF]] 327 // LAMBDA: [[SIVAR_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 2 328 // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] 329 // LAMBDA: store i{{[0-9]+}} 4, i{{[0-9]+}}* [[SIVAR_REF]] 330 }(); 331 } 332 }(); 333 return 0; 334 #elif defined(BLOCKS) 335 // BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212, 336 // BLOCKS-LABEL: @main 337 // BLOCKS: call 338 // BLOCKS: call void {{%.+}}(i8 339 ^{ 340 // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* 341 // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) 342 #pragma omp parallel 343 #pragma omp for lastprivate(g, g1, sivar) 344 for (int i = 0; i < 2; ++i) { 345 // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* noalias %{{.+}}, i32* noalias %{{.+}}, i32* dereferenceable(4) [[SIVAR:%.+]]) 346 // BLOCKS: alloca i{{[0-9]+}}, 347 // BLOCKS: alloca i{{[0-9]+}}, 348 // BLOCKS: alloca i{{[0-9]+}}, 349 // BLOCKS: alloca i{{[0-9]+}}, 350 // BLOCKS: alloca i{{[0-9]+}}, 351 // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, align 128 352 // BLOCKS: [[G1_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, align 4 353 // BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, 354 // BLOCKS: store i{{[0-9]+}}* [[SIVAR]], i{{[0-9]+}}** [[SIVAR_ADDR:%.+]], 355 // BLOCKS: {{.+}} = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_ADDR]] 356 // BLOCKS: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %{{.+}} 357 // BLOCKS: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] 358 // BLOCKS: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) 359 // BLOCKS: store i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], 360 // BLOCKS-NOT: [[G]]{{[[^:word:]]}} 361 // BLOCKS: i{{[0-9]+}}* [[G_PRIVATE_ADDR]] 362 // BLOCKS-NOT: [[G]]{{[[^:word:]]}} 363 // BLOCKS: call void {{%.+}}(i8 364 // BLOCKS: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]]) 365 g = 1; 366 g1 = 1; 367 sivar = 2; 368 // Check for final copying of private values back to original vars. 369 // BLOCKS: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]], 370 // BLOCKS: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0 371 // BLOCKS: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]] 372 // BLOCKS: [[LAST_THEN]] 373 // Actual copying. 374 375 // original g=private_g; 376 // BLOCKS: [[G_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[G_PRIVATE_ADDR]], 377 // BLOCKS: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G]], 378 // BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]], 379 // BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* %{{.+}}, 380 // BLOCKS: br label %[[LAST_DONE]] 381 // BLOCKS: [[LAST_DONE]] 382 // BLOCKS: call void @__kmpc_barrier(%{{.+}}* @{{.+}}, i{{[0-9]+}} [[GTID]]) 383 g = 1; 384 g1 = 1; 385 ^{ 386 // BLOCKS: define {{.+}} void {{@.+}}(i8* 387 g = 2; 388 g1 = 1; 389 sivar = 4; 390 // BLOCKS-NOT: [[G]]{{[[^:word:]]}} 391 // BLOCKS: store i{{[0-9]+}} 2, i{{[0-9]+}}* 392 // BLOCKS-NOT: [[G]]{{[[^:word:]]}} 393 // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} 394 // BLOCKS: store i{{[0-9]+}} 4, i{{[0-9]+}}* 395 // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} 396 // BLOCKS: ret 397 }(); 398 } 399 }(); 400 return 0; 401 // BLOCKS: define {{.+}} @{{.+}}([[SS_TY]]* 402 // BLOCKS: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0 403 // BLOCKS: store i{{[0-9]+}} 0, i{{[0-9]+}}* % 404 // BLOCKS: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1 405 // BLOCKS: store i8 406 // BLOCKS: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2 407 // BLOCKS: 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]+}}*, [[SS_TY]]*)* [[SS_MICROTASK:@.+]] to void 408 // BLOCKS: call void @__kmpc_for_static_init_4( 409 // BLOCKS-NOT: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0 410 // BLOCKS: call void 411 // BLOCKS: call void @__kmpc_for_static_fini(% 412 // BLOCKS: ret 413 414 // BLOCKS: define internal void [[SS_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}) 415 // BLOCKS: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 0 416 // BLOCKS-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1 417 // BLOCKS: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 2 418 // BLOCKS: call void @__kmpc_for_static_init_4( 419 // BLOCKS-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* 420 // BLOCKS: call{{.*}} void 421 // BLOCKS: call void @__kmpc_for_static_fini( 422 // BLOCKS: br i1 423 // BLOCKS: [[B_REF:%.+]] = getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1 424 // BLOCKS: store i8 %{{.+}}, i8* [[B_REF]], 425 // BLOCKS: br label 426 // BLOCKS: ret void 427 428 // BLOCKS: define internal void @{{.+}}(i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}, i32* {{.+}}, i32* {{.+}}, i32* {{.+}}) 429 // BLOCKS: alloca i{{[0-9]+}}, 430 // BLOCKS: alloca i{{[0-9]+}}, 431 // BLOCKS: alloca i{{[0-9]+}}, 432 // BLOCKS: alloca i{{[0-9]+}}, 433 // BLOCKS: alloca i{{[0-9]+}}, 434 // BLOCKS: alloca i{{[0-9]+}}, 435 // BLOCKS: [[A_PRIV:%.+]] = alloca i{{[0-9]+}}, 436 // BLOCKS: [[B_PRIV:%.+]] = alloca i{{[0-9]+}}, 437 // BLOCKS: [[C_PRIV:%.+]] = alloca i{{[0-9]+}}, 438 // BLOCKS: store i{{[0-9]+}}* [[A_PRIV]], i{{[0-9]+}}** [[REFA:%.+]], 439 // BLOCKS: store i{{[0-9]+}}* [[C_PRIV]], i{{[0-9]+}}** [[REFC:%.+]], 440 // BLOCKS: call void @__kmpc_for_static_init_4( 441 // BLOCKS: [[A_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFA]], 442 // BLOCKS-NEXT: [[A_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[A_PRIV]], 443 // BLOCKS-NEXT: [[INC:%.+]] = add nsw i{{[0-9]+}} [[A_VAL]], 1 444 // BLOCKS-NEXT: store i{{[0-9]+}} [[INC]], i{{[0-9]+}}* [[A_PRIV]], 445 // BLOCKS-NEXT: [[B_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[B_PRIV]], 446 // BLOCKS-NEXT: [[DEC:%.+]] = add nsw i{{[0-9]+}} [[B_VAL]], -1 447 // BLOCKS-NEXT: store i{{[0-9]+}} [[DEC]], i{{[0-9]+}}* [[B_PRIV]], 448 // BLOCKS-NEXT: [[C_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFC]], 449 // BLOCKS-NEXT: [[C_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[C_PRIV]], 450 // BLOCKS-NEXT: [[DIV:%.+]] = sdiv i{{[0-9]+}} [[C_VAL]], 1 451 // BLOCKS-NEXT: store i{{[0-9]+}} [[DIV]], i{{[0-9]+}}* [[C_PRIV]], 452 // BLOCKS: call void @__kmpc_for_static_fini( 453 // BLOCKS: br i1 454 // BLOCKS: br label 455 // BLOCKS: ret void 456 #else 457 S<float> test; 458 int t_var = 0; 459 int vec[] = {1, 2}; 460 S<float> s_arr[] = {1, 2}; 461 S<float> var(3); 462 #pragma omp parallel 463 #pragma omp for lastprivate(t_var, vec, s_arr, var, sivar) 464 for (int i = 0; i < 2; ++i) { 465 vec[i] = t_var; 466 s_arr[i] = var; 467 sivar += i; 468 } 469 #pragma omp parallel 470 #pragma omp for lastprivate(A::x, B::x) firstprivate(f) lastprivate(f) 471 for (int i = 0; i < 2; ++i) { 472 A::x++; 473 } 474 #pragma omp parallel 475 #pragma omp for allocate(omp_const_mem_alloc: f) firstprivate(f) lastprivate(f) 476 for (int i = 0; i < 2; ++i) { 477 A::x++; 478 } 479 #pragma omp parallel 480 #pragma omp for allocate(omp_const_mem_alloc :cnt) lastprivate(cnt) 481 for (cnt = 0; cnt < 2; ++cnt) { 482 A::x++; 483 } 484 return tmain<int>(); 485 #endif 486 } 487 488 // CHECK: define i{{[0-9]+}} @main() 489 // CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]], 490 // CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR:@.+]]([[S_FLOAT_TY]]* [[TEST]]) 491 // 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]+}}*, i32*, [2 x i32]*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]*, i32*)* [[MAIN_MICROTASK:@.+]] to void 492 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 0, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*)* [[MAIN_MICROTASK1:@.+]] to void 493 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 0, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*)* [[MAIN_MICROTASK2:@.+]] to void 494 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 0, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*)* [[MAIN_MICROTASK3:@.+]] to void 495 // CHECK: = call {{.+}} [[TMAIN_INT:@.+]]() 496 // CHECK: call void [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]* 497 // CHECK: ret 498 499 // CHECK: define internal void [[MAIN_MICROTASK]](i32* noalias [[GTID_ADDR:%.+]], i32* noalias %{{.+}}, i32* dereferenceable(4) %{{.+}}, [2 x i32]* dereferenceable(8) %{{.+}}, [2 x [[S_FLOAT_TY]]]* dereferenceable(8) %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}}) 500 // CHECK: alloca i{{[0-9]+}}, 501 // CHECK: alloca i{{[0-9]+}}, 502 // CHECK: alloca i{{[0-9]+}}, 503 // CHECK: alloca i{{[0-9]+}}, 504 // CHECK: alloca i{{[0-9]+}}, 505 // CHECK: alloca i{{[0-9]+}}, 506 // CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, 507 // CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], 508 // CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_FLOAT_TY]]], 509 // CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]], 510 // CHECK: [[SIVAR_PRIV:%.+]] = alloca i{{[0-9]+}}, 511 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]] 512 513 // CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** % 514 // CHECK: [[VEC_REF:%.+]] = load [2 x i32]*, [2 x i32]** % 515 // CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** % 516 // CHECK: [[VAR_REF:%.+]] = load [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** % 517 518 // Check for default initialization. 519 // CHECK-NOT: [[T_VAR_PRIV]] 520 // CHECK-NOT: [[VEC_PRIV]] 521 // CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_FLOAT_TY]]* 522 // CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]]* [[S_ARR_PRIV_ITEM]]) 523 // CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]]) 524 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) 525 // <Skip loop body> 526 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}}) 527 528 // Check for final copying of private values back to original vars. 529 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]], 530 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0 531 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]] 532 // CHECK: [[LAST_THEN]] 533 // Actual copying. 534 535 // original t_var=private_t_var; 536 // CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]], 537 // CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_REF]], 538 539 // original vec[]=private_vec[]; 540 // CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8* 541 // CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8* 542 // CHECK: call void @llvm.memcpy.{{.+}}(i8* align {{[0-9]+}} [[VEC_DEST]], i8* align {{[0-9]+}} [[VEC_SRC]], 543 544 // original s_arr[]=private_s_arr[]; 545 // CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 546 // CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = bitcast [2 x [[S_FLOAT_TY]]]* [[S_ARR_PRIV]] to [[S_FLOAT_TY]]* 547 // CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2 548 // CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]] 549 // CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]] 550 // CHECK: [[S_ARR_BODY]] 551 // CHECK: call {{.*}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]]* {{.+}}, [[S_FLOAT_TY]]* {{.+}}) 552 // CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]] 553 // CHECK: [[S_ARR_BODY_DONE]] 554 555 // original var=private_var; 556 // CHECK: call {{.*}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]]* [[VAR_REF]], [[S_FLOAT_TY]]* {{.*}} [[VAR_PRIV]]) 557 // CHECK: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIVAR_PRIV]], 558 // CHECK: br label %[[LAST_DONE]] 559 // CHECK: [[LAST_DONE]] 560 // CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]]) 561 // CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* 562 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]] 563 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] 564 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) 565 // CHECK: ret void 566 567 // 568 // CHECK: define internal void [[MAIN_MICROTASK1]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}) 569 // CHECK: [[F_PRIV:%.+]] = alloca float, 570 // CHECK-NOT: alloca float 571 // CHECK: [[X_PRIV:%.+]] = alloca double, 572 // CHECK-NOT: alloca float 573 // CHECK-NOT: alloca double 574 575 // Check for default initialization. 576 // CHECK-NOT: [[X_PRIV]] 577 // CHECK: [[F_VAL:%.+]] = load float, float* [[F]], 578 // CHECK: store float [[F_VAL]], float* [[F_PRIV]], 579 // CHECK-NOT: [[X_PRIV]] 580 581 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]] 582 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] 583 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) 584 // <Skip loop body> 585 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]]) 586 587 // Check for final copying of private values back to original vars. 588 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]], 589 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0 590 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]] 591 // CHECK: [[LAST_THEN]] 592 // Actual copying. 593 594 // original x=private_x; 595 // CHECK: [[X_VAL:%.+]] = load double, double* [[X_PRIV]], 596 // CHECK: store double [[X_VAL]], double* [[X]], 597 598 // original f=private_f; 599 // CHECK: [[F_VAL:%.+]] = load float, float* [[F_PRIV]], 600 // CHECK: store float [[F_VAL]], float* [[F]], 601 602 // CHECK-NEXT: br label %[[LAST_DONE]] 603 // CHECK: [[LAST_DONE]] 604 605 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) 606 // CHECK: ret void 607 608 // CHECK: define internal void [[MAIN_MICROTASK2]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}) 609 // CHECK-NOT: alloca float 610 611 // Check for default initialization. 612 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]] 613 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] 614 // CHECK: [[F_VOID_PTR:%.+]] = call i8* @__kmpc_alloc(i32 [[GTID]], i64 4, i8* inttoptr (i64 3 to i8*)) 615 // CHECK: [[F_PRIV:%.+]] = bitcast i8* [[F_VOID_PTR]] to float* 616 // CHECK: [[F_VAL:%.+]] = load float, float* [[F]], 617 // CHECK: store float [[F_VAL]], float* [[F_PRIV]], 618 619 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) 620 // <Skip loop body> 621 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]]) 622 623 // Check for final copying of private values back to original vars. 624 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]], 625 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0 626 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]] 627 // CHECK: [[LAST_THEN]] 628 // Actual copying. 629 630 // original f=private_f; 631 // CHECK: [[F_VAL:%.+]] = load float, float* [[F_PRIV]], 632 // CHECK: store float [[F_VAL]], float* [[F]], 633 634 // CHECK-NEXT: br label %[[LAST_DONE]] 635 // CHECK: [[LAST_DONE]] 636 637 // CHECK: call void @__kmpc_free(i32 [[GTID]], i8* [[F_VOID_PTR]], i8* inttoptr (i64 3 to i8*)) 638 // CHECK-NEXT: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) 639 // CHECK-NEXT: ret void 640 641 // CHECK: define internal void [[MAIN_MICROTASK3]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}) 642 643 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]] 644 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] 645 // CHECK: [[CNT_PRIV:%.+]] = call i8* @__kmpc_alloc(i32 [[GTID]], i64 1, i8* inttoptr (i64 3 to i8*)) 646 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1) 647 // UB = min(UB, GlobalUB) 648 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]] 649 // CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 1 650 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]] 651 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 1, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ] 652 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]] 653 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]] 654 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]] 655 // <Skip loop body> 656 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]]) 657 658 // Check for final copying of private values back to original vars. 659 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]], 660 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0 661 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]] 662 // CHECK: [[LAST_THEN]] 663 664 // Calculate private cnt value. 665 // CHECK: store i8 2, i8* [[CNT_PRIV]] 666 // original cnt=private_cnt; 667 // CHECK: [[CNT_VAL:%.+]] = load i8, i8* [[CNT_PRIV]], 668 // CHECK: store i8 [[CNT_VAL]], i8* [[CNT]], 669 670 // CHECK-NEXT: br label %[[LAST_DONE]] 671 // CHECK: [[LAST_DONE]] 672 673 // CHECK: call void @__kmpc_free(i32 [[GTID]], i8* [[CNT_PRIV]], i8* inttoptr (i64 3 to i8*)) 674 // CHECK-NEXT: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) 675 // CHECK-NEXT: ret void 676 677 // CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]() 678 // CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]], 679 // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR:@.+]]([[S_INT_TY]]* [[TEST]]) 680 // 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]+}}*, i32*, [2 x i32]*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]*)* [[TMAIN_MICROTASK:@.+]] to void 681 // CHECK: call void [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]* 682 // CHECK: ret 683 684 // CHECK: define {{.+}} @{{.+}}([[SS_TY]]* 685 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0 686 // CHECK: store i{{[0-9]+}} 0, i{{[0-9]+}}* % 687 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1 688 // CHECK: store i8 689 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2 690 // 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]+}}*, [[SS_TY]]*)* [[SS_MICROTASK:@.+]] to void 691 // CHECK: call void @__kmpc_for_static_init_4( 692 // CHECK-NOT: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0 693 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1 694 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2 695 // CHECK: call void @__kmpc_for_static_fini(% 696 // CHECK: ret 697 698 // CHECK: define internal void [[SS_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}) 699 // CHECK: alloca i{{[0-9]+}}, 700 // CHECK: alloca i{{[0-9]+}}, 701 // CHECK: alloca i{{[0-9]+}}, 702 // CHECK: alloca i{{[0-9]+}}, 703 // CHECK: alloca i{{[0-9]+}}, 704 // CHECK: alloca i{{[0-9]+}}, 705 // CHECK: alloca i{{[0-9]+}}, 706 // CHECK: [[A_PRIV:%.+]] = alloca i{{[0-9]+}}, 707 // CHECK: [[B_PRIV:%.+]] = alloca i{{[0-9]+}}, 708 // CHECK: [[C_PRIV:%.+]] = alloca i{{[0-9]+}}, 709 // CHECK: store i{{[0-9]+}}* [[A_PRIV]], i{{[0-9]+}}** [[REFA:%.+]], 710 // CHECK: store i{{[0-9]+}}* [[C_PRIV]], i{{[0-9]+}}** [[REFC:%.+]], 711 // CHECK: call void @__kmpc_for_static_init_4( 712 // CHECK: [[A_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFA]], 713 // CHECK-NEXT: [[A_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[A_PRIV]], 714 // CHECK-NEXT: [[INC:%.+]] = add nsw i{{[0-9]+}} [[A_VAL]], 1 715 // CHECK-NEXT: store i{{[0-9]+}} [[INC]], i{{[0-9]+}}* [[A_PRIV]], 716 // CHECK-NEXT: [[B_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[B_PRIV]], 717 // CHECK-NEXT: [[DEC:%.+]] = add nsw i{{[0-9]+}} [[B_VAL]], -1 718 // CHECK-NEXT: store i{{[0-9]+}} [[DEC]], i{{[0-9]+}}* [[B_PRIV]], 719 // CHECK-NEXT: [[C_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFC]], 720 // CHECK-NEXT: [[C_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[C_PRIV]], 721 // CHECK-NEXT: [[DIV:%.+]] = sdiv i{{[0-9]+}} [[C_VAL]], 1 722 // CHECK-NEXT: store i{{[0-9]+}} [[DIV]], i{{[0-9]+}}* [[C_PRIV]], 723 // CHECK: call void @__kmpc_for_static_fini( 724 // CHECK: br i1 725 // CHECK: [[B_REF:%.+]] = getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1 726 // CHECK: store i8 %{{.+}}, i8* [[B_REF]], 727 // CHECK: br label 728 // CHECK: ret void 729 730 // CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, i32* dereferenceable(4) %{{.+}}, [2 x i32]* dereferenceable(8) %{{.+}}, [2 x [[S_INT_TY]]]* dereferenceable(8) %{{.+}}, [[S_INT_TY]]* dereferenceable(4) %{{.+}}) 731 // CHECK: alloca i{{[0-9]+}}, 732 // CHECK: alloca i{{[0-9]+}}, 733 // CHECK: alloca i{{[0-9]+}}, 734 // CHECK: alloca i{{[0-9]+}}, 735 // CHECK: alloca i{{[0-9]+}}, 736 // CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, align 128 737 // CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], align 128 738 // CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_INT_TY]]], align 128 739 // CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]], align 128 740 // CHECK: [[VAR_PRIV_REF:%.+]] = alloca [[S_INT_TY]]*, 741 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]] 742 743 // CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** % 744 // CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}]*, [2 x i{{[0-9]+}}]** % 745 // CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** % 746 747 // Check for default initialization. 748 // CHECK-NOT: [[T_VAR_PRIV]] 749 // CHECK-NOT: [[VEC_PRIV]] 750 // CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_INT_TY]]* 751 // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]]* [[S_ARR_PRIV_ITEM]]) 752 // CHECK: [[VAR_REF:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** % 753 // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]]* [[VAR_PRIV]]) 754 // CHECK: store [[S_INT_TY]]* [[VAR_PRIV]], [[S_INT_TY]]** [[VAR_PRIV_REF]] 755 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) 756 // <Skip loop body> 757 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}}) 758 759 // Check for final copying of private values back to original vars. 760 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]], 761 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0 762 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]] 763 // CHECK: [[LAST_THEN]] 764 // Actual copying. 765 766 // original t_var=private_t_var; 767 // CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]], 768 // CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_REF]], 769 770 // original vec[]=private_vec[]; 771 // CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8* 772 // CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8* 773 // CHECK: call void @llvm.memcpy.{{.+}}(i8* align {{[0-9]+}} [[VEC_DEST]], i8* align {{[0-9]+}} [[VEC_SRC]], 774 775 // original s_arr[]=private_s_arr[]; 776 // CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0 777 // CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = bitcast [2 x [[S_INT_TY]]]* [[S_ARR_PRIV]] to [[S_INT_TY]]* 778 // CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2 779 // CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]] 780 // CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]] 781 // CHECK: [[S_ARR_BODY]] 782 // CHECK: call {{.*}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]]* {{.+}}, [[S_INT_TY]]* {{.+}}) 783 // CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]] 784 // CHECK: [[S_ARR_BODY_DONE]] 785 786 // original var=private_var; 787 // CHECK: [[VAR_PRIV1:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[VAR_PRIV_REF]], 788 // CHECK: call {{.*}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]]* [[VAR_REF]], [[S_INT_TY]]* {{.*}} [[VAR_PRIV1]]) 789 // CHECK: br label %[[LAST_DONE]] 790 // CHECK: [[LAST_DONE]] 791 // CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]* [[VAR_PRIV]]) 792 // CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]* 793 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]] 794 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]] 795 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]]) 796 // CHECK: ret void 797 #endif 798 799