This is an archive of the discontinued LLVM Phabricator instance.

Differential D99770

[OpenMP, test] Fix uses of undef S*VAR FileCheck var
ClosedPublic

Authored by thopre on Apr 1 2021, 2:43 PM.

Details

Reviewers
ABataev
MaskRay
jdoerfert
Commits
rGd222a07d3023: [OpenMP, test] Fix uses of undef S*VAR FileCheck var
Summary

Fix the many cases of use of undefined SIVAR/SVAR/SFVAR in OpenMP
*private_codegen tests, due to a missing BLOCK directive to capture the
IR variable when it is declared. It also fixes a few typo in its use.

Diff Detail

Event Timeline

thopre created this revision.Apr 1 2021, 2:43 PM
Herald added subscribers: guansong, yaxunl. · View Herald TranscriptApr 1 2021, 2:43 PM
thopre requested review of this revision.Apr 1 2021, 2:43 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 1 2021, 2:43 PM
Herald added subscribers: cfe-commits, sstefan1. · View Herald Transcript
thopre mentioned this in D86222: Fix PR46880: Fail CHECK-NOT with undefined variable.Apr 1 2021, 2:51 PM
MaskRay accepted this revision.Apr 1 2021, 3:06 PM
This revision is now accepted and ready to land.Apr 1 2021, 3:06 PM
Harbormaster completed remote builds in B96814: Diff 334832.Apr 1 2021, 3:24 PM
thopre updated this revision to Diff 334846.Apr 1 2021, 4:12 PM

Fix one more testcase

This revision was landed with ongoing or failed builds.Apr 1 2021, 4:36 PM
Closed by commit rGd222a07d3023: [OpenMP, test] Fix uses of undef S*VAR FileCheck var (authored by thopre). · Explain Why
This revision was automatically updated to reflect the committed changes.
thopre added a commit: rGd222a07d3023: [OpenMP, test] Fix uses of undef S*VAR FileCheck var.
Harbormaster completed remote builds in B96826: Diff 334846.Apr 1 2021, 4:47 PM

Revision Contents

Diff 334850

clang/test/OpenMP/for_firstprivate_codegen.cpp

Show First 20 Lines • Show All 141 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 6, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 6, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212, // BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212,
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel #pragma omp parallel
#pragma omp for firstprivate(g, g1, sivar) #pragma omp for firstprivate(g, g1, sivar)
for (int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i) {
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

clang/test/OpenMP/for_private_codegen.cpp

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SFVAR_REF:%.+]] = load float*, float** [[SFVAR_PTR_REF]] // LAMBDA: [[SFVAR_REF:%.+]] = load float*, float** [[SFVAR_PTR_REF]]
// LAMBDA: store float 8.0{{.+}}, float* [[SFVAR_REF]] // LAMBDA: store float 8.0{{.+}}, float* [[SFVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] = {{(dso_local )?}}global double // BLOCKS: [[G:@.+]] = {{(dso_local )?}}global double
// BLOCKS: [[SVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS: [[SFVAR:@.+]] = internal global float 0.000000e+00,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call {{.*}}void {{%.+}}(i8 // BLOCKS: call {{.*}}void {{%.+}}(i8
^{ ^{
static float sfvar; static float sfvar;
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel #pragma omp parallel
#pragma omp for private(g, g1, svar, sfvar) #pragma omp for private(g, g1, svar, sfvar)
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

clang/test/OpenMP/master_taskloop_firstprivate_codegen.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master( // BLOCKS: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master(
// BLOCKS-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0 // BLOCKS-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0
// BLOCKS-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]] // BLOCKS-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
// BLOCKS: [[THEN]] // BLOCKS: [[THEN]]
Show All 12 Lines#elif defined(BLOCKS)
// BLOCKS: [[EXIT]] // BLOCKS: [[EXIT]]
// BLOCKS: ret // BLOCKS: ret
#pragma omp master taskloop firstprivate(g, sivar) #pragma omp master taskloop firstprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store volatile double 2.0{{.+}}, double* // BLOCKS: store volatile double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 368 Lines • Show Last 20 Lines

clang/test/OpenMP/master_taskloop_lastprivate_codegen.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*)) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
// BLOCKS: ret // BLOCKS: ret
#pragma omp master taskloop lastprivate(g, sivar) #pragma omp master taskloop lastprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 419 Lines • Show Last 20 Lines

clang/test/OpenMP/master_taskloop_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 3; sivar = 3;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
▲ Show 20 Lines • Show All 331 Lines • Show Last 20 Lines

clang/test/OpenMP/master_taskloop_simd_firstprivate_codegen.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0 // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
// BLOCKS: [[G_VAL:%.+]] = load volatile double, double* @{{.+}}, // BLOCKS: [[G_VAL:%.+]] = load volatile double, double* @{{.+}},
// BLOCKS: store volatile double [[G_VAL]], double* [[G_PRIVATE_ADDR]] // BLOCKS: store volatile double [[G_VAL]], double* [[G_PRIVATE_ADDR]]
// BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 1
// BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* @{{.+}}, // BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* @{{.+}},
// BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]] // BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]]
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
#pragma omp master taskloop simd firstprivate(g, sivar) #pragma omp master taskloop simd firstprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store volatile double 2.0{{.+}}, double* // BLOCKS: store volatile double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

clang/test/OpenMP/master_taskloop_simd_lastprivate_codegen.cpp

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*)) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
// BLOCKS: ret // BLOCKS: ret
#pragma omp master taskloop simd lastprivate(g, sivar) #pragma omp master taskloop simd lastprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 401 Lines • Show Last 20 Lines

clang/test/OpenMP/master_taskloop_simd_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 3; sivar = 3;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

clang/test/OpenMP/nvptx_target_firstprivate_codegen.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines#pragma omp target firstprivate(ptr)
ptr[0]++; ptr[0]++;
} }
// TCHECK: define weak void @__omp_offloading_{{.+}}(double* [[PTR_IN:%.+]]) // TCHECK: define weak void @__omp_offloading_{{.+}}(double* [[PTR_IN:%.+]])
// TCHECK: [[PTR_ADDR:%.+]] = alloca double*, // TCHECK: [[PTR_ADDR:%.+]] = alloca double*,
// TCHECK-NOT: alloca double*, // TCHECK-NOT: alloca double*,
// TCHECK: store double* [[PTR_IN]], double** [[PTR_ADDR]], // TCHECK: store double* [[PTR_IN]], double** [[PTR_ADDR]],
// TCHECK: [[PTR_IN_REF:%.+]] = load double*, double** [[PTR_ADDR]], // TCHECK: [[PTR_IN_REF:%.+]] = load double*, double** [[PTR_ADDR]],
// TCHECK-NOT: store double* [[PTR_IN_REF]], double** [[PTR_PRIV]], // TCHECK-NOT: store double* [[PTR_IN_REF]], double** {{%.+}},
return a; return a;
} }
template <typename tx> template <typename tx>
tx ftemplate(int n) { tx ftemplate(int n) {
tx a = 0; tx a = 0;
tx b[10]; tx b[10];
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_firstprivate_codegen.cpp

Show First 20 Lines • Show All 231 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 4, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 4, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212, // BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212,
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call // BLOCKS: call
// BLOCKS: call {{.*}}void {{%.+}}(i8 // BLOCKS: call {{.*}}void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 2, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i32* [[G]], {{.+}}) // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 2, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i32* [[G]], {{.+}})
#pragma omp parallel firstprivate(g, sivar) #pragma omp parallel firstprivate(g, sivar)
{ {
▲ Show 20 Lines • Show All 346 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_master_taskloop_firstprivate_codegen.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master( // BLOCKS: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master(
// BLOCKS-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0 // BLOCKS-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0
// BLOCKS-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]] // BLOCKS-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
// BLOCKS: [[THEN]] // BLOCKS: [[THEN]]
Show All 12 Lines#elif defined(BLOCKS)
// BLOCKS: [[EXIT]] // BLOCKS: [[EXIT]]
// BLOCKS: ret // BLOCKS: ret
#pragma omp parallel master taskloop firstprivate(g, sivar) #pragma omp parallel master taskloop firstprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_master_taskloop_lastprivate_codegen.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*)) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
// BLOCKS: ret // BLOCKS: ret
#pragma omp parallel master taskloop lastprivate(g, sivar) #pragma omp parallel master taskloop lastprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 401 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_master_taskloop_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 3; sivar = 3;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
▲ Show 20 Lines • Show All 317 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_master_taskloop_simd_firstprivate_codegen.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master( // BLOCKS: [[RES:%.+]] = call {{.*}}i32 @__kmpc_master(
// BLOCKS-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0 // BLOCKS-NEXT: [[IS_MASTER:%.+]] = icmp ne i32 [[RES]], 0
// BLOCKS-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]] // BLOCKS-NEXT: br i1 [[IS_MASTER]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
// BLOCKS: [[THEN]] // BLOCKS: [[THEN]]
Show All 12 Lines#elif defined(BLOCKS)
// BLOCKS: [[EXIT]] // BLOCKS: [[EXIT]]
// BLOCKS: ret // BLOCKS: ret
#pragma omp parallel master taskloop simd firstprivate(g, sivar) #pragma omp parallel master taskloop simd firstprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_master_taskloop_simd_lastprivate_codegen.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*)) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
// BLOCKS: ret // BLOCKS: ret
#pragma omp parallel master taskloop simd lastprivate(g, sivar) #pragma omp parallel master taskloop simd lastprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 401 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_master_taskloop_simd_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 3; sivar = 3;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
▲ Show 20 Lines • Show All 317 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_private_codegen.cpp

Show First 20 Lines • Show All 184 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 4, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 4, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] = {{(dso_local )?}}global i{{[0-9]+}} 1212, // BLOCKS: [[G:@.+]] = {{(dso_local )?}}global i{{[0-9]+}} 1212,
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call // BLOCKS: call
// BLOCKS: call{{.*}} void {{%.+}}(i8 // BLOCKS: call{{.*}} void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS-NOT: = getelementptr inbounds %{{.+}}, // BLOCKS-NOT: = getelementptr inbounds %{{.+}},
// BLOCKS: call{{.*}} void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call{{.*}} void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel private(g, sivar) #pragma omp parallel private(g, sivar)
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

clang/test/OpenMP/sections_firstprivate_codegen.cpp

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 20, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 20, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212, // BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212,
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel #pragma omp parallel
#pragma omp sections firstprivate(g, sivar) #pragma omp sections firstprivate(g, sivar)
{ {
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

clang/test/OpenMP/sections_lastprivate_codegen.cpp

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 23, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 23, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212, // BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212,
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel #pragma omp parallel
#pragma omp sections lastprivate(g, sivar) #pragma omp sections lastprivate(g, sivar)
{ {
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

clang/test/OpenMP/sections_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 22, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 22, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] = {{(dso_local )?}}global double // BLOCKS: [[G:@.+]] = {{(dso_local )?}}global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call {{.*}}void {{%.+}}(i8 // BLOCKS: call {{.*}}void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel #pragma omp parallel
#pragma omp sections private(g, sivar) #pragma omp sections private(g, sivar)
{ {
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

clang/test/OpenMP/single_firstprivate_codegen.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 31, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 31, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212, // BLOCKS: [[G:@.+]] ={{.*}} global i{{[0-9]+}} 1212,
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel #pragma omp parallel
#pragma omp single firstprivate(g, sivar) #pragma omp single firstprivate(g, sivar)
{ {
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

clang/test/OpenMP/single_private_codegen.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines [&]() {
// LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]] // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
// LAMBDA: store i{{[0-9]+}} 211, i{{[0-9]+}}* [[SIVAR_REF]] // LAMBDA: store i{{[0-9]+}} 211, i{{[0-9]+}}* [[SIVAR_REF]]
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] = {{(dso_local )?}}global double // BLOCKS: [[G:@.+]] = {{(dso_local )?}}global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call {{.*}}void {{%.+}}(i8 // BLOCKS: call {{.*}}void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}) // BLOCKS: call {{.*}}void {{.+}} @__kmpc_fork_call({{.+}}, i32 0, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
#pragma omp parallel #pragma omp parallel
#pragma omp single private(g, sivar) #pragma omp single private(g, sivar)
{ {
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

clang/test/OpenMP/task_firstprivate_codegen.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines#elif defined(BLOCKS)
// BLOCKS: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]]) // BLOCKS: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]])
// BLOCKS: ret // BLOCKS: ret
#pragma omp task firstprivate(g, sivar, local) #pragma omp task firstprivate(g, sivar, local)
{ {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store volatile double 2.0{{.+}}, double* // BLOCKS: store volatile double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines

clang/test/OpenMP/task_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 3; sivar = 3;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 56, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 56, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]]) // BLOCKS: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]])
// BLOCKS: ret // BLOCKS: ret
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

clang/test/OpenMP/taskloop_firstprivate_codegen.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0 // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
// BLOCKS: [[G_VAL:%.+]] = load volatile double, double* @{{.+}}, // BLOCKS: [[G_VAL:%.+]] = load volatile double, double* @{{.+}},
// BLOCKS: store volatile double [[G_VAL]], double* [[G_PRIVATE_ADDR]] // BLOCKS: store volatile double [[G_VAL]], double* [[G_PRIVATE_ADDR]]
// BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 1
// BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* @{{.+}}, // BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* @{{.+}},
// BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]] // BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]]
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
#pragma omp taskloop firstprivate(g, sivar) #pragma omp taskloop firstprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store volatile double 2.0{{.+}}, double* // BLOCKS: store volatile double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

clang/test/OpenMP/taskloop_lastprivate_codegen.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*)) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
// BLOCKS: ret // BLOCKS: ret
#pragma omp taskloop lastprivate(g, sivar) #pragma omp taskloop lastprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 412 Lines • Show Last 20 Lines

clang/test/OpenMP/taskloop_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 3; sivar = 3;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

clang/test/OpenMP/taskloop_simd_firstprivate_codegen.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0 // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
// BLOCKS: [[G_VAL:%.+]] = load volatile double, double* @{{.+}}, // BLOCKS: [[G_VAL:%.+]] = load volatile double, double* @{{.+}},
// BLOCKS: store volatile double [[G_VAL]], double* [[G_PRIVATE_ADDR]] // BLOCKS: store volatile double [[G_VAL]], double* [[G_PRIVATE_ADDR]]
// BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 1
// BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* @{{.+}}, // BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* @{{.+}},
// BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]] // BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]]
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
#pragma omp taskloop simd firstprivate(g, sivar) #pragma omp taskloop simd firstprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store volatile double 2.0{{.+}}, double* // BLOCKS: store volatile double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

clang/test/OpenMP/taskloop_simd_lastprivate_codegen.cpp

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 22; sivar = 22;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 16, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*)) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
// BLOCKS: ret // BLOCKS: ret
#pragma omp taskloop simd lastprivate(g, sivar) #pragma omp taskloop simd lastprivate(g, sivar)
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// BLOCKS: define {{.+}} void {{@.+}}(i8* // BLOCKS: define {{.+}} void {{@.+}}(i8*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS: store double 2.0{{.+}}, double* // BLOCKS: store double 2.0{{.+}}, double*
// BLOCKS-NOT: [[G]]{{[[^:word:]]}} // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
// BLOCKS-NOT: [[ISVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}* // BLOCKS: store i{{[0-9]+}} 22, i{{[0-9]+}}*
// BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}} // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
// BLOCKS: ret // BLOCKS: ret
// BLOCKS: store double* %{{.+}}, double** %{{.+}}, // BLOCKS: store double* %{{.+}}, double** %{{.+}},
// BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}}, // BLOCKS: store i{{[0-9]+}}* %{{.+}}, i{{[0-9]+}}** %{{.+}},
// BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1) // BLOCKS: define internal i32 [[TASK_ENTRY]](i32 %0, %{{.+}}* noalias %1)
g = 1; g = 1;
▲ Show 20 Lines • Show All 401 Lines • Show Last 20 Lines

clang/test/OpenMP/taskloop_simd_private_codegen.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines [&]() {
g = 2; g = 2;
sivar = 3; sivar = 3;
}(); }();
} }
}(); }();
return 0; return 0;
#elif defined(BLOCKS) #elif defined(BLOCKS)
// BLOCKS: [[G:@.+]] ={{.*}} global double // BLOCKS: [[G:@.+]] ={{.*}} global double
// BLOCKS: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
// BLOCKS-LABEL: @main // BLOCKS-LABEL: @main
// BLOCKS: call void {{%.+}}(i8 // BLOCKS: call void {{%.+}}(i8
^{ ^{
// BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8* // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
// BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*)) // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}} @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 96, i64 1, i32 (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
// BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1 // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 1
// BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null) // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 1, i32 0, i64 0, i8* null)
// BLOCKS: ret // BLOCKS: ret
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines