r271201 - [OPENMP 4.5] Fixed codegen for 'priority' and destructors in task-based
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Mon Jul 18 14:49:14 PDT 2016
On Mon, May 30, 2016 at 2:06 AM, Alexey Bataev via cfe-commits <
cfe-commits at lists.llvm.org> wrote:
> Author: abataev
> Date: Mon May 30 04:06:50 2016
> New Revision: 271201
>
> URL: http://llvm.org/viewvc/llvm-project?rev=271201&view=rev
> Log:
> [OPENMP 4.5] Fixed codegen for 'priority' and destructors in task-based
> directives.
>
> 'kmp_task_t' record type added a new field for 'priority' clause and
> changed the representation of pointer to destructors for privates used
> within loop-based directives.
> Old representation:
>
> typedef struct kmp_task { /* GEH: Shouldn't this be
> aligned somehow? */
> void *shareds; /**< pointer to block of
> pointers to shared vars */
> kmp_routine_entry_t routine; /**< pointer to routine
> to call for executing task */
> kmp_int32 part_id; /**< part id for the
> task */
> kmp_routine_entry_t destructors; /* pointer to function to
> invoke deconstructors of firstprivate C++ objects */
> /* private vars */
> } kmp_task_t;
>
> New representation:
>
> typedef struct kmp_task { /* GEH: Shouldn't this be
> aligned somehow? */
> void *shareds; /**< pointer to block of
> pointers to shared vars */
> kmp_routine_entry_t routine; /**< pointer to routine
> to call for executing task */
> kmp_int32 part_id; /**< part id for the
> task */
> kmp_cmplrdata_t data1; /* Two known
> optional additions: destructors and priority */
> kmp_cmplrdata_t data2; /* Process
> destructors first, priority second */
> /* future data */
> /* private vars */
> } kmp_task_t;
>
> Also excessive initialization of 'destructors' fields to 'null' was
> removed from codegen if it is known that no destructors shal be used.
> Currently a special bit is used in 'kmp_tasking_flags_t' bitfields
> ('destructors_thunk' bitfield).
>
> Modified:
> cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
> cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
> cfe/trunk/test/OpenMP/task_codegen.cpp
> cfe/trunk/test/OpenMP/task_firstprivate_codegen.cpp
> cfe/trunk/test/OpenMP/task_if_codegen.cpp
> cfe/trunk/test/OpenMP/task_private_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_firstprivate_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_lastprivate_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_private_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_simd_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_simd_lastprivate_codegen.cpp
> cfe/trunk/test/OpenMP/taskloop_simd_private_codegen.cpp
>
> Modified: cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp Mon May 30 04:06:50 2016
> @@ -2653,8 +2653,10 @@ enum KmpTaskTFields {
> KmpTaskTRoutine,
> /// \brief Partition id for the untied tasks.
> KmpTaskTPartId,
> - /// \brief Function with call of destructors for private variables.
> - KmpTaskTDestructors,
> + /// Function with call of destructors for private variables.
> + Data1,
> + /// Task priority.
> + Data2,
> /// (Taskloops only) Lower bound.
> KmpTaskTLowerBound,
> /// (Taskloops only) Upper bound.
> @@ -3178,19 +3180,27 @@ createKmpTaskTRecordDecl(CodeGenModule &
> // void * shareds;
> // kmp_routine_entry_t routine;
> // kmp_int32 part_id;
> - // kmp_routine_entry_t destructors;
> + // kmp_cmplrdata_t data1;
> + // kmp_cmplrdata_t data2;
> // For taskloops additional fields:
> // kmp_uint64 lb;
> // kmp_uint64 ub;
> // kmp_int64 st;
> // kmp_int32 liter;
> // };
> + auto *UD = C.buildImplicitRecord("kmp_cmplrdata_t", TTK_Union);
> + UD->startDefinition();
> + addFieldToRecordDecl(C, UD, KmpInt32Ty);
> + addFieldToRecordDecl(C, UD, KmpRoutineEntryPointerQTy);
> + UD->completeDefinition();
> + QualType KmpCmplrdataTy = C.getRecordType(UD);
> auto *RD = C.buildImplicitRecord("kmp_task_t");
> RD->startDefinition();
> addFieldToRecordDecl(C, RD, C.VoidPtrTy);
> addFieldToRecordDecl(C, RD, KmpRoutineEntryPointerQTy);
> addFieldToRecordDecl(C, RD, KmpInt32Ty);
> - addFieldToRecordDecl(C, RD, KmpRoutineEntryPointerQTy);
> + addFieldToRecordDecl(C, RD, KmpCmplrdataTy);
> + addFieldToRecordDecl(C, RD, KmpCmplrdataTy);
> if (isOpenMPTaskLoopDirective(Kind)) {
> QualType KmpUInt64Ty =
> CGM.getContext().getIntTypeForBitwidth(/*DestWidth=*/64,
> /*Signed=*/0);
> @@ -3805,18 +3815,30 @@ CGOpenMPRuntime::emitTaskInit(CodeGenFun
> /*WithLastIter=*/!Data.LastprivateVars.empty());
> }
> }
> + // Fields of union "kmp_cmplrdata_t" for destructors and priority.
> + enum { Priority = 0, Destructors = 1 };
> // Provide pointer to function with destructors for privates.
> - llvm::Value *DestructorFn =
> - NeedsCleanup ? emitDestructorsFunction(CGM, Loc, KmpInt32Ty,
> - KmpTaskTWithPrivatesPtrQTy,
> - KmpTaskTWithPrivatesQTy)
> - : llvm::ConstantPointerNull::get(
> - cast<llvm::PointerType>(KmpRoutineEntryPtrTy));
> - LValue Destructor = CGF.EmitLValueForField(
> - TDBase, *std::next(KmpTaskTQTyRD->field_begin(),
> KmpTaskTDestructors));
> - CGF.EmitStoreOfScalar(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
> - DestructorFn, KmpRoutineEntryPtrTy),
> - Destructor);
> + auto FI = std::next(KmpTaskTQTyRD->field_begin(), Data1);
> + auto *KmpCmplrdataUD = (*FI)->getType()->getAsUnionType()->getDecl();
> + if (NeedsCleanup) {
> + llvm::Value *DestructorFn = emitDestructorsFunction(
> + CGM, Loc, KmpInt32Ty, KmpTaskTWithPrivatesPtrQTy,
> + KmpTaskTWithPrivatesQTy);
> + LValue Data1LV = CGF.EmitLValueForField(TDBase, *FI);
> + LValue DestructorsLV = CGF.EmitLValueForField(
> + Data1LV, *std::next(KmpCmplrdataUD->field_begin(), Destructors));
> + CGF.EmitStoreOfScalar(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
> + DestructorFn, KmpRoutineEntryPtrTy),
> + DestructorsLV);
> + }
> + // Set priority.
> + if (Data.Priority.getInt()) {
> + LValue Data2LV = CGF.EmitLValueForField(
> + TDBase, *std::next(KmpTaskTQTyRD->field_begin(), Data2));
> + LValue PriorityLV = CGF.EmitLValueForField(
> + Data2LV, *std::next(KmpCmplrdataUD->field_begin(), Priority));
> + CGF.EmitStoreOfScalar(Data.Priority.getPointer(), PriorityLV);
> + }
> Result.NewTask = NewTask;
> Result.TaskEntry = TaskEntry;
> Result.NewTaskNewTaskTTy = NewTaskNewTaskTTy;
>
> Modified: cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp (original)
> +++ cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp Mon May 30 04:06:50 2016
> @@ -2371,6 +2371,10 @@ void CodeGenFunction::EmitOMPTaskBasedDi
> // TODO: Add codegen for priority clause arg when runtime lib support
> it.
> auto *Prio = Clause->getPriority();
> Data.Priority.setInt(Prio);
> + Data.Priority.setPointer(EmitScalarConversion(
> + EmitScalarExpr(Prio), Prio->getType(),
> + getContext().getIntTypeForBitwidth(/*DestWidth=*/32,
> /*Signed=*/1),
> + Prio->getExprLoc()));
>
This doesn't look right: either Prio is known to be non-null here, in which
the first line should be "setInt(true)", or Prio is *not* known to be
non-null here, in which case the EmitScalarConversion call shouldn't be
dereferencing it without checking.
> }
> // The first function argument for tasks is a thread id, the second one
> is a
> // part id (0 for tied tasks, >=0 for untied task).
>
> Modified: cfe/trunk/test/OpenMP/task_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/task_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/task_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/task_codegen.cpp Mon May 30 04:06:50 2016
> @@ -9,7 +9,7 @@
> // CHECK-DAG: [[IDENT_T:%.+]] = type { i32, i32, i32, i32, i8* }
> // CHECK-DAG: [[STRUCT_SHAREDS:%.+]] = type { i8*, [2 x
> [[STRUCT_S:%.+]]]* }
> // CHECK-DAG: [[STRUCT_SHAREDS1:%.+]] = type { [2 x [[STRUCT_S:%.+]]]* }
> -// CHECK-DAG: [[KMP_TASK_T:%.+]] = type { i8*, i32 (i32, i8*)*, i32, i32
> (i32, i8*)* }
> +// CHECK-DAG: [[KMP_TASK_T:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}} }
> // CHECK-DAG: [[KMP_DEPEND_INFO:%.+]] = type { i64, i64, i8 }
> struct S {
> int a;
> @@ -30,13 +30,14 @@ int main() {
> // CHECK: store i8* [[B]], i8** [[B_REF]]
> // CHECK: [[S_REF:%.+]] = getelementptr inbounds [[STRUCT_SHAREDS]],
> [[STRUCT_SHAREDS]]* [[CAPTURES]], i32 0, i32 1
> // CHECK: store [2 x [[STRUCT_S]]]* [[S]], [2 x [[STRUCT_S]]]** [[S_REF]]
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 33, i64 32,
> i64 16, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY1:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 33, i64 40,
> i64 16, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY1:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[SHAREDS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR:%.+]], i32 0, i32 0
> // CHECK: [[SHAREDS_REF:%.+]] = load i8*, i8** [[SHAREDS_REF_PTR]]
> // CHECK: [[BITCAST:%.+]] = bitcast [[STRUCT_SHAREDS]]* [[CAPTURES]] to
> i8*
> // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[SHAREDS_REF]], i8*
> [[BITCAST]], i64 16, i32 8, i1 false)
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[PRIORITY_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 4
> +// CHECK: [[PRIORITY:%.+]] = bitcast %union{{.+}}* [[PRIORITY_REF_PTR]]
> to i32*
> +// CHECK: store i32 {{.+}}, i32* [[PRIORITY]]
> // CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]],
> i8* [[ORIG_TASK_PTR]])
> #pragma omp task shared(a, b, s) priority(b)
> {
> @@ -46,13 +47,11 @@ int main() {
> }
> // CHECK: [[S_REF:%.+]] = getelementptr inbounds [[STRUCT_SHAREDS1]],
> [[STRUCT_SHAREDS1]]* [[CAPTURES:%.+]], i32 0, i32 0
> // CHECK: store [2 x [[STRUCT_S]]]* [[S]], [2 x [[STRUCT_S]]]** [[S_REF]]
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{[^,]+}}, i32 [[GTID]], i32 1, i64
> 32, i64 8,
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{[^,]+}}, i32 [[GTID]], i32 1, i64
> 40, i64 8,
> // CHECK: [[SHAREDS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR:%.+]], i32 0, i32 0
> // CHECK: [[SHAREDS_REF:%.+]] = load i8*, i8** [[SHAREDS_REF_PTR]]
> // CHECK: [[BITCAST:%.+]] = bitcast [[STRUCT_SHAREDS1]]* [[CAPTURES]] to
> i8*
> // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[SHAREDS_REF]], i8*
> [[BITCAST]], i64 8, i32 8, i1 false)
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]], [[KMP_TASK_T]]* [[TASK_PTR]], i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> // CHECK: [[DEP:%.*]] = getelementptr inbounds [4 x [[KMP_DEPEND_INFO]]],
> [4 x [[KMP_DEPEND_INFO]]]* [[DEPENDENCIES:%.*]], i64 0, i64 0
> // CHECK: [[T0:%.*]] = getelementptr inbounds [[KMP_DEPEND_INFO]],
> [[KMP_DEPEND_INFO]]* [[DEP]], i32 0, i32 0
> // CHECK: store i64 ptrtoint (i32* @{{.+}} to i64), i64* [[T0]]
> @@ -100,17 +99,13 @@ int main() {
> a = 15;
> s[1].a = 10;
> }
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 32,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY2:@.+]] to i32 (i32, i8*)*))
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 40,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY2:@.+]] to i32 (i32, i8*)*))
> // CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]],
> i8* [[ORIG_TASK_PTR]])
> #pragma omp task untied
> {
> a = 1;
> }
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 32,
> i64 1,
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 40,
> i64 1,
> // CHECK: getelementptr inbounds [2 x [[STRUCT_S]]], [2 x [[STRUCT_S]]]*
> [[S]], i64 0, i64 0
> // CHECK: getelementptr inbounds [2 x [[KMP_DEPEND_INFO]]], [2 x
> [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i64 0, i64 0
> // CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]],
> [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0
> @@ -149,9 +144,7 @@ int main() {
> {
> a = 1;
> }
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 3, i64 32,
> i64 1,
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 3, i64 40,
> i64 1,
> // CHECK: getelementptr inbounds [3 x [[KMP_DEPEND_INFO]]], [3 x
> [[KMP_DEPEND_INFO]]]* %{{[^,]+}}, i64 0, i64 0
> // CHECK: getelementptr inbounds [[KMP_DEPEND_INFO]],
> [[KMP_DEPEND_INFO]]* %{{[^,]+}}, i32 0, i32 0
> // CHECK: store i64 ptrtoint (i32* @{{.+}} to i64), i64*
> @@ -199,17 +192,13 @@ int main() {
> {
> a = 2;
> }
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 3, i64 32,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY3:@.+]] to i32 (i32, i8*)*))
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 3, i64 40,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY3:@.+]] to i32 (i32, i8*)*))
> // CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]],
> i8* [[ORIG_TASK_PTR]])
> #pragma omp task final(true)
> {
> a = 2;
> }
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 1, i64 32,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY4:@.+]] to i32 (i32, i8*)*))
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]]{{.*}}* {{%.*}}, i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 1, i64 40,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY4:@.+]] to i32 (i32, i8*)*))
> // CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]],
> i8* [[ORIG_TASK_PTR]])
> const bool flag = false;
> #pragma omp task final(flag)
> @@ -220,9 +209,7 @@ int main() {
> // CHECK: [[CMP:%.+]] = icmp ne i8 [[B_VAL]], 0
> // CHECK: [[FINAL:%.+]] = select i1 [[CMP]], i32 2, i32 0
> // CHECK: [[FLAGS:%.+]] = or i32 [[FINAL]], 1
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 [[FLAGS]],
> i64 32, i64 8, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY5:@.+]] to i32 (i32, i8*)*))
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 [[FLAGS]],
> i64 40, i64 8, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY5:@.+]] to i32 (i32, i8*)*))
> // CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]],
> i8* [[ORIG_TASK_PTR]])
> int c __attribute__((aligned(128)));
> #pragma omp task final(b) shared(c)
> @@ -230,9 +217,7 @@ int main() {
> a = 4;
> c = 5;
> }
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 32,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY6:@.+]] to i32 (i32, i8*)*))
> -// CHECK: [[DESTRUCTORS_REF_PTR:%.+]] = getelementptr inbounds
> [[KMP_TASK_T]]{{.*}}* {{%.+}}, i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)**
> [[DESTRUCTORS_REF_PTR]]
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc([[IDENT_T]]* @{{.+}}, i32 [[GTID]], i32 0, i64 40,
> i64 1, i32 (i32, i8*)* bitcast (i32 (i32, [[KMP_TASK_T]]{{.*}}*)*
> [[TASK_ENTRY6:@.+]] to i32 (i32, i8*)*))
> // CHECK: call i32 @__kmpc_omp_task([[IDENT_T]]* @{{.+}}, i32 [[GTID]],
> i8* [[ORIG_TASK_PTR]])
> #pragma omp task untied
> {
> @@ -275,7 +260,6 @@ int main() {
> // CHECK: call i32 @__kmpc_omp_task(%
>
> // CHECK: call i8* @__kmpc_omp_task_alloc(
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %
> // CHECK: call i32 @__kmpc_omp_task(%
> // CHECK: load i32*, i32** %
> // CHECK: store i32 2, i32* %
>
> Modified: cfe/trunk/test/OpenMP/task_firstprivate_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/task_firstprivate_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/task_firstprivate_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/task_firstprivate_codegen.cpp Mon May 30
> 04:06:50 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)* }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}} }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type {{.*}}{ [2 x i32]*, i32,
> {{.*}}[2 x [[S_DOUBLE_TY]]]*, [[S_DOUBLE_TY]]*, i{{[0-9]+}}
> @@ -58,7 +58,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 48, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 56, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
> // LAMBDA: [[G_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 0
> @@ -102,7 +102,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 48, 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 56, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
> // BLOCKS: [[G_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 0
> @@ -191,7 +191,7 @@ int main() {
> // [[KMP_TASK_T]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 72, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 80, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // Fill kmp_task_t->shareds by copying from original capture argument.
> @@ -242,7 +242,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call i32 @__kmpc_omp_task([[LOC]], i32 [[GTID]], i8* [[RES]])
> @@ -387,7 +388,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call i32 @__kmpc_omp_task([[LOC]], i32 [[GTID]], i8* [[RES]])
>
> Modified: cfe/trunk/test/OpenMP/task_if_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/task_if_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/task_if_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/task_if_codegen.cpp Mon May 30 04:06:50 2016
> @@ -63,11 +63,11 @@ int tmain(T Arg) {
> // CHECK-LABEL: @main
> int main() {
> // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN7:[^ ]+]] to i32 (i32,
> i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN7:[^ ]+]] to i32 (i32,
> i8*)*))
> // CHECK: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 [[GTID]], i8*
> [[ORIG_TASK_PTR]])
> #pragma omp task if (true)
> fn7();
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN8:[^ ]+]] to i32 (i32,
> i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN8:[^ ]+]] to i32 (i32,
> i8*)*))
> // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to
> // CHECK: call void @__kmpc_omp_task_begin_if0(%{{.+}}* @{{.+}}, i{{.+}}
> [[GTID]], i8* [[ORIG_TASK_PTR]])
> // CHECK: call i32 [[CAP_FN8]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]])
> @@ -75,7 +75,7 @@ int main() {
> #pragma omp task if (false)
> fn8();
>
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN9:[^ ]+]] to i32 (i32,
> i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN9:[^ ]+]] to i32 (i32,
> i8*)*))
> // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to
> // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]]
> // CHECK: [[OMP_THEN]]
> @@ -89,7 +89,7 @@ int main() {
> // CHECK: [[OMP_END]]
> #pragma omp task if (Arg)
> fn9();
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN10:[^ ]+]] to i32
> (i32, i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc({{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN10:[^ ]+]] to i32
> (i32, i8*)*))
> // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to
> // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]]
> // CHECK: [[OMP_THEN]]
> @@ -126,7 +126,7 @@ int main() {
>
> // CHECK-LABEL: define {{.+}} @{{.+}}tmain
> // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN1:[^ ]+]] to i32
> (i32, i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN1:[^ ]+]] to i32
> (i32, i8*)*))
> // CHECK: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 [[GTID]], i8*
> [[ORIG_TASK_PTR]])
>
> // CHECK: [[ORIG_TASK_PTR:%.+]] = call i8* @__kmpc_omp_task_alloc(
> @@ -135,7 +135,7 @@ int main() {
> // CHECK: call i32 [[CAP_FN2:@.+]](i32 [[GTID]], %{{.+}}* [[TASK_PTR]])
> // CHECK: call void @__kmpc_omp_task_complete_if0(%{{.+}}* @{{.+}},
> i{{.+}} [[GTID]], i8* [[ORIG_TASK_PTR]])
>
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN3:[^ ]+]] to i32 (i32,
> i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN3:[^ ]+]] to i32 (i32,
> i8*)*))
> // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to
> // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]]
> // CHECK: [[OMP_THEN]]
> @@ -148,7 +148,7 @@ int main() {
> // CHECK: br label %[[OMP_END]]
> // CHECK: [[OMP_END]]
>
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN4:[^ ]+]] to i32 (i32,
> i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN4:[^ ]+]] to i32 (i32,
> i8*)*))
> // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to
> // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]]
> // CHECK: [[OMP_THEN]]
> @@ -162,7 +162,7 @@ int main() {
> // CHECK: br label %[[OMP_END]]
> // CHECK: [[OMP_END]]
>
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN5:[^ ]+]] to i32 (i32,
> i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN5:[^ ]+]] to i32 (i32,
> i8*)*))
> // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to
> // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]]
> // CHECK: [[OMP_THEN]]
> @@ -176,7 +176,7 @@ int main() {
> // CHECK: br label %[[OMP_END]]
> // CHECK: [[OMP_END]]
>
> -// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 32, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN6:[^ ]+]] to i32 (i32,
> i8*)*))
> +// CHECK: [[ORIG_TASK_PTR:%.+]] = call i8*
> @__kmpc_omp_task_alloc(%{{[^,]+}}, i32 [[GTID]], i32 1, i64 40, i64 1, i32
> (i32, i8*)* bitcast (i32 (i32, %{{[^*]+}}*)* [[CAP_FN6:[^ ]+]] to i32 (i32,
> i8*)*))
> // CHECK: [[TASK_PTR:%.+]] = bitcast i8* [[ORIG_TASK_PTR]] to
> // CHECK: br i1 %{{.+}}, label %[[OMP_THEN:.+]], label %[[OMP_ELSE:.+]]
> // CHECK: [[OMP_THEN]]
>
> Modified: cfe/trunk/test/OpenMP/task_private_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/task_private_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/task_private_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/task_private_codegen.cpp Mon May 30 04:06:50 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)* }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}} }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { i8 }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> @@ -56,7 +56,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 48, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[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*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // LAMBDA: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8*
> [[RES]])
> // LAMBDA: ret
> @@ -92,7 +92,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 48, 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: call i32 @__kmpc_omp_task(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8*
> [[RES]])
> // BLOCKS: ret
> @@ -158,7 +158,7 @@ int main() {
> // [[KMP_TASK_T_TY]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 72, i64 1, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 80, i64 1, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // CHECK: [[TASK:%.+]] = getelementptr inbounds [[KMP_TASK_MAIN_TY]],
> [[KMP_TASK_MAIN_TY]]* [[RES_KMP_TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
> @@ -182,7 +182,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call i32 @__kmpc_omp_task([[LOC]], i32 [[GTID]], i8* [[RES]])
> @@ -295,7 +296,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call i32 @__kmpc_omp_task([[LOC]], i32 [[GTID]], i8* [[RES]])
>
> Modified: cfe/trunk/test/OpenMP/taskloop_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_codegen.cpp Mon May 30 04:06:50 2016
> @@ -9,32 +9,28 @@
> // CHECK-LABEL: @main
> int main(int argc, char **argv) {
> // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(%ident_t*
> [[DEFLOC:@.+]])
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 33, i64 64, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK1:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 33, i64 72, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK1:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 9, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: call void @__kmpc_taskloop(%ident_t* [[DEFLOC]], i32 [[GTID]],
> i8* [[TASKV]], i32 1, i64* [[DOWN]], i64* [[UP]], i64 [[ST_VAL]], i32 0,
> i32 0, i64 0, i8* null)
> #pragma omp taskloop priority(argc)
> for (int i = 0; i < 10; ++i)
> ;
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 64, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK2:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 72, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK2:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 9, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: [[GRAINSIZE:%.+]] = zext i32 %{{.+}} to i64
> @@ -42,18 +38,16 @@ int main(int argc, char **argv) {
> #pragma omp taskloop nogroup grainsize(argc)
> for (int i = 0; i < 10; ++i)
> ;
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 64, i64 24, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK3:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 72, i64 24, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK3:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> // CHECK: [[IF:%.+]] = icmp ne i32 %{{.+}}, 0
> // CHECK: [[IF_INT:%.+]] = sext i1 [[IF]] to i32
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 %{{.+}}, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: call void @__kmpc_taskloop(%ident_t* [[DEFLOC]], i32 [[GTID]],
> i8* [[TASKV]], i32 [[IF_INT]], i64* [[DOWN]], i64* [[UP]], i64 [[ST_VAL]],
> i32 0, i32 2, i64 4, i8* null)
> @@ -65,13 +59,13 @@ int main(int argc, char **argv) {
> }
>
> // CHECK: define internal i32 [[TASK1]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
> @@ -95,13 +89,13 @@ int main(int argc, char **argv) {
> // CHECK: ret i32 0
>
> // CHECK: define internal i32 [[TASK2]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
> @@ -125,13 +119,13 @@ int main(int argc, char **argv) {
> // CHECK: ret i32 0
>
> // CHECK: define internal i32 [[TASK3]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
> @@ -147,16 +141,14 @@ struct S {
> int a;
> S(int c) {
> // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(%ident_t*
> [[DEFLOC:@.+]])
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 64, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK4:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 72, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK4:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 %{{.+}}, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: [[NUM_TASKS:%.+]] = zext i32 %{{.+}} to i64
> @@ -168,13 +160,13 @@ struct S {
> } s(1);
>
> // CHECK: define internal i32 [[TASK4]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
>
> Modified: cfe/trunk/test/OpenMP/taskloop_firstprivate_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_firstprivate_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_firstprivate_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_firstprivate_codegen.cpp Mon May 30
> 04:06:50 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)*, i64, i64, i64, i32 }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}}, i64, i64, i64, i32 }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type {{.*}}{ [2 x i32]*, i32,
> {{.*}}[2 x [[S_DOUBLE_TY]]]*, [[S_DOUBLE_TY]]*, i{{[0-9]+}}
> @@ -58,7 +58,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
> // LAMBDA: [[G_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 0
> @@ -102,7 +102,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, 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 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
> // BLOCKS: [[G_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 0
> @@ -191,7 +191,7 @@ int main() {
> // [[KMP_TASK_T]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 104, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 112, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // Fill kmp_task_t->shareds by copying from original capture argument.
> @@ -242,7 +242,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_MAIN_TY]]*, [[KMP_TASK_MAIN_TY]]*, i32)*
> [[MAIN_DUP:@.+]] to i8*))
> @@ -404,7 +405,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_TMAIN_TY]]*, [[KMP_TASK_TMAIN_TY]]*, i32)*
> [[TMAIN_DUP:@.+]] to i8*))
>
> Modified: cfe/trunk/test/OpenMP/taskloop_lastprivate_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_lastprivate_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_lastprivate_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_lastprivate_codegen.cpp Mon May 30
> 04:06:50 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)*, i64, i64, i64, i32 }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}}, i64, i64, i64, i32 }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { [2 x i32]*, i32*, [2 x
> [[S_DOUBLE_TY]]]*, [[S_DOUBLE_TY]]*, i{{[0-9]+}}* }
> @@ -58,7 +58,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
>
> // LAMBDA: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8*
> [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64
> 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*,
> i32)* [[MAIN_DUP:@.+]] to i8*))
> @@ -99,7 +99,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, 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 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}},
> i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0,
> i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*,
> [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
> // BLOCKS: ret
> @@ -183,7 +183,7 @@ int main() {
> // [[KMP_TASK_T]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 104, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 112, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // Fill kmp_task_t->shareds by copying from original capture argument.
> @@ -215,7 +215,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_MAIN_TY]]*, [[KMP_TASK_MAIN_TY]]*, i32)*
> [[MAIN_DUP:@.+]] to i8*))
> @@ -298,7 +299,7 @@ int main() {
>
> // CHECK: define internal void [[MAIN_DUP]]([[KMP_TASK_MAIN_TY]]*,
> [[KMP_TASK_MAIN_TY]]*, i32)
> // CHECK: getelementptr inbounds [[KMP_TASK_MAIN_TY]],
> [[KMP_TASK_MAIN_TY]]* %{{.+}}, i32 0, i32 0
> -// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: load i32, i32* %
> // CHECK: store i32 %{{.+}}, i32* %
> // CHECK: getelementptr inbounds [[KMP_TASK_MAIN_TY]],
> [[KMP_TASK_MAIN_TY]]* %{{.+}}, i32 0, i32 1
> @@ -388,7 +389,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_TMAIN_TY]]*, [[KMP_TASK_TMAIN_TY]]*, i32)*
> [[TMAIN_DUP:@.+]] to i8*))
> @@ -459,7 +461,7 @@ int main() {
>
> // CHECK: define internal void [[TMAIN_DUP]]([[KMP_TASK_TMAIN_TY]]*,
> [[KMP_TASK_TMAIN_TY]]*, i32)
> // CHECK: getelementptr inbounds [[KMP_TASK_TMAIN_TY]],
> [[KMP_TASK_TMAIN_TY]]* %{{.+}}, i32 0, i32 0
> -// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: load i32, i32* %
> // CHECK: store i32 %{{.+}}, i32* %
> // CHECK: getelementptr inbounds [[KMP_TASK_TMAIN_TY]],
> [[KMP_TASK_TMAIN_TY]]* %{{.+}}, i32 0, i32 2
>
> Modified: cfe/trunk/test/OpenMP/taskloop_private_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_private_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_private_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_private_codegen.cpp Mon May 30 04:06:50
> 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)*, i64, i64, i64, i32 }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}}, i64, i64, i64, i32 }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { i8 }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> @@ -56,7 +56,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 88, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // LAMBDA: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8*
> [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64
> 0, i8* null)
> // LAMBDA: ret
> @@ -92,7 +92,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, 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 88, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}},
> i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0,
> i64 0, i8* null)
> // BLOCKS: ret
> @@ -158,7 +158,7 @@ int main() {
> // [[KMP_TASK_T_TY]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 104, i64 1, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 112, i64 1, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // CHECK: [[TASK:%.+]] = getelementptr inbounds [[KMP_TASK_MAIN_TY]],
> [[KMP_TASK_MAIN_TY]]* [[RES_KMP_TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
> @@ -182,7 +182,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_MAIN_TY]]*, [[KMP_TASK_MAIN_TY]]*, i32)*
> [[MAIN_DUP:@.+]] to i8*))
> @@ -312,7 +313,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_TMAIN_TY]]*, [[KMP_TASK_TMAIN_TY]]*, i32)*
> [[TMAIN_DUP:@.+]] to i8*))
>
> Modified: cfe/trunk/test/OpenMP/taskloop_simd_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_simd_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_simd_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_simd_codegen.cpp Mon May 30 04:06:50
> 2016
> @@ -9,32 +9,28 @@
> // CHECK-LABEL: @main
> int main(int argc, char **argv) {
> // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(%ident_t*
> [[DEFLOC:@.+]])
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 33, i64 64, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK1:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 33, i64 72, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK1:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 9, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: call void @__kmpc_taskloop(%ident_t* [[DEFLOC]], i32 [[GTID]],
> i8* [[TASKV]], i32 1, i64* [[DOWN]], i64* [[UP]], i64 [[ST_VAL]], i32 0,
> i32 0, i64 0, i8* null)
> #pragma omp taskloop simd priority(argc)
> for (int i = 0; i < 10; ++i)
> ;
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 64, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK2:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 72, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK2:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 9, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: [[GRAINSIZE:%.+]] = zext i32 %{{.+}} to i64
> @@ -42,18 +38,16 @@ int main(int argc, char **argv) {
> #pragma omp taskloop simd nogroup grainsize(argc) simdlen(4)
> for (int i = 0; i < 10; ++i)
> ;
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 64, i64 24, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK3:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 72, i64 24, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK3:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> // CHECK: [[IF:%.+]] = icmp ne i32 %{{.+}}, 0
> // CHECK: [[IF_INT:%.+]] = sext i1 [[IF]] to i32
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 %{{.+}}, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: call void @__kmpc_taskloop(%ident_t* [[DEFLOC]], i32 [[GTID]],
> i8* [[TASKV]], i32 [[IF_INT]], i64* [[DOWN]], i64* [[UP]], i64 [[ST_VAL]],
> i32 0, i32 2, i64 4, i8* null)
> @@ -65,13 +59,13 @@ int main(int argc, char **argv) {
> }
>
> // CHECK: define internal i32 [[TASK1]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
> @@ -95,13 +89,13 @@ int main(int argc, char **argv) {
> // CHECK: ret i32 0
>
> // CHECK: define internal i32 [[TASK2]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
> @@ -125,13 +119,13 @@ int main(int argc, char **argv) {
> // CHECK: ret i32 0
>
> // CHECK: define internal i32 [[TASK3]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
> @@ -149,16 +143,14 @@ struct S {
> int a;
> S(int c) {
> // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(%ident_t*
> [[DEFLOC:@.+]])
> -// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 64, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK4:@.+]] to i32 (i32, i8*)*))
> +// CHECK: [[TASKV:%.+]] = call i8* @__kmpc_omp_task_alloc(%ident_t*
> [[DEFLOC]], i32 [[GTID]], i32 1, i64 72, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, [[TDP_TY:%.+]]*)* [[TASK4:@.+]] to i32 (i32, i8*)*))
> // CHECK: [[TASK:%.+]] = bitcast i8* [[TASKV]] to [[TDP_TY]]*
> // CHECK: [[TASK_DATA:%.+]] = getelementptr inbounds [[TDP_TY]],
> [[TDP_TY]]* [[TASK]], i32 0, i32 0
> -// CHECK: getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]* [[TASK_DATA]],
> i32 0, i32 3
> -// CHECK: store i32 (i32, i8*)* null, i32 (i32, i8*)** %{{.+}}
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> // CHECK: store i64 0, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> // CHECK: store i64 %{{.+}}, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> [[TASK_DATA]], i32 0, i32 7
> // CHECK: store i64 1, i64* [[ST]],
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> // CHECK: [[NUM_TASKS:%.+]] = zext i32 %{{.+}} to i64
> @@ -170,13 +162,13 @@ struct S {
> } s(1);
>
> // CHECK: define internal i32 [[TASK4]](
> -// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 4
> +// CHECK: [[DOWN:%.+]] = getelementptr inbounds [[TD_TY:%.+]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> // CHECK: [[DOWN_VAL:%.+]] = load i64, i64* [[DOWN]],
> -// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 5
> +// CHECK: [[UP:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> // CHECK: [[UP_VAL:%.+]] = load i64, i64* [[UP]],
> -// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 6
> +// CHECK: [[ST:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> // CHECK: [[ST_VAL:%.+]] = load i64, i64* [[ST]],
> -// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: [[LITER:%.+]] = getelementptr inbounds [[TD_TY]], [[TD_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: [[LITER_VAL:%.+]] = load i32, i32* [[LITER]],
> // CHECK: store i64 [[DOWN_VAL]], i64* [[LB:%[^,]+]],
> // CHECK: store i64 [[UP_VAL]], i64* [[UB:%[^,]+]],
>
> Modified: cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_codegen.cpp Mon May
> 30 04:06:50 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)*, i64, i64, i64, i32 }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}}, i64, i64, i64, i32 }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type {{.*}}{ [2 x i32]*, i32,
> {{.*}}[2 x [[S_DOUBLE_TY]]]*, [[S_DOUBLE_TY]]*, i{{[0-9]+}}
> @@ -58,7 +58,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
> // LAMBDA: [[G_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 0
> @@ -102,7 +102,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, 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 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* [[PRIVATES]], i{{.+}} 0, i{{.+}} 0
> // BLOCKS: [[G_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}},
> %{{.+}}* %{{.+}}, i{{.+}} 0, i{{.+}} 0
> @@ -191,7 +191,7 @@ int main() {
> // [[KMP_TASK_T]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 104, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 112, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // Fill kmp_task_t->shareds by copying from original capture argument.
> @@ -242,7 +242,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_MAIN_TY]]*, [[KMP_TASK_MAIN_TY]]*, i32)*
> [[MAIN_DUP:@.+]] to i8*))
> @@ -404,7 +405,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_TMAIN_TY]]*, [[KMP_TASK_TMAIN_TY]]*, i32)*
> [[TMAIN_DUP:@.+]] to i8*))
>
> Modified: cfe/trunk/test/OpenMP/taskloop_simd_lastprivate_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_simd_lastprivate_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_simd_lastprivate_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_simd_lastprivate_codegen.cpp Mon May 30
> 04:06:50 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)*, i64, i64, i64, i32 }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}}, i64, i64, i64, i32 }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { [2 x i32]*, i32*, [2 x
> [[S_DOUBLE_TY]]]*, [[S_DOUBLE_TY]]*, i{{[0-9]+}}* }
> @@ -58,7 +58,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
>
> // LAMBDA: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8*
> [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64
> 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*, [[KMP_TASK_MAIN_TY]]*,
> i32)* [[MAIN_DUP:@.+]] to i8*))
> @@ -99,7 +99,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, 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 88, i64 16, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}},
> i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0,
> i64 0, i8* bitcast (void ([[KMP_TASK_MAIN_TY:%[^*]+]]*,
> [[KMP_TASK_MAIN_TY]]*, i32)* [[MAIN_DUP:@.+]] to i8*))
> // BLOCKS: ret
> @@ -183,7 +183,7 @@ int main() {
> // [[KMP_TASK_T]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 104, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 112, i64 40, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // Fill kmp_task_t->shareds by copying from original capture argument.
> @@ -215,7 +215,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_MAIN_TY]]*, [[KMP_TASK_MAIN_TY]]*, i32)*
> [[MAIN_DUP:@.+]] to i8*))
> @@ -298,7 +299,7 @@ int main() {
>
> // CHECK: define internal void [[MAIN_DUP]]([[KMP_TASK_MAIN_TY]]*,
> [[KMP_TASK_MAIN_TY]]*, i32)
> // CHECK: getelementptr inbounds [[KMP_TASK_MAIN_TY]],
> [[KMP_TASK_MAIN_TY]]* %{{.+}}, i32 0, i32 0
> -// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: load i32, i32* %
> // CHECK: store i32 %{{.+}}, i32* %
> // CHECK: getelementptr inbounds [[KMP_TASK_MAIN_TY]],
> [[KMP_TASK_MAIN_TY]]* %{{.+}}, i32 0, i32 1
> @@ -388,7 +389,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_TMAIN_TY]]*, [[KMP_TASK_TMAIN_TY]]*, i32)*
> [[TMAIN_DUP:@.+]] to i8*))
> @@ -459,7 +461,7 @@ int main() {
>
> // CHECK: define internal void [[TMAIN_DUP]]([[KMP_TASK_TMAIN_TY]]*,
> [[KMP_TASK_TMAIN_TY]]*, i32)
> // CHECK: getelementptr inbounds [[KMP_TASK_TMAIN_TY]],
> [[KMP_TASK_TMAIN_TY]]* %{{.+}}, i32 0, i32 0
> -// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 7
> +// CHECK: getelementptr inbounds [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]*
> %{{.+}}, i32 0, i32 8
> // CHECK: load i32, i32* %
> // CHECK: store i32 %{{.+}}, i32* %
> // CHECK: getelementptr inbounds [[KMP_TASK_TMAIN_TY]],
> [[KMP_TASK_TMAIN_TY]]* %{{.+}}, i32 0, i32 2
>
> Modified: cfe/trunk/test/OpenMP/taskloop_simd_private_codegen.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/OpenMP/taskloop_simd_private_codegen.cpp?rev=271201&r1=271200&r2=271201&view=diff
>
> ==============================================================================
> --- cfe/trunk/test/OpenMP/taskloop_simd_private_codegen.cpp (original)
> +++ cfe/trunk/test/OpenMP/taskloop_simd_private_codegen.cpp Mon May 30
> 04:06:50 2016
> @@ -24,7 +24,7 @@ struct S {
>
> volatile double g;
>
> -// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> i32 (i32, i8*)*, i64, i64, i64, i32 }
> +// CHECK-DAG: [[KMP_TASK_T_TY:%.+]] = type { i8*, i32 (i32, i8*)*, i32,
> %union{{.+}}, %union{{.+}}, i64, i64, i64, i32 }
> // CHECK-DAG: [[S_DOUBLE_TY:%.+]] = type { double }
> // CHECK-DAG: [[CAP_MAIN_TY:%.+]] = type { i8 }
> // CHECK-DAG: [[PRIVATES_MAIN_TY:%.+]] = type {{.?}}{ [2 x
> [[S_DOUBLE_TY]]], [[S_DOUBLE_TY]], i32, [2 x i32]
> @@ -56,7 +56,7 @@ int main() {
> // LAMBDA: call{{( x86_thiscallcc)?}} void [[OUTER_LAMBDA:@.+]](
> [&]() {
> // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
> - // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> + // LAMBDA: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 88, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // LAMBDA: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // LAMBDA: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}}, i8*
> [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64
> 0, i8* null)
> // LAMBDA: ret
> @@ -92,7 +92,7 @@ int main() {
> // BLOCKS: call void {{%.+}}(i8
> ^{
> // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
> - // BLOCKS: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc(%{{[^ ]+}}
> @{{[^,]+}}, i32 %{{[^,]+}}, i32 1, i64 80, 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 88, i64 1, i32 (i32, i8*)* bitcast
> (i32 (i32, %{{[^*]+}}*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // BLOCKS: [[PRIVATES:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}*
> %{{.+}}, i{{.+}} 0, i{{.+}} 1
> // BLOCKS: call void @__kmpc_taskloop(%{{.+}}* @{{.+}}, i32 %{{.+}},
> i8* [[RES]], i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0,
> i64 0, i8* null)
> // BLOCKS: ret
> @@ -158,7 +158,7 @@ int main() {
> // [[KMP_TASK_T_TY]] task_data;
> // [[KMP_TASK_MAIN_TY]] privates;
> // };
> -// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 104, i64 1, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> +// CHECK: [[RES:%.+]] = call i8* @__kmpc_omp_task_alloc([[LOC]], i32
> [[GTID]], i32 9, i64 112, i64 1, i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[TASK_ENTRY:@[^ ]+]] to i32 (i32, i8*)*))
> // CHECK: [[RES_KMP_TASK:%.+]] = bitcast i8* [[RES]] to
> [[KMP_TASK_MAIN_TY]]*
>
> // CHECK: [[TASK:%.+]] = getelementptr inbounds [[KMP_TASK_MAIN_TY]],
> [[KMP_TASK_MAIN_TY]]* [[RES_KMP_TASK]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
> @@ -182,7 +182,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_MAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_MAIN_TY]]*, [[KMP_TASK_MAIN_TY]]*, i32)*
> [[MAIN_DUP:@.+]] to i8*))
> @@ -312,7 +313,8 @@ int main() {
>
> // Provide pointer to destructor function, which will destroy private
> variables at the end of the task.
> // CHECK: [[DESTRUCTORS_REF:%.+]] = getelementptr inbounds
> [[KMP_TASK_T_TY]], [[KMP_TASK_T_TY]]* [[TASK]], i{{.+}} 0, i{{.+}} 3
> -// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_REF]],
> +// CHECK: [[DESTRUCTORS_PTR:%.+]] = bitcast %union{{.+}}*
> [[DESTRUCTORS_REF]] to i32 (i32, i8*)**
> +// CHECK: store i32 (i32, i8*)* bitcast (i32 (i32,
> [[KMP_TASK_TMAIN_TY]]*)* [[DESTRUCTORS:@.+]] to i32 (i32, i8*)*), i32
> (i32, i8*)** [[DESTRUCTORS_PTR]],
>
> // Start task.
> // CHECK: call void @__kmpc_taskloop([[LOC]], i32 [[GTID]], i8* [[RES]],
> i32 1, i64* %{{.+}}, i64* %{{.+}}, i64 %{{.+}}, i32 0, i32 0, i64 0, i8*
> bitcast (void ([[KMP_TASK_TMAIN_TY]]*, [[KMP_TASK_TMAIN_TY]]*, i32)*
> [[TMAIN_DUP:@.+]] to i8*))
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20160718/f9ad8b71/attachment-0001.html>
More information about the cfe-commits
mailing list