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